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


-- | A type for integers modulo some constant.
--   
@package modular-arithmetic
@version 1.2.1.0


-- | Types for working with integers modulo some constant.
--   
--   <tt><a>Mod</a></tt> and its synonym <tt>/</tt> let you wrap arbitrary
--   numeric types in a modulus. To work with integers (mod 7) backed by
--   <tt>Integer</tt>, you could write:
--   
--   <pre>
--   Integer `Mod` 7
--   Integer/7
--   ℤ/7
--   </pre>
--   
--   (The last is a synonym for <tt>Integer</tt> provided by this library.
--   In Emacs, you can use the TeX input mode to type it with
--   <tt>\Bbb{Z}</tt>.)
--   
--   The usual numeric typeclasses are defined for these types. You can
--   always extrac the underlying value with <tt><a>unMod</a></tt>.
--   
--   Here is a quick example:
--   
--   <pre>
--   *Data.Modular&gt; (10 :: ℤ/7) * (11 :: ℤ/7)
--   5
--   </pre>
--   
--   It also works correctly with negative numeric literals:
--   
--   <pre>
--   *Data.Modular&gt; (-10 :: ℤ/7) * (11 :: ℤ/7)
--   2
--   </pre>
--   
--   To us type level numeric literals you need to enable the
--   <tt>DataKinds</tt> extension and to use infix syntax for <tt>Mod</tt>
--   or the <tt>/</tt> synonym, you need <tt>TypeOperators</tt>.
module Data.Modular

-- | Extract the underlying integral value from a modular type.
unMod :: i `Mod` n -> i

-- | Wraps the underlying type into the modular type, wrapping as
--   appropriate.
toMod :: (Integral i, KnownNat n) => i -> i `Mod` n

-- | Wraps an integral number to a mod, converting between integral types.
toMod' :: (Integral i, Integral j, KnownNat n) => i -> j `Mod` n

-- | The actual type, wrapping an underlying <tt>Integeral</tt> type
--   <tt>i</tt> in a newtype annotated with the bound.
data Mod i (n :: Nat)

-- | The modular inverse. Note that only numbers coprime to <tt>n</tt> have
--   an inverse modulo <tt>n</tt>.
inv :: (KnownNat n, Integral i) => Mod i n -> Mod i n

-- | A synonym for <tt>Mod</tt>, inspired by the ℤ/n syntax from
--   mathematics.
type (/) = Mod

-- | A synonym for Integer, also inspired by the ℤ/n syntax.
type ℤ = Integer

-- | Convert an integral number <tt>i</tt> into a <tt><a>Mod</a></tt> value
--   given modular bound <tt>n</tt> at type level.
modVal :: (Integral i, KnownNat n) => i -> proxy n -> Mod i n

-- | This type represents a modular number with unknown bound.
data SomeMod i

-- | Convert an integral number <tt>i</tt> into an unknown
--   <tt><a>Mod</a></tt> value.
someModVal :: Integral i => i -> Integer -> Maybe (SomeMod i)
instance Eq i => Eq (Mod i n)
instance Ord i => Ord (Mod i n)
instance Show i => Show (SomeMod i)
instance (Integral i, KnownNat n) => Integral (Mod i n)
instance (Integral i, KnownNat n) => Real (Mod i n)
instance (Integral i, KnownNat n) => Bounded (Mod i n)
instance (Integral i, KnownNat n) => Enum (Mod i n)
instance (Integral i, KnownNat n) => Num (Mod i n)
instance (Read i, Integral i, KnownNat n) => Read (Mod i n)
instance Show i => Show (Mod i n)