inf-backprop-0.1.0.2: Automatic differentiation and backpropagation.
Copyright(C) 2023 Alexey Tochin
LicenseBSD3 (see the file LICENSE)
MaintainerAlexey Tochin <Alexey.Tochin@gmail.com>
Safe HaskellNone
LanguageHaskell2010
Extensions
  • MonoLocalBinds
  • ScopedTypeVariables
  • TypeFamilies
  • GADTs
  • GADTSyntax
  • ConstraintKinds
  • InstanceSigs
  • DeriveFunctor
  • TypeSynonymInstances
  • FlexibleContexts
  • FlexibleInstances
  • ConstrainedClassMethods
  • MultiParamTypeClasses
  • KindSignatures
  • TupleSections
  • RankNTypes
  • ExplicitNamespaces
  • ExplicitForAll

Control.CatBifunctor

Description

Categorical Bifunctor typeclass and its trivial instances.

Synopsis

Documentation

class Category cat => CatBiFunctor (p :: Type -> Type -> Type) (cat :: Type -> Type -> Type) Source #

Categorical generalization for bifunctor with arrow notations. Notice that we do NOT require the categorical morphism (>>>) and morphism tensor product (***) are interchangeable. Namely,

 (f >>> g) *** (h >>> l) != (f *** h) >>> (g *** l)

in general.

Monad and type product instance examples of usage

Expand
>>> import Prelude (Int, pure, Maybe(Just, Nothing), const, replicate, String)
>>> import Control.Arrow (Kleisli(Kleisli), runKleisli)
>>> runKleisli (Kleisli pure *** Kleisli pure) (1,2) :: [(Int, Int)]
[(1,2)]
>>> runKleisli (Kleisli pure *** Kleisli pure) (1,2) :: Maybe (Int, Int)
Just (1,2)
>>> runKleisli (Kleisli pure *** Kleisli (const Nothing)) (1,2) :: Maybe (Int, Int)
Nothing
>>> runKleisli (Kleisli (replicate 2) *** Kleisli (replicate 3)) ("a","b") :: [(String, String)]
[("a","b"),("a","b"),("a","b"),("a","b"),("a","b"),("a","b")]

Comonad and type product instance examples of usage

Expand
>>> import Prelude (Int, pure, Maybe(..), const, replicate, String, (+), (++), Functor, Show, show, (==), (-))
>>> import Control.Comonad (Cokleisli(Cokleisli), runCokleisli, extract, duplicate, (=>=))
>>> import Control.Comonad.Store (store, seek, runStore, Store, StoreT)
>>> import Control.Category ((>>>))
>>> runCokleisli (Cokleisli extract *** Cokleisli extract) (store (\x -> (x + 1, x + 2)) 3) :: (Int, Int)
(4,5)
>>> :{
up :: Int -> Cokleisli (Store Int) Int Int
up n = Cokleisli $ \st -> let (ws, s) = runStore st in ws (s + n)
:}
>>> runCokleisli ((up 3 *** up 5) >>> (up 2 *** up 4)) (store (\x -> (x + 1, x + 2)) 0) :: (Int, Int)
(6,11)
>>> runCokleisli ((up 3 >>> up 2) *** (up 5 >>> up 4)) (store (\x -> (x + 1, x + 2)) 0) :: (Int, Int)
(6,11)
>>> :{
data Stream a = Cons a (Stream a)
tail :: Stream a -> Stream a
tail (Cons _ xs) = xs
instance Show a => Show (Stream a) where
  show (Cons x0 (Cons x1 (Cons x2 (Cons x3 (Cons x4 _))))) = show [x0, x1, x2, x3, x4] ++ "..."
instance Functor Stream where
  fmap f (Cons x xs) = Cons (f x) (fmap f xs)
instance Comonad Stream where
  extract (Cons x _ ) = x
  duplicate xs = Cons xs (duplicate (tail xs))
:}
>>> :{
dup :: a -> (a, a)
dup x = (x, x)
naturals :: Int -> Stream Int
naturals n = Cons n (naturals (n + 1))
take :: Int -> Stream a -> a
take n (Cons x xs) = if n == 0
  then x
  else take (n - 1) xs
:}
>>> naturals 0
[0,1,2,3,4]...
>>> take 5 (naturals 0)
5
>>> ((take 3) =>= (take 4)) (naturals 0)
7
>>> runCokleisli (Cokleisli (take 3) *** Cokleisli (take 4)) (fmap dup (naturals 0)) :: (Int, Int)
(3,4)
>>> streamN n = Cokleisli (take n)
>>> runCokleisli ((streamN 3 *** streamN 5) >>> (streamN 2 *** streamN 4)) (fmap dup (naturals 0)) :: (Int, Int)
(5,9)
>>> runCokleisli ((streamN 3 >>> streamN 2) *** (streamN 5 >>> streamN 4)) (fmap dup (naturals 0)) :: (Int, Int)
(5,9)

