-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | numeric classes
--   
--   A numeric class heirarchy.
@package numhask
@version 0.2.2.0


-- | A magma heirarchy for addition. The basic magma structure is repeated
--   and prefixed with 'Additive-'.
module NumHask.Algebra.Additive

-- | <a>plus</a> is used as the operator for the additive magma to
--   distinguish from <a>+</a> which, by convention, implies commutativity
--   
--   <pre>
--   ∀ a,b ∈ A: a `plus` b ∈ A
--   </pre>
--   
--   law is true by construction in Haskell
class AdditiveMagma a
plus :: AdditiveMagma a => a -> a -> a

-- | Unital magma for addition.
--   
--   <pre>
--   zero `plus` a == a
--   a `plus` zero == a
--   </pre>
class AdditiveMagma a => AdditiveUnital a
zero :: AdditiveUnital a => a

-- | Associative magma for addition.
--   
--   <pre>
--   (a `plus` b) `plus` c == a `plus` (b `plus` c)
--   </pre>
class AdditiveMagma a => AdditiveAssociative a

-- | Commutative magma for addition.
--   
--   <pre>
--   a `plus` b == b `plus` a
--   </pre>
class AdditiveMagma a => AdditiveCommutative a

-- | Invertible magma for addition.
--   
--   <pre>
--   ∀ a ∈ A: negate a ∈ A
--   </pre>
--   
--   law is true by construction in Haskell
class AdditiveMagma a => AdditiveInvertible a
negate :: AdditiveInvertible a => a -> a

-- | Idempotent magma for addition.
--   
--   <pre>
--   a `plus` a == a
--   </pre>
class AdditiveMagma a => AdditiveIdempotent a

-- | sum definition avoiding a clash with the Sum monoid in base fixme: fit
--   in with the Sum monoid
sum :: (Additive a, Foldable f) => f a -> a

-- | Additive is commutative, unital and associative under addition
--   
--   <pre>
--   zero + a == a
--   a + zero == a
--   (a + b) + c == a + (b + c)
--   a + b == b + a
--   </pre>
class (AdditiveCommutative a, AdditiveUnital a, AdditiveAssociative a) => Additive a
(+) :: Additive a => a -> a -> a

-- | Non-commutative right minus
--   
--   <pre>
--   a `plus` negate a = zero
--   </pre>
class (AdditiveUnital a, AdditiveAssociative a, AdditiveInvertible a) => AdditiveRightCancellative a
(-~) :: AdditiveRightCancellative a => a -> a -> a

-- | Non-commutative left minus
--   
--   <pre>
--   negate a `plus` a = zero
--   </pre>
class (AdditiveUnital a, AdditiveAssociative a, AdditiveInvertible a) => AdditiveLeftCancellative a
(~-) :: AdditiveLeftCancellative a => a -> a -> a

-- | Minus (<a>-</a>) is reserved for where both the left and right
--   cancellative laws hold. This then implies that the AdditiveGroup is
--   also Abelian.
--   
--   Syntactic unary negation - substituting "negate a" for "-a" in code -
--   is hard-coded in the language to assume a Num instance. So, for
--   example, using ''-a = zero - a' for the second rule below doesn't
--   work.
--   
--   <pre>
--   a - a = zero
--   negate a = zero - a
--   negate a + a = zero
--   a + negate a = zero
--   </pre>
class (Additive a, AdditiveInvertible a) => AdditiveGroup a
(-) :: AdditiveGroup a => a -> a -> a
subtract :: (AdditiveGroup a) => a -> a -> a
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Types.Double
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Types.Float
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Types.Int
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Integer.Type.Integer
instance NumHask.Algebra.Additive.AdditiveGroup a => NumHask.Algebra.Additive.AdditiveGroup (Data.Complex.Complex a)
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Int.Int8
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Int.Int16
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Int.Int32
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Int.Int64
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Types.Word
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Word.Word8
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Word.Word16
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Word.Word32
instance NumHask.Algebra.Additive.AdditiveGroup GHC.Word.Word64
instance NumHask.Algebra.Additive.Additive GHC.Types.Double
instance NumHask.Algebra.Additive.Additive GHC.Types.Float
instance NumHask.Algebra.Additive.Additive GHC.Types.Int
instance NumHask.Algebra.Additive.Additive GHC.Integer.Type.Integer
instance NumHask.Algebra.Additive.Additive GHC.Types.Bool
instance NumHask.Algebra.Additive.Additive a => NumHask.Algebra.Additive.Additive (Data.Complex.Complex a)
instance NumHask.Algebra.Additive.Additive GHC.Natural.Natural
instance NumHask.Algebra.Additive.Additive GHC.Int.Int8
instance NumHask.Algebra.Additive.Additive GHC.Int.Int16
instance NumHask.Algebra.Additive.Additive GHC.Int.Int32
instance NumHask.Algebra.Additive.Additive GHC.Int.Int64
instance NumHask.Algebra.Additive.Additive GHC.Types.Word
instance NumHask.Algebra.Additive.Additive GHC.Word.Word8
instance NumHask.Algebra.Additive.Additive GHC.Word.Word16
instance NumHask.Algebra.Additive.Additive GHC.Word.Word32
instance NumHask.Algebra.Additive.Additive GHC.Word.Word64
instance NumHask.Algebra.Additive.AdditiveIdempotent GHC.Types.Bool
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Types.Double
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Types.Float
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Types.Int
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Integer.Type.Integer
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Types.Bool
instance NumHask.Algebra.Additive.AdditiveInvertible a => NumHask.Algebra.Additive.AdditiveInvertible (Data.Complex.Complex a)
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Int.Int8
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Int.Int16
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Int.Int32
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Int.Int64
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Types.Word
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Word.Word8
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Word.Word16
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Word.Word32
instance NumHask.Algebra.Additive.AdditiveInvertible GHC.Word.Word64
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Types.Double
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Types.Float
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Types.Int
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Integer.Type.Integer
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Types.Bool
instance NumHask.Algebra.Additive.AdditiveCommutative a => NumHask.Algebra.Additive.AdditiveCommutative (Data.Complex.Complex a)
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Natural.Natural
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Int.Int8
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Int.Int16
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Int.Int32
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Int.Int64
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Types.Word
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Word.Word8
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Word.Word16
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Word.Word32
instance NumHask.Algebra.Additive.AdditiveCommutative GHC.Word.Word64
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Types.Double
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Types.Float
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Types.Int
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Integer.Type.Integer
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Types.Bool
instance NumHask.Algebra.Additive.AdditiveAssociative a => NumHask.Algebra.Additive.AdditiveAssociative (Data.Complex.Complex a)
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Natural.Natural
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Int.Int8
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Int.Int16
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Int.Int32
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Int.Int64
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Types.Word
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Word.Word8
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Word.Word16
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Word.Word32
instance NumHask.Algebra.Additive.AdditiveAssociative GHC.Word.Word64
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Types.Double
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Types.Float
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Types.Int
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Integer.Type.Integer
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Types.Bool
instance NumHask.Algebra.Additive.AdditiveUnital a => NumHask.Algebra.Additive.AdditiveUnital (Data.Complex.Complex a)
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Natural.Natural
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Int.Int8
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Int.Int16
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Int.Int32
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Int.Int64
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Types.Word
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Word.Word8
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Word.Word16
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Word.Word32
instance NumHask.Algebra.Additive.AdditiveUnital GHC.Word.Word64
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Types.Double
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Types.Float
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Types.Int
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Integer.Type.Integer
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Types.Bool
instance NumHask.Algebra.Additive.AdditiveMagma a => NumHask.Algebra.Additive.AdditiveMagma (Data.Complex.Complex a)
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Natural.Natural
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Int.Int8
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Int.Int16
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Int.Int32
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Int.Int64
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Types.Word
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Word.Word8
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Word.Word16
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Word.Word32
instance NumHask.Algebra.Additive.AdditiveMagma GHC.Word.Word64


