Generic.Functor.Internal.Implicit

Documentation

multimapI :: forall arr x y. MultimapI arr x y => arr -> x -> y

Core of multimap

multitraverse :: forall f arr x y. Multitraverse f arr x y => arr -> x -> f y

multifold_ :: forall m arr x y. Multifold_ m arr x y => arr -> Fold m x y

This is kept internal because of the Fold wrapping.

multimapOf :: forall cat arr x y. MultimapOf cat arr x y => arr -> cat x y

class MultimapOf (->) arr x y => MultimapI arr x y

Core of multimap.

Instances

MultimapOf ((->) :: Type -> Type -> Type) arr x y => MultimapI arr x y

Defined in Generic.Functor.Internal.Implicit

class MultimapOf (Fold m) arr x y => Multifold_ m arr x y

Constraint for multifold_.

Instances

MultimapOf (Fold m) arr x y => Multifold_ m arr x y

Defined in Generic.Functor.Internal.Implicit

class Multitraverse_ f arr x y => Multitraverse f arr x y

Constraint for multitraverse.

Instances

Multitraverse_ f arr x y => Multitraverse f arr x y

Defined in Generic.Functor.Internal.Implicit

type Multitraverse_ f arr x y = (MultimapOf (Kleisli f) (WrapKleisli f arr) x y, CoercibleKleisli f (WrapKleisli f arr) arr)

Internal definition of Multitraverse

type family WrapKleisli (f :: Type -> Type) (arr :: Type)

Instances

type WrapKleisli _f NilArr

Defined in Generic.Functor.Internal.Implicit

type WrapKleisli _f NilArr = NilArr

type WrapKleisli f (a -> f b)

Defined in Generic.Functor.Internal.Implicit

type WrapKleisli f (a -> f b) = Kleisli f a b

type WrapKleisli f (a :+ arr)

Defined in Generic.Functor.Internal.Implicit

type WrapKleisli f (a :+ arr) = WrapKleisli f a :+ WrapKleisli f arr

type WrapKleisli _f (Rule rule mode)

Defined in Generic.Functor.Internal.Implicit

type WrapKleisli _f (Rule rule mode) = Rule rule mode

class Coercible warr arr => CoercibleKleisli (f :: Type -> Type) warr arr

Auxiliary constraint for Multitraverse

Instances

d ~ NilArr => CoercibleKleisli f d NilArr

Defined in Generic.Functor.Internal.Implicit

(b2 ~ f c, a ~ Kleisli f b1 c) => CoercibleKleisli f a (b1 -> b2)

Defined in Generic.Functor.Internal.Implicit

d ~ Rule rule mode => CoercibleKleisli f d (Rule rule mode)

Defined in Generic.Functor.Internal.Implicit

(CoercibleKleisli f a b, CoercibleKleisli f arr arr') => CoercibleKleisli f (a :+ arr) (b :+ arr')

Defined in Generic.Functor.Internal.Implicit

class Multimap_ cat (S2 arr) x y => MultimapOf cat arr x y

Instances

Multimap_ cat (S2 arr) x y => MultimapOf cat arr x y

Defined in Generic.Functor.Internal.Implicit

newtype Fold m x y

Fold m is like Kleisli (Const m), but it has a different FunctorOf instance, with Foldable instead of Traversable.

Constructors

Fold

Fields

• unFold :: x -> m

Instances

Monoid m => CatLike (Fold m)

Defined in Generic.Functor.Internal.Implicit

Methods

catid :: Fold m x x

(Bifoldable t, Monoid m) => BifunctorOf (Fold m) t

Defined in Generic.Functor.Internal.Implicit

Methods

catbimap :: Fold m a b -> Fold m c d -> Fold m (t a c) (t b d)

(Foldable t, Monoid m) => FunctorOf (Fold m) t

Defined in Generic.Functor.Internal.Implicit

Methods

catmap :: Fold m a b -> Fold m (t a) (t b)

Internal

class CatLike cat where

Methods

catid :: cat x x

Instances

Applicative f => CatLike (Kleisli f)

Defined in Generic.Functor.Internal.Implicit

Methods

catid :: Kleisli f x x

Monoid m => CatLike (Fold m)

Defined in Generic.Functor.Internal.Implicit

Methods

catid :: Fold m x x

CatLike ((->) :: Type -> Type -> Type)

Defined in Generic.Functor.Internal.Implicit

Methods

catid :: x -> x

class FunctorOf cat t where

Methods

catmap :: cat a b -> cat (t a) (t b)

Instances

(Applicative f, Traversable t) => FunctorOf (Kleisli f) t

Defined in Generic.Functor.Internal.Implicit

