in cerca di esercizio di apprendimento: implementare queste monadi

Question

Quando imparare a conoscere nuovi soggetti di programmazione di solito seguono un modello:. L'ho letto, ho capito bene, e poi ho codificare fino alcuni esempi per assicurarsi che io davvero ottenerlo

Ho letto molto su monadi, e sono fiducioso che capisco e farli. Sono ora in una fase in cui mi piacerebbe molto al codice fino a pochi monadi a solidificare la mia comprensione, e davvero capire quello che serve per implementare bind per una varietà di tipi.

Il problema è che non riesco a pensare di molti monadi evidenti per implementare, quindi non vedo per le raccomandazioni. Preferibilmente, mi piacerebbe un elenco di raccomandazioni, con alcuni tra quelli semplici e alcuni tra quelli non così facili.

mi rendo anche conto che, mentre monadi sono utilizzate per gli effetti collaterali 'incapsulare' nei programmi funzionali, ma sono anche più generale di quello. Quindi, vorrei le raccomandazioni per includere monadi che entrambi incapsulano effetti collaterali e alcuni tra quelli generali.

Grazie!

(come nota a margine: Lavorerò con F # per fare questo, ma credo che questa domanda potrebbe applicarsi a qualsiasi linguaggio funzionale).

Answer 1

Credo che il catalogo in All About Monadi è un buon inizio (la monade proseguimento è effettivamente utile per catamorphisms, si veda ad esempio qui ); Inoltre parser , e, eventualmente, effetti transazionali . Async è un altro bel uno per cercare di implementare sul proprio (codice logico-single-threaded che saltella tra le varie discussioni effettive di essere non bloccante). E la monade alla base della quadro reattivo si presenta come una buona sfida avanzate.

Answer 2

L'elenco dei datastructues / calcoli che seguono una sorta di legge monadica è estremamente ricco.

Si raggiunge da elenca oltre i dati opzionali ('a option in F #), continuazioni e multithreading fino a cose molto complesse come parser.

Basta avviare l'attuazione di alcune di esse. exercies di base:

// Identity monad

let something = ident {
    let! value = id 42
    return value
}

let somethingelse = ident {
    let! value = something
    let! otherValues = id 40
    return value + othervalue
}


// Implement maybe for 'a option
let sum = maybe {
    let! a = maybeInputNumber("a")
    let! b = maybeInputNumber("b")
    let! c = maybeInputNumber("c")
    return a + b + c
}

match sum with
| None -> ...
| Some(n) -> ...

Si potrebbe anche aumentare la vostra comprensione giocando un po 'litte con funzioni di supporto e la sintassi monadica esplicita.

// Given m >>= f for m.Bind(f)

let (>-) f monad = monad >>= (fun k -> return(f x))

// What's this?
let res = ((+) 1) >- [1..10]

Se si desidera che alcuni esempi complessi, dare un'occhiata a monadica parser combinatori . Questo vi permetterà di implementare complesse parser ricorsivo discesa in pianura F # (date un'occhiata alla FParsec - project)

let parseVector = parser {
    do! ignore $ char '('
    let! [x;y;z] = sepBy parseNumber "," 
    do! ignore $ char ')'
    return new Vector(x, y, z)
}

Una semplice implementazione per questo si basa sui seguenti modelli:

type 't Computation = 
    | Error of ...
    | Result of 't

type Input     = char list
type 'a Parser = Input -> (('a * Input) Computation)

Prova a implementare bind e ritorno ; -)

E come un suggerimento generale: Se si vuole veramente capire monadi nel loro ambiente naturale, dovrete usare Haskell ;-) In F # ci sono solo espressioni di calcolo, solo un analogo vaga, ma Haskell introduce un'interfaccia generale per ogni computazione monadico. Perfetto a provarli!

Answer 3

Anche se suppongo che non c'è contestare il fatto che Haskell è il linguaggio naturale in cui per conoscere monadi, trovo che un esercizio molto utile è quello di portare i calcoli monadici ad una lingua che non lo fa, fuori dalla scatola, hanno Haskell -come il supporto super liscio per loro. E 'pienamente possibile in qualsiasi lingua, e in qualsiasi lingua ragionevolmente alto livello probabilmente sarà possibile essere creativi ed effettivamente farli apparire bella - imparando molto nel processo! Ho visto la sintassi monadica fresco per Python (a Lezioni Valued , credo), per esempio.

C'è anche biblioteca clojure.contrib.monads di Clojure che fornisce belle strutture per l'utilizzo di monadi in un Lisp. Cercando di ricreare alcuni dei suoi funzionalmente potrebbe essere molto istruttivo. Inoltre, utilizzando a volte al posto di Haskell può essere utile per staccare i modelli generali dei particolari della sintassi di Haskell (anche se sono molto bello, per essere sicuri).