https://gist.github.com/merijn/dc00bc7cebd6df012c5e without type families

HList.hs

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE EmptyCase #-}
{-# LANGUAGE LambdaCase #-}
module HList where

import Prelude hiding (head, tail, zip)
import GHC.Exts (Constraint)

data HList :: [*] -> * where
    Nil :: HList '[]
    Cons :: a -> HList l -> HList (a ': l)

instance Show (HList '[]) where
    show Nil = "Nil"

instance (Show a, Show (HList l)) => Show (HList (a ': l)) where
    show (Cons x xs) = "Cons " ++ show x ++ " (" ++ show xs ++ ")"

head :: HList (a ': l) -> a
head (Cons h _) = h

tail :: HList (a ': l) -> HList l
tail (Cons _ t) = t

class Fun (l :: [*]) (r :: *) t | l r -> t where
  apply :: t -> HList l -> r

instance Fun '[] r r where
  apply x Nil = x

instance Fun as r t => Fun (a ': as) r (a -> t) where
  apply f (Cons h t) = apply (f h) t

class Zip (l :: [*]) (k :: [*]) (t :: [*]) | l k -> t where
  zip :: HList l -> HList k -> HList t

instance Zip '[] '[] '[] where
  zip Nil Nil = Nil

instance Zip as bs t => Zip (a ': as) (b ': bs) ((a, b) ': t) where
  zip (Cons a as) (Cons b bs) = Cons (a, b) (zip as bs)

instance ("Error!" ~ "List length are unequal!", Zip as '[] t) => Zip (a ': as) '[] t where
  zip = \case

instance ("Error!" ~ "List length are unequal!", Zip '[] bs t) => Zip '[] (b ': bs) t where
  zip = \case

someList :: HList [Bool, Char, Int]
someList = Cons True (Cons 'c' (Cons 1 Nil))

anotherList :: HList [Maybe (), [a], Double]
anotherList = Cons (Just ()) (Cons [] (Cons 2.0 Nil))

zippedList :: HList [(Bool, Maybe ()), (Char, [a]), (Int, Double)]
zippedList = zip someList anotherList

main :: IO ()
main = print $ apply (,,) someList