# Define a record with typed fields.
deftype Point %{
    :x %{:type :number}
    :y %{:type :number}
}

# Construct by tagged-map literal.
set p %Point{ :x 3 :y 4 }

# Attach behaviour via a protocol.
defprotocol Drawable %{ draw {ctx bounds} }

defimpl Point Drawable {
    draw {|ctx bounds|
        @doc "Draw an asterisk at the point's coordinates."
        [draw/cell $ctx $self~x $self~y "*"]
    }
}

# Or define a standalone method via defmethod.
defmethod Point magnitude {|| [math/sqrt (($self~x * $self~x) + ($self~y * $self~y))] }

echo [$p magnitude]                  # => 5 

 deftype User %{
    :name     %{:type :string  :required true}
    :email    %{:type :string}
    :age      %{:type :number  :default 0}
    :roles    %{:type :list    :default @{}}
    :active   %{:type :boolean :default true}
} 

 set alice %User{
    :name "Alice"
    :email "alice@example.com"
    :roles ^{:admin :user}
} 

 echo $alice~name             # => Alice
echo $alice~roles            # => ^{:admin :user} 

 [is? "User" $alice]                          # => true
[type $alice]                                # => User 

 deftype User %{
    :first  %{:type :string  :required true}
    :last   %{:type :string  :required true}
    :dept   %{:type :string  :default "accounts"}
    :active %{:type :boolean :default true}
}

set u [User --first "Alice" --last "Smith"]
echo $u~first              # => Alice
echo $u~dept               # => accounts   (default applied)
echo $u~active             # => true       (default applied)

set v [User --first "Bob" --last "Lee" --dept "eng"]
echo $v~dept               # => eng        (overridden) 

 [User --first "a" --last "b" --bogus "x"]   # ✗ unknown field '--bogus'
[User --first "only"]                       # ✗ missing required ':last'
[User "posfirst" --last "poslast"]          # ✗ positional args rejected in kwarg mode
[Toggle --admin]                            # ✓ boolean shortcut → admin=true
[Toggle --admin false --disabled true]      # ✓ explicit boolean values 

 deftype DeployOpts %{
    :replicas %{:type :number  :default 1}
    :dry-run  %{:type :boolean :default false}
}

def deploy {|app^string opts^DeployOpts|
    echo "deploying $app with $opts~replicas replicas"
}

deploy "billing" --replicas 5 --dry-run
# opts is built as if by: %DeployOpts{ :replicas 5 :dry-run true } 

 deftype Animal %{
    :name %{:type :string}
}

deftype Dog << Animal %{
    :breed %{:type :string}
}

set rex %Dog{ :name "Rex" :breed "Malinois" }
echo $rex~name               # => Rex 

 defprotocol Drawable %{
    draw {ctx bounds}
}

defprotocol Measurable %{
    measure {}
    natural-height {}
}

defprotocol Focusable %{
    accepts-focus? {}
    on-focus {}
    on-blur {}
} 

 defprotocol Gridable %{
    row-count {}
    col-count {}
    cell {row col value opts^CellOpts}
} 

 defprotocol Keyable %{ on-key {event bounds} }

defimpl MyWidget Keyable {
    on-key {|event bounds| ... }     # ✓ matches spec
    onkey {|event bounds| ... }      # ⚠ warned — not in spec
} 

 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 } }
    natural-height {|| 1 }
} 

 def p %Point{ :x 3 :y 4 }
[draw $p $ctx $bounds]                  # routes to Point's draw method
[$p measure]                            # also works (postfix-style) 

 defimpl MyWidget [Drawable Keyable] {
    draw {|ctx bounds| ... }
    on-key {|event bounds| ... }
} 

 defmethod Point magnitude {|| [math/sqrt (($self~x * $self~x) + ($self~y * $self~y))] }
defmethod Point describe {|| "Point($self~x, $self~y)" } 

 def p %Point{ :x 3 :y 4 }
[satisfies? $p "Drawable"]              # => true
[satisfies? $p "Measurable"]            # => true (if defined)
[satisfies? $p "Container"]             # => false 

 set ok-result %Ok{ :value 42 }
set err-result %Err{ :message "broken" }

[is? "Ok" $ok-result]                   # => true
[type $ok-result]                       # => Ok

match $result {
    %Ok{ :value $v }   => $v
    %Err{ :message $m} => [throw $m]
} 

 [tag $somemap :Foo]                     # add or change a tag
[untag $foo-map]                        # strip the tag 

 [type 42]                # => "number"
[type "hi"]              # => "string"
[type @{ 1 2 }]          # => "list"
[type %Point{...}]       # => "Point"

[is? "number" 42]        # => true — type name as a STRING
[is? "Point" $p]         # => true
[nil? $x]                # => true if $x is nil
[empty? $xs]             # => true if $xs is empty