la recherche d'exercice d'apprentissage: mettre en œuvre ces monades

Question

Lors de l'apprentissage de nouveaux sujets de programmation Je suis habituellement un modèle. Je l'ai lu, je le comprends, et je coder quelques exemples pour vous assurer que je vraiment obtenir

J'ai lu beaucoup de choses sur monades, et je suis confiant que je comprends et les obtenir. Je suis maintenant à un stade où je voudrais vraiment coder quelques monades pour solidifier ma compréhension, et vraiment comprendre ce qu'il faut pour mettre en œuvre bind pour une variété de types.

Le problème est que je ne peux pas penser à beaucoup monades évidentes à mettre en œuvre, donc je suis à la recherche des recommandations. De préférence, je voudrais une liste de recommandations, avec quelques plus faciles et quelques pas si facile.

Je me rends compte aussi que tout monades sont utilisés pour des effets secondaires « de encapsulent » dans les programmes fonctionnels, ils sont aussi plus général que cela. Donc, je voudrais les recommandations à inclure monades que les deux encapsulent des effets secondaires et quelques généraux.

Merci!

(comme une note de côté: je vais travailler avec f # pour ce faire, mais je pense que cette question pourrait appliquer à tout langage fonctionnel).

Answer 1

Je pense que le catalogue Tout sur Monades est un bon début (la poursuite monade est en fait utile pour catamorphisme, voir par exemple ); en outre parseurs , et peut-être effets transactionnels . async est une autre belle à essayer de mettre en œuvre sur votre propre (code logique-thread unique que le houblon entre les différents sujets réels pour être non-blocage). Et la monade sous-jacente de la cadre réactive ressemble à un bon défi avancé.

Answer 2

La liste des datastructues / calculs qui suivent une sorte de loi monadique est extrêmement riche.

Il atteint des listes sur des données facultatives ('a option en F #), et continuations multithreading aux choses très complexes comme parseurs.

Il suffit de commencer à appliquer certains d'entre eux. exercies de 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) -> ...

Vous pouvez aussi augmenter votre compréhension en jouant un peu litte avec des fonctions d'aide et explicite la syntaxe monadique.

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

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

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

Si vous voulez quelques exemples complexes, jetez un oeil à monadique analyseur combinators . Cela vous permettra de mettre en œuvre des parseurs complexes de descente récursive en F # ordinaire (un coup d'oeil à la FParsec - projet)

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

Une mise en œuvre simple pour cela est basé sur les modèles suivants:

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

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

Essayez de mettre en œuvre bind et retour ; -)

Et comme une astuce générale: Si vous voulez vraiment comprendre monades dans leur milieu naturel, vous devrez utiliser Haskell ;-) En F # il y a juste des expressions de calcul, juste un analogue vague, mais Haskell introduit une interface générale pour tout monade. Parfait pour les essayer!

Answer 3

Bien que je suppose qu'il n'y a pas de contester le fait que Haskell est le langage naturel dans lequel se renseigner sur monades, je trouve qu'un exercice très utile est d'apporter des calculs monades à une langue qui n'a pas, hors de la boîte, ont Haskell -comme support super lisse pour eux. Il est tout à fait possible dans toutes les langues, et en tout état raisonnablement langage de haut niveau, il sera probablement possible de faire preuve de créativité et de faire réellement leur donner un aspect agréable - apprendre beaucoup dans le processus! Je l'ai vu la syntaxe monadique cool pour Python ( leçons Précieuses , je pense), par exemple.

Il y a aussi la bibliothèque de clojure.contrib.monads de Clojure qui offre de belles installations pour l'utilisation monades dans un Lisp. Essayer de recréer une partie de son plan fonctionnel pourrait être très instructif. Aussi, en utilisant parfois à la place de Haskell peut être utile pour détacher les tendances générales des détails de la syntaxe de Haskell (si elles sont très bien, pour être sûr).