{-# LANGUAGE RankNTypes, ImpredicativeTypes, ScopedTypeVariables, ExistentialQuantification #-}
 
data Numeric = forall a. Num a => Numeric a

apply :: [forall a. Num a => a -> Integer] -> [Numeric] -> [Integer]
apply = zipWith (\f (Numeric n) -> f n)

composeNum :: [forall b. Num b => b -> d] -> [forall a. Num a => a -> a] -> [forall c. Num c => c -> d]
composeNum = zipWith (\f (g :: forall a. Num a => a -> a) -> f.g)

composeEnum :: [forall b. Enum b => b -> d] -> [forall a. Enum a => a -> a] -> [forall c. Enum c => c -> d]
composeEnum = zipWith (\f (g :: forall a. Enum a => a -> a) -> f.g)

N>{-# LANGUAGE RankNTypes, ImpredicativeTypes, ScopedTypeVariables, ExistentialQuantification #-}
 
N>data Numeric = forall a. Num a => Numeric a

N>apply :: [forall a. Num a => a -> Integer] -> [Numeric] -> [Integer]
N>apply = zipWith (\f (Numeric n) -> f n)

N>composeNum :: [forall b. Num b => b -> d] -> [forall a. Num a => a -> a] -> [forall c. Num c => c -> d]
N>composeNum = zipWith (\f (g :: forall a. Num a => a -> a) -> f.g)

N>composeEnum :: [forall b. Enum b => b -> d] -> [forall a. Enum a => a -> a] -> [forall c. Enum c => c -> d]
N>composeEnum = zipWith (\f (g :: forall a. Enum a => a -> a) -> f.g)
N>

-- {-# LANGUAGE , ExistentialQuantification #-}
{-# LANGUAGE GADTs, RankNTypes, ScopedTypeVariables, ImpredicativeTypes #-}
 
data Numeric where Numeric :: Num a => a -> Numeric

apply :: [forall a. Num a => a -> Integer] -> [Numeric] -> [Integer]
apply = zipWith (\f (Numeric n) -> f n)

composeNum :: [forall b. Num b => b -> d] -> [forall a. Num a => a -> a] -> [forall c. Num c => c -> d]
composeNum = zipWith (\f (g) -> f.g)

composeEnum :: [forall b. Enum b => b -> d] -> [forall a. Enum a => a -> a] -> [forall c. Enum c => c -> d]
composeEnum = zipWith (\f (g) -> f.g)

{-# LANGUAGE RankNTypes, ImpredicativeTypes, ScopedTypeVariables, GADTs #-}
 
data NumInst a where
     MkNumInst :: Num a => NumInst a

composeList :: [forall b. ctx b -> b -> d] -> [forall a. ctx a -> a -> a] -> [forall c. ctx c -> c -> d]
composeList = zipWith (\f g ctx -> f ctx . g ctx)

test = (incAndShow (41 :: Int), incAndShow (41 :: Double))
    where 
      incAndShow :: Num a => a -> String
      incAndShow = f MkNumInst
          where f = head (composeList [showNum] [incNum])

      showNum :: NumInst a -> a -> String
      showNum MkNumInst = show

      incNum :: NumInst a -> a -> a
      incNum MkNumInst = (+1)

data NumD a = NumD {numD :: forall p. (forall x. Num x => p x) -> p a}
defaultNum :: Num a => NumD a
defaultNum = NumD id

data EnumD a = EnumD {enumD :: forall p. (forall x. Enum x => p x) -> p a}
defaultEnum :: Enum a => EnumD a
defaultEnum = EnumD id

data Some q = forall a. Some (q a) a
type Numeric' = Some NumD
apply' :: [forall a. q a -> a -> Integer] -> [Some q] -> [Integer]
apply' = zipWith (\f (Some qa a) -> f qa a)
composeQ :: [forall b. q b -> b -> d] -> [forall a. q a -> a -> a] -> [forall c. q c -> c -> d]
composeQ = zipWith (\f g qc -> f qc . g qc)

struct Monster
{
  virtual void act(Context) = 0;
};

vector<Monster*> monsters;
Context context;

int main()
{
  for_all(monsters, &Monster::act, context);
}

struct Goblin : Monster { ... }
struct Boss : Monster { ... }
// дизайнеры постоянно выдумывают новых монстров

A>struct Monster
A>{
A>  virtual void act(Context) = 0;
A>};

A>vector<Monster*> monsters;
A>Context context;

A>int main()
A>{
A>  for_all(monsters, &Monster::act, context);
A>}

A>struct Goblin : Monster { ... }
A>struct Boss : Monster { ... }
A>// дизайнеры постоянно выдумывают новых монстров
A>

class Monster a where
    act :: Context -> a -> IO a

data Boss = ...
data Goblin = ...

instance Monster Boss where
    act cxt (Boss ...) = ...
instance Monster Goblin where
    act cxt (Goblin ...) = ...

monsters = [...]
main = mapM (act cxt) monsters

T>>class Monster a where
T>>    act :: Context -> a -> IO a

T>>data Boss = ...
T>>data Goblin = ...

T>>instance Monster Boss where
T>>    act cxt (Boss ...) = ...
T>>instance Monster Goblin where
T>>    act cxt (Goblin ...) = ...

T>>monsters = [...]
T>>main = mapM (act cxt) monsters
T>>

data GMonster where
    GMonster :: Monster a => a -> GMonster

instance Monster GMonster where
    act cxt (GMonster a) = liftM GMonster $ act cxt a

monsters :: [GMonster]

A>struct Monster
A>{
A>  virtual void act(Context) = 0;
A>};

A>vector<Monster*> monsters;
A>Context context;

A>int main()
A>{
A>  for_all(monsters, &Monster::act, context);
A>}

A>struct Goblin : Monster { ... }
A>struct Boss : Monster { ... }
A>// дизайнеры постоянно выдумывают новых монстров
A>

newtype Monster = Monster {act :: Context -> IO ()}
monsters :: [Monster]
data GoblinParameters = ...whatever...
goblin :: GoblinParameters -> Monster
goblin (...) = Monster $ \context -> ...