Among the set of built-in types, exception type (exn) is manipulated by handle and raise expressions defined in section 19.14. There is no primitive functions for the unit type (unit). All the other built-in types are manipulated by built-in primitive functions through function application.

Values of built-in types other than reference type (’a ref) and array types (’a array) are ordinary values in a standard functional language semantics, and their built-in primitive functions are those that take values and return values.

Values of reference types (’a ref) and array types (’a array) are pointers to mutable memory blocks, and their built-in primitive function may have side effect of destructive memory update.

For values of type $\mathrm{⟨}$ty$\mathrm{⟩}$ ref, the following built-in primitive functions are provided.

ref : $\mathrm{⟨}$ty$\mathrm{⟩}$ -> $\mathrm{⟨}$ty$\mathrm{⟩}$ ref
  ! : $\mathrm{⟨}$ty$\mathrm{⟩}$ ref -> $\mathrm{⟨}$ty$\mathrm{⟩}$
 := : $\mathrm{⟨}$ty$\mathrm{⟩}$ ref * $\mathrm{⟨}$ty$\mathrm{⟩}$ -> unit
infix 3 :=

ref $⟨$exp$\mathrm{⟩}$ creates a reference, i.e. a pointer to a memory block containing a value denoted by $⟨$exp$\mathrm{⟩}$. ! $⟨$exp$\mathrm{⟩}$ dereferences the pointer and return the stored value. $\mathrm{⟨}$exp$\mathrm{⟩}$${}_{\mathrm{1}}$ := $\mathrm{⟨}$exp$\mathrm{⟩}$${}_{\mathrm{2}}$ destructively updates the memory block pointed to by the denotation of $⟨$exp$\mathrm{⟩}$${}_{\mathrm{1}}$ with the value denoted by $⟨$exp$\mathrm{⟩}$${}_{\mathrm{2}}$.

The built-in primitive functions for any other types, including $\mathrm{⟨}$ty$\mathrm{⟩}$ array, are provided by the following structures of the library defined in Chapter 25. General structure includes the reference primitives and defines exceptions that may raised by built-in primitives.

The set of built-in primitive functions for a built-in type can be displayed by evaluating a structure replication declaration of the structure that implements the built-in type, as seen in the following example.

# structure X = Int;
structure X =
  struct
    type int = Int32.int
    val * = <builtin> : int * int -> int
    val + = <builtin> : int * int -> int
    val - = <builtin> : int * int -> int
    val < = <builtin> : int * int -> bool
    val <= = <builtin> : int * int -> bool
    val > = <builtin> : int * int -> bool
    val >= = <builtin> : int * int -> bool
    val abs = <builtin> : int -> int
    val compare = fn : int * int -> General.order
    val div = <builtin> : int * int -> int
    val fmt = fn : StringCvt.radix -> int -> string
    val fromInt = fn : int -> int
    val fromLarge = fn : intInf -> int
    val fromString = fn : string -> int option
    val max = fn : int * int -> int
    val maxInt = SOME 2147483647 : int option
    val min = fn : int * int -> int
    val minInt = SOME  2147483648 : int option
    val mod = <builtin> : int * int -> int
    val precision = SOME 32 : int option
    val quot = <builtin> : int * int -> int
    val rem = <builtin> : int * int -> int
    val sameSign = fn : int * int -> bool
    val scan = fn
      : [’a. StringCvt.radix
          -> (’a -> (char * ’a) option) -> ’a -> (int * ’a) option]
    val sign = fn : int -> int
    val toInt = fn : int -> int
    val toLarge = fn : int -> intInf
    val toString = fn : int -> string
    val ~ = <builtin> : int -> int
  end