Hello, I am working on a Vector class, heavily based on the paper "Faking It: Simulating Dependent Types in Haskell" by Connor McBride. Here is a stripped down version of my code: --- {-# LANGUAGE RankNTypes #-} import Control.Applicative import Data.Functor infixr 5 :. data Cons u t = (:.) t (u t) deriving (Show) data Nil t = Nil deriving (Show) class (Applicative v, Functor v) => Vector v where wrap :: (forall u. Vector u => s -> f (u t) -> f (Cons u t)) -> f (Nil t) -> v s -> f (v t) instance (Vector u) => Vector (Cons u) where wrap f n (x:.xs) = f x (wrap f n xs) instance Vector Nil where wrap _ n Nil = n instance (Applicative u) => Applicative (Cons u) where pure x = x:.(pure x) (f:.fs) <*> (x:.xs) = (f x):.(fs <*> xs) instance Applicative Nil where pure _ = Nil _ <*> _ = Nil instance (Functor u) => Functor (Cons u) where fmap f (x:.xs) = (f x):.(fmap f xs) instance Functor Nil where fmap _ Nil = Nil transpose :: (Vector w, Vector u) => w (u t) -> u (w t) transpose v = wrap (\x xs -> (:.) <$> x <*> xs) (pure Nil) v --- I am having trouble understanding the type signature of 'wrap'. This is how I interpret it: (function that takes an 's' and container of 'u t' and returns a container of 'Cons u t') -> (container of 'Nil') -> (a vector of 's') -> (a container with the same type as the container of Nil, but containing v t instead) What doesn't make sense to me is how the signature seems to imply that the structure of the container in the return type is the same as the structure of the container holding the Nils, but in 'transpose' the container holding Nil seems to be infinite. Can someone help me to understand what is going on here? Thanks, Ben