C9 Lectures: Dr. Erik Meijer - Functional Programming Fundamentals Chapter 4 of 13

I love currying and partial application and sectioning just elevates that to a higher level of bliss.

It would be great if this expression type-checked in C#: s.Select(1+).

Then about \x -> x vs x |-> x. I must admit the mathematical notation is less noiseful.

In both situations an IDE should automatically transform both symbols into their unicode equivalents.

So even if typing ==, it will be transformed (graphically) to =, possibly colored differently, and remain unambiguous.

It's also funny, because when trying to model boolean expressions in Java back in 2002, it became very obvious to use this approach outlined by Erik. Still, not entirely convinced it's superior to the functional approach but indeed it does provide some abstraction over structure: F# has these Active Patterns which may be a solution to that problem, haven't looked into it. Let me try again, forgot the old implementation...

It's definitely it's something interesting to ponder.

n+k patterns. Not enough data to conclude non-/justification, must search...

public abstract class Bool
{
    public abstract Bool Not();
    public abstract Bool And(Bool _);
    public abstract Bool Or(Bool _);
}
public class False : Bool
{
    private False() { }
    public static readonly Bool A = new False();
    public override Bool Not()
    {
        return True.A;
    }
    public override Bool And(Bool _)
    {
        return this;
    }
    public override Bool Or(Bool that)
    {
        return that;
    }
}
public class True : Bool
{
    private True() {}
    public static readonly Bool A = new True();
    public override Bool Not()
    {
        return False.A;
    }
    public override Bool And(Bool that)
    {
        return that;
    }
    public override Bool Or(Bool _)
    {
        return this;
    }
}
public static class Bools
{
    public static Bool Box(this bool x)
    {
        return x ? True.A : False.A;
    }
    public static bool Unbox(this Bool x)
    {
        return x is True; // unsafe : x == True.A; unless we seal
    }
    public static Bool Andy(this Bool a, Bool b)
    {
        return (a.Unbox() && b.Unbox()).Box();
    }
    public static Bool Ory(this Bool a, Bool b)
    {
        return (a.Unbox() || b.Unbox()).Box();
    }
}

Day.Exit;

Ok that does it. Time to install Emacs.

...It's a fun idea to use a Lisp-based editor to "type" Haskell