Question

I have this data type, which should represent a table:

data R = R [Bool]  deriving Eq -- Row
data T = T [R]     deriving Eq -- Table

The problem is that it allows to have table of rows with different length, eg:

tab =T [R [True, False, True, True],
        R [False, False, True, False],
        R [False, False, False, True],
        R [False, False]]

Is it possible to modify the data definition of T to impose that all the R elements have the same length?

Answer 1

You can do it with DataKinds. This may be overcomplicated, though:

{-# LANGUAGE DataKinds, KindSignatures, GADTs #-}
-- requires 7.4.1, I think

data Nat = S Nat | Z

infixr 0 :.
data R (n :: Nat) where
  Nil :: R Z                     -- like []
  (:.) :: Bool -> R n -> R (S n) -- and (:)

data T (n :: Nat) = T [R n]

-- OK
test1 = T [(True :. True :. Nil), (True :. False :. Nil)]

-- will fail
test2 = T [(True :. True :. Nil), (False :. Nil)]

I’d rather recommend @MathematicalOrchids alternative approach using smart constructors.

---

EDIT: What DataKinds do.

The DataKinds extension lets the compiler automatically create a new kind other than * for each data type one writes, and new types living in this kind from the constructors.

So Nat, besides being a simple ADT, also gives rise to a kind Nat , and type constructors Z :: Nat and S :: Nat -> Nat. This S is comparable to Maybe :: * -> * — it just doesn’t use the kind of all types, but your new kind Nat, inhabited only by the representations of the natural numbers.

The point is, that now you also can define type constructors of mixed kinds. The classic example for this is Vec:

data Vec (n :: Nat) (a :: *) where {-...-}

which has kind Vec :: Nat -> * -> *. Similarly, T has kind T :: Nat -> *. This let’s you use it with a type-encoded constant lenght, and leads to a type error if one two rows of different lenght are put together.

Although this looks extremely powerful, it is in fact restricted. To get the everything out of such representations, dependently typed languages should like Agda should be used.