An exemple ? It’s safe to have a method returning a cat when you expect it to return an animal.

In C sharp it’s

public class Animal
{
}
 
public class Cat : Animal
{
}
 
public class Dog : Animal
{
}
 
// It's safe to say that something returns a Animal when in fact this thing returns a Cat
class Covariance
{
	void test()
	{
		Func<Animal> a = Method; // OK
		Func<Animal> b = delegate { return new Cat(); }; // OK
		Func<Animal> c = () => new Cat(); // OK
	}
 
	Cat Method()
	{
		return new Cat();
	}
}

So Funcs a, b, and c are returning animals which in fact are cats, which is true.

And, what is contravariance ?
Contravariance is basically using a method which takes something which is a parent of the expected type.
An exemple ? It’s safe to have a method taking an animal when you expect it to take a cat

// It's safe to say that something can take a Cat if in fact this thing can take any Animal
class Contravariance
{
	static void test()
	{
		Action<Cat> a = Method; // OK
		Action<Cat> b = delegate(Animal value) { }; // ERROR
		// From C#3 Specification :
		// $7.14.1 Anonymous function signatures :
		// [...] contra-variance of anonymous function parameter types is not supported.
		Action<Cat> d = (Animal value) => { }; // idem... anonymous... not supported.
	}
 
	public static void Method(Animal value)
	{
	}
}

So Action a take Cats, but in fact can take any Animals, so it’s safe.

As i’m speaking to developers, i’ll use the C# Lambda syntax which is :
(parameter) => statement

Let’s now try our first Combinator, named the Identity Combinator
I = (a) => a;
I named it I, it takes one parameter, localy named ‘a’ and return the parameter as is.

Important Point : How to build combinator taking more than one parameter ?
In C# you should use (a, b, c) => blah blah… but the Rule 4 forbid us to give more than one paraneter, so let’s cheat, imagine :
K = (x) => (y) => x;
K is a Combinator taking x, returning a Combinator taking y and returning x.
so we have K(x) = (y) => x and K(x)(y) = x !
So K take two arguments, x and y, and returns x, but ! K can take only one argument, look at the “K(x) = (y) => x” …

Let’s try with three arguments :

S = (x) => (y) => (z) => x(z)(y(z))
can be called with one, two, or three arguments :
S(x) returns (y) => (z) => x(z)(y(z))
S(x)(y) returns (z) => x(z)(y(z))
s(x)(y)(z) returns x(z)(y(z))

In combinatory logic, they wrote :
I a = a
K x y = x
S x y z = x(z)(y(z))

then they say that in fact, I can be build from S and K :
I = SKK
Ok but what does it means ? where are arguments ? it’s easy :

I = S(K)(K);
S can take 2 parameters “S(x)(y) returns (z) => x(z)(y(z))” ok ? so :
I = (z) => K(z)(K(z))
We have to execute it from left to right, remember, K(a)(b) returns a, so (with a == z and b == K(z)) :
I = (z) => z;

Do you want more ?

Let’s try to understand
B = S (K S) K x y z
B stands for Barbara, from “Syllogism Barbara” (wikipedia says :)
Barbara :
All men are animals.
All animals are mortal.
All men are mortal.

So before all, write B as we understand it, and for readability reasons, i’ll underline parameters for the bolded combinator :
B = S (K(S)) K (x) (y) (z)
We have to execute it from left to right, and we have a S with three parameters :
S(a)(b)(c) returns a(c)(b(c)) :
B = K (S) (x) (K(x)) (y) (z)
From left to right we have a K with two parameters, S and y, it will return S :
B = S (K(x)) (y) (z)
Calling S with three parameters (K(x)), (y), (z) returns (K(x))(z)((y)(z)) :
B = K (x) (z) ((y)(z))
Calling K with two parameters (x), (z), it returns x :
B = x((y)(z))
Which can be simplified to :
B = x(y(z))

