{-# LANGUAGE DerivingVia #-}{-# LANGUAGE EmptyCase #-}{-# LANGUAGE GeneralizedNewtypeDeriving #-}{-# LANGUAGE InstanceSigs #-}{-# LANGUAGE StandaloneDeriving #-}{-# LANGUAGE Trustworthy #-}{-# LANGUAGE TypeOperators #-}------------------------------------------------------------------------------- |-- Module : Data.Functor.Contravariant-- Copyright : (C) 2007-2015 Edward Kmett-- License : BSD-style (see the file LICENSE)---- Maintainer : libraries@haskell.org-- Stability : provisional-- Portability : portable---- 'Contravariant' functors, sometimes referred to colloquially as @Cofunctor@,-- even though the dual of a 'Functor' is just a 'Functor'. As with 'Functor'-- the definition of 'Contravariant' for a given ADT is unambiguous.---- @since 4.12.0.0----------------------------------------------------------------------------moduleData.Functor.Contravariant(-- * Contravariant FunctorsContravariant (..),phantom -- * Operators,(>$<) ,(>$$<) ,($<) -- * Predicates,Predicate (..)-- * Comparisons,Comparison (..),defaultComparison -- * Equivalence Relations,Equivalence (..),defaultEquivalence ,comparisonEquivalence -- * Dual arrows,Op (..))whereimportControl.Applicative importControl.Category importData.Function (on )importData.Functor.Product importData.Functor.Sum importData.Functor.Compose importData.Monoid (Alt (..),All (..))importData.Proxy importGHC.Generics importPrelude hiding((.) ,id )-- | The class of contravariant functors.---- Whereas in Haskell, one can think of a 'Functor' as containing or producing-- values, a contravariant functor is a functor that can be thought of as-- /consuming/ values.---- As an example, consider the type of predicate functions @a -> Bool@. One-- such predicate might be @negative x = x < 0@, which-- classifies integers as to whether they are negative. However, given this-- predicate, we can re-use it in other situations, providing we have a way to-- map values /to/ integers. For instance, we can use the @negative@ predicate-- on a person's bank balance to work out if they are currently overdrawn:---- @-- newtype Predicate a = Predicate { getPredicate :: a -> Bool }---- instance Contravariant Predicate where-- contramap :: (a' -> a) -> (Predicate a -> Predicate a')-- contramap f (Predicate p) = Predicate (p . f)-- | `- First, map the input...-- `----- then apply the predicate.---- overdrawn :: Predicate Person-- overdrawn = contramap personBankBalance negative-- @---- Any instance should be subject to the following laws:---- [Identity] @'contramap' 'id' = 'id'@-- [Composition] @'contramap' (g . f) = 'contramap' f . 'contramap' g@---- Note, that the second law follows from the free theorem of the type of-- 'contramap' and the first law, so you need only check that the former-- condition holds.classContravariant f wherecontramap ::(a' ->a )->(f a ->f a' )-- | Replace all locations in the output with the same value.-- The default definition is @'contramap' . 'const'@, but this may be-- overridden with a more efficient version.(>$) ::b ->f b ->f a (>$) =forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. a -> b -> a
const -- | If @f@ is both 'Functor' and 'Contravariant' then by the time you factor-- in the laws of each of those classes, it can't actually use its argument in-- any meaningful capacity.---- This method is surprisingly useful. Where both instances exist and are-- lawful we have the following laws:---- @-- 'fmap' f ≡ 'phantom'-- 'contramap' f ≡ 'phantom'-- @phantom ::(Functor f ,Contravariant f )=>f a ->f b phantom :: forall (f :: * -> *) a b.
(Functor f, Contravariant f) =>
f a -> f b
phantom f a
x =()forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ f a
x forall (f :: * -> *) b a. Contravariant f => f b -> b -> f a
$< ()infixl4>$ ,$< ,>$< ,>$$< -- | This is '>$' with its arguments flipped.($<) ::Contravariant f =>f b ->b ->f a $< :: forall (f :: * -> *) b a. Contravariant f => f b -> b -> f a
($<) =forall a b c. (a -> b -> c) -> b -> a -> c
flip forall (f :: * -> *) b a. Contravariant f => b -> f b -> f a
(>$) -- | This is an infix alias for 'contramap'.(>$<) ::Contravariant f =>(a ->b )->(f b ->f a )>$< :: forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
(>$<) =forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap -- | This is an infix version of 'contramap' with the arguments flipped.(>$$<) ::Contravariant f =>f b ->(a ->b )->f a >$$< :: forall (f :: * -> *) b a. Contravariant f => f b -> (a -> b) -> f a
(>$$<) =forall a b c. (a -> b -> c) -> b -> a -> c
flip forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap derivingnewtype instanceContravariant f =>Contravariant (Alt f )derivingnewtype instanceContravariant f =>Contravariant (Rec1 f )derivingnewtype instanceContravariant f =>Contravariant (M1 i c f )instanceContravariant V1 wherecontramap ::(a' ->a )->(V1 a ->V1 a' )contramap :: forall a' a. (a' -> a) -> V1 a -> V1 a'
contramap a' -> a
_V1 a
x =caseV1 a
x ofinstanceContravariant U1 wherecontramap ::(a' ->a )->(U1 a ->U1 a' )contramap :: forall a' a. (a' -> a) -> U1 a -> U1 a'
contramap a' -> a
_U1 a
_=forall k (p :: k). U1 p
U1 instanceContravariant (K1 i c )wherecontramap ::(a' ->a )->(K1 i c a ->K1 i c a' )contramap :: forall a' a. (a' -> a) -> K1 i c a -> K1 i c a'
contramap a' -> a
_(K1 c
c )=forall k i c (p :: k). c -> K1 i c p
K1 c
c instance(Contravariant f ,Contravariant g )=>Contravariant (f :*: g )wherecontramap ::(a' ->a )->((f :*: g )a ->(f :*: g )a' )contramap :: forall a' a. (a' -> a) -> (:*:) f g a -> (:*:) f g a'
contramap a' -> a
f (f a
xs :*: g a
ys )=forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap a' -> a
f f a
xs forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap a' -> a
f g a
ys instance(Functor f ,Contravariant g )=>Contravariant (f :.: g )wherecontramap ::(a' ->a )->((f :.: g )a ->(f :.: g )a' )contramap :: forall a' a. (a' -> a) -> (:.:) f g a -> (:.:) f g a'
contramap a' -> a
f (Comp1 f (g a)
fg )=forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).
f (g p) -> (:.:) f g p
Comp1 (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap a' -> a
f )f (g a)
fg )instance(Contravariant f ,Contravariant g )=>Contravariant (f :+: g )wherecontramap ::(a' ->a )->((f :+: g )a ->(f :+: g )a' )contramap :: forall a' a. (a' -> a) -> (:+:) f g a -> (:+:) f g a'
contramap a' -> a
f (L1 f a
xs )=forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap a' -> a
f f a
xs )contramap a' -> a
f (R1 g a
ys )=forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap a' -> a
f g a
ys )instance(Contravariant f ,Contravariant g )=>Contravariant (Sum f g )wherecontramap ::(a' ->a )->(Sum f g a ->Sum f g a' )contramap :: forall a' a. (a' -> a) -> Sum f g a -> Sum f g a'
contramap a' -> a
f (InL f a
xs )=forall {k} (f :: k -> *) (g :: k -> *) (a :: k). f a -> Sum f g a
InL (forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap a' -> a
f f a
xs )contramap a' -> a
f (InR g a
ys )=forall {k} (f :: k -> *) (g :: k -> *) (a :: k). g a -> Sum f g a
InR (forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap a' -> a
f g a
ys )instance(Contravariant f ,Contravariant g )=>Contravariant (Product f g )wherecontramap ::(a' ->a )->(Product f g a ->Product f g a' )contramap :: forall a' a. (a' -> a) -> Product f g a -> Product f g a'
contramap a' -> a
f (Pair f a
a g a
b )=forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
Pair (forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap a' -> a
f f a
a )(forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap a' -> a
f g a
b )instanceContravariant (Const a )wherecontramap ::(b' ->b )->(Const a b ->Const a b' )contramap :: forall a' a. (a' -> a) -> Const a a -> Const a a'
contramap b' -> b
_(Const a
a )=forall {k} a (b :: k). a -> Const a b
Const a
a instance(Functor f ,Contravariant g )=>Contravariant (Compose f g )wherecontramap ::(a' ->a )->(Compose f g a ->Compose f g a' )contramap :: forall a' a. (a' -> a) -> Compose f g a -> Compose f g a'
contramap a' -> a
f (Compose f (g a)
fga )=forall {k} {k} (f :: k -> *) (g :: k -> k) (a :: k).
f (g a) -> Compose f g a
Compose (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap a' -> a
f )f (g a)
fga )instanceContravariant Proxy wherecontramap ::(a' ->a )->(Proxy a ->Proxy a' )contramap :: forall a' a. (a' -> a) -> Proxy a -> Proxy a'
contramap a' -> a
_Proxy a
_=forall {k} (t :: k). Proxy t
Proxy newtypePredicate a =Predicate {forall a. Predicate a -> a -> Bool
getPredicate ::a ->Bool }deriving(-- | @('<>')@ on predicates uses logical conjunction @('&&')@ on-- the results. Without newtypes this equals @'liftA2' (&&)@.---- @-- (<>) :: Predicate a -> Predicate a -> Predicate a-- Predicate pred <> Predicate pred' = Predicate \a ->-- pred a && pred' a-- @NonEmpty (Predicate a) -> Predicate a
Predicate a -> Predicate a -> Predicate a
forall b. Integral b => b -> Predicate a -> Predicate a
forall a. NonEmpty (Predicate a) -> Predicate a
forall a. Predicate a -> Predicate a -> Predicate a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a b. Integral b => b -> Predicate a -> Predicate a
stimes :: forall b. Integral b => b -> Predicate a -> Predicate a
$cstimes :: forall a b. Integral b => b -> Predicate a -> Predicate a
sconcat :: NonEmpty (Predicate a) -> Predicate a
$csconcat :: forall a. NonEmpty (Predicate a) -> Predicate a
<> :: Predicate a -> Predicate a -> Predicate a
$c<> :: forall a. Predicate a -> Predicate a -> Predicate a
Semigroup ,-- | @'mempty'@ on predicates always returns @True@. Without-- newtypes this equals @'pure' True@.---- @-- mempty :: Predicate a-- mempty = \_ -> True-- @Predicate a
[Predicate a] -> Predicate a
Predicate a -> Predicate a -> Predicate a
forall a. Semigroup (Predicate a)
forall a. Predicate a
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. [Predicate a] -> Predicate a
forall a. Predicate a -> Predicate a -> Predicate a
mconcat :: [Predicate a] -> Predicate a
$cmconcat :: forall a. [Predicate a] -> Predicate a
mappend :: Predicate a -> Predicate a -> Predicate a
$cmappend :: forall a. Predicate a -> Predicate a -> Predicate a
mempty :: Predicate a
$cmempty :: forall a. Predicate a
Monoid )viaa ->All deriving(-- | A 'Predicate' is a 'Contravariant' 'Functor', because-- 'contramap' can apply its function argument to the input of-- the predicate.---- Without newtypes @'contramap' f@ equals precomposing with @f@-- (= @(. f)@).---- @-- contramap :: (a' -> a) -> (Predicate a -> Predicate a')-- contramap f (Predicate g) = Predicate (g . f)-- @forall b a. b -> Predicate b -> Predicate a
forall a' a. (a' -> a) -> Predicate a -> Predicate a'
forall (f :: * -> *).
(forall a' a. (a' -> a) -> f a -> f a')
-> (forall b a. b -> f b -> f a) -> Contravariant f
>$ :: forall b a. b -> Predicate b -> Predicate a
$c>$ :: forall b a. b -> Predicate b -> Predicate a
contramap :: forall a' a. (a' -> a) -> Predicate a -> Predicate a'
$ccontramap :: forall a' a. (a' -> a) -> Predicate a -> Predicate a'
Contravariant )viaOp Bool -- | Defines a total ordering on a type as per 'compare'.---- This condition is not checked by the types. You must ensure that the-- supplied values are valid total orderings yourself.newtypeComparison a =Comparison {forall a. Comparison a -> a -> a -> Ordering
getComparison ::a ->a ->Ordering }derivingnewtype(-- | @('<>')@ on comparisons combines results with @('<>')-- \@Ordering@. Without newtypes this equals @'liftA2' ('liftA2'-- ('<>'))@.---- @-- (<>) :: Comparison a -> Comparison a -> Comparison a-- Comparison cmp <> Comparison cmp' = Comparison \a a' ->-- cmp a a' <> cmp a a'-- @NonEmpty (Comparison a) -> Comparison a
Comparison a -> Comparison a -> Comparison a
forall b. Integral b => b -> Comparison a -> Comparison a
forall a. NonEmpty (Comparison a) -> Comparison a
forall a. Comparison a -> Comparison a -> Comparison a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a b. Integral b => b -> Comparison a -> Comparison a
stimes :: forall b. Integral b => b -> Comparison a -> Comparison a
$cstimes :: forall a b. Integral b => b -> Comparison a -> Comparison a
sconcat :: NonEmpty (Comparison a) -> Comparison a
$csconcat :: forall a. NonEmpty (Comparison a) -> Comparison a
<> :: Comparison a -> Comparison a -> Comparison a
$c<> :: forall a. Comparison a -> Comparison a -> Comparison a
Semigroup ,-- | @'mempty'@ on comparisons always returns @EQ@. Without-- newtypes this equals @'pure' ('pure' EQ)@.---- @-- mempty :: Comparison a-- mempty = Comparison \_ _ -> EQ-- @Comparison a
[Comparison a] -> Comparison a
Comparison a -> Comparison a -> Comparison a
forall a. Semigroup (Comparison a)
forall a. Comparison a
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. [Comparison a] -> Comparison a
forall a. Comparison a -> Comparison a -> Comparison a
mconcat :: [Comparison a] -> Comparison a
$cmconcat :: forall a. [Comparison a] -> Comparison a
mappend :: Comparison a -> Comparison a -> Comparison a
$cmappend :: forall a. Comparison a -> Comparison a -> Comparison a
mempty :: Comparison a
$cmempty :: forall a. Comparison a
Monoid )-- | A 'Comparison' is a 'Contravariant' 'Functor', because 'contramap' can-- apply its function argument to each input of the comparison function.instanceContravariant Comparison wherecontramap ::(a' ->a )->(Comparison a ->Comparison a' )contramap :: forall a' a. (a' -> a) -> Comparison a -> Comparison a'
contramap a' -> a
f (Comparison a -> a -> Ordering
g )=forall a. (a -> a -> Ordering) -> Comparison a
Comparison (forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on a -> a -> Ordering
g a' -> a
f )-- | Compare using 'compare'.defaultComparison ::Ord a =>Comparison a defaultComparison :: forall a. Ord a => Comparison a
defaultComparison =forall a. (a -> a -> Ordering) -> Comparison a
Comparison forall a. Ord a => a -> a -> Ordering
compare -- | This data type represents an equivalence relation.---- Equivalence relations are expected to satisfy three laws:---- [Reflexivity]: @'getEquivalence' f a a = True@-- [Symmetry]: @'getEquivalence' f a b = 'getEquivalence' f b a@-- [Transitivity]:-- If @'getEquivalence' f a b@ and @'getEquivalence' f b c@ are both 'True'-- then so is @'getEquivalence' f a c@.---- The types alone do not enforce these laws, so you'll have to check them-- yourself.newtypeEquivalence a =Equivalence {forall a. Equivalence a -> a -> a -> Bool
getEquivalence ::a ->a ->Bool }deriving(-- | @('<>')@ on equivalences uses logical conjunction @('&&')@-- on the results. Without newtypes this equals @'liftA2'-- ('liftA2' (&&))@.---- @-- (<>) :: Equivalence a -> Equivalence a -> Equivalence a-- Equivalence equiv <> Equivalence equiv' = Equivalence \a b ->-- equiv a b && equiv a b-- @NonEmpty (Equivalence a) -> Equivalence a
Equivalence a -> Equivalence a -> Equivalence a
forall b. Integral b => b -> Equivalence a -> Equivalence a
forall a. NonEmpty (Equivalence a) -> Equivalence a
forall a. Equivalence a -> Equivalence a -> Equivalence a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a b. Integral b => b -> Equivalence a -> Equivalence a
stimes :: forall b. Integral b => b -> Equivalence a -> Equivalence a
$cstimes :: forall a b. Integral b => b -> Equivalence a -> Equivalence a
sconcat :: NonEmpty (Equivalence a) -> Equivalence a
$csconcat :: forall a. NonEmpty (Equivalence a) -> Equivalence a
<> :: Equivalence a -> Equivalence a -> Equivalence a
$c<> :: forall a. Equivalence a -> Equivalence a -> Equivalence a
Semigroup ,-- | @'mempty'@ on equivalences always returns @True@. Without-- newtypes this equals @'pure' ('pure' True)@.---- @-- mempty :: Equivalence a-- mempty = Equivalence \_ _ -> True-- @Equivalence a
[Equivalence a] -> Equivalence a
Equivalence a -> Equivalence a -> Equivalence a
forall a. Semigroup (Equivalence a)
forall a. Equivalence a
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. [Equivalence a] -> Equivalence a
forall a. Equivalence a -> Equivalence a -> Equivalence a
mconcat :: [Equivalence a] -> Equivalence a
$cmconcat :: forall a. [Equivalence a] -> Equivalence a
mappend :: Equivalence a -> Equivalence a -> Equivalence a
$cmappend :: forall a. Equivalence a -> Equivalence a -> Equivalence a
mempty :: Equivalence a
$cmempty :: forall a. Equivalence a
Monoid )viaa ->a ->All -- | Equivalence relations are 'Contravariant', because you can-- apply the contramapped function to each input to the equivalence-- relation.instanceContravariant Equivalence wherecontramap ::(a' ->a )->(Equivalence a ->Equivalence a' )contramap :: forall a' a. (a' -> a) -> Equivalence a -> Equivalence a'
contramap a' -> a
f (Equivalence a -> a -> Bool
g )=forall a. (a -> a -> Bool) -> Equivalence a
Equivalence (forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on a -> a -> Bool
g a' -> a
f )-- | Check for equivalence with '=='.---- Note: The instances for 'Double' and 'Float' violate reflexivity for @NaN@.defaultEquivalence ::Eq a =>Equivalence a defaultEquivalence :: forall a. Eq a => Equivalence a
defaultEquivalence =forall a. (a -> a -> Bool) -> Equivalence a
Equivalence forall a. Eq a => a -> a -> Bool
(==) comparisonEquivalence ::Comparison a ->Equivalence a comparisonEquivalence :: forall a. Comparison a -> Equivalence a
comparisonEquivalence (Comparison a -> a -> Ordering
p )=forall a. (a -> a -> Bool) -> Equivalence a
Equivalence forall a b. (a -> b) -> a -> b
$ \a
a a
b ->a -> a -> Ordering
p a
a a
b forall a. Eq a => a -> a -> Bool
== Ordering
EQ -- | Dual function arrows.newtypeOp a b =Op {forall a b. Op a b -> b -> a
getOp ::b ->a }derivingnewtype(-- | @('<>') \@(Op a b)@ without newtypes is @('<>') \@(b->a)@ =-- @liftA2 ('<>')@. This lifts the 'Semigroup' operation-- @('<>')@ over the output of @a@.---- @-- (<>) :: Op a b -> Op a b -> Op a b-- Op f <> Op g = Op \a -> f a <> g a-- @NonEmpty (Op a b) -> Op a b
Op a b -> Op a b -> Op a b
forall b. Integral b => b -> Op a b -> Op a b
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a b. Semigroup a => NonEmpty (Op a b) -> Op a b
forall a b. Semigroup a => Op a b -> Op a b -> Op a b
forall a b b. (Semigroup a, Integral b) => b -> Op a b -> Op a b
stimes :: forall b. Integral b => b -> Op a b -> Op a b
$cstimes :: forall a b b. (Semigroup a, Integral b) => b -> Op a b -> Op a b
sconcat :: NonEmpty (Op a b) -> Op a b
$csconcat :: forall a b. Semigroup a => NonEmpty (Op a b) -> Op a b
<> :: Op a b -> Op a b -> Op a b
$c<> :: forall a b. Semigroup a => Op a b -> Op a b -> Op a b
Semigroup ,-- | @'mempty' \@(Op a b)@ without newtypes is @mempty \@(b->a)@-- = @\_ -> mempty@.---- @-- mempty :: Op a b-- mempty = Op \_ -> mempty-- @Op a b
[Op a b] -> Op a b
Op a b -> Op a b -> Op a b
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall {a} {b}. Monoid a => Semigroup (Op a b)
forall a b. Monoid a => Op a b
forall a b. Monoid a => [Op a b] -> Op a b
forall a b. Monoid a => Op a b -> Op a b -> Op a b
mconcat :: [Op a b] -> Op a b
$cmconcat :: forall a b. Monoid a => [Op a b] -> Op a b
mappend :: Op a b -> Op a b -> Op a b
$cmappend :: forall a b. Monoid a => Op a b -> Op a b -> Op a b
mempty :: Op a b
$cmempty :: forall a b. Monoid a => Op a b
Monoid )instanceCategory Op whereid ::Op a a id :: forall a. Op a a
id =forall a b. (b -> a) -> Op a b
Op forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id (.) ::Op b c ->Op a b ->Op a c Op c -> b
f . :: forall b c a. Op b c -> Op a b -> Op a c
. Op b -> a
g =forall a b. (b -> a) -> Op a b
Op (b -> a
g forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. c -> b
f )instanceContravariant (Op a )wherecontramap ::(b' ->b )->(Op a b ->Op a b' )contramap :: forall a' a. (a' -> a) -> Op a a -> Op a a'
contramap b' -> b
f Op a b
g =forall a b. (b -> a) -> Op a b
Op (forall a b. Op a b -> b -> a
getOp Op a b
g forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b' -> b
f )instanceNum a =>Num (Op a b )whereOp b -> a
f + :: Op a b -> Op a b -> Op a b
+ Op b -> a
g =forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ \b
a ->b -> a
f b
a forall a. Num a => a -> a -> a
+ b -> a
g b
a Op b -> a
f * :: Op a b -> Op a b -> Op a b
* Op b -> a
g =forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ \b
a ->b -> a
f b
a forall a. Num a => a -> a -> a
* b -> a
g b
a Op b -> a
f - :: Op a b -> Op a b -> Op a b
- Op b -> a
g =forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ \b
a ->b -> a
f b
a forall a. Num a => a -> a -> a
- b -> a
g b
a abs :: Op a b -> Op a b
abs (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Num a => a -> a
abs forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f signum :: Op a b -> Op a b
signum (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Num a => a -> a
signum forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f fromInteger :: Integer -> Op a b
fromInteger =forall a b. (b -> a) -> Op a b
Op forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. a -> b -> a
const forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. Num a => Integer -> a
fromInteger instanceFractional a =>Fractional (Op a b )whereOp b -> a
f / :: Op a b -> Op a b -> Op a b
/ Op b -> a
g =forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ \b
a ->b -> a
f b
a forall a. Fractional a => a -> a -> a
/ b -> a
g b
a recip :: Op a b -> Op a b
recip (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Fractional a => a -> a
recip forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f fromRational :: Rational -> Op a b
fromRational =forall a b. (b -> a) -> Op a b
Op forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. a -> b -> a
const forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a. Fractional a => Rational -> a
fromRational instanceFloating a =>Floating (Op a b )wherepi :: Op a b
pi =forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a b. a -> b -> a
const forall a. Floating a => a
pi exp :: Op a b -> Op a b
exp (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
exp forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f sqrt :: Op a b -> Op a b
sqrt (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
sqrt forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f log :: Op a b -> Op a b
log (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
log forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f sin :: Op a b -> Op a b
sin (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
sin forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f tan :: Op a b -> Op a b
tan (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
tan forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f cos :: Op a b -> Op a b
cos (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
cos forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f asin :: Op a b -> Op a b
asin (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
asin forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f atan :: Op a b -> Op a b
atan (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
atan forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f acos :: Op a b -> Op a b
acos (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
acos forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f sinh :: Op a b -> Op a b
sinh (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
sinh forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f tanh :: Op a b -> Op a b
tanh (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
tanh forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f cosh :: Op a b -> Op a b
cosh (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
cosh forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f asinh :: Op a b -> Op a b
asinh (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
asinh forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f atanh :: Op a b -> Op a b
atanh (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
atanh forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f acosh :: Op a b -> Op a b
acosh (Op b -> a
f )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
acosh forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. b -> a
f Op b -> a
f ** :: Op a b -> Op a b -> Op a b
** Op b -> a
g =forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ \b
a ->b -> a
f b
a forall a. Floating a => a -> a -> a
** b -> a
g b
a logBase :: Op a b -> Op a b -> Op a b
logBase (Op b -> a
f )(Op b -> a
g )=forall a b. (b -> a) -> Op a b
Op forall a b. (a -> b) -> a -> b
$ \b
a ->forall a. Floating a => a -> a -> a
logBase (b -> a
f b
a )(b -> a
g b
a )