Monad and type sum examples of usage

Expand
>>> import Prelude (Int, pure, Maybe(Just, Nothing), const, replicate, String)
>>> import Control.Arrow (Kleisli(Kleisli), runKleisli)
>>> runKleisli (Kleisli pure *** Kleisli pure) (Left "a") :: [Either String Int]
[Left "a"]
>>> runKleisli (Kleisli pure *** Kleisli pure) (Right 1) :: Maybe (Either String Int)
Just (Right 1)

Minimal complete definition

(***)

Instances

Instances details
Monad m => CatBiFunctor Either (Kleisli m) Source # 
Instance details

Defined in Control.CatBifunctor

Methods

(***) :: Kleisli m a1 b1 -> Kleisli m a2 b2 -> Kleisli m (Either a1 a2) (Either b1 b2) Source #

first :: Kleisli m a b -> Kleisli m (Either a c) (Either b c) Source #

second :: Kleisli m a b -> Kleisli m (Either c a) (Either c b) Source #

Monad m => CatBiFunctor (,) (Kleisli m) Source # 
Instance details

Defined in Control.CatBifunctor

Methods

(***) :: Kleisli m a1 b1 -> Kleisli m a2 b2 -> Kleisli m (a1, a2) (b1, b2) Source #

first :: Kleisli m a b -> Kleisli m (a, c) (b, c) Source #

second :: Kleisli m a b -> Kleisli m (c, a) (c, b) Source #

(Isomorphism cat, CatBiFunctor (,) cat) => CatBiFunctor (,) (Backprop cat) Source # 
Instance details

Defined in InfBackprop.Common

Methods

(***) :: Backprop cat a1 b1 -> Backprop cat a2 b2 -> Backprop cat (a1, a2) (b1, b2) Source #

first :: Backprop cat a b -> Backprop cat (a, c) (b, c) Source #

second :: Backprop cat a b -> Backprop cat (c, a) (c, b) Source #

CatBiFunctor (,) ((->) :: Type -> Type -> Type) Source # 
Instance details

Defined in Control.CatBifunctor

Methods

(***) :: (a1 -> b1) -> (a2 -> b2) -> (a1, a2) -> (b1, b2) Source #

first :: (a -> b) -> (a, c) -> (b, c) Source #

second :: (a -> b) -> (c, a) -> (c, b) Source #

Comonad m => CatBiFunctor (,) (Cokleisli m) Source # 
Instance details

Defined in Control.CatBifunctor

Methods

(***) :: Cokleisli m a1 b1 -> Cokleisli m a2 b2 -> Cokleisli m (a1, a2) (b1, b2) Source #

first :: Cokleisli m a b -> Cokleisli m (a, c) (b, c) Source #

second :: Cokleisli m a b -> Cokleisli m (c, a) (c, b) Source #

first :: CatBiFunctor p cat => cat a b -> cat (p a c) (p b c) Source #

Categorical generalization of

first :: (a -> b) -> (p a c -> p c b)

borrowed from arrows.

second :: CatBiFunctor p cat => cat a b -> cat (p c a) (p c b) Source #

Categorical generalization of

second :: (a -> b) -> (p a c -> p c b)

borrowed from arrows.

(***) :: CatBiFunctor p cat => cat a1 b1 -> cat a2 b2 -> cat (p a1 a2) (p b1 b2) Source #

Categorical generalization of

bimap :: (a1 -> b1) -> (a2 -> b2) -> (p a1 a2 -> p c1 c2)

borrowed from arrows.