105 lines
4.2 KiB
Pony
105 lines
4.2 KiB
Pony
actor Main
|
|
new create(env: Env) =>
|
|
env.out.print("Honk hjonk")
|
|
let lots = true
|
|
let x: I32 = 1 + if lots then 100 else 2 end
|
|
// If the `then` and `else` branches of an `if` expression produce different types
|
|
// then the `if` produces a union of the types produced by the `then` and `else
|
|
// branches
|
|
let friendly = false
|
|
var y: (String | Bool) =
|
|
if friendly then
|
|
"Hello"
|
|
else
|
|
false
|
|
end
|
|
// If the `if` doesn't have an else, then the tested condition evaluating false
|
|
// returns an implicit None.
|
|
var z: (String | None) =
|
|
if friendly then
|
|
"Hello"
|
|
end
|
|
// (z is now None)
|
|
|
|
// Loop expressions also return values
|
|
// This one returns "Sarah" because it is the last expression in the list
|
|
// If the loop had no iterations, then the value of the loop's `else` block
|
|
// will be returned; if the loop has no `else` block then None will be returned
|
|
var a: (String | None) =
|
|
for name in ["Bob"; "Fred"; "Sarah"].values() do
|
|
name
|
|
end
|
|
// I think this works like a `case` statement?
|
|
match a
|
|
| let s: String => env.out.print("a is " + s)
|
|
| None => env.out.print("a is None")
|
|
end
|
|
|
|
// Pony `while` loops
|
|
var count: U32 = 1
|
|
while count <= 10 do
|
|
env.out.print(count.string())
|
|
count = count + 1
|
|
end
|
|
// This `while` returns 10 (11 is the highest value reached by count,
|
|
// but Pony assignments return the *old* value of the variable!)
|
|
|
|
// You can stick an `else` on the `while` to cause it to return something other than
|
|
// `None` if no iterations occur, as we saw above
|
|
|
|
// You can `break` from loops in Pony, but since loops must return a value, the `break`
|
|
// statement can also provide an expression to return. If the `break` does not provide
|
|
// anything to return, the loop will fall through to returning the value from the `else`
|
|
// block, or None, as usual.
|
|
|
|
// This loop assigns "Jack" or "Jill" to name if that name is found (the first one found
|
|
// is assigned), else "Herbert"
|
|
var name =
|
|
while false do // while moreNames() do
|
|
var name' = "" // var name' = getName()
|
|
if (name' == "Jack") or (name' == "Jill") then
|
|
break name'
|
|
end
|
|
name'
|
|
else
|
|
"Herbert"
|
|
end
|
|
|
|
// Pony also has a `continue` keyword which skips iterations, like Python's. If the
|
|
// final iteration of a loop is skipped, then the final return value will not be
|
|
// calculated, so it cannot be returned -- in this case the value from the `else`
|
|
// or None is used as before.
|
|
|
|
// Pony `for` loops
|
|
// Pony's `for` is like Python's `for` and not like C and C++'s `for`
|
|
// For example, to iterate over an array and print its elements:
|
|
for name' in ["Mike"; "Fred"; "Sarah"].values() do
|
|
env.out.print(name')
|
|
end
|
|
|
|
// `for` loops take *iterators* after the `in` keyword. (This is why we call
|
|
// .values() on the array instead of using it straight up.)
|
|
// An iterator does not have to be any particular type, but it does need to
|
|
// provide two particular methods:
|
|
// has_next(): Bool
|
|
// and
|
|
// next(): T?
|
|
// where T is the type of the objects in the collection over which the iterator
|
|
// is iterating.
|
|
// Pony uses structural typing internally, so if we want to create our own iterator
|
|
// we don't have to declare that it provides any particular type
|
|
|
|
// You can use `break` and `continue`, and `else`, with `for` loops just like with
|
|
// `while` loops
|
|
|
|
// Pony `repeat .. until` loops
|
|
// oh wow Pony provides these? rare
|
|
// They look like this:
|
|
var counter = U64(1)
|
|
repeat
|
|
env.out.print("hello!!")
|
|
counter = counter + 1
|
|
until counter > 7 end
|
|
|
|
// You can use `break`, `continue` and `else` with these loops too
|