Debug.Reflect

Documentation

data a ~> b infixr 5

analog of (->)

Constructors

Fn String (a -> b)

name and function itself

Instances

Functor ((~>) a)

Methods

fmap :: (a -> b) -> (a ~> a) -> a ~> b

(<$) :: a -> (a ~> b) -> a ~> a

Show ((~>) a b)

Methods

showsPrec :: Int -> (a ~> b) -> ShowS

show :: (a ~> b) -> String

showList :: [a ~> b] -> ShowS

fromFn :: (a ~> b) -> a -> b

gets function

parens :: String -> String

adds brackets

isInfixFn :: String -> Bool

checks whether function is infix

showFn :: String -> String -> String

shows function with its argument

makeFn2 :: Show a => String -> (a -> b -> c) -> a ~> (b ~> c)

translates function (a -> b -> c) into (a ~> b ~> c)

makeBinOp :: Show a => String -> (a -> b -> c) -> a ~> (b ~> c)

makes binary operation

data Ap b

reflected expression

Constructors

Val b

Show a => (Ap (a ~> b)) :$ (Ap a)

Instances

Show a => Show (Ap a)

Methods

showsPrec :: Int -> Ap a -> ShowS

show :: Ap a -> String

showList :: [Ap a] -> ShowS

isVal :: Ap a -> Bool

checks whether expression is Val

balanceParens :: String -> String

balances brackets

parensFr :: String -> String

balances brackets

showOp :: String -> String -> String -> String

shows operation application

showF :: String -> String -> String

shows operation application

fmap' :: Functor f => (a ~> b) ~> (f a ~> f b)

analog of fmap using (~>)

pure' :: Applicative f => a ~> f a

analog of pure using (~>)

ap' :: (Show (f (a ~> b)), Applicative f) => f (a ~> b) ~> (f a ~> f b)

analog of <*> using (~>)

(-$-) :: (Show (f a), Functor f) => (a ~> b) -> f a -> Ap (f b) infix 6

analog of <$>

(-*-) :: (Show (f (a ~> b)), Show (f a), Applicative f) => Ap (f (a ~> b)) -> f a -> Ap (f b) infixl 5

analog of <*>

pure'' :: (Show a, Applicative f) => a -> Ap (f a)

analog of pure

fmap'' :: (Show (f a), Functor f) => (a ~> b) -> f a -> Ap (f b)

analog of fmap

reduce'' :: Ap a -> Ap a

reduces an expression

reduce' :: Show a => Ap a -> Ap a

reduces (evaluates) an expression once

reductions :: Show a => Ap a -> [Ap a]

gets all reduction steps when evaluating an expression