The `monomorphic` library
==========================

What is this?
-------------
This library provides the type-class and functions to convert polymorphic data-types to/from its monomorphic representation types.
It is convenient to provide a monomorphic interface for dependently-typed programs.

Usage
-----
Consider the following example:

```haskell
data Nat = Z | S Nat
data SNat (n :: Nat) where
  SZ :: SNat Z
  SS :: SNat n -> SNat (S n)

instance Monomorphicable SNat where
  type MonomorphicRep SNat = Int
  promote 0     = Monomorphic SZ
  promote n
    | n < 0     = error "negative number"
    | otherwise =
        case promote (n - 1) of
          Monomorphic sn -> Monomorphic (SS sn)
  demote (Monomorphic sn) = toInt sn

data Vector (a :: *) (n :: Nat) where
  VNil :: Vector a Z
  (:-) :: a -> Vector a n -> Vector a (S n)

instance Monomorphicable (Vector a) whre
  type MonomorphicRep (Vector a) = [a]
  demote  (Monomorphic n) = toList n
  promote [] = Monomorphic Nil
  promote (x:xs) =
    case promote xs of
      Monomorphic xs' -> Monomorphic $ x :- xs'
```

`Monomorphic k` is the wrapper type to eliminate the polymorphic part of the types.
The `Monomorphicable` type-class provides the functions to convert polymorphic value from/to its monomorphic representation, say `MonomorphicRep k` associated type.

In the example above, `SNat n` can be monomorphically represented by `Int`.
There are some convenient functions to manipulate monomorphic types and functions. For more detail, see API documentation.