Question

I would like to do this:

data Foo n = Foo $(tuple n Integer)

and thus allow

x :: Foo 3
x = Foo (1, 2, 3)

y :: Foo 5
y = Foo (5, 4, 3, 2, 1)

Currently I have simply

data Foo = Foo [Integer]

which can be made to work, but throws away a lot of nice compile-time checking. I’ll be making a few different Foo data objects, and each will have a fixed number of foos throughout its lifespan, and it feels silly to not be able to check that in the type system.

Is this possible in haskell?

Answer 1

How about

data IntAnd b = Int :. b
infixr 5 :.

So that way you can do

data Foo n = Foo n

x :: Foo (IntAnd (IntAnd Int))
x = Foo (3 :. 4 :. 5)

y :: Foo (IntAnd (IntAnd (IntAnd (IntAnd Int))))
y = Foo (5 :. 4 :. 3 :. 2 :. 1)

Or, if you want something a bit closer to your original syntax, try TypeFamilies:

data One 
data Succ a
type Two = Succ One 
type Three = Succ Two 
type Four = Succ Three
type Five = Succ Four

class NTuple a where
  type IntTuple a

instance NTuple One where
  type IntTuple One = Int 

instance (NTuple a) => NTuple (Succ a) where
  type IntTuple (Succ a) = IntAnd (IntTuple a)

x :: Foo (IntTuple Three)
x = Foo (3 :. 4 :. 5)

y :: Foo (IntTuple Five)
y = Foo (5 :. 4 :. 3 :. 2 :. 1)

Or with even more magic (TypeOperators, MultiParamTypeClasses, and FlexibleInstance, oh my!):

data a :. b = a :. b
infixr 5 :.

class NTuple a b where
  type HomoTuple a b

instance NTuple One b where
  type HomoTuple One b = b

instance (NTuple a b) => NTuple (Succ a) b where
  type HomoTuple (Succ a) b = b :. HomoTuple a b

x :: Foo (HomoTuple Three Int)
x = Foo ( 3 :. 4 :. 5 )

y :: Foo (HomoTuple Five Int)
y = Foo ( 1 :. 2 :. 3 :. 4 :. 5 )