est-ce un exemple de monade simple?

Question

Ceci est ma tentative de grok fonctions monadiques après avoir regardé this.

h utilise bind pour composer ensemble deux fonctions arbitraires f et g. Quel est l'opérateur unit dans ce cas?

;; f :: int -> [str] 
;; g :: str -> [keyword] 
;; bind :: [str] -> (str -> [keyword]) -> [keyword] 
;; h :: int -> [keyword] 

(defn f [v] 
    (map str (range v))) 

(defn g [s] 
    (map keyword (repeat 4 s))) 

(defn bind [l f] 
    (flatten 
    (map f l))) 

(f 8) ;; :: (0 1 2 3 4 5 6 7) 
(g "s") ;; :: (:s :s :s :s) 

(defn h [v] 
    (bind (f v) g)) 

(h 9) 
;; :: (:0 :0 :0 :0 :1 :1 :1 :1 :2 :2 :2 :2 :3 :3 :3 :3 :4 :4 :4 :4 :5 :5 :5 :5) 

---

Ah, merci pour les commentaires; Je vois où j'étais confus.

Je connaissais ces fonctions et comment les composer en utilisant bind:

f0 :: a -> M a 
g0 :: a -> M a 

mais pas avec ces fonctions:

f1 :: a -> M b 
g1 :: b -> M c 

mais essentiellement, l'opérateur bind est le même pour les deux cas, si M est la même chose. Dans mon cas, M est la liste monad donc f1 et g1 peuvent être combinés de la même manière que f0 et g0.

Answer 1

Essayez-vous d'implémenter la liste monad? Si oui, alors il serait:

(defn unit [x] 
    [x]) 

Ceci est basé sur la Haskell implementation:

instance Monad [] where 
    m >>= k    = foldr ((++) . k) [] m 
    return x   = [x] 

Answer 2

Ceci est une liste monad, et donc l'opérateur unit est x & mapsto; [x], à savoir

(defn return [x] [x]) 

(. Appelé return après la fonction Haskell du même nom & usage)

On peut voir que c'est l'opérateur de l'unité en cochant la case satisfait the monad laws:

(bind (return a) f) => (bind [a] f) 
     => (flatten (map f [a])) => (flatten [f a]) => f a ;; f returns a vector 

Et de même pour (bind x return).