-- | Bootstrapping the number system.
--   
--   This heirarchy is repeated for the Additive and Multiplicative
--   structures, in order to achieve class separation, so these classes are
--   not used in the main numerical classes.
module NumHask.Algebra.Magma

-- | A <a>Magma</a> is a tuple (T,⊕) consisting of
--   
--   <ul>
--   <li>a type a, and</li>
--   <li>a function (⊕) :: T -&gt; T -&gt; T</li>
--   </ul>
--   
--   The mathematical laws for a magma are:
--   
--   <ul>
--   <li>⊕ is defined for all possible pairs of type T, and</li>
--   <li>⊕ is closed in the set of all possible values of type T</li>
--   </ul>
--   
--   or, more tersly,
--   
--   <pre>
--   ∀ a, b ∈ T: a ⊕ b ∈ T
--   </pre>
--   
--   These laws are true by construction in haskell: the type signature of
--   <tt>magma</tt> and the above mathematical laws are synonyms.
class Magma a
(⊕) :: Magma a => a -> a -> a

-- | A Unital Magma
--   
--   <pre>
--   unit ⊕ a = a
--   a ⊕ unit = a
--   </pre>
class Magma a => Unital a
unit :: Unital a => a

-- | An Associative Magma
--   
--   <pre>
--   (a ⊕ b) ⊕ c = a ⊕ (b ⊕ c)
--   </pre>
class Magma a => Associative a

-- | A Commutative Magma
--   
--   <pre>
--   a ⊕ b = b ⊕ a
--   </pre>
class Magma a => Commutative a

-- | An Invertible Magma
--   
--   <pre>
--   ∀ a ∈ T: inv a ∈ T
--   </pre>
--   
--   law is true by construction in Haskell
class Magma a => Invertible a
inv :: Invertible a => a -> a

-- | An Idempotent Magma
--   
--   <pre>
--   a ⊕ a = a
--   </pre>
class Magma a => Idempotent a

-- | A Monoidal Magma is associative and unital.
class (Associative a, Unital a) => Monoidal a

-- | A CMonoidal Magma is commutative, associative and unital.
class (Commutative a, Associative a, Unital a) => CMonoidal a

-- | A Loop is unital and invertible
class (Unital a, Invertible a) => Loop a

-- | A Group is associative, unital and invertible
class (Associative a, Unital a, Invertible a) => Group a

-- | see <a>http://chris-taylor.github.io/blog/2013/02/25/xor-trick/</a>
groupSwap :: (Group a) => (a, a) -> (a, a)

-- | An Abelian Group is associative, unital, invertible and commutative
class (Associative a, Unital a, Invertible a, Commutative a) => Abelian a


-- | A magma heirarchy for multiplication. The basic magma structure is
--   repeated and prefixed with 'Multiplicative-'.
module NumHask.Algebra.Multiplicative

-- | <a>times</a> is used as the operator for the multiplicative magam to
--   distinguish from <a>*</a> which, by convention, implies commutativity
--   
--   <pre>
--   ∀ a,b ∈ A: a `times` b ∈ A
--   </pre>
--   
--   law is true by construction in Haskell
class MultiplicativeMagma a
times :: MultiplicativeMagma a => a -> a -> a

-- | Unital magma for multiplication.
--   
--   <pre>
--   one `times` a == a
--   a `times` one == a
--   </pre>
class MultiplicativeMagma a => MultiplicativeUnital a
one :: MultiplicativeUnital a => a

-- | Associative magma for multiplication.
--   
--   <pre>
--   (a `times` b) `times` c == a `times` (b `times` c)
--   </pre>
class MultiplicativeMagma a => MultiplicativeAssociative a

-- | Commutative magma for multiplication.
--   
--   <pre>
--   a `times` b == b `times` a
--   </pre>
class MultiplicativeMagma a => MultiplicativeCommutative a

-- | Invertible magma for multiplication.
--   
--   <pre>
--   ∀ a ∈ A: recip a ∈ A
--   </pre>
--   
--   law is true by construction in Haskell
class MultiplicativeMagma a => MultiplicativeInvertible a
recip :: MultiplicativeInvertible a => a -> a

-- | product definition avoiding a clash with the Product monoid in base
--   fixme: fit in with Product in base
product :: (Multiplicative a, Foldable f) => f a -> a

-- | Multiplicative is commutative, associative and unital under
--   multiplication
--   
--   <pre>
--   one * a == a
--   a * one == a
--   (a * b) * c == a * (b * c)
--   a * b == b * a
--   </pre>
class (MultiplicativeCommutative a, MultiplicativeUnital a, MultiplicativeAssociative a) => Multiplicative a
(*) :: Multiplicative a => a -> a -> a

-- | Non-commutative right divide
--   
--   <pre>
--   a `times` recip a = one
--   </pre>
class (MultiplicativeUnital a, MultiplicativeAssociative a, MultiplicativeInvertible a) => MultiplicativeRightCancellative a
(/~) :: MultiplicativeRightCancellative a => a -> a -> a

-- | Non-commutative left divide
--   
--   <pre>
--   recip a `times` a = one
--   </pre>
class (MultiplicativeUnital a, MultiplicativeAssociative a, MultiplicativeInvertible a) => MultiplicativeLeftCancellative a
(~/) :: MultiplicativeLeftCancellative a => a -> a -> a

-- | Divide (<a>/</a>) is reserved for where both the left and right
--   cancellative laws hold. This then implies that the MultiplicativeGroup
--   is also Abelian.
--   
--   <pre>
--   a / a = one
--   recip a = one / a
--   recip a * a = one
--   a * recip a = one
--   </pre>
class (Multiplicative a, MultiplicativeInvertible a) => MultiplicativeGroup a
(/) :: MultiplicativeGroup a => a -> a -> a

