This is a standard type of integers. In SML#, a value of int is a two’s compliment integer and is the same as long in C. Constants of int are written either the usual decimal notation or hexadecimal notation of the form 0x$\mathrm{⟨}$h$\mathrm{⟩}$ where $⟨$h$\mathrm{⟩}$ is a sequence of digits from 0 to 9 and letters from a(or A) to f(or F). A negative constant is written with ~. SML# prints int values in decimal notation.

# 10;
val it = 10 : int
# 0xA;
val it = 10 : int
# ~0xFF;
val it = ~255 : int

Binary arithmetic operations +, -, *, div are defined on int.

# 10 + 0xA;
val it = 20 : int
# 0 - 0xA;
val it = ~10 : int
# 10 div 2;
val it = 5 : int
# 10 * 2;
val it = 20 : int

As in arithmetic expressions in mathematics, *,div associate stronger than +, -, and operators of the same strength are computed from left to right.

# 1 + 2 * 3;
val it = 7 : int
# 4 - 3 - 2;
val it = ~1 : int

real is a type of floating point data. In SML#, a value of real is a 64 bit double precision floating point numbers and is the same as double in C. real constants are written in the notation $\mathrm{⟨}$s$\mathrm{⟩}$.$\mathrm{⟨}$d$\mathrm{⟩}$E$\mathrm{⟨}$s$\mathrm{⟩}$, where $⟨$s$\mathrm{⟩}$ is a decimal string possibly with the negation symbol and $⟨$d$\mathrm{⟩}$ is a decimal string. Each of the three parts can be omitted, but decimal string is interpreted as a value of int.

# 10.0;
val it = 10.0 : real
# 1E2;
val it = 100.0 : real
# 0.001;
val it = 0.001 : real
# ~1E~2;
val it = ~0.01 : real
# 10;
val it = 10 : int

Binary arithmetic operators +, -, *, / are defined for real. Note that the division operator on real is / and not div.

# 10.0 + 1E1;
val it = 20.0 : real
# 0.0 - 10.0;
val it = ~10.0 : real
# 10.0 / 2.0;
val it = 5.0 : real
# 10.0 * 2.0;
val it = 20.0 : real

char is a type for one character data. A constant for a character $⟨$c$\mathrm{⟩}$ is written as #"$\mathrm{⟨}$c$\mathrm{⟩}$". $⟨$c$\mathrm{⟩}$ may be any printable character or one of the following special escape sequences.

# #"a";
val it = #"a" : char
# #"\n";
val it = #"\n" : char

The following primitive functions are defined on char.

val chr : int -> char
val ord : char -> int

chr $n$ assumes that $n$ is an ASCII code and returns the character of that code. ord $c$ returns the ASCII code of $c$.

# ord #"a";
val it = 97 : int
# chr(97 + 7);
val it = #"h" : char
# ord #"a" - ord #"A";
val it = 32 : int
# chr(ord #"H" + 32);
val it = #"h" : char

string is a type for character strings. string constants are written with " and ". A string constant may contain escape sequences shown above. For string data, a print function print and a concatenation binary operator ^ are defined.

# "SML#" ^ "\n";
val it = "SML#\n" : string
# print it;
SML#
val it = () : unit

word is a type for unsigned integers. word constants are written as 0w$\mathrm{⟨}$d$\mathrm{⟩}$ or 0wx$\mathrm{⟨}$h$\mathrm{⟩}$ where $⟨$d$\mathrm{⟩}$ is a decimal digit sequence and $⟨$h$\mathrm{⟩}$ is a hexadecimal digit sequence. SML# prints word data in a hexadecimal notation.

# 0w10;
val it = 0wxa : word
# 0wxA;
val it = 0wxa : word