{-# LANGUAGE DataKinds, KindSignatures, TypeFamilies, GADTs #-}
 
import Control.Applicative
 
-- | Type-level naturals
data Nat = Z | S Nat
 
-- | Type family for n-ary functions
type family   Fn (n :: Nat) a b
type instance Fn Z     a b = b
type instance Fn (S n) a b = a -> Fn n a b
 
-- | Lists exposing their length in their type
data List a (n :: Nat) where
  Nil :: List a Z
  Cons :: a -> List a n -> List a (S n)
 
-- | General <*> applied to a list of arguments of the right length
class Apply (n :: Nat) where
   foldF :: Applicative f => f (Fn n a b) -> List (f a) n -> f b
 
instance Apply Z where
   foldF f0 Nil = f0
 
instance Apply n => Apply (S n) where
   foldF fn (Cons x xs) = foldF (fn <*> x) xs
 
-- test :: [(Integer,Integer,Integer)]
test :: [(Integer,Integer,Int)]
test = foldF (pure (,,)) (Cons [10,11] (Cons [20,21] (Cons [30,31] Nil)))
-- Result: [(10,20,30),(10,20,31),(10,21,30),(10,21,31)
--         ,(11,20,30),(11,20,31),(11,21,30),(11,21,31)]
{-
prog.hs:30:15:
    Couldn't match type `Integer' with `Int'
    Expected type: [Fn
                      ('S ('S ('S 'Z))) Integer (Integer, Integer, Int)]
      Actual type: [Integer
                    -> Integer -> Integer -> (Integer, Integer, Integer)]
    In the return type of a call of `pure'
    In the first argument of `foldF', namely `(pure (,,))'
    In the expression:
      foldF
        (pure (,,)) (Cons [10, 11] (Cons [20, 21] (Cons [30, 31] Nil)))
-}
 
main = print test
 
main2 = print $ zipWith3 (,,) [10,11] ([20,21]::[Integer]) ([30,31]::[Int])

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