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 ╭─────╮ c
>───┼─ f ─┼───>
>───┼─ g ─┼───>
  b'╰─────╯ c'

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

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

Стрелки Клейсли монады.

returnA :: Arrow a => a b b Исходный код

Стрелка тождества, играющая роль return в стрелочной нотации.

  b
>───>

(^>>) :: Arrow a => (b -> c) -> a c d -> a b d infixr 1 Исходный код

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

(>>^) :: Arrow a => a b c -> (c -> d) -> a b d infixr 1 Исходный код

Посткомпозиция с чистой функцией.

(>>>) :: forall {k} cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c infixr 1 Исходный код

Композиция слева направо. Полезна, если нужно записать морфизм в виде конвейера, направленного слева направо.

(<<<) :: forall {k} cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c infixr 1 Исходный код

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

(<<^) :: Arrow a => a c d -> (b -> c) -> a b d infixr 1 Исходный код

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

(^<<) :: Arrow a => (c -> d) -> a b c -> a b d infixr 1 Исходный код

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

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

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

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

class Arrow a => ArrowChoice (a :: Type -> Type -> Type) 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 :: Type -> Type -> Type) 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 :: Type -> Type -> Type) b Исходный код

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

leftApp :: ArrowApply a => a b c -> a (Either b d) (Either c d) Исходный код

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

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

Оператор 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 │ ╰───╯ │  │
    │   └───<───┘  │
    ╰──────────────╯