module Acme.Grawlix where
import Data.List ((\\))
import Control.Applicative (Alternative, (<|>), (<**>))
import Data.Monoid ((<>))
import Control.Monad ((>=>), (<=<))
import Control.Applicative ( (<$>), (<*>), (<$), (<*), (*>)
, Applicative)
import Data.Monoid (Monoid)
type List = []
emptyList :: List a
emptyList = []
cons :: a -> List a -> List a
cons = (:)
append :: List a -> List a -> List a
append = (++)
index :: List a -> Int -> a
index = (!!)
difference :: Eq a => List a -> List a -> List a
difference = (\\)
apply :: (a -> b) -> a -> b
apply = ($)
dot :: (b -> c) -> (a -> b) -> a -> c
dot = (.)
fmap :: Functor f => (a -> b) -> f a -> f b
fmap = (<$>)
constMap :: Functor f => a -> f b -> f a
constMap = (<$)
ap :: Applicative f => f (a -> b) -> f a -> f b
ap = (<*>)
leftAp :: Applicative f => f a -> f b -> f a
leftAp = (<*)
rightAp :: Applicative f => f a -> f b -> f b
rightAp = (*>)
flipAp :: Applicative f => f a -> f (a -> b) -> f b
flipAp = (<**>)
orElse :: Alternative f => f a -> f a -> f a
orElse = (<|>)
mappend :: Monoid m => m -> m -> m
mappend = (<>)
bind :: Monad m => m a -> (a -> m b) -> m b
bind = (>>=)
andThen :: Monad m => m a -> m b -> m b
andThen = (>>)
flipBind :: Monad m => (a -> m b) -> m a -> m b
flipBind = (=<<)
kleisliCompose :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
kleisliCompose = (>=>)
flipKleisliCompose :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
flipKleisliCompose = (<=<)
type Unit = ()
unit :: Unit
unit = ()
type ZeroTuple = Unit
type TwoTuple a b = (a, b)
type ThreeTuple a b c = (a, b, c)
type FourTuple a b c d = (a, b, c, d)
type FiveTuple a b c d e = (a, b, c, d, e)
type SixTuple a b c d e f = (a, b, c, d, e, f)
type SevenTuple a b c d e f g = (a, b, c, d, e, f, g)
type EightTuple a b c d e f g h = (a, b, c, d, e, f, g, h)
type NineTuple a b c d e f g h i = (a, b, c, d, e, f, g, h, i)
type TenTuple a b c d e f g h i j= (a, b, c, d, e, f, g, h, i, j)