A better Dictionary

[arialdomartini]

@aironangel ha proposto un tema: un approccio funzionale per la gestione dei dizionari, in particolare per la gestione delle chiavi inesistenti.

Usiamo questa discussion per raccogliere un po' di idee?

[arialdomartini]

Mi viene in mente che l'approccio più naturale potrebbe essere quella di usare un Option/Maybe.

Un approccio non rigorosamente funzionale (non ha strutture mutabili) potrebbe essere questo:

    static class DictionaryExtensions
    {
        internal static TValue Get<TKey, TValue>(
            this Dictionary<TKey, TValue> dictionary,
            TKey key,
            Func<TValue> fallback) =>

            dictionary.ContainsKey(key) ?
                dictionary[key] :
                fallback();
    }

    public class DictionaryTest
    {
        [Fact]
        void fallback()
        {
            var dictionary = new Dictionary<int, string>
            {
                [1] = "foo",
                [2] = "bar"
            };

            dictionary.Get(1, () => "fallback")
                .Should().Be("foo");

            dictionary.Get(-99, () => "fallback")
                .Should().Be("fallback");
        }
    }

Come valore di fallback uso una function, in modo che la valutazione sia lazy.

Si potrebbe anche pensare a un GetUpdate che si comporti come un Get, ma nel caso di missing key aggiunga il valore nel dictionary

    static class DictionaryUpdateExtensions
    {
        internal static TValue GetUpdate<TKey, TValue>(
            this Dictionary<TKey, TValue> dictionary,
            TKey key,
            Func<TValue> fallback)
        {
            if (!dictionary.ContainsKey(key))
                dictionary.Add(key, fallback());

            return dictionary[key];
        }
    }

    public class DictionaryUpdateTest
    {
        [Fact]
        void uses_fallback()
        {
            var dictionary = new Dictionary<int, string>
            {
                [1] = "foo",
                [2] = "bar"
            };


            dictionary.GetUpdate(1, () => "fallback").Should().Be("foo");
            dictionary.GetUpdate(-99, () => "fallback").Should().Be("fallback");
        }

        [Fact]
        void stores_fallback()
        {
            var dictionary = new Dictionary<int, string>
            {
                [1] = "foo",
                [2] = "bar"
            };


            dictionary.ContainsKey(-99).Should().Be(false);

            dictionary.GetUpdate(-99, () => "fallback").Should().Be("fallback");

            dictionary.ContainsKey(-99).Should().Be(true);

        }
}

Sono sicuro a voi verranno in mente implementazioni più fantasiose e furbe.

[arialdomartini]

Bello, @aironangel! Mi piace molto!

[arialdomartini]

Mannaggia a quanto è prolisso C# senza il type inference, vero @aironangel?

Se non si dovessero specificare i tipi così pedissequamente, il tuo extension method sarebbe

var GetSafe =
  (this dictionary, key, fallBackValue) =>       
    dictionary.ContainsKey(key)
      ? dictionary[key]
      : fallBackValue;

Per l'indentazione, potrebbe piacerti questo video

Kevlin Henney - Seven Ineffective Coding Habits of Many Programmers

Nella prima parte parla proprio di formattazione del codice.

A me ha rovinato la vita. Immagino lo abbia visto anche tu, @emanuelefirmani, perché riconosco nel tuo codice le stesse scelte stilistiche, possibile?

Guardatelo! È micidiale...

[matteobertaiola]

interessanti le idee, ci sono 2 cose che non ho capito:

1. @arialdomartini perché mettere il valore di fallback nel dictionary? in ogni caso mi tornerebbe lo stesso valore
2. @aironangel che differenza z'è tra oggetto di fallback e valore di ritorno di fallback?

[arialdomartini]

@matteobertaiola hai ragione, ha poco senso. Pensavo a un caso di uso del tipo: "cerca il valore per chiave; se non trovi nulla, assegna un valore di default a quella chiave mancante". Ma in effetti è un caso di uso balzano.

L'idea di () => fallback era per usare un valore di fallback lazy, da eseguire solo nel caso di mancanza di chiave, principalmente per i casi in cui valutare il valore di fallback richiedesse l'esecuzione di qualche operazione. Tipo:

dictionary.Get("foo", () => _someRepository.QueryLastInserted())

[aironangel]

Ho creato un repository per BetterDictionary.
per rispondere a @matteobertaiola il valore di fault back ha senso se nel dictionary viene messa una classe che implementa un metodo specifico che ritorna un valore, lo stesso valore che vogliamo poi gestire.
Il caso d'uso era la gestione attraverso il dictionary di validatori di stringhe da processare in base alla loro lunghezza.
I validatori sono implementati attraverso un interfaccia IValidator

    /// <summary>
    /// Generic interface for a validator
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TResult"></typeparam>
    public interface IValidator<T, TResult>
    {
        TResult IsValid(T toValidate);
    }

che espone un metodo IsValid, generico.
A questo punto l'extension può ritornare direttamente il valore ritornato dal metodo "IsValid":

        internal static TResult GetSafe<TKey, TValidator, TToValidate, TResult>(
this Dictionary<TKey, TValidator> dictionary, 
TKey key, 
TToValidate toValidate, 
TResult faultBackValue)
            where TValidator : IValidator<TToValidate, TResult> => 
            dictionary.ContainsKey(key) ? dictionary[key].IsValid(toValidate) : faultBackValue;

Ora però ci manca un passaggio, cioè la gestione del fatto che la chiave NON sia presente nel dictionary o che il value sia null.
Questo si può sicuramente gestire con un tipo di dato che consenta più valori (int, string,...) mentre con il bool siamo limitati a TRUE e FALSE.
Per generalizzare bisognerebbe gestire qesto caso..