Algebra.Additive

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 (-))

zero element of the vector space

add and subtract elements

add and subtract elements

inverse with respect to +

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

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

This function is inappropriate for number types like Peano. Maybe we should make sum a method of Additive. This would also make lengthLeft and lengthRight superfluous.

Sum up all elements of a non-empty list. This avoids including a zero which is useful for types where no universal zero is available. ToDo: Should have NonEmpty type.

prop> \(QC.NonEmpty ns) -> A.sum ns == (A.sum1 ns :: Integer)

Sum the operands in an order, such that the dependencies are minimized. Does this have a measurably effect on speed?

Requires associativity.

prop> \ns -> A.sum ns == (A.sumNestedAssociative ns :: Integer)

Make sure that the last entries in the list are equally often part of an addition. Maybe this can reduce rounding errors. The list that sum2 computes is a breadth-first-flattened binary tree.

Requires associativity and commutativity.

prop> \ns -> A.sum ns == (A.sumNestedCommutative ns :: Integer)

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.