Enumerated type unions

Last time, we saw “type declarations:” type name = type-expr

The simplest case that does introduces a new type and values is an enumerated union:
type name = Value1 | Value2 | ... | Value𝓀

For example:

type size = Tall | Grande | Venti

Introduces the new type size, and three values that only belong to the type size: Tall, Grande, Venti.

We can also use type to declare a disjoint union type:

type number = Int of int
  | Real of float
  | Complex of float*float

This declaration introduces new value constructors: Int, Real, and Complex construct new values of type number.

# let x = Int 2 ;;

Functions on disjoint unions

Computing with disjoint unions works similarly to lists and product types:

let abs x = match x with
  | Int n -> float_of_int (abs n)
  | Real r -> abs_float r
  | Complex (r,i) -> sqrt(r*.r +. i*.i)

let rec sum_ints = function
  | [] -> 0
  | (Int n)::t -> n + sum_ints t
  | (Real _)::t | (Complex _)::t -> sum_ints t

Examples

Define real_part, imag_part : number -> float

Polymorphic value constructors

Disjoint unions can also be parametric: e.g. what should imag_part and class_b_subnet do:

let imag_part = function
  | Complex (_,i) -> i
  | Real _ | Int _ -> (* ?? *)

# let imag_part = function
  | Complex (_,i) -> Some i
  | Real _ | Int _ -> None ;;

Examples

class_b_subnet : hostinfo -> (int*int) option

hd_opt : 'a list -> 'a option
tl_opt : 'a list -> 'a list option

list_max_opt : 'a list -> 'a option