1:  type Vector<'a> = VectorC of 'a * 'a * 'a 

This line defines an algebraic data type. The type keyword introduces a type (named Vector<'a>) and one single constructor called VectorC. In class notation this looks like:

  1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28:  public class Vector { private T e1, e2, e3; private Vector(T e1, T e2, T e3) { this.e1 = e1; this.e2 = e2; this.e3 = e3; } public override Equals(object other) { Vector x = other as Vector; if(x == null) return false; return x.e1 == e1 && x.e2 == e2 && x.e3 == e3; } public override GetHashCode() { return CombineHash(e1,e2,e3); } public T E1 { get { return e1; } } public T E2 { get { return e2; } } public T E3 { get { return e3; } } public static Vector VectorC(T e1, T e2, T e3) { return Vector(e1,e2,e3); } } 

Algebraic data types have no identity, i.e. the only way to compare them is by using their value. There is no built in way to modify values. Algebraic data types come in two favors: Product and Sum types.

 1: 2: 3: 4:  type Maybe<'a> = Nothing | Just of 'a type MyTuple<'a,'b> = MyTuple of 'a * 'b 

Maybe<'a> is a sum type. In F# we call it discriminated union. Other frequently used names are variant or tagged union. MyTuple<'a,'b> is a product type. The cross product of its parts is the set of inhabited values. In F# product types are special discriminated unions with only one single variant.

Please note that abstract data types are something completly different. Abstract data types describe abstract programming interfaces and (possibly) properties thereof.

As copy from wikipedia consider imperative abstract variables (simplest non-trivial abstract data type (ADT)): An abstract variable V is a mutable entity that admits two operations:

• store(V,x) where x is a value of unspecified nature; and
• fetch(V), that yields a value; with the constraint that
• fetch(V) always returns the value x used in the most recent store(V,x) operation on the same variable V.
union case Vector.VectorC: 'a * 'a * 'a -> Vector<'a>
type Maybe<'a> =
| Nothing
| Just of 'a

Full name: Concepts-and-names.Maybe<_>
union case Maybe.Nothing: Maybe<'a>
union case Maybe.Just: 'a -> Maybe<'a>
Multiple items
union case MyTuple.MyTuple: 'a * 'b -> MyTuple<'a,'b>

--------------------
type MyTuple<'a,'b> = | MyTuple of 'a * 'b

Full name: Concepts-and-names.MyTuple<_,_>