-- | Idempotent magma for multiplication.
--   
--   <pre>
--   a `times` a == a
--   </pre>
class MultiplicativeMagma a => MultiplicativeIdempotent a
instance NumHask.Algebra.Multiplicative.MultiplicativeGroup GHC.Types.Double
instance NumHask.Algebra.Multiplicative.MultiplicativeGroup GHC.Types.Float
instance (NumHask.Algebra.Additive.AdditiveGroup a, NumHask.Algebra.Multiplicative.MultiplicativeGroup a) => NumHask.Algebra.Multiplicative.MultiplicativeGroup (Data.Complex.Complex a)
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Types.Double
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Types.Float
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Types.Int
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Integer.Type.Integer
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Types.Bool
instance (NumHask.Algebra.Additive.AdditiveGroup a, NumHask.Algebra.Multiplicative.Multiplicative a) => NumHask.Algebra.Multiplicative.Multiplicative (Data.Complex.Complex a)
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Natural.Natural
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Int.Int8
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Int.Int16
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Int.Int32
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Int.Int64
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Types.Word
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Word.Word8
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Word.Word16
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Word.Word32
instance NumHask.Algebra.Multiplicative.Multiplicative GHC.Word.Word64
instance NumHask.Algebra.Multiplicative.MultiplicativeIdempotent GHC.Types.Bool
instance NumHask.Algebra.Multiplicative.MultiplicativeInvertible GHC.Types.Double
instance NumHask.Algebra.Multiplicative.MultiplicativeInvertible GHC.Types.Float
instance (NumHask.Algebra.Additive.AdditiveGroup a, NumHask.Algebra.Multiplicative.MultiplicativeInvertible a) => NumHask.Algebra.Multiplicative.MultiplicativeInvertible (Data.Complex.Complex a)
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Types.Double
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Types.Float
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Types.Int
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Integer.Type.Integer
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Types.Bool
instance (NumHask.Algebra.Additive.AdditiveGroup a, NumHask.Algebra.Multiplicative.MultiplicativeCommutative a) => NumHask.Algebra.Multiplicative.MultiplicativeCommutative (Data.Complex.Complex a)
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Natural.Natural
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Int.Int8
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Int.Int16
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Int.Int32
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Int.Int64
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Types.Word
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Word.Word8
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Word.Word16
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Word.Word32
instance NumHask.Algebra.Multiplicative.MultiplicativeCommutative GHC.Word.Word64
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Types.Double
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Types.Float
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Types.Int
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Integer.Type.Integer
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Types.Bool
instance (NumHask.Algebra.Additive.AdditiveGroup a, NumHask.Algebra.Multiplicative.MultiplicativeAssociative a) => NumHask.Algebra.Multiplicative.MultiplicativeAssociative (Data.Complex.Complex a)
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Natural.Natural
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Int.Int8
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Int.Int16
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Int.Int32
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Int.Int64
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Types.Word
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Word.Word8
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Word.Word16
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Word.Word32
instance NumHask.Algebra.Multiplicative.MultiplicativeAssociative GHC.Word.Word64
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Types.Double
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Types.Float
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Types.Int
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Integer.Type.Integer
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Types.Bool
instance (NumHask.Algebra.Additive.AdditiveUnital a, NumHask.Algebra.Additive.AdditiveGroup a, NumHask.Algebra.Multiplicative.MultiplicativeUnital a) => NumHask.Algebra.Multiplicative.MultiplicativeUnital (Data.Complex.Complex a)
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Natural.Natural
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Int.Int8
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Int.Int16
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Int.Int32
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Int.Int64
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Types.Word
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Word.Word8
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Word.Word16
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Word.Word32
instance NumHask.Algebra.Multiplicative.MultiplicativeUnital GHC.Word.Word64
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Types.Double
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Types.Float
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Types.Int
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Integer.Type.Integer
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Types.Bool
instance (NumHask.Algebra.Multiplicative.MultiplicativeMagma a, NumHask.Algebra.Additive.AdditiveGroup a) => NumHask.Algebra.Multiplicative.MultiplicativeMagma (Data.Complex.Complex a)
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Natural.Natural
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Int.Int8
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Int.Int16
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Int.Int32
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Int.Int64
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Types.Word
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Word.Word8
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Word.Word16
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Word.Word32
instance NumHask.Algebra.Multiplicative.MultiplicativeMagma GHC.Word.Word64


-- | <a>Distribution</a> avoids a name clash with <a>Distributive</a>
module NumHask.Algebra.Distribution

-- | Distribution (and annihilation) laws
--   
--   <pre>
--   a * (b + c) == a * b + a * c
--   (a + b) * c == a * c + b * c
--   a * zero == zero
--   zero * a == zero
--   </pre>
class (Additive a, MultiplicativeMagma a) => Distribution a
instance NumHask.Algebra.Distribution.Distribution GHC.Types.Double
instance NumHask.Algebra.Distribution.Distribution GHC.Types.Float
instance NumHask.Algebra.Distribution.Distribution GHC.Types.Int
instance NumHask.Algebra.Distribution.Distribution GHC.Integer.Type.Integer
instance NumHask.Algebra.Distribution.Distribution GHC.Types.Bool
instance (NumHask.Algebra.Additive.AdditiveGroup a, NumHask.Algebra.Distribution.Distribution a) => NumHask.Algebra.Distribution.Distribution (Data.Complex.Complex a)
instance NumHask.Algebra.Distribution.Distribution GHC.Natural.Natural
instance NumHask.Algebra.Distribution.Distribution GHC.Int.Int8
instance NumHask.Algebra.Distribution.Distribution GHC.Int.Int16
instance NumHask.Algebra.Distribution.Distribution GHC.Int.Int32
instance NumHask.Algebra.Distribution.Distribution GHC.Int.Int64
instance NumHask.Algebra.Distribution.Distribution GHC.Types.Word
instance NumHask.Algebra.Distribution.Distribution GHC.Word.Word8
instance NumHask.Algebra.Distribution.Distribution GHC.Word.Word16
instance NumHask.Algebra.Distribution.Distribution GHC.Word.Word32
instance NumHask.Algebra.Distribution.Distribution GHC.Word.Word64


-- | Element-by-element operations
module NumHask.Algebra.Basis

-- | element by element addition
--   
--   <pre>
--   (a .+. b) .+. c == a .+. (b .+. c)
--   zero .+. a = a
--   a .+. zero = a
--   a .+. b == b .+. a
--   </pre>
class (Additive a) => AdditiveBasis m a
(.+.) :: AdditiveBasis m a => m a -> m a -> m a

-- | element by element subtraction
--   
--   <pre>
--   a .-. a = singleton zero
--   </pre>
class (AdditiveGroup a) => AdditiveGroupBasis m a
(.-.) :: AdditiveGroupBasis m a => m a -> m a -> m a

-- | element by element multiplication
--   
--   <pre>
--   (a .*. b) .*. c == a .*. (b .*. c)
--   singleton one .*. a = a
--   a .*. singelton one = a
--   a .*. b == b .*. a
--   </pre>
class (Multiplicative a) => MultiplicativeBasis m a
(.*.) :: MultiplicativeBasis m a => m a -> m a -> m a

-- | element by element division
--   
--   <pre>
--   a ./. a == singleton one
--   </pre>
class (MultiplicativeGroup a) => MultiplicativeGroupBasis m a
(./.) :: MultiplicativeGroupBasis m a => m a -> m a -> m a


-- | Ring classes. A distinguishment is made between Rings and Commutative
--   Rings.
module NumHask.Algebra.Ring

-- | Semiring
class (MultiplicativeAssociative a, MultiplicativeUnital a, Distribution a) => Semiring a

-- | Ring
--   
--   A Ring consists of a set equipped with two binary operations that
--   generalize the arithmetic operations of addition and multiplication;
--   it is an abelian group with a second binary operation that is
--   associative, is distributive over the abelian group operation, and has
--   an identity element.
--   
--   Summary of the laws inherited from the ring super-classes:
--   
--   <pre>
--   zero + a == a
--   a + zero == a
--   (a + b) + c == a + (b + c)
--   a + b == b + a
--   a - a = zero
--   negate a = zero - a
--   negate a + a = zero
--   a + negate a = zero
--   one `times` a == a
--   a `times` one == a
--   (a `times` b) `times` c == a `times` (b `times` c)
--   a `times` (b + c) == a `times` b + a `times` c
--   (a + b) `times` c == a `times` c + b `times` c
--   a `times` zero == zero
--   zero `times` a == zero
--   </pre>
class (Semiring a, AdditiveGroup a) => Ring a

