21 votos

Flecha sin arr

Si restringimos nuestra comprensión de una categoría a ser el habitual Category de la clase en Haskell:

class Category c where
  id :: c x x
  (>>>) :: c x y -> c y z -> c x z

A continuación, vamos a decir que un Arrow es Category que además:

class Category c => Arrow c where
  (***) :: c x y -> c x' y' -> c (x,x') (y,y')
  (&&&) :: c x y -> c x y' -> c x (y,y')

Podemos deducir con facilidad:

first :: c x y -> c (x,z) (y,z)
first a = a *** id

second :: c x y -> c (z,x) (z,y)
second a = id *** a

O podemos derivar (***) de first y second:

a1 *** a2 = first a1 >>> second a2

También podemos derivar:

dup :: c x (x,x)
dup = id &&& id

O podemos derivar (&&&) da dup y (***):

a1 &&& a2 = dup >>> (a1 *** a2)

¿Cuál es mi punto y lo que mi pregunta? Es este:

¿Qué es Arrow sin arr? Parece perfectamente coherente y útil. ¿Hay alguna flecha leyes (además de la categoría de leyes) que no implican arr y permanecen intactos aquí? Y ¿qué significa todo esto en la categoría de teoría?


Básicamente me robaron esta pregunta de reddit, pero generalizada y se explayó sobre ella: http://www.reddit.com/r/haskell/comments/2e0ane/category_with_fanout_and_split_but_not_an_arrow/

2voto

谷口昂平 Puntos 43

Como Arrow es una categoría del producto, Arrow sin arr es también una categoría de producto (por lo tanto la categoría de las leyes siempre espera).

arr es un functor de Hask categoría a c categoría. El código que se muestra a continuación indica esto. arr proporciona una manera para levantar funciones normales (que son morfismos en Hask) en la instancia c categoría. Esto es algo como fmap (endofunctor de Hask a Hask), pero es más generalizada. Referente a esto, algunos de la flecha leyes que aquí se describe el functor leyes (aunque también existen las leyes para el producto).

Así omitiendo arr, se pierde la función para levantar funciones normales, o, desde otro punto de vista, liberarse de su aplicación. Sin embargo, todas las demás características son las mismas.

{-# LANGUAGE TypeOperators, RankNTypes #-}

-- | Functor arrow
type (:->) c d = forall a b. c a b -> d a b

-- | Hask category; types are objects, functions are morphisms.
type Hask = (->)

arr :: Arrow c => Hask :-> c
arr = Control.Arrow.arr

Iteramos.com

Iteramos es una comunidad de desarrolladores que busca expandir el conocimiento de la programación mas allá del inglés.
Tenemos una gran cantidad de contenido, y también puedes hacer tus propias preguntas o resolver las de los demás.

Powered by:

X