The following mostly applies to strict typing mode which can be enabled by putting

_pragma_ {strictTyping: true}

at the beginning of modules.

Overview

TYPES

• null (bottom type for data)
  • value: null
  • type: null
• any (top type)
  • value: n/a (every value is any)
  • type: any
  • warning: do not use any in your own code as the typing rules are tweaked for certain purposes
• bool
  • values: false, true
  • type: bool
• number
  • values: integers and floats
  • type: number
• string
  • values: string literals
  • type: string
• word
  • values: all of number and string
  • type: word
• data
  • values: all of null, bool, number, and string, and any tuple, array, record or map where the elements are also data
  • type: data
  • specialty: data is the type of serializable values. The compiler includes a comfy mechanism that casts data to any smaller type without having to add code for that (at the price of getting a compiler warning)
• tuple
  • values: like [ element1, element2, element3 ]
  • type: like [ string, number, bool -> string ]
  • access:
    • with pattern: let [fst, snd] = pair (preferred)
    • projection: pair[#0 of 2] (index 0 of a 2-tuple)
• labeled tuple
  • values: like [ #name: "Tom", #age: 28 ]:person
  • type: like [ #name: string, #age: number ]
  • access:
    • projection: person[#name] (index corresponding to the name label)
• array
  • values: like [ element1, element2, element3 ]:array
  • type: like array(string)
  • access: like a[i]
  • test for membership: like a[i]? (results in a bool)
• record
  • values: like { field1: element1, field2: element2 }
  • type: like { field1: number, field2: bool -> string }
  • access: like rec.field1 or rec."field1" (but not the form rec.(expr))
• map
  • values: any record can be upcast to a map, also immediately like { field1:10, field2:20 }:map
  • type: like map(number)
  • access: like m.(key)
  • test for membership: like m.(key)? (results in a bool)

UNDEFINED

The undefined value is element of all types.