-- | CRing is a Ring with Multiplicative Commutation. It arises often due
--   to <a>*</a> being defined as a multiplicative commutative operation.
class (Multiplicative a, Ring a) => CRing a

-- | StarSemiring
--   
--   <pre>
--   star a = one + a `times` star a
--   </pre>
class (Semiring a) => StarSemiring a
star :: StarSemiring a => a -> a
plus' :: StarSemiring a => a -> a

-- | KleeneAlgebra
--   
--   <pre>
--   a `times` x + x = a ==&gt; star a `times` x + x = x
--   x `times` a + x = a ==&gt; x `times` star a + x = x
--   </pre>
class (StarSemiring a, AdditiveIdempotent a) => KleeneAlgebra a

-- | Involutive Ring
--   
--   <pre>
--   adj (a + b) ==&gt; adj a + adj b
--   adj (a * b) ==&gt; adj a * adj b
--   adj one ==&gt; one
--   adj (adj a) ==&gt; a
--   </pre>
--   
--   Note: elements for which <tt>adj a == a</tt> are called
--   "self-adjoint".
class Semiring a => InvolutiveRing a
adj :: InvolutiveRing a => a -> a
instance NumHask.Algebra.Ring.InvolutiveRing GHC.Types.Double
instance NumHask.Algebra.Ring.InvolutiveRing GHC.Types.Float
instance NumHask.Algebra.Ring.InvolutiveRing GHC.Integer.Type.Integer
instance NumHask.Algebra.Ring.InvolutiveRing GHC.Types.Int
instance NumHask.Algebra.Ring.Ring a => NumHask.Algebra.Ring.InvolutiveRing (Data.Complex.Complex a)
instance NumHask.Algebra.Ring.InvolutiveRing GHC.Natural.Natural
instance NumHask.Algebra.Ring.InvolutiveRing GHC.Int.Int8
instance NumHask.Algebra.Ring.InvolutiveRing GHC.Int.Int16
instance NumHask.Algebra.Ring.InvolutiveRing GHC.Int.Int32
instance NumHask.Algebra.Ring.InvolutiveRing GHC.Int.Int64
instance NumHask.Algebra.Ring.InvolutiveRing GHC.Types.Word
instance NumHask.Algebra.Ring.InvolutiveRing GHC.Word.Word8
instance NumHask.Algebra.Ring.InvolutiveRing GHC.Word.Word16
instance NumHask.Algebra.Ring.InvolutiveRing GHC.Word.Word32
instance NumHask.Algebra.Ring.InvolutiveRing GHC.Word.Word64
instance NumHask.Algebra.Ring.CRing GHC.Types.Double
instance NumHask.Algebra.Ring.CRing GHC.Types.Float
instance NumHask.Algebra.Ring.CRing GHC.Types.Int
instance NumHask.Algebra.Ring.CRing GHC.Integer.Type.Integer
instance NumHask.Algebra.Ring.CRing a => NumHask.Algebra.Ring.CRing (Data.Complex.Complex a)
instance NumHask.Algebra.Ring.CRing GHC.Int.Int8
instance NumHask.Algebra.Ring.CRing GHC.Int.Int16
instance NumHask.Algebra.Ring.CRing GHC.Int.Int32
instance NumHask.Algebra.Ring.CRing GHC.Int.Int64
instance NumHask.Algebra.Ring.CRing GHC.Types.Word
instance NumHask.Algebra.Ring.CRing GHC.Word.Word8
instance NumHask.Algebra.Ring.CRing GHC.Word.Word16
instance NumHask.Algebra.Ring.CRing GHC.Word.Word32
instance NumHask.Algebra.Ring.CRing GHC.Word.Word64
instance NumHask.Algebra.Ring.Ring GHC.Types.Double
instance NumHask.Algebra.Ring.Ring GHC.Types.Float
instance NumHask.Algebra.Ring.Ring GHC.Types.Int
instance NumHask.Algebra.Ring.Ring GHC.Integer.Type.Integer
instance NumHask.Algebra.Ring.Ring a => NumHask.Algebra.Ring.Ring (Data.Complex.Complex a)
instance NumHask.Algebra.Ring.Ring GHC.Int.Int8
instance NumHask.Algebra.Ring.Ring GHC.Int.Int16
instance NumHask.Algebra.Ring.Ring GHC.Int.Int32
instance NumHask.Algebra.Ring.Ring GHC.Int.Int64
instance NumHask.Algebra.Ring.Ring GHC.Types.Word
instance NumHask.Algebra.Ring.Ring GHC.Word.Word8
instance NumHask.Algebra.Ring.Ring GHC.Word.Word16
instance NumHask.Algebra.Ring.Ring GHC.Word.Word32
instance NumHask.Algebra.Ring.Ring GHC.Word.Word64
instance NumHask.Algebra.Ring.Semiring GHC.Types.Double
instance NumHask.Algebra.Ring.Semiring GHC.Types.Float
instance NumHask.Algebra.Ring.Semiring GHC.Types.Int
instance NumHask.Algebra.Ring.Semiring GHC.Integer.Type.Integer
instance NumHask.Algebra.Ring.Semiring GHC.Types.Bool
instance (NumHask.Algebra.Additive.AdditiveGroup a, NumHask.Algebra.Ring.Semiring a) => NumHask.Algebra.Ring.Semiring (Data.Complex.Complex a)
instance NumHask.Algebra.Ring.Semiring GHC.Natural.Natural
instance NumHask.Algebra.Ring.Semiring GHC.Int.Int8
instance NumHask.Algebra.Ring.Semiring GHC.Int.Int16
instance NumHask.Algebra.Ring.Semiring GHC.Int.Int32
instance NumHask.Algebra.Ring.Semiring GHC.Int.Int64
instance NumHask.Algebra.Ring.Semiring GHC.Types.Word
instance NumHask.Algebra.Ring.Semiring GHC.Word.Word8
instance NumHask.Algebra.Ring.Semiring GHC.Word.Word16
instance NumHask.Algebra.Ring.Semiring GHC.Word.Word32
instance NumHask.Algebra.Ring.Semiring GHC.Word.Word64


-- | Integral classes
module NumHask.Algebra.Integral

-- | Integral laws
--   
--   <pre>
--   b == zero || b * (a `div` b) + (a `mod` b) == a
--   </pre>
class (Semiring a) => Integral a
div :: Integral a => a -> a -> a
mod :: Integral a => a -> a -> a
divMod :: Integral a => a -> a -> (a, a)
quot :: Integral a => a -> a -> a
rem :: Integral a => a -> a -> a
quotRem :: Integral a => a -> a -> (a, a)

-- | toInteger is kept separate from Integral to help with compatability
--   issues.
class ToInteger a
toInteger :: ToInteger a => a -> Integer

-- | fromInteger is the most problematic of the <tt>Num</tt> class
--   operators. Particularly heinous, it is assumed that any number type
--   can be constructed from an Integer, so that the broad classes of
--   objects that are composed of multiple elements is avoided in haskell.
class FromInteger a
fromInteger :: FromInteger a => Integer -> a

-- | coercion of <a>Integral</a>s
--   
--   <pre>
--   fromIntegral a == a
--   </pre>
fromIntegral :: (ToInteger a, FromInteger b) => a -> b
even :: (Eq a, Integral a) => a -> Bool
odd :: (Eq a, Integral a) => a -> Bool