Methods

catmap :: Kleisli f a b -> Kleisli f (t a) (t b)

(Foldable t, Monoid m) => FunctorOf (Fold m) t

Defined in Generic.Functor.Internal.Implicit

Methods

catmap :: Fold m a b -> Fold m (t a) (t b)

Functor t => FunctorOf ((->) :: Type -> Type -> Type) t

Defined in Generic.Functor.Internal.Implicit

Methods

catmap :: (a -> b) -> t a -> t b

class BifunctorOf cat t where

Methods

catbimap :: cat a b -> cat c d -> cat (t a c) (t b d)

Instances

(Applicative f, Bitraversable t) => BifunctorOf (Kleisli f) t

Defined in Generic.Functor.Internal.Implicit

Methods

catbimap :: Kleisli f a b -> Kleisli f c d -> Kleisli f (t a c) (t b d)

(Bifoldable t, Monoid m) => BifunctorOf (Fold m) t

Defined in Generic.Functor.Internal.Implicit

Methods

catbimap :: Fold m a b -> Fold m c d -> Fold m (t a c) (t b d)

Bifunctor t => BifunctorOf ((->) :: Type -> Type -> Type) t

Defined in Generic.Functor.Internal.Implicit

Methods

catbimap :: (a -> b) -> (c -> d) -> t a c -> t b d

class Multimap_ cat arr x y where

Internal implementation of MultimapOf.

Methods

multimap_ :: arr -> cat x y

Instances

