A language that
reads like English.

let pi = 3.14159        # named once, never changes
var count = 0           # this one can
count += 1

if age >= 18
  say "you can vote"
else if age >= 16
  say "nearly there"
else
  say "not yet"
end

for each n in 1..10 by 2
  say "{n} squared is {n ^ 2}"
end

repeat
  tries += 1
until tries >= 3

let [first, second, ...rest] = numbers   # destructuring
let nickname = user?.profile?.name ?? "friend"

fun greet(who = "world") -> "Hello, {who}!"

fun classify(n)
  if n < 0 then return "negative"
  if n is 0 then return "zero"
  return "positive"
end

# as many values as you like
fun total(...numbers) -> sum(numbers)

# name your arguments when it reads better
say rectangle(width: 4, height: 3)

# functions are values, and they close over what they see
let double = fun(n) -> n * 2

# gradual types — optional, checked when present
fun area(w: number, h: number): number -> w * h

type Point has x, y
  "A place on a flat grid."

  fun length(self) -> math.sqrt(self.x ^ 2 + self.y ^ 2)
  fun plus(self, other) -> Point(self.x + other.x, self.y + other.y)
  fun to_text(self) -> "({self.x}, {self.y})"
end

say Point(3, 4).length()          → 5

# fields can declare a kind and a default
type Account has owner: text, balance: number = 0
  fun deposit(self, amount)
    if amount <= 0 then throw "a deposit has to be positive"
    self.balance += amount
    return self.balance
  end
end

# one type can build on another
type Dog from Animal
  fun speak(self) -> "woof"
end

match value
  case 0                    -> "nothing at all"
  case 1 | 2 | 3            -> "a small number"
  case number(n) if n < 0    -> "below zero"
  case 4..99                -> "a middling number"
  case []                   -> "an empty list"
  case [only]               -> "just {only}"
  case [first, ...rest]     -> "{first}, {rest.length} more"
  case {name: n}            -> "something called {n}"
  case Point(0, 0)          -> "the origin"
  case Point(x, y)          -> "the point {x},{y}"
  case text(t)             -> "some words: {t}"
  case _                    -> "something else"
end

# forget a case and SHE tells you which value was not handled

try
  let answer = 1 / 0
catch e: MathError
  say "a maths problem: {e.message}"
catch e: IndexError | KeyError
  say "looked for something that was not there"
catch e
  say "anything else: {e.kind}"
finally
  say "cleaned up either way"
end

# throw text, or a kind you name yourself
throw "the amount has to be positive"
throw error("NotEnough", "you only have {balance}")

# state your assumptions up front
assert numbers.length > 0, "average needs a number"

# an async function runs on its own thread
async fun fetch_price(symbol)
  return http.json("https://api.example.com/{symbol}").price
end

# calling it hands back a task, straight away
let tasks = ["AAPL", "MSFT", "GOOG"] |> map(fetch_price)

# await one, or a whole list at once
for each price in await tasks
  say price
end

# three requests in the time of the slowest, not the sum

# tests live next to the code they check

fun celsius_to_fahrenheit(c) -> c * 9 / 5 + 32

test "converts freezing and boiling"
  expect celsius_to_fahrenheit(0) is 32
  expect celsius_to_fahrenheit(100) is 212
end

test "dividing by zero is refused"
  try
    safe_divide(1, 0)
    expect false, "it should have thrown"
  catch e
    expect e.kind is "MathError"
  end
end

#  $ she test
#  ok    converts freezing and boiling
#  ok    dividing by zero is refused
#  2 passed, 0 failed, 2 total