-- | raise a number to a non-negative integral power
(^) :: (Ord b, Integral b, Multiplicative a) => a -> b -> a
(^^) :: (MultiplicativeGroup a) => a -> Integer -> a
instance NumHask.Algebra.Integral.FromInteger GHC.Types.Double
instance NumHask.Algebra.Integral.FromInteger GHC.Types.Float
instance NumHask.Algebra.Integral.FromInteger GHC.Types.Int
instance NumHask.Algebra.Integral.FromInteger GHC.Integer.Type.Integer
instance NumHask.Algebra.Integral.FromInteger GHC.Natural.Natural
instance NumHask.Algebra.Integral.FromInteger GHC.Int.Int8
instance NumHask.Algebra.Integral.FromInteger GHC.Int.Int16
instance NumHask.Algebra.Integral.FromInteger GHC.Int.Int32
instance NumHask.Algebra.Integral.FromInteger GHC.Int.Int64
instance NumHask.Algebra.Integral.FromInteger GHC.Types.Word
instance NumHask.Algebra.Integral.FromInteger GHC.Word.Word8
instance NumHask.Algebra.Integral.FromInteger GHC.Word.Word16
instance NumHask.Algebra.Integral.FromInteger GHC.Word.Word32
instance NumHask.Algebra.Integral.FromInteger GHC.Word.Word64
instance NumHask.Algebra.Integral.ToInteger GHC.Types.Int
instance NumHask.Algebra.Integral.ToInteger GHC.Integer.Type.Integer
instance NumHask.Algebra.Integral.ToInteger GHC.Natural.Natural
instance NumHask.Algebra.Integral.ToInteger GHC.Int.Int8
instance NumHask.Algebra.Integral.ToInteger GHC.Int.Int16
instance NumHask.Algebra.Integral.ToInteger GHC.Int.Int32
instance NumHask.Algebra.Integral.ToInteger GHC.Int.Int64
instance NumHask.Algebra.Integral.ToInteger GHC.Types.Word
instance NumHask.Algebra.Integral.ToInteger GHC.Word.Word8
instance NumHask.Algebra.Integral.ToInteger GHC.Word.Word16
instance NumHask.Algebra.Integral.ToInteger GHC.Word.Word32
instance NumHask.Algebra.Integral.ToInteger GHC.Word.Word64
instance NumHask.Algebra.Integral.Integral GHC.Types.Int
instance NumHask.Algebra.Integral.Integral GHC.Integer.Type.Integer
instance NumHask.Algebra.Integral.Integral GHC.Natural.Natural
instance NumHask.Algebra.Integral.Integral GHC.Int.Int8
instance NumHask.Algebra.Integral.Integral GHC.Int.Int16
instance NumHask.Algebra.Integral.Integral GHC.Int.Int32
instance NumHask.Algebra.Integral.Integral GHC.Int.Int64
instance NumHask.Algebra.Integral.Integral GHC.Types.Word
instance NumHask.Algebra.Integral.Integral GHC.Word.Word8
instance NumHask.Algebra.Integral.Integral GHC.Word.Word16
instance NumHask.Algebra.Integral.Integral GHC.Word.Word32
instance NumHask.Algebra.Integral.Integral GHC.Word.Word64


-- | Field classes
module NumHask.Algebra.Field

-- | A Semifield is chosen here to be a Field without an Additive Inverse
class (MultiplicativeInvertible a, MultiplicativeGroup a, Semiring a) => Semifield a

-- | A Field is a Ring plus additive invertible and multiplicative
--   invertible operations.
--   
--   A summary of the rules inherited from super-classes of Field
--   
--   <pre>
--   zero + a == a
--   a + zero == a
--   (a + b) + c == a + (b + c)
--   a + b == b + a
--   a - a = zero
--   negate a = zero - a
--   negate a + a = zero
--   a + negate a = zero
--   one * a == a
--   a * one == a
--   (a * b) * c == a * (b * c)
--   a * (b + c) == a * b + a * c
--   (a + b) * c == a * c + b * c
--   a * zero == zero
--   zero * a == zero
--   a * b == b * a
--   a / a = one
--   recip a = one / a
--   recip a * a = one
--   a * recip a = one
--   </pre>
class (AdditiveGroup a, MultiplicativeGroup a, Ring a) => Field a

-- | A hyperbolic field class
--   
--   <pre>
--   sqrt . (**2) == identity
--   log . exp == identity
--   for +ive b, a != 0,1: a ** logBase a b ≈ b
--   </pre>
class (Field a) => ExpField a
exp :: ExpField a => a -> a
log :: ExpField a => a -> a
logBase :: ExpField a => a -> a -> a
(**) :: ExpField a => a -> a -> a
sqrt :: ExpField a => a -> a

-- | quotient fields explode constraints if they allow for polymorphic
--   integral types
--   
--   <pre>
--   a - one &lt; floor a &lt;= a &lt;= ceiling a &lt; a + one
--   round a == floor (a + one/(one+one))
--   </pre>
--   
--   fixme: had to redefine Signed operators here because of the Field
--   import in Metric, itself due to Complex being defined there
class (Ord a, Field a, Eq b, Integral b, AdditiveGroup b, MultiplicativeUnital b) => QuotientField a b
properFraction :: QuotientField a b => a -> (b, a)
round :: QuotientField a b => a -> b
ceiling :: QuotientField a b => a -> b
floor :: QuotientField a b => a -> b

-- | A bounded field includes the concepts of infinity and NaN, thus moving
--   away from error throwing.
--   
--   <pre>
--   one / zero + infinity == infinity
--   infinity + a == infinity
--   zero / zero != nan
--   </pre>
--   
--   Note the tricky law that, although nan is assigned to zero/zero, they
--   are never-the-less not equal. A committee decided this.
class (Semifield a) => UpperBoundedField a
infinity :: UpperBoundedField a => a
nan :: UpperBoundedField a => a
class (Field a) => LowerBoundedField a
negInfinity :: LowerBoundedField a => a
class (UpperBoundedField a, LowerBoundedField a) => BoundedField a

