F#:

type 'a 'b optfun =
  | Konst of 'b
  | Fun of ('a -> 'b)

...
let x = Konst 0

C#:

abstract public class OptFun {
    public sealed class Konst {
        B Value {get; private set;}
        public Konst(B value) { Value = value; }
    }
    public sealed class Fun {
        Func Func {get; private set;}
        public Konst(Func func) { Func = func; }
    }

// You get to implement your own Equals, ==, !=, GetHashCode, comparison (not in this case)
// again, once you want to pattern match on two values, you are in trouble.
}

...
OptFun x = new OptFun.Konst(0)
// or at best
var x = OptFun.Konst(0)

First of all. Thanks very much for your useful post.

I just came across your blog and wanted to drop you a note telling you how impressed I

was with the information you have posted here.

Please let me introduce you some info related to this post and I hope that it is useful

for .Net community.

There is a good C# resource site, Have alook

http://www.csharptalk.com

simi

let rec zip la lb =
match (la, lb) with
| (ha::ta), (hb::tb) -> (ha, hb) :: (zipWith func ta tb)
| _ -> []

Pattern matching on one argument can look nice in C# (not as nice as in F#, IMHO), but on several arguments at once you are going to have a problem.

The closest I can come up with is (FList is a functional list class):

FList<Tuple<A>> Zip<A>(FList<A> la, FList<B> lb)
{
return la.Match(() => FList<Tuple<A>>.Empty,
(ha, ta) => lb.Match(() => FList<Tuple<A>>.Empty,
(hb, tb) => Tuple.New(ha, hb).Cons(Zip(la, lb))));
}

which looks _a lot_ worse to me. And this is a very simple pattern match…

Full type inference.

I’d add first-class events, but Reactive Framework will be available for all languages, so I won’t.