CatLike cat => Multimap_ cat (S arr (Rule AnyId Incoherent :+ arr')) x x

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyId Incoherent :+ arr') -> cat x x

Multimap_ cat (S arr (cat a b :+ arr')) a b

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (cat a b :+ arr') -> cat a b

Multimap_ cat (S arr arr') x y => Multimap_ cat (S arr (() :+ arr')) x y

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (() :+ arr') -> cat x y

Multimap_ cat (S arr arr') x y => Multimap_ cat (S arr (NilArr :+ arr')) x y

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (NilArr :+ arr') -> cat x y

Multimap_ cat (S arr (arr0 :+ (arr1 :+ arr2))) x y => Multimap_ cat (S arr ((arr0 :+ arr1) :+ arr2)) x y

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr ((arr0 :+ arr1) :+ arr2) -> cat x y

Multimap_ cat (S arr arr') x y => Multimap_ cat (S arr (arr0 :+ arr')) x y

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (arr0 :+ arr') -> cat x y

(FunctorOf cat f, MultimapOf cat arr x y) => Multimap_ cat (S arr (Rule AnyFunctor Incoherent :+ arr')) (f x) (f y)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyFunctor Incoherent :+ arr') -> cat (f x) (f y)

(BifunctorOf cat f, MultimapOf cat arr x1 y1, MultimapOf cat arr x2 y2) => Multimap_ cat (S arr (Rule AnyBifunctor Incoherent :+ arr')) (f x1 x2) (f y1 y2)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyBifunctor Incoherent :+ arr') -> cat (f x1 x2) (f y1 y2)

(MultimapOf ((->) :: Type -> Type -> Type) arr y1 x1, MultimapOf ((->) :: Type -> Type -> Type) arr x2 y2) => Multimap_ ((->) :: Type -> Type -> Type) (S arr (Rule AnyBifunctor Incoherent :+ arr')) (x1 -> x2) (y1 -> y2)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyBifunctor Incoherent :+ arr') -> (x1 -> x2) -> (y1 -> y2)

data a :+ b infixr 1

Heterogeneous lists of arrows are constructed as lists separated by (:+) and terminated by ().

Example

Given f :: a -> a' and g :: b -> b', (f :+ g :+ ()) is a list with the two elements f and g.

if
  f :: a -> a'
  g :: b -> b'

then
  f :+ g :+ ()  ::  (a -> a') :+ (b -> b') :+ ()

Those lists are used by gmultimap and multimap.

bimap_ :: (a -> a') -> (b -> b') -> (Maybe a, [Either b a]) -> (Maybe a', [Either b' a'])
bimap_ f g = multimap (f :+ g :+ ())

Constructors

a :+ b infixr 1

Instances

CatLike cat => Multimap_ cat (S arr (Rule AnyId Incoherent :+ arr')) x x

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyId Incoherent :+ arr') -> cat x x

Multimap_ cat (S arr (cat a b :+ arr')) a b

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (cat a b :+ arr') -> cat a b

Multimap_ cat (S arr arr') x y => Multimap_ cat (S arr (() :+ arr')) x y

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (() :+ arr') -> cat x y

Multimap_ cat (S arr arr') x y => Multimap_ cat (S arr (NilArr :+ arr')) x y

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (NilArr :+ arr') -> cat x y

Multimap_ cat (S arr (arr0 :+ (arr1 :+ arr2))) x y => Multimap_ cat (S arr ((arr0 :+ arr1) :+ arr2)) x y

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr ((arr0 :+ arr1) :+ arr2) -> cat x y

Multimap_ cat (S arr arr') x y => Multimap_ cat (S arr (arr0 :+ arr')) x y

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (arr0 :+ arr') -> cat x y

(FunctorOf cat f, MultimapOf cat arr x y) => Multimap_ cat (S arr (Rule AnyFunctor Incoherent :+ arr')) (f x) (f y)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyFunctor Incoherent :+ arr') -> cat (f x) (f y)

(CoercibleKleisli f a b, CoercibleKleisli f arr arr') => CoercibleKleisli f (a :+ arr) (b :+ arr')

Defined in Generic.Functor.Internal.Implicit

(BifunctorOf cat f, MultimapOf cat arr x1 y1, MultimapOf cat arr x2 y2) => Multimap_ cat (S arr (Rule AnyBifunctor Incoherent :+ arr')) (f x1 x2) (f y1 y2)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyBifunctor Incoherent :+ arr') -> cat (f x1 x2) (f y1 y2)

(MultimapOf ((->) :: Type -> Type -> Type) arr y1 x1, MultimapOf ((->) :: Type -> Type -> Type) arr x2 y2) => Multimap_ ((->) :: Type -> Type -> Type) (S arr (Rule AnyBifunctor Incoherent :+ arr')) (x1 -> x2) (y1 -> y2)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyBifunctor Incoherent :+ arr') -> (x1 -> x2) -> (y1 -> y2)

type WrapKleisli f (a :+ arr)

Defined in Generic.Functor.Internal.Implicit

type WrapKleisli f (a :+ arr) = WrapKleisli f a :+ WrapKleisli f arr

data Rule rule mode

Constructors

Rule rule mode

Instances

d ~ Rule rule mode => CoercibleKleisli f d (Rule rule mode)

Defined in Generic.Functor.Internal.Implicit

CatLike cat => Multimap_ cat (S arr (Rule AnyId Incoherent :+ arr')) x x

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyId Incoherent :+ arr') -> cat x x

(FunctorOf cat f, MultimapOf cat arr x y) => Multimap_ cat (S arr (Rule AnyFunctor Incoherent :+ arr')) (f x) (f y)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyFunctor Incoherent :+ arr') -> cat (f x) (f y)

(BifunctorOf cat f, MultimapOf cat arr x1 y1, MultimapOf cat arr x2 y2) => Multimap_ cat (S arr (Rule AnyBifunctor Incoherent :+ arr')) (f x1 x2) (f y1 y2)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyBifunctor Incoherent :+ arr') -> cat (f x1 x2) (f y1 y2)

(MultimapOf ((->) :: Type -> Type -> Type) arr y1 x1, MultimapOf ((->) :: Type -> Type -> Type) arr x2 y2) => Multimap_ ((->) :: Type -> Type -> Type) (S arr (Rule AnyBifunctor Incoherent :+ arr')) (x1 -> x2) (y1 -> y2)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyBifunctor Incoherent :+ arr') -> (x1 -> x2) -> (y1 -> y2)

type WrapKleisli _f (Rule rule mode)

Defined in Generic.Functor.Internal.Implicit

type WrapKleisli _f (Rule rule mode) = Rule rule mode

data AnyId

Constructors

AnyId

Instances

CatLike cat => Multimap_ cat (S arr (Rule AnyId Incoherent :+ arr')) x x

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyId Incoherent :+ arr') -> cat x x

data AnyFunctor

Constructors

AnyFunctor

Instances

(FunctorOf cat f, MultimapOf cat arr x y) => Multimap_ cat (S arr (Rule AnyFunctor Incoherent :+ arr')) (f x) (f y)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyFunctor Incoherent :+ arr') -> cat (f x) (f y)

data AnyBifunctor

Constructors

AnyBifunctor

Instances

(BifunctorOf cat f, MultimapOf cat arr x1 y1, MultimapOf cat arr x2 y2) => Multimap_ cat (S arr (Rule AnyBifunctor Incoherent :+ arr')) (f x1 x2) (f y1 y2)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyBifunctor Incoherent :+ arr') -> cat (f x1 x2) (f y1 y2)

(MultimapOf ((->) :: Type -> Type -> Type) arr y1 x1, MultimapOf ((->) :: Type -> Type -> Type) arr x2 y2) => Multimap_ ((->) :: Type -> Type -> Type) (S arr (Rule AnyBifunctor Incoherent :+ arr')) (x1 -> x2) (y1 -> y2)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyBifunctor Incoherent :+ arr') -> (x1 -> x2) -> (y1 -> y2)

data NilArr

Constructors

NilArr

Instances

d ~ NilArr => CoercibleKleisli f d NilArr

Defined in Generic.Functor.Internal.Implicit

Multimap_ cat (S arr arr') x y => Multimap_ cat (S arr (NilArr :+ arr')) x y

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (NilArr :+ arr') -> cat x y

type WrapKleisli _f NilArr

Defined in Generic.Functor.Internal.Implicit

type WrapKleisli _f NilArr = NilArr

data Incoherent

Constructors

Incoherent

Instances

CatLike cat => Multimap_ cat (S arr (Rule AnyId Incoherent :+ arr')) x x

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyId Incoherent :+ arr') -> cat x x

(FunctorOf cat f, MultimapOf cat arr x y) => Multimap_ cat (S arr (Rule AnyFunctor Incoherent :+ arr')) (f x) (f y)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyFunctor Incoherent :+ arr') -> cat (f x) (f y)

(BifunctorOf cat f, MultimapOf cat arr x1 y1, MultimapOf cat arr x2 y2) => Multimap_ cat (S arr (Rule AnyBifunctor Incoherent :+ arr')) (f x1 x2) (f y1 y2)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyBifunctor Incoherent :+ arr') -> cat (f x1 x2) (f y1 y2)

(MultimapOf ((->) :: Type -> Type -> Type) arr y1 x1, MultimapOf ((->) :: Type -> Type -> Type) arr x2 y2) => Multimap_ ((->) :: Type -> Type -> Type) (S arr (Rule AnyBifunctor Incoherent :+ arr')) (x1 -> x2) (y1 -> y2)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyBifunctor Incoherent :+ arr') -> (x1 -> x2) -> (y1 -> y2)

type Default mode arr = arr :+ (Rule AnyId mode :+ (Rule AnyFunctor mode :+ (Rule AnyBifunctor mode :+ NilArr)))

defaultIncoherent :: arr -> Default Incoherent arr

def :: mode -> arr -> Default mode arr

data S arr arr'

arr is the list of arrows provided by the user. It is constant. When testing whether any arrow matches, arr' is the remaining list of arrows to be tested.

Constructors

S arr arr'

Instances

CatLike cat => Multimap_ cat (S arr (Rule AnyId Incoherent :+ arr')) x x

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyId Incoherent :+ arr') -> cat x x

Multimap_ cat (S arr (cat a b :+ arr')) a b

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (cat a b :+ arr') -> cat a b

Multimap_ cat (S arr arr') x y => Multimap_ cat (S arr (() :+ arr')) x y

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (() :+ arr') -> cat x y

Multimap_ cat (S arr arr') x y => Multimap_ cat (S arr (NilArr :+ arr')) x y

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (NilArr :+ arr') -> cat x y

Multimap_ cat (S arr (arr0 :+ (arr1 :+ arr2))) x y => Multimap_ cat (S arr ((arr0 :+ arr1) :+ arr2)) x y

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr ((arr0 :+ arr1) :+ arr2) -> cat x y

Multimap_ cat (S arr arr') x y => Multimap_ cat (S arr (arr0 :+ arr')) x y

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (arr0 :+ arr') -> cat x y

(FunctorOf cat f, MultimapOf cat arr x y) => Multimap_ cat (S arr (Rule AnyFunctor Incoherent :+ arr')) (f x) (f y)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyFunctor Incoherent :+ arr') -> cat (f x) (f y)

(BifunctorOf cat f, MultimapOf cat arr x1 y1, MultimapOf cat arr x2 y2) => Multimap_ cat (S arr (Rule AnyBifunctor Incoherent :+ arr')) (f x1 x2) (f y1 y2)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyBifunctor Incoherent :+ arr') -> cat (f x1 x2) (f y1 y2)

(MultimapOf ((->) :: Type -> Type -> Type) arr y1 x1, MultimapOf ((->) :: Type -> Type -> Type) arr x2 y2) => Multimap_ ((->) :: Type -> Type -> Type) (S arr (Rule AnyBifunctor Incoherent :+ arr')) (x1 -> x2) (y1 -> y2)

Defined in Generic.Functor.Internal.Implicit

Methods

multimap_ :: S arr (Rule AnyBifunctor Incoherent :+ arr') -> (x1 -> x2) -> (y1 -> y2)

type S2 arr = S arr arr

s2 :: arr -> S2 arr