-- | Trigonometric Field
class (Field a) => TrigField a
pi :: TrigField a => a
sin :: TrigField a => a -> a
cos :: TrigField a => a -> a
tan :: TrigField a => a -> a
asin :: TrigField a => a -> a
acos :: TrigField a => a -> a
atan :: TrigField a => a -> a
sinh :: TrigField a => a -> a
cosh :: TrigField a => a -> a
tanh :: TrigField a => a -> a
asinh :: TrigField a => a -> a
acosh :: TrigField a => a -> a
atanh :: TrigField a => a -> a
instance (GHC.Classes.Ord a, NumHask.Algebra.Field.TrigField a, NumHask.Algebra.Field.ExpField a) => NumHask.Algebra.Field.ExpField (Data.Complex.Complex a)
instance NumHask.Algebra.Field.TrigField GHC.Types.Double
instance NumHask.Algebra.Field.TrigField GHC.Types.Float
instance (NumHask.Algebra.Field.UpperBoundedField a, NumHask.Algebra.Field.LowerBoundedField a) => NumHask.Algebra.Field.BoundedField a
instance NumHask.Algebra.Field.LowerBoundedField GHC.Types.Float
instance NumHask.Algebra.Field.LowerBoundedField GHC.Types.Double
instance NumHask.Algebra.Field.UpperBoundedField GHC.Types.Float
instance NumHask.Algebra.Field.UpperBoundedField GHC.Types.Double
instance (NumHask.Algebra.Additive.AdditiveGroup a, NumHask.Algebra.Field.UpperBoundedField a) => NumHask.Algebra.Field.UpperBoundedField (Data.Complex.Complex a)
instance NumHask.Algebra.Field.QuotientField GHC.Types.Float GHC.Integer.Type.Integer
instance NumHask.Algebra.Field.QuotientField GHC.Types.Double GHC.Integer.Type.Integer
instance NumHask.Algebra.Field.ExpField GHC.Types.Double
instance NumHask.Algebra.Field.ExpField GHC.Types.Float
instance NumHask.Algebra.Field.Field GHC.Types.Double
instance NumHask.Algebra.Field.Field GHC.Types.Float
instance NumHask.Algebra.Field.Field a => NumHask.Algebra.Field.Field (Data.Complex.Complex a)
instance NumHask.Algebra.Field.Semifield GHC.Types.Double
instance NumHask.Algebra.Field.Semifield GHC.Types.Float
instance (NumHask.Algebra.Field.Semifield a, NumHask.Algebra.Additive.AdditiveGroup a) => NumHask.Algebra.Field.Semifield (Data.Complex.Complex a)


-- | Metric classes
module NumHask.Algebra.Metric

-- | <a>signum</a> from base is not an operator replicated in numhask,
--   being such a very silly name, and preferred is the much more obvious
--   <a>sign</a>. Compare with <tt>Norm</tt> and <tt>Banach</tt> where
--   there is a change in codomain
--   
--   <pre>
--   abs a * sign a == a
--   </pre>
--   
--   Generalising this class tends towards size and direction (abs is the
--   size on the one-dim number line of a vector with its tail at zero, and
--   sign is the direction, right?).
class (MultiplicativeUnital a) => Signed a
sign :: Signed a => a -> a
abs :: Signed a => a -> a

-- | L1 and L2 norms are provided for potential speedups, as well as the
--   generalized p-norm.
--   
--   for p &gt;= 1
--   
--   <pre>
--   normLp p a &gt;= zero
--   normLp p zero == zero
--   </pre>
--   
--   Note that the Normed codomain can be different to the domain.
class Normed a b
normL1 :: Normed a b => a -> b
normL2 :: Normed a b => a -> b
normLp :: Normed a b => b -> a -> b

-- | distance between numbers using L1, L2 or Lp-norms
--   
--   <pre>
--   distanceL2 a b &gt;= zero
--   distanceL2 a a == zero
--   \a b c -&gt; distanceL2 a c + distanceL2 b c - distanceL2 a b &gt;= zero &amp;&amp;
--             distanceL2 a b + distanceL2 b c - distanceL2 a c &gt;= zero &amp;&amp;
--             distanceL2 a b + distanceL2 a c - distanceL2 b c &gt;= zero &amp;&amp;
--   </pre>
class Metric a b
distanceL1 :: Metric a b => a -> a -> b
distanceL2 :: Metric a b => a -> a -> b
distanceLp :: Metric a b => b -> a -> a -> b

-- | todo: This should probably be split off into some sort of alternative
--   Equality logic, but to what end?
class (Eq a, AdditiveGroup a) => Epsilon a
nearZero :: Epsilon a => a -> Bool
aboutEqual :: Epsilon a => a -> a -> Bool
positive :: (Epsilon a, (Signed a)) => a -> Bool
veryPositive :: (Epsilon a, (Signed a)) => a -> Bool
veryNegative :: (Epsilon a, (Signed a)) => a -> Bool

-- | todo: is utf perfectly acceptable these days?
(≈) :: (Epsilon a) => a -> a -> Bool
infixl 4 ≈
instance NumHask.Algebra.Metric.Epsilon GHC.Types.Double
instance NumHask.Algebra.Metric.Epsilon GHC.Types.Float
instance NumHask.Algebra.Metric.Epsilon GHC.Types.Int
instance NumHask.Algebra.Metric.Epsilon GHC.Integer.Type.Integer
instance NumHask.Algebra.Metric.Epsilon a => NumHask.Algebra.Metric.Epsilon (Data.Complex.Complex a)
instance NumHask.Algebra.Metric.Epsilon GHC.Int.Int8
instance NumHask.Algebra.Metric.Epsilon GHC.Int.Int16
instance NumHask.Algebra.Metric.Epsilon GHC.Int.Int32
instance NumHask.Algebra.Metric.Epsilon GHC.Int.Int64
instance NumHask.Algebra.Metric.Epsilon GHC.Types.Word
instance NumHask.Algebra.Metric.Epsilon GHC.Word.Word8
instance NumHask.Algebra.Metric.Epsilon GHC.Word.Word16
instance NumHask.Algebra.Metric.Epsilon GHC.Word.Word32
instance NumHask.Algebra.Metric.Epsilon GHC.Word.Word64
instance NumHask.Algebra.Metric.Metric GHC.Types.Double GHC.Types.Double
instance NumHask.Algebra.Metric.Metric GHC.Types.Float GHC.Types.Float
instance NumHask.Algebra.Metric.Metric GHC.Types.Int GHC.Types.Int
instance NumHask.Algebra.Metric.Metric GHC.Integer.Type.Integer GHC.Integer.Type.Integer
instance (NumHask.Algebra.Multiplicative.Multiplicative a, NumHask.Algebra.Field.ExpField a, NumHask.Algebra.Metric.Normed a a) => NumHask.Algebra.Metric.Metric (Data.Complex.Complex a) a
instance NumHask.Algebra.Metric.Metric GHC.Natural.Natural GHC.Natural.Natural
instance NumHask.Algebra.Metric.Metric GHC.Int.Int8 GHC.Int.Int8
instance NumHask.Algebra.Metric.Metric GHC.Int.Int16 GHC.Int.Int16
instance NumHask.Algebra.Metric.Metric GHC.Int.Int32 GHC.Int.Int32
instance NumHask.Algebra.Metric.Metric GHC.Int.Int64 GHC.Int.Int64
instance NumHask.Algebra.Metric.Metric GHC.Types.Word GHC.Types.Word
instance NumHask.Algebra.Metric.Metric GHC.Word.Word8 GHC.Word.Word8
instance NumHask.Algebra.Metric.Metric GHC.Word.Word16 GHC.Word.Word16
instance NumHask.Algebra.Metric.Metric GHC.Word.Word32 GHC.Word.Word32
instance NumHask.Algebra.Metric.Metric GHC.Word.Word64 GHC.Word.Word64
instance NumHask.Algebra.Metric.Normed GHC.Types.Double GHC.Types.Double
instance NumHask.Algebra.Metric.Normed GHC.Types.Float GHC.Types.Float
instance NumHask.Algebra.Metric.Normed GHC.Types.Int GHC.Types.Int
instance NumHask.Algebra.Metric.Normed GHC.Integer.Type.Integer GHC.Integer.Type.Integer
instance (NumHask.Algebra.Multiplicative.Multiplicative a, NumHask.Algebra.Field.ExpField a, NumHask.Algebra.Metric.Normed a a) => NumHask.Algebra.Metric.Normed (Data.Complex.Complex a) a
instance NumHask.Algebra.Metric.Normed GHC.Natural.Natural GHC.Natural.Natural
instance NumHask.Algebra.Metric.Normed GHC.Int.Int8 GHC.Int.Int8
instance NumHask.Algebra.Metric.Normed GHC.Int.Int16 GHC.Int.Int16
instance NumHask.Algebra.Metric.Normed GHC.Int.Int32 GHC.Int.Int32
instance NumHask.Algebra.Metric.Normed GHC.Int.Int64 GHC.Int.Int64
instance NumHask.Algebra.Metric.Normed GHC.Types.Word GHC.Types.Word
instance NumHask.Algebra.Metric.Normed GHC.Word.Word8 GHC.Word.Word8
instance NumHask.Algebra.Metric.Normed GHC.Word.Word16 GHC.Word.Word16
instance NumHask.Algebra.Metric.Normed GHC.Word.Word32 GHC.Word.Word32
instance NumHask.Algebra.Metric.Normed GHC.Word.Word64 GHC.Word.Word64
instance NumHask.Algebra.Metric.Signed GHC.Types.Double
instance NumHask.Algebra.Metric.Signed GHC.Types.Float
instance NumHask.Algebra.Metric.Signed GHC.Types.Int
instance NumHask.Algebra.Metric.Signed GHC.Integer.Type.Integer
instance NumHask.Algebra.Metric.Signed GHC.Natural.Natural
instance NumHask.Algebra.Metric.Signed GHC.Int.Int8
instance NumHask.Algebra.Metric.Signed GHC.Int.Int16
instance NumHask.Algebra.Metric.Signed GHC.Int.Int32
instance NumHask.Algebra.Metric.Signed GHC.Int.Int64
instance NumHask.Algebra.Metric.Signed GHC.Types.Word
instance NumHask.Algebra.Metric.Signed GHC.Word.Word8
instance NumHask.Algebra.Metric.Signed GHC.Word.Word16
instance NumHask.Algebra.Metric.Signed GHC.Word.Word32
instance NumHask.Algebra.Metric.Signed GHC.Word.Word64


