プログラム中では、多相バリアントは通常のバリアントと同じように使えます。ただし、名前の前にバッククオート（`）をつける必要があります。

#[`On; `Off];;
- : [> `Off | `On] list = [`On; `Off]

#`Number 1;;
- : [> `Number of int] = `Number 1

#let f = function `On -> 1 | `Off -> 0 | `Number n -> n;;
val f : [< `Number of int | `Off | `On] -> int = <fun>

#List.map f [`On; `Off];;
- : int list = [1; 0]
      

[>`Off|`On] list は、すくなくとも `Off と `On にマッチするもののリストを意味します（`Off、 `On ともに引数なし）。 [<`On|`Off|`Number of int] は、 f が `Off、 `On（ともに引数なし）、もしくは `Number n（n は int）を受け取ることを意味します。バリアントの型の中の > と < は、これらの型がタグを増やしたり減らしたりといった変更が可能なことを示しています。そのようなものは、暗黙の型変数を含んでいます。どちらのバリアント型も型中で一度しか現れないので、暗黙の型変数は表示されません。

上記のバリアント型は多相的で、変更が可能です。型注釈を書く場合には固定バリアント型、すなわち変更できない型として書かれることがほとんどでしょう。これは型の略記形^[3]でも同様です。そのような型は > や < を含まず、通常のデータ型の記述と同様に単にタグと関連した型を並べてあるだけです。

#type 'a vlist = [`Nil | `Cons of 'a * 'a vlist];;
type 'a vlist = [ `Cons of 'a * 'a vlist | `Nil]

#let rec map f : 'a vlist -> 'b vlist = function
   | `Nil -> `Nil
   | `Cons(a, l) -> `Cons(f a, map f l)
 ;;
val map : ('a -> 'b) -> 'a vlist -> 'b vlist = <fun>
      

多相バリアントの型チェックは微妙なもので、型情報が通常よりも複雑になってしまう式も存在します。

#let f = function `A -> `C | `B -> `D | x -> x;;
val f : ([> `A | `B | `C | `D] as 'a) -> 'a = <fun>

#f `E;;
- : _[> `A | `B | `C | `D | `E] = `E
      

ここではふたつのことが起こっています。 まずこのパターンマッチは開いているので（最後の場合ですべてのタグを捕まえています）、型は、閉じた [< `A | `B] ではなく [> `A | `B] になります。 それから、 x がそのまま返るので、入力の型と戻り値の型は同一です。 'a という表記はその共有を表しているのです。 f をまた別のタグ `E に適用すると、それがまたリストに追加されます。

#let f1 = function `A x -> x = 1 | `B -> true | `C -> false
 let f2 = function `A x -> x = "a" | `B -> true ;;
val f1 : [< `A of int | `B | `C] -> bool = <fun>
val f2 : [< `A of string | `B] -> bool = <fun>

#let f x = f1 x && f2 x;;
val f : [< `A of string & int | `B] -> bool = <fun>
      

ここでは f1 と f2 はどちらもバリアントタグ `A と `B を受け取りますが、 `A の引数は f1 では int で f2 では string です。 f の型には、 f1 だけが受け取る `C は現れず、 `A の引数型には int & string と両方が現れています。 これはすなわち、バリアントタグ `A を f に渡す場合には、 `A の引数は int と string の両方でなければならないということです。 このような値は存在しないため、 f は `A には適用できず、 `B だけが入力として与えられるということになります。

ある値の型が固定的なバリアントであっても、型変換によって、それをより大きな型にすることもできます。 型変換は通常、変換元の型と変換先の型の両方を指定しなければなりませんが、単純な場合には元の型を省略することができます。

#type 'a wlist = [`Nil | `Cons of 'a * 'a wlist | `Snoc of 'a wlist * 'a];;
type 'a wlist = [ `Cons of 'a * 'a wlist | `Nil | `Snoc of 'a wlist * 'a]

#let wlist_of_vlist  l = (l : 'a vlist :> 'a wlist);;
val wlist_of_vlist : 'a vlist -> 'a wlist = <fun>

#let open_vlist l = (l : 'a vlist :> [> 'a vlist]);;
val open_vlist : 'a vlist -> [> 'a vlist] = <fun>

#fun x -> (x :> [`A|`B|`C]);;
- : [< `A | `B | `C] -> [ `A | `B | `C] = <fun>
      

パターンマッチを使って値を選択的に型変換することもできます。

#let split_cases = function
   | `Nil | `Cons _ as x -> `A x
   | `Snoc _ as x -> `B x
 ;;
val split_cases :
  [< `Cons of 'a | `Nil | `Snoc of 'b] ->
  [> `A of [> `Cons of 'a | `Nil] | `B of [> `Snoc of 'b]] = <fun>
      

バリアントタグを組み合わせた or パターンが alias パターンの中に現れた場合には、その alias には or パターンで列挙されたタグだけを含む型がつけられます。 これによって、関数の漸次定義などの便利なイディオムが実現できます。

#let num x = `Num x
 let eval1 eval (`Num x) = x
 let rec eval x = eval1 eval x ;;
val num : 'a -> [> `Num of 'a] = <fun>
val eval1 : 'a -> [ `Num of 'b] -> 'b = <fun>
val eval : [ `Num of 'a] -> 'a = <fun>

#let plus x y = `Plus(x,y)
 let eval2 eval = function
   | `Plus(x,y) -> eval x + eval y
   | `Num _ as x -> eval1 eval x
 let rec eval x = eval2 eval x ;;
val plus : 'a -> 'b -> [> `Plus of 'a * 'b] = <fun>
val eval2 : ('a -> int) -> [< `Num of int | `Plus of 'a * 'a] -> int = <fun>
val eval : ([< `Num of int | `Plus of 'a * 'a] as 'a) -> int = <fun>
      

これをもっと便利に使うために、型定義を or パターンの略記として使うこともできます。 すなわち、 type myvariant = [`Tag1 int | `Tag2 bool] を定義すると、 #myvariant というパターンは (`Tag1(_ : int) | `Tag2(_ : bool)) と書いたのと等価になります。

このような略記を単独で使うこともできますし、

#let f = function
   | #myvariant -> "myvariant"
   | `Tag3 -> "Tag3";;
val f : [< `Tag1 of int | `Tag2 of bool | `Tag3] -> string = <fun>
      

alias と組み合わせることもできます。

#let g1 = function `Tag1 _ -> "Tag1" | `Tag2 _ -> "Tag2";;
val g1 : [< `Tag1 of 'a | `Tag2 of 'b] -> string = <fun>

#let g = function
   | #myvariant as x -> g1 x
   | `Tag3 -> "Tag3";;
val g : [< `Tag1 of int | `Tag2 of bool | `Tag3] -> string = <fun>
      

#type abc = [`A | `B | `C] ;;
type abc = [ `A | `B | `C]

#let f = function
   | `As -> "A"
   | #abc -> "other" ;;
val f : [< `A | `As | `B | `C] -> string = <fun>

#let f : abc -> string = f ;;
val f : abc -> string = <fun>
      

#let f : abc -> string = function
   | `As -> "A"
   | #abc -> "other" ;;
Warning: this match case is unused.
val f : abc -> string = <fun>