def greet {|name^string|
    @doc "Print a greeting to stdout."
    echo "Hello, $name!"
}

def magic-number {|| 42 }

greet "world"               # => Hello, world!
echo [magic-number]         # => 42

def fib {|n^number|
    if ($n < 2) { return $n }
    [$fib ($n - 1)] + [$fib ($n - 2)]
}

echo [fib 10]               # => 55

def add       {|a b|        ($a + $b) }
def add-also  {|a, b|       ($a + $b) }
def variadic  {|first @rest| $rest }       # variadic via @

def sum-all {|@nums|
    @doc "Sum any number of arguments."
    reduce $nums 0 { ($acc + $it) }
}

echo [sum-all 1 2 3 4]      # => 10

def greet {|name="World"| echo "Hello, $name!" }
greet                # => Hello, World!
greet "Alice"        # => Hello, Alice!

def distance {|p^Point|
    [math/sqrt (($p~x * $p~x) + ($p~y * $p~y))]
}

def greet {|name^string count^number|
    for i [range $count] {
        echo "Hello, $name!"
    }
}

deftype User %{
    :name %{:type :string :required true}
    :email %{:type :string}
    :age %{:type :number}
}

def display {|u^User| echo "$u~name <$u~email>" }

def alice %User{ :name "Alice" :email "alice@example.com" :age 30 }
display $alice

def greet {|name^string| echo "Hello, $name!" }

greet "Alice"     # ✓
greet 42          # ✗ Error: type error in 'greet': parameter 'name' expected string, got number

def flexible {|typed^string untyped|
    # $typed is validated at call time
    # $untyped can be anything
}

set name^string "Alice"
set count^number 42
set user^User [create-user "Bob"]

def fetch-user^string {|id^string|
    # ...
}
}

deftype BuildOpts %{
    :push    %{:type :boolean :default false}
    :nocache %{:type :boolean :default false}
    :tag     %{:type :string}
}

def build {|service^string opts^BuildOpts|
    echo "building $service"
    if $opts~push    { echo "  will push" }
    if $opts~nocache { echo "  no cache" }
    if ($opts~?tag)  { echo "  tag: $opts~tag" }
}

build "myapp" --push --tag latest       # => building myapp / will push / tag: latest
build "myapp" --nocache                 # => building myapp / no cache
build "myapp"                          # => building myapp   (opts omitted entirely)

if $opts~push { ... }                 # bool field — false if defaulted
if ($opts~?tag) != nil { ... }        # was --tag passed at all?

def deploy {|app^string env^string opts^DeployOpts|
    # ...
}

deploy "billing" "prod" --replicas 5 --dry-run

# ✗ invalid — deftype parameter is not last
def broken {|opts^Opts app^string| ... }

def square {|x| ($x * $x) }
set also-square {|x| ($x * $x) }       # assign closure to a variable

[map $xs { ($it * 2) }]                # implicit $it param
[map $xs { |x| ($x * 2) }]             # explicit param

@{ 1 2 3 } |> map { $it * 2 }          # $it is 1, then 2, then 3
$xs |> filter { ($it % 2) == 0 }

@{ 1 2 3 } |> reduce 0 { |acc x| ($acc + $x) }

def counter {||
    set count 0
    {||
        incr count
        $count
    
    }
}

set bump $counter
echo [$bump]                # => 1
echo [$bump]                # => 2

def range {
    {|n| [range 0 $n] }
    {|start end| [range $start $end] }
}

[range 5]                   # => @{0 1 2 3 4}
[range 2 5]                 # => @{2 3 4}

def distance {|p^Point|
    @doc "Euclidean distance from origin."
    @returns :number
    [math/sqrt (($p~x * $p~x) + ($p~y * $p~y))]
}

def old-helper {|x|
    @doc "Use `helper` instead."
    @deprecated true
    @since "0.3.0"
    # ...
}

echo [meta $distance "doc"]               # => "Euclidean distance from origin."
echo [meta $distance "returns"]           # => :number

def greet {|name^string times^number|
    @doc "Print a greeting N times."
    @name "The user's name (required)."
    @times "How many times to print (defaults to 1)."
    for i [range $times] { echo "Hello, $name!" }
}

echo [info/sig "greet"]
# => greet(name^string, times^number) | Print a greeting N times.

def handler {|req|
    @doc "Handle an HTTP request."
    @auth-required true
    @category :experimental
    @since 3
    @tags @{"v1" "stable"}
    @config %{ :timeout 30 :retries 3 }
    # ...
}

echo [meta $handler "auth-required"]      # => true
echo [meta $handler "since"]              # => 3
echo [meta $handler "tags"](0)            # => "v1"
echo [meta $handler "config"]~timeout     # => 30

echo [info/props $handler]                # => full metadata map

def cmd-open-file {|path^string|
    @rpc true
    @doc "Open a file in this editor panel."
    # ...
}

def fetch-data {|url^string|
    @async
    @doc "Fetch a URL concurrently; resolves to the response body."
    set resp [await [http/get $url]]
    return $resp~body
}

set fut [fetch-data "https://api.example.com/data"]
echo $fut                          # => <future:pending>

set body [await $fut]              # suspends the current coroutine until done
echo $body

def aggregate {|urls^list|
    @async
    set bodies @{}
    each { |u|
        $bodies << [await [fetch-data $u]]      # sequential awaits
    } $urls
    $bodies
}

def risky {|x^number|
    @async
    if ($x == 0) { [throw "div by zero"] }
    ($x / $x)
}

try {
    [await [risky 0]]               # re-throws here, not at [risky 0]
} catch e {
    echo "caught: $e"
}

def range-from {|start^number|
    @generator
    @doc "Yield start, start+1, start+2, ..."
    set n $start
    while true {
        yield $n
        incr n
    }
}

set g [range-from 5]           # => <coroutine> — body hasn't run yet
[coro-state $g]                # => :ready

[next $g]                      # => 5
[next $g]                      # => 6
[resume $g]                    # => 7   (resume and next are the same)

def double {|x| ($x * 2) }

[map $xs $double]                          # pass function value
[map $xs double]                            # bare name also works
[apply $double @{5}]                       # => 10

def lookup %{ :name "Alice" :role :admin }
echo [$lookup :name]                       # => Alice — map called with key

def users %{ :alice %{ :role :admin } :bob %{ :role :user } }
echo [$users :alice]                       # => %{ :role :admin }

echo [:name $lookup]                       # => Alice — keyword called on map

def add {|a b| ($a + $b) }

set inc [curry $add 1]            # fix the first arg
echo [$inc 41]                    # => 42  (calls add 1 41)

set ten [curry $add 10]
echo [$ten 5]                     # => 15

set greet-bob [curry "greet" "Bob"]
$greet-bob                        # calls (greet "Bob")

def count-down {|n^number|
    echo $n
    if ($n > 0) { count-down ($n - 1) }
}

count-down 1000000                  # does not overflow

deftype Point %{ :x %{} :y %{} }

defimpl Point Drawable {
    draw {|ctx bounds| [draw/cell $ctx $self~x $self~y "*"] }
}

defimpl Point Measurable {
    measure {|| %{ :w 1 :h 1 } }
}