-- | Integral classes
module NumHask.Algebra.Rational
data Ratio a
(:%) :: !a -> !a -> Ratio a
type Rational = Ratio Integer

-- | toRatio is equivalent to <tt>Real</tt> in base.
class ToRatio a
toRatio :: ToRatio a => a -> Ratio Integer

-- | <tt>Fractional</tt> in base splits into fromRatio and
--   MultiplicativeGroup
class FromRatio a
fromRatio :: FromRatio a => Ratio Integer -> a

-- | coercion of <a>Rational</a>s
--   
--   <pre>
--   fromRational a == a
--   </pre>
fromRational :: (ToRatio a, FromRatio b) => a -> b

-- | <a>reduce</a> is a subsidiary function used only in this module. It
--   normalises a ratio by dividing both numerator and denominator by their
--   greatest common divisor.
reduce :: (Ord a, AdditiveInvertible a, Signed a, Integral a) => a -> a -> Ratio a

-- | <tt><a>gcd</a> x y</tt> is the non-negative factor of both <tt>x</tt>
--   and <tt>y</tt> of which every common factor of <tt>x</tt> and
--   <tt>y</tt> is also a factor; for example <tt><a>gcd</a> 4 2 = 2</tt>,
--   <tt><a>gcd</a> (-4) 6 = 2</tt>, <tt><a>gcd</a> 0 4</tt> = <tt>4</tt>.
--   <tt><a>gcd</a> 0 0</tt> = <tt>0</tt>. (That is, the common divisor
--   that is "greatest" in the divisibility preordering.)
--   
--   Note: Since for signed fixed-width integer types, <tt><a>abs</a>
--   <tt>minBound</tt> &lt; 0</tt>, the result may be negative if one of
--   the arguments is <tt><tt>minBound</tt></tt> (and necessarily is if the
--   other is <tt>0</tt> or <tt><tt>minBound</tt></tt>) for such types.
gcd :: (Ord a, Signed a, Integral a) => a -> a -> a
instance GHC.Show.Show a => GHC.Show.Show (NumHask.Algebra.Rational.Ratio a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (NumHask.Algebra.Rational.Ratio a)
instance NumHask.Algebra.Integral.FromInteger a => NumHask.Algebra.Rational.FromRatio (NumHask.Algebra.Rational.Ratio a)
instance NumHask.Algebra.Rational.FromRatio GHC.Types.Double
instance NumHask.Algebra.Rational.FromRatio GHC.Types.Float
instance NumHask.Algebra.Integral.ToInteger a => NumHask.Algebra.Rational.ToRatio (NumHask.Algebra.Rational.Ratio a)
instance NumHask.Algebra.Rational.ToRatio GHC.Types.Double
instance NumHask.Algebra.Rational.ToRatio GHC.Types.Float
instance NumHask.Algebra.Rational.ToRatio GHC.Types.Int
instance NumHask.Algebra.Rational.ToRatio GHC.Integer.Type.Integer
instance NumHask.Algebra.Rational.ToRatio GHC.Natural.Natural
instance NumHask.Algebra.Rational.ToRatio GHC.Real.Rational
instance NumHask.Algebra.Rational.ToRatio GHC.Int.Int8
instance NumHask.Algebra.Rational.ToRatio GHC.Int.Int16
instance NumHask.Algebra.Rational.ToRatio GHC.Int.Int32
instance NumHask.Algebra.Rational.ToRatio GHC.Int.Int64
instance NumHask.Algebra.Rational.ToRatio GHC.Types.Word
instance NumHask.Algebra.Rational.ToRatio GHC.Word.Word8
instance NumHask.Algebra.Rational.ToRatio GHC.Word.Word16
instance NumHask.Algebra.Rational.ToRatio GHC.Word.Word32
instance NumHask.Algebra.Rational.ToRatio GHC.Word.Word64
instance (GHC.Classes.Ord a, NumHask.Algebra.Multiplicative.Multiplicative a, NumHask.Algebra.Integral.Integral a) => GHC.Classes.Ord (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Additive.AdditiveMagma (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Additive.AdditiveUnital (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Additive.AdditiveAssociative (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Additive.AdditiveCommutative (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Additive.AdditiveInvertible (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Additive.Additive (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveGroup a) => NumHask.Algebra.Additive.AdditiveGroup (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Multiplicative.MultiplicativeMagma (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Multiplicative.MultiplicativeUnital (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Multiplicative.MultiplicativeAssociative (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Multiplicative.MultiplicativeCommutative (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Multiplicative.MultiplicativeInvertible (NumHask.Algebra.Rational.Ratio a)
instance (NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Additive.AdditiveInvertible a, NumHask.Algebra.Additive.AdditiveUnital a, NumHask.Algebra.Integral.Integral a, GHC.Classes.Ord a, NumHask.Algebra.Multiplicative.Multiplicative a) => NumHask.Algebra.Multiplicative.Multiplicative (NumHask.Algebra.Rational.Ratio a)
instance (NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Additive.AdditiveInvertible a, NumHask.Algebra.Additive.AdditiveUnital a, NumHask.Algebra.Integral.Integral a, GHC.Classes.Ord a, NumHask.Algebra.Multiplicative.Multiplicative a) => NumHask.Algebra.Multiplicative.MultiplicativeGroup (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Distribution.Distribution (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Ring.Semiring (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveGroup a) => NumHask.Algebra.Ring.Ring (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Multiplicative.Multiplicative a, NumHask.Algebra.Ring.Ring a) => NumHask.Algebra.Ring.CRing (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Multiplicative.Multiplicative a, NumHask.Algebra.Ring.Ring a) => NumHask.Algebra.Ring.InvolutiveRing (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Multiplicative.Multiplicative a, NumHask.Algebra.Ring.Ring a) => NumHask.Algebra.Field.Semifield (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Multiplicative.Multiplicative a, NumHask.Algebra.Ring.Ring a) => NumHask.Algebra.Field.Field (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.ToInteger a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Multiplicative.Multiplicative a, NumHask.Algebra.Ring.Ring a, GHC.Classes.Eq b, NumHask.Algebra.Additive.AdditiveGroup b, NumHask.Algebra.Integral.Integral b, NumHask.Algebra.Integral.FromInteger b) => NumHask.Algebra.Field.QuotientField (NumHask.Algebra.Rational.Ratio a) b
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveInvertible a, NumHask.Algebra.Multiplicative.Multiplicative a, NumHask.Algebra.Ring.Ring a) => NumHask.Algebra.Field.UpperBoundedField (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Multiplicative.Multiplicative a, NumHask.Algebra.Ring.Ring a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Field.LowerBoundedField (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Metric.Signed (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Additive.AdditiveInvertible a) => NumHask.Algebra.Metric.Normed (NumHask.Algebra.Rational.Ratio a) (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Additive.AdditiveGroup a) => NumHask.Algebra.Metric.Metric (NumHask.Algebra.Rational.Ratio a) (NumHask.Algebra.Rational.Ratio a)
instance (GHC.Classes.Ord a, NumHask.Algebra.Metric.Signed a, NumHask.Algebra.Integral.Integral a, NumHask.Algebra.Additive.AdditiveGroup a) => NumHask.Algebra.Metric.Epsilon (NumHask.Algebra.Rational.Ratio a)
instance (NumHask.Algebra.Integral.FromInteger a, NumHask.Algebra.Multiplicative.MultiplicativeUnital a) => NumHask.Algebra.Integral.FromInteger (NumHask.Algebra.Rational.Ratio a)


-- | Algebra for Modules
module NumHask.Algebra.Module

-- | Additive Module Laws
--   
--   <pre>
--   (a + b) .+ c == a + (b .+ c)
--   (a + b) .+ c == (a .+ c) + b
--   a .+ zero == a
--   a .+ b == b +. a
--   </pre>
class (Additive a) => AdditiveModule r a
(.+) :: AdditiveModule r a => r a -> a -> r a
(+.) :: AdditiveModule r a => a -> r a -> r a

-- | Subtraction Module Laws
--   
--   <pre>
--   (a + b) .- c == a + (b .- c)
--   (a + b) .- c == (a .- c) + b
--   a .- zero == a
--   a .- b == negate b +. a
--   </pre>
class (AdditiveGroup a, AdditiveModule r a) => AdditiveGroupModule r a
(.-) :: AdditiveGroupModule r a => r a -> a -> r a
(-.) :: AdditiveGroupModule r a => a -> r a -> r a

-- | Multiplicative Module Laws
--   
--   <pre>
--   a .* one == a
--   (a + b) .* c == (a .* c) + (b .* c)
--   c *. (a + b) == (c *. a) + (c *. b)
--   a .* zero == zero
--   a .* b == b *. a
--   </pre>
class (Multiplicative a) => MultiplicativeModule r a
(.*) :: MultiplicativeModule r a => r a -> a -> r a
(*.) :: MultiplicativeModule r a => a -> r a -> r a

-- | Division Module Laws
--   
--   <pre>
--   nearZero a || a ./ one == a
--   b == zero || a ./ b == recip b *. a
--   </pre>
class (MultiplicativeGroup a, MultiplicativeModule r a) => MultiplicativeGroupModule r a
(./) :: MultiplicativeGroupModule r a => r a -> a -> r a
(/.) :: MultiplicativeGroupModule r a => a -> r a -> r a

-- | Banach (with Norm) laws form rules around size and direction of a
--   number, with a potential crossing into another codomain.
--   
--   <pre>
--   a == singleton zero || normalizeL2 a *. normL2 a == a
--   </pre>
class (ExpField a, Normed (r a) a, MultiplicativeGroupModule r a) => Banach r a
normalizeL1 :: Banach r a => r a -> r a
normalizeL2 :: Banach r a => r a -> r a
normalizeLp :: Banach r a => a -> r a -> r a

-- | the inner product of a representable over a semiring
--   
--   <pre>
--   a &lt;.&gt; b == b &lt;.&gt; a
--   a &lt;.&gt; (b +c) == a &lt;.&gt; b + a &lt;.&gt; c
--   a &lt;.&gt; (s *. b + c) == s * (a &lt;.&gt; b) + a &lt;.&gt; c
--   </pre>
--   
--   (s0 *. a) <a>.</a> (s1 *. b) == s0 * s1 * (a <a>.</a> b)
class (Semiring a) => Hilbert r a
(<.>) :: Hilbert r a => r a -> r a -> a

-- | tensorial type

-- | generalised outer product
--   
--   <pre>
--   a&gt;&lt;b + c&gt;&lt;b == (a+c) &gt;&lt; b
--   a&gt;&lt;b + a&gt;&lt;c == a &gt;&lt; (b+c)
--   </pre>
--   
--   todo: work out why these laws down't apply &gt; a *. (b&gt;<a>==
--   (a</a>&lt;b) .* c &gt; (a&gt;<a>.* c == a *. (b</a>&lt;c)
class TensorProduct a
(><) :: TensorProduct a => a -> a -> (a >< a)
outer :: TensorProduct a => a -> a -> (a >< a)
timesleft :: TensorProduct a => a -> (a >< a) -> a
timesright :: TensorProduct a => (a >< a) -> a -> a


-- | The basic algebraic class structure of a number.
--   
--   <pre>
--   import NumHask.Algebra
--   import Prelude hiding (Integral(..), (*), (**), (+), (-), (/), (^), (^^), abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceiling, cos, cosh, exp, floor, fromInteger, fromIntegral, log, logBase, negate, pi, product, recip, round, sin, sinh, sqrt, sum, tan, tanh, toInteger, fromRational)
--   </pre>
module NumHask.Algebra

-- | Complex numbers are an algebraic type.
--   
--   For a complex number <tt>z</tt>, <tt><a>abs</a> z</tt> is a number
--   with the magnitude of <tt>z</tt>, but oriented in the positive real
--   direction, whereas <tt><a>signum</a> z</tt> has the phase of
--   <tt>z</tt>, but unit magnitude.
--   
--   The <a>Foldable</a> and <a>Traversable</a> instances traverse the real
--   part first.
data Complex a :: * -> *

-- | forms a complex number from its real and imaginary rectangular
--   components.
(:+) :: !a -> !a -> Complex a


-- | Homomorphic operation from element to structured number
module NumHask.Algebra.Singleton

-- | This class could also be called replicate. Looking forward, however,
--   it may be useful to consider a Representable such as
--   
--   <pre>
--   VectorThing a = Vector a | Single a | Zero
--   </pre>
--   
--   and then
--   
--   <pre>
--   singleton a = Single a
--   singleton zero = Zero
--   </pre>
--   
--   short-circuiting an expensive computation. As the class action then
--   doesn't actually involve replication, it would be mis-named.
class Singleton f
singleton :: Singleton f => a -> f a