¿Es posible hacer el Reader Monad de Haskell en Clojure?

monads reader-monad

Question

He echado un vistazo al algo.monads y la documentación de Fluokitten . También he leído entradas de blog de mónada de Jim Duey , Konrad Hinsen y Leonardo Borges .

La única referencia que puedo encontrar al Reader Monad en Clojure es esta discusión de grupos de google .

Mi pregunta es: ¿es posible hacer el Reader Monad de Haskell en Clojure? Podría dar un ejemplo?

Answer 1

Por supuesto. Un Reader es solo una función que toma un entorno y extrae algo de valor de él.

Con Reader , m-result toma algún valor y produce un lector que ignora el entorno y devuelve ese valor:

(defn reader-result
[value]
"Ignores environment, returns value"
(fn [env]
value))

m-bind toma un lector y una función f que acepta un valor y produce un nuevo lector. Luego combina esos argumentos para producir un nuevo lector que aplica el lector inicial a un entorno, alimenta el valor que produce para producir un nuevo lector y luego aplica ese lector al entorno:

(defn reader-bind
[reader f]
"Applies reader to environment,
then applies f to new environment"
(fn [env]
(let [read-value (reader env)]
((f read-value) env))))

Con estas funciones, podemos definir Reader con algo.monads :

(m/defmonad Reader
[m-result reader-result
m-bind reader-bind])

Hay algunas funciones de ayuda importantes. run-reader toma un lector y entorno y aplica el lector a ese entorno:

(defn run-reader
"Runs a reader against an environment,
returns the resulting environment"
[reader env]
(reader env))

Dado que nuestros lectores son solo funciones, run-reader no es estrictamente necesario. Sin embargo, puede aclarar las cosas y nos mantiene más cerca de la implementación de Haskell, por lo que la usaremos para seguir adelante.

ask y asks vamos a examinar el entorno. ask es un lector que devuelve el entorno. asks toma un selector y crea un lector que aplica ese selector a un entorno:

(defn ask
"A reader that returns the environment"
[env]
env)
(defn asks
"A reader that returns the result of
f applied to the environment"
[f]
(fn [env]
(f env)))

Esto nos lleva lo suficientemente lejos como para pasar por el primer ejemplo de Reader :

(defn lookup-var
[name bindings]
(get bindings name))
(def calc-is-count-correct?
(m/domonad Reader
[binding-count (asks #(lookup-var "count" %))
bindings ask]
(= binding-count (count bindings))))
(defn is-count-correct?
[bindings]
(run-reader calc-is-count-correct? bindings))
(def sample-bindings {"count" 3, "1" 1, "b" 2})
(println
(str "Count is correct for bindings " sample-bindings ": "
(is-count-correct? sample-bindings)))

La otra función importante de Reader es local . Esto toma una función que modifica un entorno y un lector y crea un nuevo lector que modifica el entorno antes de pasarlo al lector original:

(defn local
[modify reader]
"A reader that modifies the environment
before calling the original reader"
(fn [env]
(run-reader reader (modify env))))

Con eso, podemos pasar por el segundo ejemplo :

(def calc-content-len
(m/domonad Reader
[content ask]
(count content)))
(def calc-modified-content-len
(local #(str "Prefix " %) calc-content-len))
(let [s "12345"
modified-len (run-reader calc-modified-content-len s)
len (run-reader calc-content-len s)]
(println
(str "Modified ''s'' length: " modified-len))
(println
(str "Original ''s'' length: " len)))

Entonces, eso es todo lo que se necesita para hacer Reader .

Answer 2

Hay algunos ejemplos fantásticos de las siguientes mónadas en Clojure aquí :

• el lector mónada en clojure
• el escritor mónada en clojure
• la mónada estatal en clojure
• la mónada de identidad en clojure
• la tal vez mónada en clojure
• la mónada en clojure