numeric-prelude-0.4.2: An experimental alternative hierarchy of numeric type classes

Safe HaskellNone




data T a Source

The best solution seems to let modulus be part of the type. This could happen with a phantom type for modulus and a run function like runST. Then operations with non-matching moduli could be detected at compile time and zero and one could be generated with the correct modulus. An alternative trial can be found in module ResidueClassMaybe.


Cons infix 7 


modulus :: !a
representative :: !a


Eq a => Eq (T a) 
(Read a, C a) => Read (T a) 
Show a => Show (T a) 
(Eq 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 => a -> a -> T a infix 7 Source

r /: m is the residue class containing r with respect to the modulus m

isCompatible :: Eq a => T a -> T a -> Bool Source

Check if two residue classes share the same modulus

maybeCompatible :: Eq a => T a -> T a -> Maybe a Source

fromRepresentative :: C a => a -> a -> T a Source

lift1 :: Eq a => (a -> a -> a) -> T a -> T a Source

lift2 :: Eq a => (a -> a -> a -> a) -> T a -> T a -> T a Source

zero :: C a => a -> T a Source

one :: C a => a -> T a Source

fromInteger :: C a => a -> Integer -> T a Source