--------------------------------------------------------------------- -- -- Module : Uniform.Pointless -- collecting some of the operations for a -- pointless (pairs based) programming style -- demonstrated in the book by -- Bird \& deMoore \"The Algebra of Programming\" -- which is available from hackage -- https://hackage.haskell.org/package/aop-prelude-0.4.1.1 ---------------------------------------------------------------------- module Uniform.Pointless (module Uniform.Pointless -- , module AOPPrelude ) where -- import AOPPrelude (outl, outr, swap, assocl, assocr, dupl -- , pair, cross, cond ) -- code copied from aop-prelude (partial) -- const :: a -> b -> a -- const k a = k -- id :: a -> a -- id a = a -- id and const are imported from regular prelude outl :: (a, b) -> a outl (a, _) = a outr :: (a, b) -> b outr (_, b) = b swap :: (a, b) -> (b, a) swap (a, b) = (b, a) assocl :: (a, (b, c)) -> ((a, b), c) assocl (a, (b, c)) = ((a, b), c) assocr :: ((a, b), c) -> (a, (b, c)) assocr ((a, b), c) = (a, (b, c)) dupl :: (a, (b, c)) -> ((a, b), (a, c)) dupl (a, (b, c)) = ((a, b), (a, c)) dupr :: ((a, b), c) -> ((a, c), (b, c)) dupr ((a, b), c) = ((a, c), (b, c)) pair :: (a -> b, a -> c) -> a -> (b, c) pair (f, g) a = (f a, g a) cross :: (a -> c, b -> d) -> (a, b) -> (c, d) cross (f, g) (a, b) = (f a, g b) cond :: (a -> Bool) -> (a -> b, a -> b) -> a -> b cond p (f, g) a = if p a then f a else g a curry :: ((a, b) -> c) -> a -> b -> c curry f a b = f (a, b) uncurry :: (a -> b -> c) -> (a, b) -> c uncurry f (a, b) = f a b -- pair :: (t -> b) -> (t, t) -> (b, b) -- my old different definitions (with prime): pair' :: (a->b) -> (a,a) -> (b,b) pair' f (a, b) = (f a, f b) -- ^ replace wth both swapPair :: (b, a) -> (a, b) -- | replace with swap swapPair (a, b) = (b, a) dup :: b -> (b, b) -- make a pair from a value dup a = (a,a)