Capitolo 1 - Count invocations with Closure

[arialdomartini]

Func<int, int> double = n => n * 2;

double(10).Should().Be(20);
double(10).Should().Be(20);
double(10).Should().Be(20);

Func<int, (int value, string count)> doubleCount = double.andAlsoCountCalls();

{
    var result = doubleCount(10);
    result.value.Should().Be(20);
    result.count.Should().Be(1);
}
{
    var result = doubleCount(10);
    result.value.Should().Be(20);
    result.count.Should().Be(2);
}
{
    var result = doubleCount(10);
    result.value.Should().Be(20);
    result.count.Should().Be(3);
}

[matteobertaiola]

static int counter = 0;
public static Func<int, (int,int)> andAlsoCountCalls(this Func<int, int> func) => new Func<int, (int, int)>((t) => (func(t), ++counter));

[arialdomartini]

Provaci anche tu, @emanuelefirmani!

[matteobertaiola]

ma se la closure mi fa persistere la variabile... il GC non la libera più? e quindi potrei in linea teorica generare un numero sufficientemente grande di metodi arrivando ad allocare tutta la memoria disponibile e generare una System.OutOfMemoryException?

[arialdomartini]

@matteobertaiola
Corretto: la closure contiene una reference alla variabile e quindi fintanto che l'instanza della closure non viene rimossa dal GC, anche la variabile viene tenuta in vita.

Ma non dovrebbe stupire poi molto: non è troppo diverso da quel che accade con le istanze delle classi:

Bar LocalFunction()
{
    var localInstance = new Foo();

    return new Bar { Foo = localInstance };
}

var bar = LocalFunction();

La variabile localInstance esce dal suo scope alla fine della funzione LocalFunction: ma l'instanza ritornata di Bar ne conserva una reference. Per cui, fintanto che la variabile bar non viene liberata, lo spazio di memoria per l'istanza di Foo viene conservato. Prima o poi, la closure esce dal suo scope,e il GC fa il suo lavoro.

Volendo, uno può pensare a una closure come all'instanza della classe Func alla quale sia stato passata una lambda e un'instanza della variabile locale. Dovrebbe risultare intuitivo pensare che il GC non rimuverà lo spazio di memoria.

Quello che trae in inganno, nelle closure, è che sembra che la variabile locale continui a vivere. Non è proprio così: la variabile locale muore: dentro la closure c'è una nuova variabile, col medesimo nome, che punta alla stessa area di memoria.

Ti torna?

[emanuelefirmani]

Fatto! Si', si tratta di infilare una variabile dentro la closure. Considera che devi restituire una Func da un metodo. Quindi, tutto cio' che inserisci nel metodo, puo' essere usato come closure nella Func.

[arialdomartini]

Bravo, @emanuelefirmani. E Grazie per il test!

Ora, dobbiamo eliminare la mutazione di stato. Che ne dite @aironangel @matteobertaiola @emanuelefirmani di qualcosa così?

delegate int Sum(int a, int b);

class Stateful
{
    internal int Count;

    Stateful(Sum func, int count)
    {
        _func = func;
        _count = count;
    }

    (int result, Stateful newState) Exec(int a, int b) =>
        (_func(a, b), new StateFul(func, _count + 1);
}

static class FuncExtensions
{
    static Stateful Lift(this sum f) => new StateFul(f, 0); 
}

Sum sum = (a, b) => a + b;

Stateful statefulSum = sum.Lift();

var (result, count) =
    statefulSum
        .Exec(1, 2)
        .Exec(2, 3)
        .Exec(3, 4);

result.Should().Be(7);
count.Should().Be(3);

Questa implementazione non ha mutazione di stato: tutto è immutabile.

Ma non è bellissima. C'è un'implementazione molto più generale e furba di questa, e la vedremo quando faremo la State Monad.

[emanuelefirmani]

Visto il problema riscontrato (usare un contatore esterno statico che calcola male la count), mi sono permesso di riscrivere il test:

        [Fact]
        void should_count()
        {
            Func<int, int> f = n => n * 2;

            f(10).Should().Be(20);
            f(10).Should().Be(20);
            f(10).Should().Be(20);

            var doubleCount = f.AndAlsoCountCalls();
            var anotherDoubleCount = f.AndAlsoCountCalls();

            {
                var result = doubleCount(10);
                result.value.Should().Be(20);
                result.count.Should().Be(1);
            }
            {
                var result = anotherDoubleCount(10);
                result.value.Should().Be(20);
                result.count.Should().Be(1);
            }
            {
                var result = doubleCount(10);
                result.value.Should().Be(20);
                result.count.Should().Be(2);
            }
            {
                var result = anotherDoubleCount(20);
                result.value.Should().Be(40);
                result.count.Should().Be(2);
            }
            {
                var result = doubleCount(10);
                result.value.Should().Be(20);
                result.count.Should().Be(3);
            }    
        }