Data.Functor.Rep: exported symbols usage examples

Symbols

  • apRep See 16 Occurences [+] Collapse [-]
    Found in Numeric.Algebra.Complex from the package algebra
      index (Complex a _ ) E = a
      index (Complex _ b ) I = b
    
    instance Distributive Complex where
      distribute = distributeRep 
    
    instance Functor Complex where
      fmap f (Complex a b) = Complex (f a) (f b)
    
    instance Apply Complex where
      (<.>) = apRep
    
    instance Applicative Complex where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Complex where
      (>>-) = bindRep
    
    instance Monad Complex where
    

    Found in Numeric.Algebra.Complex from the package algebra
    instance Representable Complex where
      type Rep Complex = ComplexBasis
      tabulate f = Complex (f E) (f I)
      index (Complex a _ ) E = a
      index (Complex _ b ) I = b
    
    instance Distributive Complex where
      distribute = distributeRep 
    
    instance Functor Complex where
      fmap f (Complex a b) = Complex (f a) (f b)
    
    instance Apply Complex where
      (<.>) = apRep
    
    instance Applicative Complex where
      pure = pureRep
      (<*>) = apRep 
    

    Found in Numeric.Algebra.Dual from the package algebra
      index (Dual a _ ) E = a
      index (Dual _ b ) D = b
    
    instance Distributive Dual where
      distribute = distributeRep 
    
    instance Functor Dual where
      fmap f (Dual a b) = Dual (f a) (f b)
    
    instance Apply Dual where
      (<.>) = apRep
    
    instance Applicative Dual where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Dual where
      (>>-) = bindRep
    
    instance Monad Dual where
    

    Found in Numeric.Algebra.Dual from the package algebra
    instance Representable Dual where
      type Rep Dual = DualBasis
      tabulate f = Dual (f E) (f D)
      index (Dual a _ ) E = a
      index (Dual _ b ) D = b
    
    instance Distributive Dual where
      distribute = distributeRep 
    
    instance Functor Dual where
      fmap f (Dual a b) = Dual (f a) (f b)
    
    instance Apply Dual where
      (<.>) = apRep
    
    instance Applicative Dual where
      pure = pureRep
      (<*>) = apRep 
    

    Found in Numeric.Algebra.Hyperbolic from the package algebra
      index (Hyper' a _ ) Cosh' = a
      index (Hyper' _ b ) Sinh' = b
    
    instance Distributive Hyper' where
      distribute = distributeRep 
    
    instance Functor Hyper' where
      fmap f (Hyper' a b) = Hyper' (f a) (f b)
    
    instance Apply Hyper' where
      (<.>) = apRep
    
    instance Applicative Hyper' where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Hyper' where
      (>>-) = bindRep
    
    instance Monad Hyper' where
    

    Found in Numeric.Algebra.Hyperbolic from the package algebra
    instance Representable Hyper' where
      type Rep Hyper' = HyperBasis'
      tabulate f = Hyper' (f Cosh') (f Sinh')
      index (Hyper' a _ ) Cosh' = a
      index (Hyper' _ b ) Sinh' = b
    
    instance Distributive Hyper' where
      distribute = distributeRep 
    
    instance Functor Hyper' where
      fmap f (Hyper' a b) = Hyper' (f a) (f b)
    
    instance Apply Hyper' where
      (<.>) = apRep
    
    instance Applicative Hyper' where
      pure = pureRep
      (<*>) = apRep 
    

    Found in Numeric.Algebra.Quaternion from the package algebra
      index (Quaternion _ _ c _) J = c
      index (Quaternion _ _ _ d) K = d
    
    instance Distributive Quaternion where
      distribute = distributeRep 
    
    instance Functor Quaternion where
      fmap = fmapRep
    
    instance Apply Quaternion where
      (<.>) = apRep
    
    instance Applicative Quaternion where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Quaternion where
      (>>-) = bindRep
    
    instance Monad Quaternion where
    

    Found in Numeric.Algebra.Quaternion from the package algebra
      type Rep Quaternion = QuaternionBasis
      tabulate f = Quaternion (f E) (f I) (f J) (f K)
      index (Quaternion a _ _ _) E = a
      index (Quaternion _ b _ _) I = b
      index (Quaternion _ _ c _) J = c
      index (Quaternion _ _ _ d) K = d
    
    instance Distributive Quaternion where
      distribute = distributeRep 
    
    instance Functor Quaternion where
      fmap = fmapRep
    
    instance Apply Quaternion where
      (<.>) = apRep
    
    instance Applicative Quaternion where
      pure = pureRep
      (<*>) = apRep 
    

    Found in Numeric.Coalgebra.Dual from the package algebra
      index (Dual' a _ ) E = a
      index (Dual' _ b ) D = b
    
    instance Distributive Dual' where
      distribute = distributeRep 
    
    instance Functor Dual' where
      fmap f (Dual' a b) = Dual' (f a) (f b)
    
    instance Apply Dual' where
      (<.>) = apRep
    
    instance Applicative Dual' where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Dual' where
      (>>-) = bindRep
    
    instance Monad Dual' where
    

    Found in Numeric.Coalgebra.Dual from the package algebra
    instance Representable Dual' where
      type Rep Dual' = DualBasis'
      tabulate f = Dual' (f E) (f D)
      index (Dual' a _ ) E = a
      index (Dual' _ b ) D = b
    
    instance Distributive Dual' where
      distribute = distributeRep 
    
    instance Functor Dual' where
      fmap f (Dual' a b) = Dual' (f a) (f b)
    
    instance Apply Dual' where
      (<.>) = apRep
    
    instance Applicative Dual' where
      pure = pureRep
      (<*>) = apRep 
    

    Found in Numeric.Coalgebra.Hyperbolic from the package algebra
      index (Hyper a _ ) Cosh = a
      index (Hyper _ b ) Sinh = b
    
    instance Distributive Hyper where
      distribute = distributeRep 
    
    instance Functor Hyper where
      fmap f (Hyper a b) = Hyper (f a) (f b)
    
    instance Apply Hyper where
      (<.>) = apRep
    
    instance Applicative Hyper where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Hyper where
      (>>-) = bindRep
    
    instance Monad Hyper where
    

    Found in Numeric.Coalgebra.Hyperbolic from the package algebra
    instance Representable Hyper where
      type Rep Hyper = HyperBasis
      tabulate f = Hyper (f Cosh) (f Sinh)
      index (Hyper a _ ) Cosh = a
      index (Hyper _ b ) Sinh = b
    
    instance Distributive Hyper where
      distribute = distributeRep 
    
    instance Functor Hyper where
      fmap f (Hyper a b) = Hyper (f a) (f b)
    
    instance Apply Hyper where
      (<.>) = apRep
    
    instance Applicative Hyper where
      pure = pureRep
      (<*>) = apRep 
    

    Found in Numeric.Coalgebra.Quaternion from the package algebra
      index (Quaternion' _ _ c _) J' = c
      index (Quaternion' _ _ _ d) K' = d
    
    instance Distributive Quaternion' where
      distribute = distributeRep
    
    instance Functor Quaternion' where
      fmap = fmapRep
    
    instance Apply Quaternion' where
      (<.>) = apRep
    
    instance Applicative Quaternion' where
      pure = pureRep
      (<*>) = apRep
    
    instance Bind Quaternion' where
      (>>-) = bindRep
    
    instance Monad Quaternion' where
    

    Found in Numeric.Coalgebra.Quaternion from the package algebra
      type Rep Quaternion' = QuaternionBasis'
      tabulate f = Quaternion' (f E') (f I') (f J') (f K')
      index (Quaternion' a _ _ _) E' = a
      index (Quaternion' _ b _ _) I' = b
      index (Quaternion' _ _ c _) J' = c
      index (Quaternion' _ _ _ d) K' = d
    
    instance Distributive Quaternion' where
      distribute = distributeRep
    
    instance Functor Quaternion' where
      fmap = fmapRep
    
    instance Apply Quaternion' where
      (<.>) = apRep
    
    instance Applicative Quaternion' where
      pure = pureRep
      (<*>) = apRep
    

    Found in Numeric.Coalgebra.Trigonometric from the package algebra
      index (Trig a _ ) Cos = a
      index (Trig _ b ) Sin = b
    
    instance Distributive Trig where
      distribute = distributeRep 
    
    instance Functor Trig where
      fmap f (Trig a b) = Trig (f a) (f b)
    
    instance Apply Trig where
      (<.>) = apRep
    
    instance Applicative Trig where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Trig where
      (>>-) = bindRep
    
    instance Monad Trig where
    

    Found in Numeric.Coalgebra.Trigonometric from the package algebra
    instance Representable Trig where
      type Rep Trig = TrigBasis
      tabulate f = Trig (f Cos) (f Sin)
      index (Trig a _ ) Cos = a
      index (Trig _ b ) Sin = b
    
    instance Distributive Trig where
      distribute = distributeRep 
    
    instance Functor Trig where
      fmap f (Trig a b) = Trig (f a) (f b)
    
    instance Apply Trig where
      (<.>) = apRep
    
    instance Applicative Trig where
      pure = pureRep
      (<*>) = apRep 
    

    askRep See 18 Occurences [+] Collapse [-]
    Found in Numeric.Algebra.Complex from the package algebra
      (<.>) = apRep
    
    instance Applicative Complex where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Complex where
      (>>-) = bindRep
    
    instance Monad Complex where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader ComplexBasis Complex where
      ask = askRep
      local = localRep
    
    instance Foldable Complex where
      foldMap f (Complex a b) = f a `mappend` f b
    

    Found in Numeric.Algebra.Dual from the package algebra
      (<.>) = apRep
    
    instance Applicative Dual where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Dual where
      (>>-) = bindRep
    
    instance Monad Dual where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader DualBasis Dual where
      ask = askRep
      local = localRep
    
    instance Foldable Dual where
      foldMap f (Dual a b) = f a `mappend` f b
    

    Found in Numeric.Algebra.Hyperbolic from the package algebra
      (<.>) = apRep
    
    instance Applicative Hyper' where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Hyper' where
      (>>-) = bindRep
    
    instance Monad Hyper' where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader HyperBasis' Hyper' where
      ask = askRep
      local = localRep
    
    instance Foldable Hyper' where
      foldMap f (Hyper' a b) = f a `mappend` f b
    

    Found in Numeric.Algebra.Quaternion from the package algebra
      (<.>) = apRep
    
    instance Applicative Quaternion where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Quaternion where
      (>>-) = bindRep
    
    instance Monad Quaternion where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader QuaternionBasis Quaternion where
      ask = askRep
      local = localRep
    
    instance Foldable Quaternion where
      foldMap f (Quaternion a b c d) = 
        f a `mappend` f b `mappend` f c `mappend` f d
    

    Found in Numeric.Coalgebra.Dual from the package algebra
      (<.>) = apRep
    
    instance Applicative Dual' where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Dual' where
      (>>-) = bindRep
    
    instance Monad Dual' where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader DualBasis' Dual' where
      ask = askRep
      local = localRep
    
    instance Foldable Dual' where
      foldMap f (Dual' a b) = f a `mappend` f b
    

    Found in Numeric.Coalgebra.Hyperbolic from the package algebra
      (<.>) = apRep
    
    instance Applicative Hyper where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Hyper where
      (>>-) = bindRep
    
    instance Monad Hyper where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader HyperBasis Hyper where
      ask = askRep
      local = localRep
    
    instance Foldable Hyper where
      foldMap f (Hyper a b) = f a `mappend` f b
    

    Found in Numeric.Coalgebra.Quaternion from the package algebra
      (<.>) = apRep
    
    instance Applicative Quaternion' where
      pure = pureRep
      (<*>) = apRep
    
    instance Bind Quaternion' where
      (>>-) = bindRep
    
    instance Monad Quaternion' where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader QuaternionBasis' Quaternion' where
      ask = askRep
      local = localRep
    
    instance Foldable Quaternion' where
      foldMap f (Quaternion' a b c d) =
        f a `mappend` f b `mappend` f c `mappend` f d
    

    Found in Numeric.Coalgebra.Trigonometric from the package algebra
      (<.>) = apRep
    
    instance Applicative Trig where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Trig where
      (>>-) = bindRep
    
    instance Monad Trig where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader TrigBasis Trig where
      ask = askRep
      local = localRep
    
    instance Foldable Trig where
      foldMap f (Trig a b) = f a `mappend` f b
    

    Found in Data.Fold.L from the package folds
      _ @> m = m
      {-# INLINE (@>) #-}
    
    instance Distributive (L a) where
      distribute = L (fmap extract) (\fm a -> fmap (prefix1 a) fm)
      {-# INLINE distribute #-}
    
    instance Functor.Representable (L a) where
      type Rep (L a) = [a]
      index = cosieve
      tabulate = cotabulate
    
    instance MonadReader [a] (L a) where
      ask = askRep
      local = localRep
    
    instance Costrong L where
      unfirst = unfirstCorep
      unsecond = unsecondCorep
    

    Found in Data.Fold.L' from the package folds
      closed (L' k h z) = L' (\f x -> k (f x)) (liftA2 h) (pure z)
    
    instance Profunctor.Corepresentable L' where
      type Corep L' = []
      cotabulate f = L' (f . reverse) (flip (:)) []
      {-# INLINE cotabulate #-}
    
    instance Cosieve L' [] where
      cosieve (L' k0 h0 z0) as0 = go k0 h0 z0 as0 where
        go k _ z [] = k z
        go k h z (a:as) = go k h (h z a) as
      {-# INLINE cosieve #-}
    
    instance MonadReader [a] (L' a) where
      ask = askRep
      local = localRep
    
    instance MonadFix (L' a) where
      mfix = mfixRep
    

    Found in Data.Fold.L1 from the package folds
      {-# INLINE cotabulate #-}
    
    instance Distributive (L1 a) where
      distribute = distributeRep
    
    instance Functor.Representable (L1 a) where
      type Rep (L1 a) = NonEmpty a
      tabulate = cotabulate
      index = cosieve
    
    instance Closed L1 where
      closed (L1 k h z) = L1 (\f x -> k (f x)) (liftA2 h) (fmap z)
    
    instance MonadReader (NonEmpty a) (L1 a) where
      ask = askRep
      local = localRep
    
    instance MonadFix (L1 a) where
      mfix = mfixRep
    

    Found in Data.Fold.L1' from the package folds
      {-# INLINE cotabulate #-}
    
    instance Distributive (L1' a) where
      distribute = distributeRep
    
    instance Functor.Representable (L1' a) where
      type Rep (L1' a) = NonEmpty a
      tabulate = cotabulate
      index = cosieve
    
    instance Closed L1' where
      closed (L1' k h z) = L1' (\f x -> k (f x)) (liftA2 h) (fmap z)
    
    instance MonadReader (NonEmpty a) (L1' a) where
      ask = askRep
      local = localRep
    
    instance MonadFix (L1' a) where
      mfix = mfixRep
    

    Found in Data.Fold.M from the package folds
      distribute fm = M (\t -> let g = foldDeRef t in run g <$> fm) One Two Zero
      {-# INLINE distribute #-}
    
    instance Closed M where
      closed (M k h m z) = M (\f x -> k (f x)) (fmap h) (liftA2 m) (pure z)
    
    instance Cosieve M FreeMonoid where
      cosieve = flip run
    
    instance Profunctor.Corepresentable M where
      type Corep M = FreeMonoid
      cotabulate f = M (f . foldDeRef) One Two Zero
    
    instance MonadReader (FreeMonoid a) (M a) where
      ask = askRep
      local = localRep
    
    instance Functor.Representable (M a) where
      type Rep (M a) = FreeMonoid a
      tabulate = cotabulate
    

    Found in Data.Fold.M1 from the package folds
    instance Profunctor.Corepresentable M1 where
      type Corep M1 = FreeSemigroup
      cotabulate f = M1 (f . foldDeRef1) Tip1 Bin1
    
    instance Functor.Representable (M1 a) where
      type Rep (M1 a) = FreeSemigroup a
      tabulate = cotabulate
      index = cosieve
    
    instance Costrong M1 where
      unfirst = unfirstCorep
      unsecond = unsecondCorep
    
    instance MonadReader (FreeSemigroup a) (M1 a) where
      ask = askRep
      local = localRep
    
    instance MonadFix (M1 a) where
      mfix = mfixRep
    

    Found in Data.Fold.R from the package folds
      unsecond = unsecondCorep
    
    instance Profunctor.Corepresentable R where
      type Corep R = []
      cotabulate f = R (f . reverse) (:) []
      {-# INLINE cotabulate #-}
    
    instance Cosieve R [] where
      cosieve (R k0 h0 z0) as0 = go k0 h0 z0 as0 where
        go k _ z [] = k z
        go k h z (a:as) = go k h (h a z) as
      {-# INLINE cosieve #-}
    
    instance MonadReader [a] (R a) where
      ask = askRep
      local = localRep
    
    instance Closed R where
      closed (R k h z) = R (\f x -> k (f x)) (liftA2 h) (pure z)
    

    Found in Data.Fold.R1 from the package folds
    instance Profunctor.Corepresentable R1 where
      type Corep R1 = NonEmpty
      cotabulate f = R1 (f . NonEmpty.fromList . Prelude.reverse) (:) pure
      {-# INLINE cotabulate #-}
    
    instance Distributive (R1 a) where
      distribute = distributeRep
    
    instance Functor.Representable (R1 a) where
      type Rep (R1 a) = NonEmpty a
      tabulate = cotabulate
      index = cosieve
    
    instance MonadReader (NonEmpty a) (R1 a) where
      ask = askRep
      local = localRep
    
    instance MonadFix (R1 a) where
      mfix = mfixRep
    

    Found in Data.Machine.Mealy from the package machines
    instance Profunctor.Corepresentable Mealy where
      type Corep Mealy = NonEmpty
      cotabulate f0 = Mealy $ \a -> go [a] f0 where
         go as f = (f (NonEmpty.fromList (Prelude.reverse as)), Mealy $ \b -> go (b:as) f)
    
    instance MonadFix (Mealy a) where
      mfix = mfixRep
    
    instance MonadZip (Mealy a) where
      mzipWith = mzipWithRep
      munzip m = (fmap fst m, fmap snd m)
    
    instance MonadReader (NonEmpty a) (Mealy a) where
      ask = askRep
      local = localRep
    
    instance Closed Mealy where
      closed m = cotabulate $ \fs x -> cosieve m (fmap ($x) fs)
    

    Found in Data.Machine.Moore from the package machines
    instance Profunctor.Corepresentable Moore where
      type Corep Moore = []
      cotabulate f0 = go (f0 . reverse) where
        go f = Moore (f []) $ \a -> go (f.(a:))
    
    instance MonadFix (Moore a) where
      mfix = mfixRep
    
    instance MonadZip (Moore a) where
      mzipWith = mzipWithRep
      munzip m = (fmap fst m, fmap snd m)
    
    instance MonadReader [a] (Moore a) where
      ask = askRep
      local = localRep
    
    instance Closed Moore where
      closed m = cotabulate $ \fs x -> cosieve m (fmap ($x) fs)
    

    bindRep See 16 Occurences [+] Collapse [-]
    Found in Numeric.Algebra.Complex from the package algebra
      fmap f (Complex a b) = Complex (f a) (f b)
    
    instance Apply Complex where
      (<.>) = apRep
    
    instance Applicative Complex where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Complex where
      (>>-) = bindRep
    
    instance Monad Complex where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader ComplexBasis Complex where
      ask = askRep
      local = localRep
    

    Found in Numeric.Algebra.Complex from the package algebra
    instance Distributive Complex where
      distribute = distributeRep 
    
    instance Functor Complex where
      fmap f (Complex a b) = Complex (f a) (f b)
    
    instance Apply Complex where
      (<.>) = apRep
    
    instance Applicative Complex where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Complex where
      (>>-) = bindRep
    
    instance Monad Complex where
      return = pureRep
      (>>=) = bindRep
    

    Found in Numeric.Algebra.Dual from the package algebra
      fmap f (Dual a b) = Dual (f a) (f b)
    
    instance Apply Dual where
      (<.>) = apRep
    
    instance Applicative Dual where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Dual where
      (>>-) = bindRep
    
    instance Monad Dual where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader DualBasis Dual where
      ask = askRep
      local = localRep
    

    Found in Numeric.Algebra.Dual from the package algebra
    instance Distributive Dual where
      distribute = distributeRep 
    
    instance Functor Dual where
      fmap f (Dual a b) = Dual (f a) (f b)
    
    instance Apply Dual where
      (<.>) = apRep
    
    instance Applicative Dual where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Dual where
      (>>-) = bindRep
    
    instance Monad Dual where
      return = pureRep
      (>>=) = bindRep
    

    Found in Numeric.Algebra.Hyperbolic from the package algebra
      fmap f (Hyper' a b) = Hyper' (f a) (f b)
    
    instance Apply Hyper' where
      (<.>) = apRep
    
    instance Applicative Hyper' where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Hyper' where
      (>>-) = bindRep
    
    instance Monad Hyper' where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader HyperBasis' Hyper' where
      ask = askRep
      local = localRep
    

    Found in Numeric.Algebra.Hyperbolic from the package algebra
    instance Distributive Hyper' where
      distribute = distributeRep 
    
    instance Functor Hyper' where
      fmap f (Hyper' a b) = Hyper' (f a) (f b)
    
    instance Apply Hyper' where
      (<.>) = apRep
    
    instance Applicative Hyper' where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Hyper' where
      (>>-) = bindRep
    
    instance Monad Hyper' where
      return = pureRep
      (>>=) = bindRep
    

    Found in Numeric.Algebra.Quaternion from the package algebra
      fmap = fmapRep
    
    instance Apply Quaternion where
      (<.>) = apRep
    
    instance Applicative Quaternion where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Quaternion where
      (>>-) = bindRep
    
    instance Monad Quaternion where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader QuaternionBasis Quaternion where
      ask = askRep
      local = localRep
    

    Found in Numeric.Algebra.Quaternion from the package algebra
    instance Distributive Quaternion where
      distribute = distributeRep 
    
    instance Functor Quaternion where
      fmap = fmapRep
    
    instance Apply Quaternion where
      (<.>) = apRep
    
    instance Applicative Quaternion where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Quaternion where
      (>>-) = bindRep
    
    instance Monad Quaternion where
      return = pureRep
      (>>=) = bindRep
    

    Found in Numeric.Coalgebra.Dual from the package algebra
      fmap f (Dual' a b) = Dual' (f a) (f b)
    
    instance Apply Dual' where
      (<.>) = apRep
    
    instance Applicative Dual' where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Dual' where
      (>>-) = bindRep
    
    instance Monad Dual' where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader DualBasis' Dual' where
      ask = askRep
      local = localRep
    

    Found in Numeric.Coalgebra.Dual from the package algebra
    instance Distributive Dual' where
      distribute = distributeRep 
    
    instance Functor Dual' where
      fmap f (Dual' a b) = Dual' (f a) (f b)
    
    instance Apply Dual' where
      (<.>) = apRep
    
    instance Applicative Dual' where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Dual' where
      (>>-) = bindRep
    
    instance Monad Dual' where
      return = pureRep
      (>>=) = bindRep
    

    Found in Numeric.Coalgebra.Hyperbolic from the package algebra
      fmap f (Hyper a b) = Hyper (f a) (f b)
    
    instance Apply Hyper where
      (<.>) = apRep
    
    instance Applicative Hyper where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Hyper where
      (>>-) = bindRep
    
    instance Monad Hyper where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader HyperBasis Hyper where
      ask = askRep
      local = localRep
    

    Found in Numeric.Coalgebra.Hyperbolic from the package algebra
    instance Distributive Hyper where
      distribute = distributeRep 
    
    instance Functor Hyper where
      fmap f (Hyper a b) = Hyper (f a) (f b)
    
    instance Apply Hyper where
      (<.>) = apRep
    
    instance Applicative Hyper where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Hyper where
      (>>-) = bindRep
    
    instance Monad Hyper where
      return = pureRep
      (>>=) = bindRep
    

    Found in Numeric.Coalgebra.Quaternion from the package algebra
      fmap = fmapRep
    
    instance Apply Quaternion' where
      (<.>) = apRep
    
    instance Applicative Quaternion' where
      pure = pureRep
      (<*>) = apRep
    
    instance Bind Quaternion' where
      (>>-) = bindRep
    
    instance Monad Quaternion' where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader QuaternionBasis' Quaternion' where
      ask = askRep
      local = localRep
    

    Found in Numeric.Coalgebra.Quaternion from the package algebra
    instance Distributive Quaternion' where
      distribute = distributeRep
    
    instance Functor Quaternion' where
      fmap = fmapRep
    
    instance Apply Quaternion' where
      (<.>) = apRep
    
    instance Applicative Quaternion' where
      pure = pureRep
      (<*>) = apRep
    
    instance Bind Quaternion' where
      (>>-) = bindRep
    
    instance Monad Quaternion' where
      return = pureRep
      (>>=) = bindRep
    

    Found in Numeric.Coalgebra.Trigonometric from the package algebra
      fmap f (Trig a b) = Trig (f a) (f b)
    
    instance Apply Trig where
      (<.>) = apRep
    
    instance Applicative Trig where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Trig where
      (>>-) = bindRep
    
    instance Monad Trig where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader TrigBasis Trig where
      ask = askRep
      local = localRep
    

    Found in Numeric.Coalgebra.Trigonometric from the package algebra
    instance Distributive Trig where
      distribute = distributeRep 
    
    instance Functor Trig where
      fmap f (Trig a b) = Trig (f a) (f b)
    
    instance Apply Trig where
      (<.>) = apRep
    
    instance Applicative Trig where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Trig where
      (>>-) = bindRep
    
    instance Monad Trig where
      return = pureRep
      (>>=) = bindRep
    

    collectRep No usage example found for this symbol :( Collapse [-]
    distributeRep See 14 Occurences [+] Collapse [-]
    Found in Numeric.Algebra.Complex from the package algebra
      e E = one
      e _ = zero
      
    instance Rig r => Complicated (ComplexBasis -> r) where
      i I = one
      i _ = zero 
    
    instance Representable Complex where
      type Rep Complex = ComplexBasis
      tabulate f = Complex (f E) (f I)
      index (Complex a _ ) E = a
      index (Complex _ b ) I = b
    
    instance Distributive Complex where
      distribute = distributeRep 
    
    instance Functor Complex where
      fmap f (Complex a b) = Complex (f a) (f b)
    
    instance Apply Complex where
    

    Found in Numeric.Algebra.Dual from the package algebra
      e _ = zero
    
    instance Rig r => Infinitesimal (DualBasis -> r) where
      d D = one
      d _       = zero 
    
    
    instance Representable Dual where
      type Rep Dual = DualBasis
      tabulate f = Dual (f E) (f D)
      index (Dual a _ ) E = a
      index (Dual _ b ) D = b
    
    instance Distributive Dual where
      distribute = distributeRep 
    
    instance Functor Dual where
      fmap f (Dual a b) = Dual (f a) (f b)
    
    instance Apply Dual where
    

    Found in Numeric.Algebra.Hyperbolic from the package algebra
      
    instance Rig r => Hyperbolic (HyperBasis' -> r) where
      cosh Sinh' = zero
      cosh Cosh' = one
      sinh Sinh' = one
      sinh Cosh' = zero
    
    instance Representable Hyper' where
      type Rep Hyper' = HyperBasis'
      tabulate f = Hyper' (f Cosh') (f Sinh')
      index (Hyper' a _ ) Cosh' = a
      index (Hyper' _ b ) Sinh' = b
    
    instance Distributive Hyper' where
      distribute = distributeRep 
    
    instance Functor Hyper' where
      fmap f (Hyper' a b) = Hyper' (f a) (f b)
    
    instance Apply Hyper' where
    

    Found in Numeric.Algebra.Quaternion from the package algebra
    -- quaternion basis
    data QuaternionBasis = E | I | J | K deriving (Eq,Ord,Enum,Read,Show,Bounded,Ix,Data,Typeable)
    
    data Quaternion a = Quaternion a a a a deriving (Eq,Show,Read,Data,Typeable)
    
    instance Representable Quaternion where
      type Rep Quaternion = QuaternionBasis
      tabulate f = Quaternion (f E) (f I) (f J) (f K)
      index (Quaternion a _ _ _) E = a
      index (Quaternion _ b _ _) I = b
      index (Quaternion _ _ c _) J = c
      index (Quaternion _ _ _ d) K = d
    
    instance Distributive Quaternion where
      distribute = distributeRep 
    
    instance Functor Quaternion where
      fmap = fmapRep
    
    instance Apply Quaternion where
    

    Found in Numeric.Coalgebra.Dual from the package algebra
      e E = one
      e _ = zero
    
    instance Rig r => Infinitesimal (DualBasis' -> r) where
      d D = one
      d _       = zero 
    
    instance Representable Dual' where
      type Rep Dual' = DualBasis'
      tabulate f = Dual' (f E) (f D)
      index (Dual' a _ ) E = a
      index (Dual' _ b ) D = b
    
    instance Distributive Dual' where
      distribute = distributeRep 
    
    instance Functor Dual' where
      fmap f (Dual' a b) = Dual' (f a) (f b)
    
    instance Apply Dual' where
    

    Found in Numeric.Coalgebra.Hyperbolic from the package algebra
    instance Rig r => Hyperbolic (HyperBasis -> r) where
      cosh Sinh = zero
      cosh Cosh = one
      sinh Sinh = one
      sinh Cosh = zero
    
    
    instance Representable Hyper where
      type Rep Hyper = HyperBasis
      tabulate f = Hyper (f Cosh) (f Sinh)
      index (Hyper a _ ) Cosh = a
      index (Hyper _ b ) Sinh = b
    
    instance Distributive Hyper where
      distribute = distributeRep 
    
    instance Functor Hyper where
      fmap f (Hyper a b) = Hyper (f a) (f b)
    
    instance Apply Hyper where
    

    Found in Numeric.Coalgebra.Quaternion from the package algebra
    -- quaternion basis
    data QuaternionBasis' = E' | I' | J' | K' deriving (Eq,Ord,Enum,Read,Show,Bounded,Ix,Data,Typeable)
    
    data Quaternion' a = Quaternion' a a a a deriving (Eq,Show,Read,Data,Typeable)
    
    instance Representable Quaternion' where
      type Rep Quaternion' = QuaternionBasis'
      tabulate f = Quaternion' (f E') (f I') (f J') (f K')
      index (Quaternion' a _ _ _) E' = a
      index (Quaternion' _ b _ _) I' = b
      index (Quaternion' _ _ c _) J' = c
      index (Quaternion' _ _ _ d) K' = d
    
    instance Distributive Quaternion' where
      distribute = distributeRep
    
    instance Functor Quaternion' where
      fmap = fmapRep
    
    instance Apply Quaternion' where
    

    Found in Numeric.Coalgebra.Trigonometric from the package algebra
    instance Rig r => Trigonometric (TrigBasis -> r) where
      cos Sin = zero
      cos Cos = one
    
      sin Sin = one
      sin Cos = zero
    
    instance Representable Trig where
      type Rep Trig = TrigBasis
      tabulate f = Trig (f Cos) (f Sin)
      index (Trig a _ ) Cos = a
      index (Trig _ b ) Sin = b
    
    instance Distributive Trig where
      distribute = distributeRep 
    
    instance Functor Trig where
      fmap f (Trig a b) = Trig (f a) (f b)
    
    instance Apply Trig where
    

    Found in Data.Fold.L1 from the package folds
    instance Cosieve L1 NonEmpty where
      cosieve (L1 k h z) (a :| as) = k (foldl h (z a) as)
    
    instance Costrong L1 where
      unfirst = unfirstCorep
      unsecond = unsecondCorep
    
    instance Profunctor.Corepresentable L1 where
      type Corep L1 = NonEmpty
      cotabulate f = L1 (f . NonEmpty.fromList . Prelude.reverse) (flip (:)) pure
      {-# INLINE cotabulate #-}
    
    instance Distributive (L1 a) where
      distribute = distributeRep
    
    instance Functor.Representable (L1 a) where
      type Rep (L1 a) = NonEmpty a
      tabulate = cotabulate
      index = cosieve
    

    Found in Data.Fold.L1' from the package folds
    instance Cosieve L1' NonEmpty where
      cosieve (L1' k h z) (a :| as) = k (foldl h (z a) as)
    
    instance Costrong L1' where
      unfirst = unfirstCorep
      unsecond = unsecondCorep
    
    instance Profunctor.Corepresentable L1' where
      type Corep L1' = NonEmpty
      cotabulate f = L1' (f . NonEmpty.fromList . Prelude.reverse) (flip (:)) pure
      {-# INLINE cotabulate #-}
    
    instance Distributive (L1' a) where
      distribute = distributeRep
    
    instance Functor.Representable (L1' a) where
      type Rep (L1' a) = NonEmpty a
      tabulate = cotabulate
      index = cosieve
    

    Found in Data.Fold.R1 from the package folds
    cata f0 z0 (a0 :| as0) = go f0 z0 a0 as0 where
      go _ z a [] = z a
      go f z a (b:bs) = f a (go f z b bs)
    
    instance Costrong R1 where
      unfirst = unfirstCorep
      unsecond = unsecondCorep
    
    instance Profunctor.Corepresentable R1 where
      type Corep R1 = NonEmpty
      cotabulate f = R1 (f . NonEmpty.fromList . Prelude.reverse) (:) pure
      {-# INLINE cotabulate #-}
    
    instance Distributive (R1 a) where
      distribute = distributeRep
    
    instance Functor.Representable (R1 a) where
      type Rep (R1 a) = NonEmpty a
      tabulate = cotabulate
      index = cosieve
    

    Found in Data.Vec.Lazy from the package vec
        pure x = N.induction1 VNil (x :::)
        (<*>)  = zipWith ($)
        _ *> x = x
        x <* _ = x
    #if MIN_VERSION_base(4,10,0)
        liftA2 = zipWith
    #endif
    
    instance N.SNatI n => Monad (Vec n) where
        return = pure
        (>>=)  = bind
        _ >> x = x
    
    instance N.SNatI n => Distributive (Vec n) where
        distribute = distributeRep
    
    instance N.SNatI n => Representable (Vec n) where
        type Rep (Vec n) = Fin n
        tabulate = fromPull . tabulate
        index    = index . toPull
    

    Found in Data.Vec.Lazy from the package vec
        )  where
    
    import Prelude ()
    import Prelude.Compat
           (Bool (..), Eq (..), Functor (..), Int, Maybe (..),
           Monad (..), Monoid (..), Num (..), Ord (..), Show (..), id, seq,
           showParen, showString, ($), (.), (<$>))
    
    import Control.Applicative (Applicative (..))
    import Control.DeepSeq     (NFData (..))
    import Control.Lens        ((<&>))
    import Data.Distributive   (Distributive (..))
    import Data.Fin            (Fin)
    import Data.Functor.Apply  (Apply (..))
    import Data.Functor.Rep    (Representable (..), distributeRep)
    import Data.Hashable       (Hashable (..))
    import Data.Nat
    import Data.Semigroup      (Semigroup (..))
    import Data.Typeable       (Typeable)
    

    Found in Data.Vector.Generic.Sized from the package vector-sized
    -- | The 'Monoid' instance for sized vectors does not have the same
    -- behaviour as the 'Monoid' instance for the unsized vectors found in the
    -- 'vectors' package. This instance has @mempty = replicate mempty@ and
    -- @mappend = zipWith mappend@, where the 'vectors' instance uses the empty
    -- vector and concatenation.
    --
    -- If 'mempty' is not necessary, using the 'Semigroup' instance over this
    -- 'Monoid' will dodge the 'KnownNat' constraint.
    instance (Monoid m, VG.Vector v m, KnownNat n) => Monoid (Vector v n m) where
      mempty = replicate mempty
      mappend = zipWith mappend
      mconcat vs = generate $ mconcat . flip fmap vs . flip index
    
    instance KnownNat n => Distributive (Vector Boxed.Vector n) where
      distribute = Rep.distributeRep
      {-# inline distribute #-}
    
    instance KnownNat n => Rep.Representable (Vector Boxed.Vector n) where
      type Rep (Vector Boxed.Vector n) = Finite n
      tabulate = generate
    

    duplicateRep No usage example found for this symbol :( Collapse [-]
    duplicateRepBy No usage example found for this symbol :( Collapse [-]
    duplicatedRep No usage example found for this symbol :( Collapse [-]
    extendRep No usage example found for this symbol :( Collapse [-]
    extendRepBy No usage example found for this symbol :( Collapse [-]
    extendedRep No usage example found for this symbol :( Collapse [-]
    extractRep No usage example found for this symbol :( Collapse [-]
    extractRepBy No usage example found for this symbol :( Collapse [-]
    fmapRep See 2 Occurences [+] Collapse [-]
    Found in Numeric.Algebra.Quaternion from the package algebra
    data Quaternion a = Quaternion a a a a deriving (Eq,Show,Read,Data,Typeable)
    
    instance Representable Quaternion where
      type Rep Quaternion = QuaternionBasis
      tabulate f = Quaternion (f E) (f I) (f J) (f K)
      index (Quaternion a _ _ _) E = a
      index (Quaternion _ b _ _) I = b
      index (Quaternion _ _ c _) J = c
      index (Quaternion _ _ _ d) K = d
    
    instance Distributive Quaternion where
      distribute = distributeRep 
    
    instance Functor Quaternion where
      fmap = fmapRep
    
    instance Apply Quaternion where
      (<.>) = apRep
    
    instance Applicative Quaternion where
    

    Found in Numeric.Coalgebra.Quaternion from the package algebra
    data Quaternion' a = Quaternion' a a a a deriving (Eq,Show,Read,Data,Typeable)
    
    instance Representable Quaternion' where
      type Rep Quaternion' = QuaternionBasis'
      tabulate f = Quaternion' (f E') (f I') (f J') (f K')
      index (Quaternion' a _ _ _) E' = a
      index (Quaternion' _ b _ _) I' = b
      index (Quaternion' _ _ c _) J' = c
      index (Quaternion' _ _ _ d) K' = d
    
    instance Distributive Quaternion' where
      distribute = distributeRep
    
    instance Functor Quaternion' where
      fmap = fmapRep
    
    instance Apply Quaternion' where
      (<.>) = apRep
    
    instance Applicative Quaternion' where
    

    gindex No usage example found for this symbol :( Collapse [-]
    gtabulate No usage example found for this symbol :( Collapse [-]
    ifoldMapRep No usage example found for this symbol :( Collapse [-]
    imapRep No usage example found for this symbol :( Collapse [-]
    itraverseRep No usage example found for this symbol :( Collapse [-]
    liftR2 No usage example found for this symbol :( Collapse [-]
    liftR3 No usage example found for this symbol :( Collapse [-]
    localRep See 18 Occurences [+] Collapse [-]
    Found in Numeric.Algebra.Complex from the package algebra
    instance Applicative Complex where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Complex where
      (>>-) = bindRep
    
    instance Monad Complex where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader ComplexBasis Complex where
      ask = askRep
      local = localRep
    
    instance Foldable Complex where
      foldMap f (Complex a b) = f a `mappend` f b
    
    instance Traversable Complex where
    

    Found in Numeric.Algebra.Dual from the package algebra
    instance Applicative Dual where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Dual where
      (>>-) = bindRep
    
    instance Monad Dual where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader DualBasis Dual where
      ask = askRep
      local = localRep
    
    instance Foldable Dual where
      foldMap f (Dual a b) = f a `mappend` f b
    
    instance Traversable Dual where
    

    Found in Numeric.Algebra.Hyperbolic from the package algebra
    instance Applicative Hyper' where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Hyper' where
      (>>-) = bindRep
    
    instance Monad Hyper' where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader HyperBasis' Hyper' where
      ask = askRep
      local = localRep
    
    instance Foldable Hyper' where
      foldMap f (Hyper' a b) = f a `mappend` f b
    
    instance Traversable Hyper' where
    

    Found in Numeric.Algebra.Quaternion from the package algebra
    instance Applicative Quaternion where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Quaternion where
      (>>-) = bindRep
    
    instance Monad Quaternion where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader QuaternionBasis Quaternion where
      ask = askRep
      local = localRep
    
    instance Foldable Quaternion where
      foldMap f (Quaternion a b c d) = 
        f a `mappend` f b `mappend` f c `mappend` f d
    

    Found in Numeric.Coalgebra.Dual from the package algebra
    instance Applicative Dual' where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Dual' where
      (>>-) = bindRep
    
    instance Monad Dual' where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader DualBasis' Dual' where
      ask = askRep
      local = localRep
    
    instance Foldable Dual' where
      foldMap f (Dual' a b) = f a `mappend` f b
    
    instance Traversable Dual' where
    

    Found in Numeric.Coalgebra.Hyperbolic from the package algebra
    instance Applicative Hyper where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Hyper where
      (>>-) = bindRep
    
    instance Monad Hyper where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader HyperBasis Hyper where
      ask = askRep
      local = localRep
    
    instance Foldable Hyper where
      foldMap f (Hyper a b) = f a `mappend` f b
    
    instance Traversable Hyper where
    

    Found in Numeric.Coalgebra.Quaternion from the package algebra
    instance Applicative Quaternion' where
      pure = pureRep
      (<*>) = apRep
    
    instance Bind Quaternion' where
      (>>-) = bindRep
    
    instance Monad Quaternion' where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader QuaternionBasis' Quaternion' where
      ask = askRep
      local = localRep
    
    instance Foldable Quaternion' where
      foldMap f (Quaternion' a b c d) =
        f a `mappend` f b `mappend` f c `mappend` f d
    

    Found in Numeric.Coalgebra.Trigonometric from the package algebra
    instance Applicative Trig where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Trig where
      (>>-) = bindRep
    
    instance Monad Trig where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader TrigBasis Trig where
      ask = askRep
      local = localRep
    
    instance Foldable Trig where
      foldMap f (Trig a b) = f a `mappend` f b
    
    instance Traversable Trig where
    

    Found in Data.Fold.L from the package folds
      _ @> m = m
      {-# INLINE (@>) #-}
    
    instance Distributive (L a) where
      distribute = L (fmap extract) (\fm a -> fmap (prefix1 a) fm)
      {-# INLINE distribute #-}
    
    instance Functor.Representable (L a) where
      type Rep (L a) = [a]
      index = cosieve
      tabulate = cotabulate
    
    instance MonadReader [a] (L a) where
      ask = askRep
      local = localRep
    
    instance Costrong L where
      unfirst = unfirstCorep
      unsecond = unsecondCorep
    

    Found in Data.Fold.L' from the package folds
    instance Profunctor.Corepresentable L' where
      type Corep L' = []
      cotabulate f = L' (f . reverse) (flip (:)) []
      {-# INLINE cotabulate #-}
    
    instance Cosieve L' [] where
      cosieve (L' k0 h0 z0) as0 = go k0 h0 z0 as0 where
        go k _ z [] = k z
        go k h z (a:as) = go k h (h z a) as
      {-# INLINE cosieve #-}
    
    instance MonadReader [a] (L' a) where
      ask = askRep
      local = localRep
    
    instance MonadFix (L' a) where
      mfix = mfixRep
    

    Found in Data.Fold.L1 from the package folds
    instance Distributive (L1 a) where
      distribute = distributeRep
    
    instance Functor.Representable (L1 a) where
      type Rep (L1 a) = NonEmpty a
      tabulate = cotabulate
      index = cosieve
    
    instance Closed L1 where
      closed (L1 k h z) = L1 (\f x -> k (f x)) (liftA2 h) (fmap z)
    
    instance MonadReader (NonEmpty a) (L1 a) where
      ask = askRep
      local = localRep
    
    instance MonadFix (L1 a) where
      mfix = mfixRep
    

    Found in Data.Fold.L1' from the package folds
    instance Distributive (L1' a) where
      distribute = distributeRep
    
    instance Functor.Representable (L1' a) where
      type Rep (L1' a) = NonEmpty a
      tabulate = cotabulate
      index = cosieve
    
    instance Closed L1' where
      closed (L1' k h z) = L1' (\f x -> k (f x)) (liftA2 h) (fmap z)
    
    instance MonadReader (NonEmpty a) (L1' a) where
      ask = askRep
      local = localRep
    
    instance MonadFix (L1' a) where
      mfix = mfixRep
    

    Found in Data.Fold.M from the package folds
      {-# INLINE distribute #-}
    
    instance Closed M where
      closed (M k h m z) = M (\f x -> k (f x)) (fmap h) (liftA2 m) (pure z)
    
    instance Cosieve M FreeMonoid where
      cosieve = flip run
    
    instance Profunctor.Corepresentable M where
      type Corep M = FreeMonoid
      cotabulate f = M (f . foldDeRef) One Two Zero
    
    instance MonadReader (FreeMonoid a) (M a) where
      ask = askRep
      local = localRep
    
    instance Functor.Representable (M a) where
      type Rep (M a) = FreeMonoid a
      tabulate = cotabulate
      index = cosieve
    

    Found in Data.Fold.M1 from the package folds
      type Corep M1 = FreeSemigroup
      cotabulate f = M1 (f . foldDeRef1) Tip1 Bin1
    
    instance Functor.Representable (M1 a) where
      type Rep (M1 a) = FreeSemigroup a
      tabulate = cotabulate
      index = cosieve
    
    instance Costrong M1 where
      unfirst = unfirstCorep
      unsecond = unsecondCorep
    
    instance MonadReader (FreeSemigroup a) (M1 a) where
      ask = askRep
      local = localRep
    
    instance MonadFix (M1 a) where
      mfix = mfixRep
    

    Found in Data.Fold.R from the package folds
    instance Profunctor.Corepresentable R where
      type Corep R = []
      cotabulate f = R (f . reverse) (:) []
      {-# INLINE cotabulate #-}
    
    instance Cosieve R [] where
      cosieve (R k0 h0 z0) as0 = go k0 h0 z0 as0 where
        go k _ z [] = k z
        go k h z (a:as) = go k h (h a z) as
      {-# INLINE cosieve #-}
    
    instance MonadReader [a] (R a) where
      ask = askRep
      local = localRep
    
    instance Closed R where
      closed (R k h z) = R (\f x -> k (f x)) (liftA2 h) (pure z)
    
    instance MonadFix (R a) where
    

    Found in Data.Fold.R1 from the package folds
      type Corep R1 = NonEmpty
      cotabulate f = R1 (f . NonEmpty.fromList . Prelude.reverse) (:) pure
      {-# INLINE cotabulate #-}
    
    instance Distributive (R1 a) where
      distribute = distributeRep
    
    instance Functor.Representable (R1 a) where
      type Rep (R1 a) = NonEmpty a
      tabulate = cotabulate
      index = cosieve
    
    instance MonadReader (NonEmpty a) (R1 a) where
      ask = askRep
      local = localRep
    
    instance MonadFix (R1 a) where
      mfix = mfixRep
    

    Found in Data.Machine.Mealy from the package machines
    instance Profunctor.Corepresentable Mealy where
      type Corep Mealy = NonEmpty
      cotabulate f0 = Mealy $ \a -> go [a] f0 where
         go as f = (f (NonEmpty.fromList (Prelude.reverse as)), Mealy $ \b -> go (b:as) f)
    
    instance MonadFix (Mealy a) where
      mfix = mfixRep
    
    instance MonadZip (Mealy a) where
      mzipWith = mzipWithRep
      munzip m = (fmap fst m, fmap snd m)
    
    instance MonadReader (NonEmpty a) (Mealy a) where
      ask = askRep
      local = localRep
    
    instance Closed Mealy where
      closed m = cotabulate $ \fs x -> cosieve m (fmap ($x) fs)
    
    instance Semigroup b => Semigroup (Mealy a b) where
    

    Found in Data.Machine.Moore from the package machines
    instance Profunctor.Corepresentable Moore where
      type Corep Moore = []
      cotabulate f0 = go (f0 . reverse) where
        go f = Moore (f []) $ \a -> go (f.(a:))
    
    instance MonadFix (Moore a) where
      mfix = mfixRep
    
    instance MonadZip (Moore a) where
      mzipWith = mzipWithRep
      munzip m = (fmap fst m, fmap snd m)
    
    instance MonadReader [a] (Moore a) where
      ask = askRep
      local = localRep
    
    instance Closed Moore where
      closed m = cotabulate $ \fs x -> cosieve m (fmap ($x) fs)
    

    mfixRep See 10 Occurences [+] Collapse [-]
    Found in Data.Fold.L from the package folds
      cosieve (L k0 h0 z0) as0 = go k0 h0 z0 as0 where
        go k _ z [] = k z
        go k h z (a:as) = go k h (h z a) as
      {-# INLINE cosieve #-}
    
    instance Closed L where
      closed (L k h z) = L (\f x -> k (f x)) (liftA2 h) (pure z)
    
    instance Profunctor.Corepresentable L where
      type Corep L = []
      cotabulate f = L (f . reverse) (flip (:)) []
      {-# INLINE cotabulate #-}
    
    instance MonadFix (L a) where
      mfix = mfixRep
    

    Found in Data.Fold.L' from the package folds
      cotabulate f = L' (f . reverse) (flip (:)) []
      {-# INLINE cotabulate #-}
    
    instance Cosieve L' [] where
      cosieve (L' k0 h0 z0) as0 = go k0 h0 z0 as0 where
        go k _ z [] = k z
        go k h z (a:as) = go k h (h z a) as
      {-# INLINE cosieve #-}
    
    instance MonadReader [a] (L' a) where
      ask = askRep
      local = localRep
    
    instance MonadFix (L' a) where
      mfix = mfixRep
    

    Found in Data.Fold.L1 from the package folds
    instance Functor.Representable (L1 a) where
      type Rep (L1 a) = NonEmpty a
      tabulate = cotabulate
      index = cosieve
    
    instance Closed L1 where
      closed (L1 k h z) = L1 (\f x -> k (f x)) (liftA2 h) (fmap z)
    
    instance MonadReader (NonEmpty a) (L1 a) where
      ask = askRep
      local = localRep
    
    instance MonadFix (L1 a) where
      mfix = mfixRep
    

    Found in Data.Fold.L1' from the package folds
    instance Functor.Representable (L1' a) where
      type Rep (L1' a) = NonEmpty a
      tabulate = cotabulate
      index = cosieve
    
    instance Closed L1' where
      closed (L1' k h z) = L1' (\f x -> k (f x)) (liftA2 h) (fmap z)
    
    instance MonadReader (NonEmpty a) (L1' a) where
      ask = askRep
      local = localRep
    
    instance MonadFix (L1' a) where
      mfix = mfixRep
    

    Found in Data.Fold.M from the package folds
    instance MonadReader (FreeMonoid a) (M a) where
      ask = askRep
      local = localRep
    
    instance Functor.Representable (M a) where
      type Rep (M a) = FreeMonoid a
      tabulate = cotabulate
      index = cosieve
    
    instance Costrong M where
      unfirst = unfirstCorep
      unsecond = unsecondCorep
    
    instance MonadFix (M a) where
      mfix = mfixRep
    

    Found in Data.Fold.M1 from the package folds
    instance Functor.Representable (M1 a) where
      type Rep (M1 a) = FreeSemigroup a
      tabulate = cotabulate
      index = cosieve
    
    instance Costrong M1 where
      unfirst = unfirstCorep
      unsecond = unsecondCorep
    
    instance MonadReader (FreeSemigroup a) (M1 a) where
      ask = askRep
      local = localRep
    
    instance MonadFix (M1 a) where
      mfix = mfixRep
    

    Found in Data.Fold.R from the package folds
    instance Cosieve R [] where
      cosieve (R k0 h0 z0) as0 = go k0 h0 z0 as0 where
        go k _ z [] = k z
        go k h z (a:as) = go k h (h a z) as
      {-# INLINE cosieve #-}
    
    instance MonadReader [a] (R a) where
      ask = askRep
      local = localRep
    
    instance Closed R where
      closed (R k h z) = R (\f x -> k (f x)) (liftA2 h) (pure z)
    
    instance MonadFix (R a) where
      mfix = mfixRep
    

    Found in Data.Fold.R1 from the package folds
    instance Distributive (R1 a) where
      distribute = distributeRep
    
    instance Functor.Representable (R1 a) where
      type Rep (R1 a) = NonEmpty a
      tabulate = cotabulate
      index = cosieve
    
    instance MonadReader (NonEmpty a) (R1 a) where
      ask = askRep
      local = localRep
    
    instance MonadFix (R1 a) where
      mfix = mfixRep
    

    Found in Data.Machine.Mealy from the package machines
          (b, m') -> case as of
            [] -> b
            a':as' -> go m' a' as'
    
    instance Costrong Mealy where
      unfirst = unfirstCorep
      unsecond = unsecondCorep
    
    instance Profunctor.Corepresentable Mealy where
      type Corep Mealy = NonEmpty
      cotabulate f0 = Mealy $ \a -> go [a] f0 where
         go as f = (f (NonEmpty.fromList (Prelude.reverse as)), Mealy $ \b -> go (b:as) f)
    
    instance MonadFix (Mealy a) where
      mfix = mfixRep
    
    instance MonadZip (Mealy a) where
      mzipWith = mzipWithRep
      munzip m = (fmap fst m, fmap snd m)
    

    Found in Data.Machine.Moore from the package machines
    instance Cosieve Moore [] where
      cosieve (Moore b _) [] = b
      cosieve (Moore _ k) (a:as) = cosieve (k a) as
    
    instance Costrong Moore where
      unfirst = unfirstCorep
      unsecond = unsecondCorep
    
    instance Profunctor.Corepresentable Moore where
      type Corep Moore = []
      cotabulate f0 = go (f0 . reverse) where
        go f = Moore (f []) $ \a -> go (f.(a:))
    
    instance MonadFix (Moore a) where
      mfix = mfixRep
    
    instance MonadZip (Moore a) where
      mzipWith = mzipWithRep
      munzip m = (fmap fst m, fmap snd m)
    

    mzipRep No usage example found for this symbol :( Collapse [-]
    mzipWithRep See 2 Occurences [+] Collapse [-]
    Found in Data.Machine.Mealy from the package machines
    instance Costrong Mealy where
      unfirst = unfirstCorep
      unsecond = unsecondCorep
    
    instance Profunctor.Corepresentable Mealy where
      type Corep Mealy = NonEmpty
      cotabulate f0 = Mealy $ \a -> go [a] f0 where
         go as f = (f (NonEmpty.fromList (Prelude.reverse as)), Mealy $ \b -> go (b:as) f)
    
    instance MonadFix (Mealy a) where
      mfix = mfixRep
    
    instance MonadZip (Mealy a) where
      mzipWith = mzipWithRep
      munzip m = (fmap fst m, fmap snd m)
    
    instance MonadReader (NonEmpty a) (Mealy a) where
      ask = askRep
      local = localRep
    

    Found in Data.Machine.Moore from the package machines
    instance Costrong Moore where
      unfirst = unfirstCorep
      unsecond = unsecondCorep
    
    instance Profunctor.Corepresentable Moore where
      type Corep Moore = []
      cotabulate f0 = go (f0 . reverse) where
        go f = Moore (f []) $ \a -> go (f.(a:))
    
    instance MonadFix (Moore a) where
      mfix = mfixRep
    
    instance MonadZip (Moore a) where
      mzipWith = mzipWithRep
      munzip m = (fmap fst m, fmap snd m)
    
    instance MonadReader [a] (Moore a) where
      ask = askRep
      local = localRep
    

    pureRep See 16 Occurences [+] Collapse [-]
    Found in Numeric.Algebra.Complex from the package algebra
    instance Functor Complex where
      fmap f (Complex a b) = Complex (f a) (f b)
    
    instance Apply Complex where
      (<.>) = apRep
    
    instance Applicative Complex where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Complex where
      (>>-) = bindRep
    
    instance Monad Complex where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader ComplexBasis Complex where
      ask = askRep
      local = localRep
    

    Found in Numeric.Algebra.Complex from the package algebra
      tabulate f = Complex (f E) (f I)
      index (Complex a _ ) E = a
      index (Complex _ b ) I = b
    
    instance Distributive Complex where
      distribute = distributeRep 
    
    instance Functor Complex where
      fmap f (Complex a b) = Complex (f a) (f b)
    
    instance Apply Complex where
      (<.>) = apRep
    
    instance Applicative Complex where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Complex where
      (>>-) = bindRep
    

    Found in Numeric.Algebra.Dual from the package algebra
    instance Functor Dual where
      fmap f (Dual a b) = Dual (f a) (f b)
    
    instance Apply Dual where
      (<.>) = apRep
    
    instance Applicative Dual where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Dual where
      (>>-) = bindRep
    
    instance Monad Dual where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader DualBasis Dual where
      ask = askRep
      local = localRep
    

    Found in Numeric.Algebra.Dual from the package algebra
      tabulate f = Dual (f E) (f D)
      index (Dual a _ ) E = a
      index (Dual _ b ) D = b
    
    instance Distributive Dual where
      distribute = distributeRep 
    
    instance Functor Dual where
      fmap f (Dual a b) = Dual (f a) (f b)
    
    instance Apply Dual where
      (<.>) = apRep
    
    instance Applicative Dual where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Dual where
      (>>-) = bindRep
    

    Found in Numeric.Algebra.Hyperbolic from the package algebra
    instance Functor Hyper' where
      fmap f (Hyper' a b) = Hyper' (f a) (f b)
    
    instance Apply Hyper' where
      (<.>) = apRep
    
    instance Applicative Hyper' where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Hyper' where
      (>>-) = bindRep
    
    instance Monad Hyper' where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader HyperBasis' Hyper' where
      ask = askRep
      local = localRep
    

    Found in Numeric.Algebra.Hyperbolic from the package algebra
      tabulate f = Hyper' (f Cosh') (f Sinh')
      index (Hyper' a _ ) Cosh' = a
      index (Hyper' _ b ) Sinh' = b
    
    instance Distributive Hyper' where
      distribute = distributeRep 
    
    instance Functor Hyper' where
      fmap f (Hyper' a b) = Hyper' (f a) (f b)
    
    instance Apply Hyper' where
      (<.>) = apRep
    
    instance Applicative Hyper' where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Hyper' where
      (>>-) = bindRep
    

    Found in Numeric.Algebra.Quaternion from the package algebra
    instance Functor Quaternion where
      fmap = fmapRep
    
    instance Apply Quaternion where
      (<.>) = apRep
    
    instance Applicative Quaternion where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Quaternion where
      (>>-) = bindRep
    
    instance Monad Quaternion where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader QuaternionBasis Quaternion where
      ask = askRep
      local = localRep
    

    Found in Numeric.Algebra.Quaternion from the package algebra
      index (Quaternion _ b _ _) I = b
      index (Quaternion _ _ c _) J = c
      index (Quaternion _ _ _ d) K = d
    
    instance Distributive Quaternion where
      distribute = distributeRep 
    
    instance Functor Quaternion where
      fmap = fmapRep
    
    instance Apply Quaternion where
      (<.>) = apRep
    
    instance Applicative Quaternion where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Quaternion where
      (>>-) = bindRep
    

    Found in Numeric.Coalgebra.Dual from the package algebra
    instance Functor Dual' where
      fmap f (Dual' a b) = Dual' (f a) (f b)
    
    instance Apply Dual' where
      (<.>) = apRep
    
    instance Applicative Dual' where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Dual' where
      (>>-) = bindRep
    
    instance Monad Dual' where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader DualBasis' Dual' where
      ask = askRep
      local = localRep
    

    Found in Numeric.Coalgebra.Dual from the package algebra
      tabulate f = Dual' (f E) (f D)
      index (Dual' a _ ) E = a
      index (Dual' _ b ) D = b
    
    instance Distributive Dual' where
      distribute = distributeRep 
    
    instance Functor Dual' where
      fmap f (Dual' a b) = Dual' (f a) (f b)
    
    instance Apply Dual' where
      (<.>) = apRep
    
    instance Applicative Dual' where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Dual' where
      (>>-) = bindRep
    

    Found in Numeric.Coalgebra.Hyperbolic from the package algebra
    instance Functor Hyper where
      fmap f (Hyper a b) = Hyper (f a) (f b)
    
    instance Apply Hyper where
      (<.>) = apRep
    
    instance Applicative Hyper where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Hyper where
      (>>-) = bindRep
    
    instance Monad Hyper where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader HyperBasis Hyper where
      ask = askRep
      local = localRep
    

    Found in Numeric.Coalgebra.Hyperbolic from the package algebra
      tabulate f = Hyper (f Cosh) (f Sinh)
      index (Hyper a _ ) Cosh = a
      index (Hyper _ b ) Sinh = b
    
    instance Distributive Hyper where
      distribute = distributeRep 
    
    instance Functor Hyper where
      fmap f (Hyper a b) = Hyper (f a) (f b)
    
    instance Apply Hyper where
      (<.>) = apRep
    
    instance Applicative Hyper where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Hyper where
      (>>-) = bindRep
    

    Found in Numeric.Coalgebra.Quaternion from the package algebra
    instance Functor Quaternion' where
      fmap = fmapRep
    
    instance Apply Quaternion' where
      (<.>) = apRep
    
    instance Applicative Quaternion' where
      pure = pureRep
      (<*>) = apRep
    
    instance Bind Quaternion' where
      (>>-) = bindRep
    
    instance Monad Quaternion' where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader QuaternionBasis' Quaternion' where
      ask = askRep
      local = localRep
    

    Found in Numeric.Coalgebra.Quaternion from the package algebra
      index (Quaternion' _ b _ _) I' = b
      index (Quaternion' _ _ c _) J' = c
      index (Quaternion' _ _ _ d) K' = d
    
    instance Distributive Quaternion' where
      distribute = distributeRep
    
    instance Functor Quaternion' where
      fmap = fmapRep
    
    instance Apply Quaternion' where
      (<.>) = apRep
    
    instance Applicative Quaternion' where
      pure = pureRep
      (<*>) = apRep
    
    instance Bind Quaternion' where
      (>>-) = bindRep
    

    Found in Numeric.Coalgebra.Trigonometric from the package algebra
    instance Functor Trig where
      fmap f (Trig a b) = Trig (f a) (f b)
    
    instance Apply Trig where
      (<.>) = apRep
    
    instance Applicative Trig where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Trig where
      (>>-) = bindRep
    
    instance Monad Trig where
      return = pureRep
      (>>=) = bindRep
    
    instance MonadReader TrigBasis Trig where
      ask = askRep
      local = localRep
    

    Found in Numeric.Coalgebra.Trigonometric from the package algebra
      tabulate f = Trig (f Cos) (f Sin)
      index (Trig a _ ) Cos = a
      index (Trig _ b ) Sin = b
    
    instance Distributive Trig where
      distribute = distributeRep 
    
    instance Functor Trig where
      fmap f (Trig a b) = Trig (f a) (f b)
    
    instance Apply Trig where
      (<.>) = apRep
    
    instance Applicative Trig where
      pure = pureRep
      (<*>) = apRep 
    
    instance Bind Trig where
      (>>-) = bindRep
    

    tabulated No usage example found for this symbol :( Collapse [-]
    Co No usage example found for this symbol :( Collapse [-]
    GRep No usage example found for this symbol :( Collapse [-]
    Representable No usage example found for this symbol :( Collapse [-]
    WrappedRep No usage example found for this symbol :( Collapse [-]