salir - Comprender las flechas en Haskell

salir de haskell

Question

He intentado controlar las flechas ya que son la base de la mayoría de las implementaciones de FRP . Creo que entiendo la idea básica: están relacionados con las mónadas, pero almacenan información estática en cada operador de enlace para que pueda caminar a través de una cadena de flechas y mirar la información estática sin tener que evaluar toda la flecha.

Pero me pierdo en el punto donde comenzamos a discutir primero, segundo y cambiar. ¿Qué tienen que ver las 2-tuplas con las flechas? Los tutoriales presentan las cosas de la tupla como si fuera un siguiente paso obvio, pero realmente no veo la conexión.

Para el caso, ¿qué significa la sintaxis de flecha de forma intuitiva?

Answer 1

Eche un vistazo en http://www.cs.yale.edu/homes/hudak/CS429F04/AFPLectureNotes.pdf , que explica cómo funcionan las flechas en FRP.

2-tuplas se usan para definir Flechas porque es necesario para representar una función de flecha tomando 2 argumentos.

En FRP, las constantes y variables a menudo se representan como flechas que ignoran su "entrada", por ej.

twelve, eleven :: Arrow f => f p Int
twelve = arr (const 12)
eleven = arr (const 11)

Las aplicaciones de funciones se convierten en composiciones ( >>> ):

# (6-) 12

arr (6-) <<< twelve

¿Ahora cómo convertimos una función de 2 argumentos en una flecha? Por ejemplo

(+) :: Num a => a -> a -> a

debido al currying podemos tratar esto como una función que devuelve una función. Asi que

arr (+) :: (Arrow f, Num a) => f a (a -> a)

ahora vamos a aplicarlo a una constante

arr (+)             -- # f     a (a -> a)
  <<< twelve        -- # f b Int
                      :: f b     (Int -> Int)

+----------+      +-----+      +--------------+
| const 12 |----> | (+) |  ==  | const (+ 12) |
+----------+      +-----+      +--------------+

oye espera, no funciona. El resultado sigue siendo una flecha que devuelve una función, pero esperamos algo similar a f Int Int . Notamos que el currying falla en Arrow porque solo se permite la composición. Por lo tanto, debemos descifrar la función primero

uncurry :: (a -> b -> c) -> ((a, b) -> c)

uncurry (+) :: Num a => (a, a) -> a

Entonces tenemos la flecha

(arr.uncurry) (+) :: (Num a, Arrow f) => f (a, a) a

La 2-tupla surge por esto. Entonces las funciones de grupo como &&& son necesarias para tratar con estas 2-tuplas.

(&&&) :: f a b -> f a d -> f a (b, d)

entonces la adición se puede realizar correctamente.

(arr.uncurry) (+)        -- # f   (a,    a) a
  <<<     twelve         -- # f b  Int
      &&& eleven         -- # f b      Int
                           :: f b           a

+--------+
|const 12|-----.
+--------+     |       +-----+      +----------+
              &&&====> | (+) |  ==  | const 23 |
+--------+     |       +-----+      +----------+
|const 11|-----''
+--------+

(Ahora, ¿por qué no necesitamos cosas como &&&& para 3- &&&& para funciones que tienen 3 argumentos? Porque en su lugar se puede usar a ((a,b),c) ).

Editar: Del documento original de John Hughes Generalizando Mónadas a Flechas , dice la razón como

4.1 Flechas y pares

Sin embargo, a pesar de que en el caso de las mónadas, los operadores return y >>= son todo lo que necesitamos para comenzar a escribir un código útil, para las flechas los operadores análogos arr y >>> no son suficientes. Incluso la función de adición monádica simple que vimos antes

   add :: Monad m => m Int -> m Int -> m Int
   add x y = x >>= /u -> (y >>= /v -> return (u + v))

todavía no se puede expresar en forma de flecha. Haciendo explícita la dependencia de un input, vemos que una definición análoga debe tomar la forma

   add :: Arrow a => a b Int -> a b Int -> a b Int
   add f g = ...

donde debemos combinar f y g en secuencia. El único operador de secuenciación disponible es >>> , pero g no tienen los tipos correctos para componer. De hecho, la función add necesita guardar la entrada de tipo b en el cálculo de f , para poder suministrar la misma entrada a g . Del mismo modo, el resultado de f debe guardar en el cálculo de g , de modo que los dos resultados eventualmente se puedan agregar y devolver. Los combinadores de flechas hasta ahora introducidos no nos dan la posibilidad de guardar un valor en otro cálculo, por lo que no tenemos más alternativa que introducir otro combinador.