Data.DivisionRing

class (Ring a) <= DivisionRing a  where

The DivisionRing class is for non-zero rings in which every non-zero element has a multiplicative inverse. Division rings are sometimes also called skew fields.

Instances must satisfy the following laws in addition to the Ring laws:

• Non-zero ring: one /= zero
• Non-zero multiplicative inverse: recip a * a = a * recip a = one for all non-zero a

The result of recip zero is left undefined; individual instances may choose how to handle this case.

If a type has both DivisionRing and CommutativeRing instances, then it is a field and should have a Field instance.

Members

• recip :: a -> a

Instances

• DivisionRing Number

leftDiv :: forall a. DivisionRing a => a -> a -> a

Left division, defined as leftDiv a b = recip b * a. Left and right division are distinct in this module because a DivisionRing is not necessarily commutative.

If the type a is also a EuclideanRing, then this function is equivalent to div from the EuclideanRing class. When working abstractly, div should generally be preferred, unless you know that you need your code to work with noncommutative rings.

rightDiv :: forall a. DivisionRing a => a -> a -> a

Right division, defined as rightDiv a b = a * recip b. Left and right division are distinct in this module because a DivisionRing is not necessarily commutative.

If the type a is also a EuclideanRing, then this function is equivalent to div from the EuclideanRing class. When working abstractly, div should generally be preferred, unless you know that you need your code to work with noncommutative rings.

class (Semiring a) <= Ring a  where

The Ring class is for types that support addition, multiplication, and subtraction operations.

Instances must satisfy the following law in addition to the Semiring laws:

• Additive inverse: a - a = (zero - a) + a = zero

Members

• sub :: a -> a -> a

Instances

• Ring Int
• Ring Number
• Ring Unit
• (Ring b) => Ring (a -> b)

negate :: forall a. Ring a => a -> a

negate x can be used as a shorthand for zero - x.

class Semiring a  where

The Semiring class is for types that support an addition and multiplication operation.

Instances must satisfy the following laws:

• Commutative monoid under addition:
  • Associativity: (a + b) + c = a + (b + c)
  • Identity: zero + a = a + zero = a
  • Commutative: a + b = b + a
• Monoid under multiplication:
  • Associativity: (a * b) * c = a * (b * c)
  • Identity: one * a = a * one = a
• Multiplication distributes over addition:
  • Left distributivity: a * (b + c) = (a * b) + (a * c)
  • Right distributivity: (a + b) * c = (a * c) + (b * c)
• Annihilation: zero * a = a * zero = zero

Note: The Number and Int types are not fully law abiding members of this class hierarchy due to the potential for arithmetic overflows, and in the case of Number, the presence of NaN and Infinity values. The behaviour is unspecified in these cases.

Members

• add :: a -> a -> a
• zero :: a
• mul :: a -> a -> a
• one :: a

Instances

• Semiring Int
• Semiring Number
• (Semiring b) => Semiring (a -> b)
• Semiring Unit

Operator alias for Data.Semiring.add (left-associative / precedence 6)

Operator alias for Data.Semiring.mul (left-associative / precedence 7)