It’s time to try it !

 
delegate C C(C c);
static void Main(string[] args)
{
	C K = (a) => (b) => a;
	C S = (a) => (b) => (c) => a(c)(b(c));
	C I = S(K)(K);
	C B = S(K(S))(K);
}

It works ! Enjoy ! ! Next time, we will try a Swap combinator, a Combinator reducing to himself and progressing step to the Y Combinator !
[dramatic chord]

So we have to remove the A’s reference in the B ctor.
How B should communicate now ?
– Using Events !
B exposes an event, the builder of B can register on it.
– B can speak to A throwing this event.
– Every class can build a B, and can, if it needs, register on its events, doing whatever he wants when the event is thrown.
B is now fully reusable !

Let’s try to raise an event with reflection …

Firstly, let’s search, but not in GetEvent, in GetField :
Type.GetField(String, BindingFlags)
String is the name of the field to get and BindingFlags a bitmask of serarching flags.

Note : To use reflexion, use “System.Reflection”

Let’s try a GetField :

FieldInfo my_event_FieldInfo = this.GetType().GetField("my_event",
                                                       BindingFlags.NonPublic
                                                       | BindingFlags.Instance);

Yeah ! it’s not null ! we have now the FieldInfo of our event.
What to do now ? in a FieldInfo, we do not have something like “Fire the event”, huh
But what about “GetValue” ? The “Value” of a “FieldInfo” is the field, so the Value of an event’s FieldInfo isn’t the Event ?
FieldInfo.GetValue(object)
let’s try :

object my_event_by_reflection = my_event_FieldInfo.GetValue(this);

Is null … ):
Ohhhh but, while not registered, an event is null … so, let’s try adding a handler…
Is not null ! ! Yeah, so we have our event by reflection now.
————————————————————
Note for those who just said “Why giving an object to GetValue ? And why giving ‘this’” :
1) Take a look at the first “this.getType()”
2) Deduce that it ask the Object to give you its Type, an Object knows its Type.
3) Note that a Type can’t know its Objects …
4) Finally to get a Field of your Object, you ask the Type to give it or your Object, giving a reference to your Object, here : ‘this’;
————————————————————
Now, we have an object, which is the event to call, but, how to call it ?
By reflection ? but … where to search ?
TRICK : Put a breakpoint just after the GetValue, when breaked, add a watch on “my_event_by_reflection.GetType()” and browse it… try my_event_by_reflection.GetType().GetFields() … nothing … try my_event_by_reflection.GetType().GetMethods() … browse it … OH ? What is “Invoke” ?

var my_event_invoke = my_event_type.GetMethod("Invoke");

Searching how to call the Invoke … by reflection ? Invoking invoke ? Let’s try :

my_event_invoke.Invoke(my_event_by_reflection, new object[] {this, new EventArgs()} );

Invoke take the instance of this type, so the object where GetType where called, and in second parameter an array of object to be given as parameter to the method called, we have to give an object and an eventArgs.
It Works ! here the full working source code :

using System.Reflection;
 
class Cage_en_metal
{
    public event EventHandler ecraser;
 
    public Cage_en_metal()
    {
        ecraser += new EventHandler(Libellule_ecraser);
        fireEvent("ecraser", new EventArgs());
    }
 
    void Libellule_ecraser(object sender, EventArgs e)
    {
        Console.WriteLine("Splatch !");
    }
 
    void fireEvent(string handler, EventArgs eventArgs)
    {
        var eventInfo = this.GetType().GetField(handler,
		                                BindingFlags.Instance
						| BindingFlags.NonPublic);
        if (eventInfo != null)
        {
            var event_member = eventInfo.GetValue(this);
		// Note : If event_member is null, nobody registered to the event, you can't call it.
            if (event_member != null)
                event_member.GetType().GetMethod("Invoke").Invoke(event_member, new object[] { this, eventArgs });
        }
    }
}