133 lines
No EOL
3.2 KiB
Text
133 lines
No EOL
3.2 KiB
Text
// Examples of alternate types/union types/heterogeneous types.
|
|
class Foo {
|
|
x: f64;
|
|
}
|
|
|
|
class Bar {
|
|
y: f64;
|
|
}
|
|
|
|
fun extract_value(v: Foo or Bar) -> f64 {
|
|
if match v as Foo {
|
|
v.x // Magic type binding!
|
|
} else as Bar {
|
|
v.y // Same magic re-binding of the variable to the new type
|
|
} // No error; exhaustivity analysis should work.
|
|
}
|
|
|
|
// This is Bob Nystrom's example from
|
|
// https://journal.stuffwithstuff.com/2023/08/04/representing-heterogeneous-data/
|
|
//
|
|
class MeleeWeapon {
|
|
damage: f64;
|
|
}
|
|
|
|
class RangedWeapon {
|
|
minRange: f64;
|
|
maxRange: f64;
|
|
}
|
|
|
|
class Monster {
|
|
health: f64;
|
|
}
|
|
|
|
fun print(x:string) {}
|
|
|
|
fun in_range(weapon: MeleeWeapon or RangedWeapon, distance: f64) {
|
|
if match weapon as w : RangedWeapon {
|
|
distance >= w.minRange and distance <= w.maxRange
|
|
} else {
|
|
distance == 1
|
|
}
|
|
}
|
|
|
|
fun attack(weapon: MeleeWeapon or RangedWeapon, monster: Monster, distance: f64) {
|
|
// This is worse but it works.
|
|
if match weapon as MeleeWeapon and distance > 1 or
|
|
match weapon as w:RangedWeapon and (distance < w.minRange or distance > w.maxRange) {
|
|
print("You are out of range")
|
|
return
|
|
}
|
|
|
|
// Bob says he doesn't want to do flow analysis but we're doing all our
|
|
// tricks with variables and scoping here, with one *big* bit of magic which
|
|
// is...
|
|
//
|
|
// NOTE: special syntax here: `identifier` as `TypeExpression` ALMOST means
|
|
// `identifier as identifier : TypeExpression` as the shorthand for checking
|
|
// local variables. The *almost* part is that the effective type of the
|
|
// variable changes but not the binding. (Is this what we want?)
|
|
let damage = if match weapon as w: MeleeWeapon {
|
|
roll_dice(w.damage)
|
|
} else as w: RangedWeapon {
|
|
// This is the trick here: else as re-uses the expression from the match
|
|
// and so we can do exhaustivity analysis.
|
|
w.maxRange - w.minRange
|
|
};
|
|
|
|
if monster.health <= damage {
|
|
print("You kill the monster!");
|
|
monster.health = 0
|
|
} else {
|
|
print("You wound the monster.");
|
|
monster.health = monster.health - damage
|
|
}
|
|
}
|
|
|
|
fun more_examples(weapon: MeleeWeapon or RangedWeapon) -> f64 or () {
|
|
if match weapon as w: RangedWeapon and w.maxRange > 10 {
|
|
// w is still in scope here; the `and` is bound into a predicate expression
|
|
// and breaks exhaustivity
|
|
w.minRange
|
|
}
|
|
}
|
|
|
|
// Some fun with iterators
|
|
class Finished {}
|
|
let FINISHED = new Finished {}
|
|
|
|
class Iterator {
|
|
current: f64;
|
|
|
|
fun next(self) -> f64 or Finished {
|
|
if self.current < 10 {
|
|
let result = self.current;
|
|
self.current = self.current + 1;
|
|
return result;
|
|
}
|
|
|
|
FINISHED
|
|
}
|
|
}
|
|
|
|
fun test() -> f64 {
|
|
let sum = 0;
|
|
|
|
// A single step of an iterator...
|
|
let it = new Iterator { current: 0 };
|
|
if match it.next() as v: f64 {
|
|
sum = sum + v;
|
|
}
|
|
|
|
// Looping by hand over an iterator is pretty clean.
|
|
let it = new Iterator { current: 0 };
|
|
while match it.next() as v: f64 {
|
|
sum = sum + v;
|
|
}
|
|
|
|
// Unroll by hand...
|
|
let it = new Iterator { current: 0 };
|
|
loop {
|
|
if match it.next() as v: f64 {
|
|
sum = sum + v;
|
|
} else {
|
|
return sum;
|
|
}
|
|
}
|
|
|
|
// Not in this test but `for` over an object should turn into something
|
|
// like the above.
|
|
}
|
|
|
|
// @ignore WIP
|
|
// @no-errors |