Builtin types
=============

Here is the list of types defined in Antilisp: ::

    type  ; the parent type of all builtin types
    integer
    string
    dictionary  ; string->value hashmaps
    env  ; represent variable scopes
    symbol  ; variable identifiers, found in code when metaprogramming
    cell  ; cons cells, used for lists
    bool  ; booleans
    function
    class



The empty list, nil, also has a type, but its type is not bound to a global name: ::

    (print (repr (get-type nil)))
    ; <type nil-type>

Dictionaries work like Python dicts, but they can only store string keys: ::

    (define d (dict))
    (set (at d "key") "value")
    (has-key d "key")  # true
    (at d "key")  # "value"
    (list-keys d)  # ("key")



Environments use symbols as keys, and can have a parent scope: ::

    (let x 4
    (print (repr current-scope)))

    (env
    (env ...)
    x 5)


Cons cells are used to build lists from the empty list nil: ::


    (cons 1 nil)  # (1)
    (list 1)  # also (1)



Note: In Lisp, ' (or (quote)) is used to use code as a value without executing it: ::


    (cons 1 nil)  # (1)
    '(print x) # (print x)



It is common practice to describe lists with it: ::


    '(1)  # also (1)
    (quote (1)) # (1) again



Symbols are variable identifiers. Since code is data, symbols are needed to represent variable names in code. However, you can also use them as a simple way to send and process messages without declaring an enumeration: ::


    (if (= direction 'left)
      'right
      'left)



Functions are also values and can be set with anonymous function objects: ::


    (define f (fn (x)
                (print x)))
    (f 5)  # prints 5