





Synopsis 

class C a where    subtract :: C a => a > a > a   sum :: C a => [a] > a   sum1 :: C a => [a] > a   elementAdd :: C x => (v > x) > T (v, v) x   elementSub :: C x => (v > x) > T (v, v) x   elementNeg :: C x => (v > x) > T v x   (<*>.+) :: C x => T (v, v) (x > a) > (v > x) > T (v, v) a   (<*>.) :: C x => T (v, v) (x > a) > (v > x) > T (v, v) a   (<*>.$) :: C x => T v (x > a) > (v > x) > T v a   propAssociative :: (Eq a, C a) => a > a > a > Bool   propCommutative :: (Eq a, C a) => a > a > Bool   propIdentity :: (Eq a, C a) => a > Bool   propInverse :: (Eq a, C a) => a > Bool 



Class



Additive a encapsulates the notion of a commutative group, specified
by the following laws:
a + b === b + a
(a + b) + c === a + (b + c)
zero + a === a
a + negate a === 0
Typical examples include integers, dollars, and vectors.
Minimal definition: +, zero, and (negate or '()')
  Methods   zero element of the vector space
   add and subtract elements
     inverse with respect to +

  Instances  C Double  C Float  C Int  C Int8  C Int16  C Int32  C Int64  C Integer  C Word  C Word8  C Word16  C Word32  C Word64  C T  C T  C T  C T  C v => C ([] v)  Integral a => C (Ratio a)  (Ord a, C a) => C (T a)  C a => C (T a)  C a => C (T a)  (C a, C a, C a) => C (T a)  C a => C (T a)  C a => C (T a)  C a => C (T a)  C a => C (T a)  (C a, C a) => C (T a)  C a => C (T a)  C a => C (T a)  C a => C (T a)  C a => C (T a)  C a => C (T a)  (Eq a, C a) => C (T a)  (Eq a, C a) => C (T a)  C a => C (T a)  C v => C (b > v)  (C v0, C v1) => C ((,) v0 v1)  (Ord i, Eq v, C v) => C (Map i v)  (Ord a, C b) => C (T a b)  (C u, C a) => C (T u a)  C v => C (T a v)  (Ord i, C a) => C (T i a)  C v => C (T a v)  (C v0, C v1, C v2) => C ((,,) v0 v1 v2) 



subtract :: C a => a > a > a  Source 

subtract is () with swapped operand order.
This is the operand order which will be needed in most cases
of partial application.


Complex functions



Sum up all elements of a list.
An empty list yields zero.



Sum up all elements of a nonempty list.
This avoids including a zero which is useful for types
where no universal zero is available.


Instance definition helpers


elementAdd :: C x => (v > x) > T (v, v) x  Source 

Instead of baking the add operation into the element function,
we could use higher rank types
and pass a generic uncurry (+) to the run function.
We do not do so in order to stay Haskell 98
at least for parts of NumericPrelude.


elementSub :: C x => (v > x) > T (v, v) x  Source 


elementNeg :: C x => (v > x) > T v x  Source 


(<*>.+) :: C x => T (v, v) (x > a) > (v > x) > T (v, v) a  Source 

addPair :: (Additive.C a, Additive.C b) => (a,b) > (a,b) > (a,b)
addPair = Elem.run2 $ Elem.with (,) <*>.+ fst <*>.+ snd


(<*>.) :: C x => T (v, v) (x > a) > (v > x) > T (v, v) a  Source 


(<*>.$) :: C x => T v (x > a) > (v > x) > T v a  Source 


Instances for atomic types










Produced by Haddock version 2.4.2 