This example illustrates some choices that come up when using existential types in combination with singleton types. The choices are illustrated with an example, which defines a typed interface for working with array. (Constructors with existential types are written in GADT notation.)

{-# LANGUAGE DataKinds, GADTs, KindSignatures #-}

import Control.Monad(forM_)
import GHC.TypeLits
import Foreign(Ptr, pokeElemOff, Storable, mallocArray)

Arrays with Statically Known Sizes

We start by defining a type for pointers to a sequence of adjacent elements in memory. The number of elements is statically known at compile time, which is why we add it to the type of the pointer:

newtype ArrPtr (n :: Nat) a = ArrPtr (Ptr a)

Now we can define a function which sets all elements in the array to a specific value:

memset_c :: Storable a => ArrPtr n a -> a -> Sing n -> IO ()
memset_c (ArrPtr p) a n =
  forM_ [1 .. fromSing n - 1 ] $ \i ->
    pokeElemOff p (fromIntegral i) a

Because the size of the array is statically known, we may define an overloaded function, that will use the correct size automatically, based on the type:

memset :: (Storable a, SingI n) => ArrPtr n a -> a -> IO ()
memset p a = withSing (memset_c p a)

Here is an example of how we might use these types:

clearPage :: ArrPtr 4096 Word8 -> IO ()
clearPage p = memset p 0

Note that because of the way we wrote the code, there is no danger of accidentally passing the incorrect size for an array.

Hiding the Array Size with an Existential

We may also define a type for array whose sizes are not known statically. Such arrays have two components: a pointer to data, and a number storing how many elements there are in the array.

There are two different ways to define such arrays, and the difference between these two choices is the central point of this example:

data ArrayS :: * -> * where
  ArrS :: Sing n -> ArrPtr n a -> ArrayS a

data ArrayD :: * -> * where
  ArrD :: SingI n => ArrPtr n a -> ArrayD a

The difference between the two is how we store the size of the array: in ArrayS we are using an explicit singleton values, while in ArrayD the size is stored in an implicit dictionary field.

Both representations have the size of the array, so we can use them with the functions that we already defined for arrays of statically known sizes:

memsetS :: Storable a => ArrayS a -> a -> IO ()
memsetS (ArrS s p) a = memset_c p a s

memsetD :: Storable a => ArrayD a -> a -> IO ()
memsetD (ArrD p) a = memset p a

The interesting difference between the two is that ArrayD is (in some sense) more static. In particular, we can always convert an ArrayD into an ArrayS, but we cannot define the inverse function:

fromArrD :: ArrayD a -> ArrayS a
fromArrD (ArrD p) = ArrS sing p

Creating Dynamically Sized Arrays

-- Unsafe, in general.
uncheckedSing :: Integral a => a -> Sing (n :: Nat)
uncheckedSing a = Sing (toInteger a)

mallocS :: Storable a => Int -> IO (ArrayS a)
mallocS n = do p <- mallocArray n
               return (ArrS (uncheckedSing n) (ArrPtr p))

example = do arr <- mallocS 10
             memsetS arr (0 :: Int)
             return arr