Control.Arrow

class Category a => Arrow (a :: Type -> Type -> Type) where Исходный код

Базовый класс стрелок.

Экземпляры должны удовлетворять следующим законам:

• arr id = id

• arr (f >>> g) = arr f >>> arr g

• first (arr f) = arr (first f)

• first (f >>> g) = first f >>> first g

• first f >>> arr fst = arr fst >>> f

• first f >>> arr (id *** g) = arr (id *** g) >>> first f

• first (first f) >>> arr assoc = arr assoc >>> first f

где

assoc ((a,b),c) = (a,(b,c))

Другие комбинаторы имеют разумные определения по умолчанию, которые могут быть переопределены для повышения эффективности.

  b ╭───╮ c
>───┤ f ├───>
    ╰───╯

  b ╭─────╮ c
>───┼─ f ─┼───>
>───┼─────┼───>
  d ╰─────╯ d

  d ╭─────╮ d
>───┼─────┼───>
>───┼─ f ─┼───>
  b ╰─────╯ c

  b ╭─────╮ b'
>───┼─ f ─┼───>
>───┼─ g ─┼───>
  c ╰─────╯ c'

    ╭───────╮ c
  b │ ┌─ f ─┼───>
>───┼─┤     │
    │ └─ g ─┼───>
    ╰───────╯ c'

newtype Kleisli (m :: Type -> Type) a b Исходный код

Стрелки Kleisli монады.

returnA :: Стрелка a => a b b Исходный код

Тождественная стрелка, играющая роль return в записи стрелок.

  b
>───>

(^>>) :: Стрелка a => (b -> c) -> a c d -> a b d infixr 1 Исходный код

Представление с чистой функцией.

(>>^) :: Стрелка a => a b c -> (c -> d) -> a b d infixr 1 Исходный код

Последовательное применение чистой функции.

(>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Категория cat => cat a b -> cat b c -> cat a c infixr 1 Исходный код

Композиция слева направо. Это полезно, если вы хотите записать морфизм как конвейер, идущий слева направо.

(<<<) :: forall {k} cat (b :: k) (c :: k) (a :: k). Категория cat => cat b c -> cat a b -> cat a c infixr 1 Исходный код

Композиция справа налево. Это синоним для (.), но может быть полезно, чтобы сделать порядок композиции более очевидным.

(<<^) :: Стрелка a => a c d -> (b -> c) -> a b d infixr 1 Исходный код

Представление с чистой функцией (вариант справа налево).

(^<<) :: Стрелка a => (c -> d) -> a b c -> a b d infixr 1 Исходный код

Последовательное применение чистой функции (вариант справа налево).

class Стрелка a => ArrowZero (a :: Тип -> Тип -> Тип) where Исходный код

class ArrowZero a => ArrowPlus (a :: Тип -> Тип -> Тип) where Исходный код

Моноид на стрелках.

class Arrow a => ArrowChoice (a :: Тип -> Тип -> Тип) where Исходный код

Выбор, для стрелок, которые его поддерживают. Этот класс лежит в основе конструкций if и case в обозначении стрелок.

Примеры реализации должны удовлетворять следующим законам:

• left (arr f) = arr (left f)

• left (f >>> g) = left f >>> left g

• f >>> arr Left = arr Left >>> left f

• left f >>> arr (id +++ g) = arr (id +++ g) >>> left f

• left (left f) >>> arr assocsum = arr assocsum >>> left f

где

assocsum (Left (Left x)) = Left x
assocsum (Left (Right y)) = Right (Left y)
assocsum (Right z) = Right (Right z)

Другие комбинаторы имеют разумные определения по умолчанию, которые могут быть переопределены для повышения эффективности.

class Arrow a => ArrowApply (a :: Тип -> Тип -> Тип) where Исходный код

Некоторые стрелки позволяют применять входные данные стрелки к другим входным данным. Примеры реализации должны удовлетворять следующим законам:

• first (arr (\x -> arr (\y -> (x,y)))) >>> app = id

• first (arr (g >>>)) >>> app = second g >>> app

• first (arr (>>> h)) >>> app = app >>> h

Такие стрелки эквивалентны монадам (см. ArrowMonad).

newtype ArrowMonad (a :: Тип -> Тип -> Тип) b Исходный код

Класс ArrowApply эквивалентен классу Monad: любой монада порождает стрелку Kleisli, и любой экземпляр ArrowApply определяет монаду.

leftApp :: ArrowApply a => a b c -> a (Either b d) (Either c d) Источник

Любой экземпляр ArrowApply может быть преобразован в экземпляр ArrowChoice путем определения left = leftApp.

класс Arrow a => ArrowLoop (a :: Тип -> Тип -> Тип) где Источник

Оператор loop описывает вычисления, в которых значение результата используется в качестве входного значения, хотя вычисление выполняется только один раз. Он лежит в основе конструкции рекурсии значений rec в стрелочной нотации. loop должен удовлетворять следующим законам:

расширение

loop (arr f) = arr (\ b -> fst (fix (\ (c,d) -> f (b,d))))

усиление слева

loop (first h >>> f) = h >>> loop f

усиление справа

loop (f >>> first h) = loop f >>> h

сдвиг

loop (f >>> arr (id *** k)) = loop (arr (id *** k) >>> f)

исчезновение

loop (loop f) = loop (arr unassoc >>> f >>> arr assoc)

наложение

second (loop f) = loop (arr assoc >>> second f >>> arr unassoc)

где

assoc ((a,b),c) = (a,(b,c))
unassoc (a,(b,c)) = ((a,b),c)

    ╭──────────────╮
  b │     ╭───╮    │ c
>───┼─────┤   ├────┼───>
    │   ┌─┤   ├─┐  │
    │ d │ ╰───╯ │  │
    │   └───<───┘  │
    ╰──────────────╯