let sort list =
    match list with
        | [] -> []
        | x::xs -> List.concat [(List.filter (fun i -> i <= x) xs) ;  [x] ; (List.filter (fun i -> i > x) xs)]

J>let sort list =
J>    match list with
J>        | [] -> []
J>        | x::xs -> List.concat [(List.filter (fun i -> i <= x) xs) ;  [x] ; (List.filter (fun i -> i > x) xs)]
J>

# type 'a t = First of 'a | Second | Third of 'a;;
type 'a t = First of 'a | Second | Third of 'a
# Second < Third 'x';;
- : bool = true
# First 'x' < Third 'x';;
- : bool = true
# First 'x' < Second;;
- : bool = false   (* опа! *)

let inline adder2 x y = x + y

       let inline (+) (x: ^T) (y: ^U) : ^V = 
             AdditionDynamic<(^T),(^U),(^V)>  x y 
             when ^T : int32       and ^U : int32      = (# "add" x y : int32 #)
             when ^T : float       and ^U : float      = (# "add" x y : float #)
             when ^T : float32     and ^U : float32    = (# "add" x y : float32 #)
...
...
             when ^T : ^T = ((^T or ^U): (static member (+) : ^T * ^U -> ^V) (x,y))

#light
#r @"FSharp.PowerPack.dll"
open Microsoft.FSharp.Math.GlobalAssociations

module GenAdder =
  let (+) (a:'a) (b:'a) =
    let v = GetNumericAssociation<'a>()
    v.Add(a,b)

  let add3 (a:'a) (b:'a) (c:'a) =
    a + b + c

> GenAdder.add3 1 2 3;;
val it : int = 6
> GenAdder.add3 1.0 2.0 3.0;;
val it : float = 6.0
> GenAdder.add3 1I 2I 3I;;
val it : bigint = 6I

>> GenAdder.add3 1 2 3;;
M>val it : int = 6
>> GenAdder.add3 1.0 2.0 3.0;;
M>val it : float = 6.0
>> GenAdder.add3 1I 2I 3I;;
M>val it : bigint = 6I
M>

let r3 = add3 "one" "two" "three"
let r4 = add3 (new obj()) (new obj()) (new obj())

type Maybe<'a> = (unit -> 'a option)

let succeed x : Maybe<'a> = fun () -> Some(x)
let fail : Maybe<'a> = fun () -> None
let run (a: Maybe<'a>) = a()
let bind p rest = match run p with None -> fail | Some r -> (rest r)
let delay f = fun () -> run (f ())

type MaybeBuilder() =
  member this.Return(x) = succeed x
  member this.Let(p,rest) = rest p
  member this.Bind(p,rest) = bind p rest
  member this.Delay(f) = delay f

let maybe = new MaybeBuilder()

let add (a:'a) (b:'a) =
  maybe {
    match TryGetNumericAssociation<'a>() with
    | Some v -> return (v.Add(a,b))
    | _ -> return! fail
  }

let add3 (a:'a) (b:'a) (c:'a) =
  maybe {
    let! ab = add a b
    let! abc = add ab c
    return abc
  }

> let r1 = add 1 2;;
val r1 : (unit -> int option)
> r1();;
val it : int option = Some 3
> let r2 = add "1" "2";;
val r2 : (unit -> string option)
> r2();;
val it : string option = None
> let r3 = add3 "one" "two" "three";;
val r3 : (unit -> string option)
> r3();;
val it : string option = None

А>let r3 = add3 "one" "two" "three"
А>let r4 = add3 (new obj()) (new obj()) (new obj())
А>

type 'a Maybe = 'a option

let succeed = Some
let fail = None
let (>>=) p rest =
    match p with
        |Some r -> rest r
        |None -> fail

type MaybeBuilder() =
  member this.Return(x) = succeed x
  member this.Let(p,rest) = rest p
  member this.Bind(p,rest) = p >>= rest
  member this.Delay(f) = f()

let maybe = new MaybeBuilder()
  
let add a b =
  TryGetNumericAssociation<_>()
    >>= fun v -> Some (v.Add(a,b))

let add3 a b c =
  maybe {
    let! ab = add a b
    let! abc = add ab c
    return abc
  }