-- 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.0.0


-- | This module provides types for working with integers modulo some
--   constant.
--   
--   This module uses some new Haskell features introduced in 7.6. In
--   particular, it needs <tt>DataKinds</tt> and type literals
--   (<a>GHC.TypeLits</a>). The <tt>TypeOperators</tt> extension is needed
--   for the nice infix syntax.
--   
--   These types are created with the type constructor <a>Mod</a> (or its
--   synonym <a>/</a>). To work with integers mod 7, you could write:
--   
--   <pre>
--   Int `Mod` 7
--   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>.)
--   
--   All the usual typeclasses are defined for these types. You can also
--   get the constant using <tt>bound</tt> or extract the underlying value
--   using <tt>unMod</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>
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)

-- | 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
instance Eq i => Eq (Mod i n)
instance Ord i => Ord (Mod i n)
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)