fork download

-- *whistles*
{-# LANGUAGE MultiParamTypeClasses,
             FunctionalDependencies,
             FlexibleInstances,
             OverlappingInstances,
             UndecidableInstances,
             FlexibleContexts #-}
 
-- actual thingy
 
class PipeFirst b f | f -> b where
 (|>) :: f -> (b -> c) -> c
 
class PipeFirst' r b f | f -> b where
 pipeImpl :: r -> f -> (b -> c) -> c
 
instance (IsFunction b r, PipeFirst' r b f) => PipeFirst b f where
 (|>) = pipeImpl (undefined :: r)
 
instance PipeFirst' HTrue b (a -> b) where
 pipeImpl _ f g x = (f x) |> g
 
instance PipeFirst' HFalse b (a -> b) where
 pipeImpl _ = flip (.)
 
main = print $ (f |> g) 1 2 3
 where f x y z = x + y + z
       g = (*2)
 
-- start black magic
 
class IsFunction a b | a -> b
instance TypeCast f HTrue => IsFunction (a -> b) f
instance TypeCast f HFalse => IsFunction a f
 
class TypeCast a b | a -> b, b -> a where
 typeCast :: a -> b
class TypeCast' t a b | t a -> b, t b -> a where
 typeCast' :: t->a->b
class TypeCast'' t a b | t a -> b, t b -> a where
 typeCast'' :: t->a->b
instance TypeCast' () a b => TypeCast a b where
 typeCast x = typeCast' () x
instance TypeCast'' t a b => TypeCast' t a b where
 typeCast' = typeCast''
instance TypeCast'' () a a where
 typeCast'' _ x  = x
 
data HTrue
data HFalse
 
-- end of black magic

[1 of 1] Compiling Main             ( prog.hs, prog.o )

prog.hs:21:2:
    Couldn't match expected type `c' with actual type `a -> c'
      `c' is a rigid type variable bound by
          the type signature for
            pipeImpl :: HTrue -> (a -> b) -> (b -> c) -> c
          at prog.hs:21:2
    The equation(s) for `pipeImpl' have four arguments,
    but its type `HTrue -> (a -> b) -> (b -> c) -> c' has only three
    In the instance declaration for `PipeFirst' HTrue b (a -> b)'

prog.hs:24:20:
    Couldn't match type `c' with `a -> c'
      `c' is a rigid type variable bound by
          the type signature for
            pipeImpl :: HFalse -> (a -> b) -> (b -> c) -> c
          at prog.hs:24:2
    Expected type: (b -> c) -> (a -> b) -> c
      Actual type: (b -> c) -> (a -> b) -> a -> c
    In the first argument of `flip', namely `(.)'
    In the expression: flip (.)
    In an equation for `pipeImpl': pipeImpl _ = flip (.)

Standard output is empty