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


-- | /Arbitrary/ type-level digits
--   
--   Arbitrary ype-level digits, for when the radix itself doesn't actually
--   matter. It's currently base-128, because that seemed to best expedite
--   the compilation of the modules using this package. Please let me know
--   what you find if you experiment with this. <a>Type.Digits.radix</a> is
--   the (arbitrary) radix. <a>Type.Digits.digit</a> computes the
--   <a>NameG</a> of a digit from its value (assuming its less than the
--   radix). Combinators are provided to compute a full type-level numeral
--   from values (potentially) larger than the radix.
@package type-digits
@version 0.1


-- | The parameters for the <tt>type-digits</tt> package.
module Type.Digits.Aux

-- | The names of the digits.
digitNames :: [String]

-- | The number of digits.
radix :: Num i => i


-- | Type-level numerals built from type-level digits of an arbitrary
--   radix.
module Type.Digits

-- | Convert a number to the name of the corresponding digit -- error if
--   the argument is out of range.
digit :: Num a => a -> Name

-- | Give a list of digit names, and a base type, yields a type.
toType :: [Name] -> Type -> Type

-- | <tt>toType_ = ($ TupleT 0) . toType</tt>.
toType_ :: [Name] -> Type

-- | <pre>
--   toDigits f = toType . f
--   </pre>
toDigits :: (a -> [Name]) -> a -> Type -> Type

-- | <tt>toDigits_ = (($ TupleT 0) .) . toDigits</tt>.
toDigits_ :: (a -> [Name]) -> a -> Type

-- | Converts an <tt>Integral</tt> to a type-level numeral using as many
--   digits as it takes that particular number.
flexible :: Integral a => a -> [Name]

-- | Converts a <tt>Bounded</tt> <tt>Integral</tt> to a type-level numeral
--   using exactly the number of digits it takes to represent each value of
--   that type uniquely.
fixed :: (Bounded a, Integral a) => a -> [Name]

-- | <pre>
--   flexible' = flexible . fromEnum
--   </pre>
flexible' :: Enum a => a -> [Name]

-- | <pre>
--   fixed' = fixed . fromEnum
--   </pre>
fixed' :: Enum a => a -> [Name]

-- | Pads its second argument so that the resulting length is its first
--   argument; fails if the second argument is already larger.
exactly :: Int -> [Name] -> [Name]