| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
ConCat.Misc
Description
Miscellany
Synopsis
- type family as ++ bs where ...
- type C1 (con :: u -> Constraint) a = con a
- type C = Complex R
- type R = Double
- class (a, b) => a && b
- type (:+) = Either
- class f b a => Flip f a b
- type (:=>) = (->)
- type (:*) = (,)
- newtype Parity = Parity {}
- type (:^) s n = n -> s
- type Binop a = a -> Unop a
- data PseudoFun = PseudoFun {
- pseudoArgs :: Int
- class (a t, b t) => (a &+& b) t
- type C2 (con :: u -> Constraint) a b = (con a, con b)
- type C3 (con :: u -> Constraint) a b c = (con a, con b, con c)
- type C4 (con :: u -> Constraint) a b c d = (con a, con b, con c, con d)
- type C5 (con :: u -> Constraint) a b c d e = (con a, con b, con c, con d, con e)
- type C6 (con :: u -> Constraint) a b c d e f = (con a, con b, con c, con d, con e, con f)
- type Unop a = a -> a
- type Ternop a = a -> Binop a
- class Yes0
- class Yes1 a
- class Yes2 a b
- type family FoldrC op b0 as where ...
- type family MapC f us where ...
- type AndC cs = FoldrC (&&) Yes0 cs
- type AllC f us = AndC (MapC f us)
- type family CrossWith f as bs where ...
- type AllC2 f as bs = AndC (CrossWith f as bs)
- transpose :: (Traversable t, Applicative f) => t (f a) -> f (t a)
- unzip :: Functor f => f (a :* b) -> f a :* f b
- xor :: Binop Bool
- compose :: Foldable f => f (Unop a) -> Unop a
- bottom :: a
- delay :: a -> a
- int :: forall n. KnownNat n => Int
- inComp :: (g (f a) -> g' (f' a')) -> (g :.: f) a -> (g' :.: f') a'
- inComp2 :: (g (f a) -> g' (f' a') -> g'' (f'' a'')) -> (g :.: f) a -> (g' :.: f') a' -> (g'' :.: f'') a''
- underF :: (Newtype n, Newtype n', o' ~ O n', o ~ O n, Functor f, Functor g) => (o -> n) -> (f n -> g n') -> f o -> g o'
- overF :: (Newtype n, Newtype n', o' ~ O n', o ~ O n, Functor f, Functor g) => (o -> n) -> (f o -> g o') -> f n -> g n'
- inNew2 :: (Newtype p, Newtype q, Newtype r) => (O p -> O q -> O r) -> p -> q -> r
- (<~) :: forall a b a' b'. (b -> b') -> (a' -> a) -> (a -> b) -> a' -> b'
- (~>) :: forall a b a' b'. (a' -> a) -> (b -> b') -> (a -> b) -> a' -> b'
- result :: (b -> c) -> (a -> b) -> a -> c
- inGeneric1 :: (Generic1 f, Generic1 g) => (Rep1 f a -> Rep1 g b) -> f a -> g b
- absurdF :: V1 a -> b
- boolToInt :: Bool -> Int
- cond :: a -> a -> Bool -> a
- typeR :: forall a. Typeable a => TypeRep
- sqr :: Num a => a -> a
- magSqr :: Num a => (a :* a) -> a
- inTranspose :: (Applicative f, Traversable t, Applicative f', Traversable t') => (f (t a) -> t' (f' a)) -> t (f a) -> f' (t' a)
- natValAt :: forall n. KnownNat n => Integer
- nat :: forall n. KnownNat n => Integer
- inNew :: (Newtype p, Newtype q) => (O p -> O q) -> p -> q
- exNew :: (Newtype p, Newtype q) => (p -> q) -> O p -> O q
- exNew2 :: (Newtype p, Newtype q, Newtype r) => (p -> q -> r) -> O p -> O q -> O r
- oops :: String -> b
Documentation
type C1 (con :: u -> Constraint) a = con a Source #
class f b a => Flip f a b Source #
Instances
| f b a => Flip (f :: k1 -> k2 -> Constraint) (a :: k2) (b :: k1) Source # | |
Defined in ConCat.Misc | |
Annotation for pseudo-function, i.e., defined by rules. During ccc generation, don't split applications. TODO: maybe add an arity.
Constructors
| PseudoFun | |
Fields
| |
Instances
| Data PseudoFun Source # | |
Defined in ConCat.Misc Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PseudoFun -> c PseudoFun Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PseudoFun Source # toConstr :: PseudoFun -> Constr Source # dataTypeOf :: PseudoFun -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PseudoFun) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PseudoFun) Source # gmapT :: (forall b. Data b => b -> b) -> PseudoFun -> PseudoFun Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PseudoFun -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PseudoFun -> r Source # gmapQ :: (forall d. Data d => d -> u) -> PseudoFun -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> PseudoFun -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PseudoFun -> m PseudoFun Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PseudoFun -> m PseudoFun Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PseudoFun -> m PseudoFun Source # | |
class (a t, b t) => (a &+& b) t infixr 3 Source #
Instances
| (a t, b t) => ((a :: k -> Constraint) &+& (b :: k -> Constraint)) (t :: k) Source # | |
Defined in ConCat.Misc | |
| (OpSat op con, OpSat op con') => OpCon (op :: k -> k -> k) (Sat (con &+& con') :: k -> Type) Source # | |
type C2 (con :: u -> Constraint) a b = (con a, con b) Source #
type C3 (con :: u -> Constraint) a b c = (con a, con b, con c) Source #
type C4 (con :: u -> Constraint) a b c d = (con a, con b, con c, con d) Source #
type C5 (con :: u -> Constraint) a b c d e = (con a, con b, con c, con d, con e) Source #
type C6 (con :: u -> Constraint) a b c d e f = (con a, con b, con c, con d, con e, con f) Source #
transpose :: (Traversable t, Applicative f) => t (f a) -> f (t a) Source #
inComp :: (g (f a) -> g' (f' a')) -> (g :.: f) a -> (g' :.: f') a' Source #
Apply a unary function within the Comp1 constructor.
inComp2 :: (g (f a) -> g' (f' a') -> g'' (f'' a'')) -> (g :.: f) a -> (g' :.: f') a' -> (g'' :.: f'') a'' Source #
Apply a binary function within the Comp1 constructor.
underF :: (Newtype n, Newtype n', o' ~ O n', o ~ O n, Functor f, Functor g) => (o -> n) -> (f n -> g n') -> f o -> g o' Source #
overF :: (Newtype n, Newtype n', o' ~ O n', o ~ O n, Functor f, Functor g) => (o -> n) -> (f o -> g o') -> f n -> g n' Source #
(<~) :: forall a b a' b'. (b -> b') -> (a' -> a) -> (a -> b) -> a' -> b' infixl 1 Source #
Add post- and pre-processing
(~>) :: forall a b a' b'. (a' -> a) -> (b -> b') -> (a -> b) -> a' -> b' infixr 1 Source #
Add pre- and post-processing
inGeneric1 :: (Generic1 f, Generic1 g) => (Rep1 f a -> Rep1 g b) -> f a -> g b Source #
Operate inside a Generic1
inTranspose :: (Applicative f, Traversable t, Applicative f', Traversable t') => (f (t a) -> t' (f' a)) -> t (f a) -> f' (t' a) Source #