-{-# OPTIONS_GHC -fno-warn-unused-do-bind #-}
{-# LANGUAGE PatternSynonyms #-}
-- |
( -- * Types
VarName
, Term(..)
- -- * Parsing terms
- , parseTerm
- , tRead
+ , pattern RedEx
-- * Reduction
+ , alphaNorm
, reduce
+ , toNormalForm
+ , Strategy(..)
) where
-
-import Data.Text as T
-import Data.Attoparsec.Text
-import Control.Applicative
import Control.Monad.State
--- $setup
--- >>> import Test.QuickCheck
--- >>> import Control.Applicative
--- >>> let aTerm 0 = liftA (Var . ("x" ++) . show) (arbitrary :: Gen Int)
--- >>> let aTerm n = oneof [aTerm 0, liftA (Lambda "x") $ aTerm (n - 1), liftA2 App (aTerm (n `div` 2)) (aTerm (n `div` 2))]
--- >>> instance Arbitrary Term where arbitrary = sized aTerm
-
-cY :: Term
-cY = tRead "λf.(λx.f (x x)) (λx.f (x x))"
-
-cI :: Term
-cI = tRead "λx.x"
-
-cK :: Term
-cK = tRead "λx y.x"
-
-type VarName = String
-
--- |
--- >>> print $ Lambda "x" (Var "x")
--- (λx.x)
-
-data Term = EmptyT | Var VarName | Lambda VarName Term | App Term Term deriving (Eq)
-
-pattern RedEx x t s = App (Lambda x t) s
-pattern AppApp a b c = App a (App b c)
-pattern EmLambda x y t = Lambda x (Lambda y t)
+import Lambda.Term
+import Debug.Trace
+import Lambda.Parser.Fancy ()
-instance Show Term where
- show (Var x) = x
- show (EmLambda x y t) = show (Lambda (x ++ " " ++ y) t)
- show (Lambda x t) = "(λ" ++ x ++ "." ++ show t ++ ")"
- show (AppApp a b c) = show a ++ " " ++ braced (App b c)
- show (App t r) = show t ++ " " ++ show r
+-- $setup
+-- >>> import Control.Applicative
+-- >>> import Lambda.Parser.Fancy
+-- >>> import Test.Term
+-- >>> import Test.QuickCheck
-braced :: Term -> String
-braced t = "(" ++ show t ++ ")"
+varnames :: [VarName]
+varnames = map (:[]) ['a'..'z'] ++ [c : s | s <- varnames, c <- ['a'..'z']]
--- |
--- prop> t == tRead (show (t :: Term))
-
-tRead :: String -> Term
-tRead s = case parseOnly (parseTerm <* endOfInput) (T.pack s) of
- (Right t) -> t
- (Left e) -> error e
-
-parseVar :: Parser Term
-parseVar = do
- x <- many1 (letter <|> digit)
- return $! Var x
-
-parseLambda :: Parser Term
-parseLambda = do
- char '\\' <|> char 'λ'
- vars <- sepBy1 parseVar (char ' ')
- char '.'
- t <- parseTerm
- return $! createLambda vars t
-
-createLambda :: [Term] -> Term -> Term
-createLambda (Var x : vs) t = Lambda x $ createLambda vs t
-createLambda [] t = t
-createLambda _ _ = error "createLambda failed"
-
-parseApp :: Parser Term
-parseApp = do
- aps <- sepBy1 (parseBraces <|> parseLambda <|> parseVar) (char ' ')
- return $! createApp aps
-
-createApp :: [Term] -> Term
-createApp [t] = t
-createApp (t:ts:tss) = createApp (App t ts : tss)
-createApp [] = error "empty createApp"
-
-parseBraces :: Parser Term
-parseBraces = do
- char '('
- t <- parseTerm
- char ')'
- return t
-
-parseTerm :: Parser Term
-parseTerm = parseApp <|>
- parseBraces <|>
- parseLambda <|>
- parseVar
-
--------------------------------------------------
+alphaNorm :: Term -> Term
+alphaNorm = alpha varnames
+ where
+ alpha (v:vs) (Lambda x r) = Lambda v . alpha vs $ substitute x (Var v) r
+ alpha vs (App u v) = App (alpha vs u) (alpha vs v)
+ alpha _ (Var x) = Var x
+ alpha [] _ = undefined
isFreeIn :: VarName -> Term -> Bool
isFreeIn x (Var v) = x == v
data Strategy = Eager | Lazy
-reduceStep :: (Monad m) => Term -> m Term
-reduceStep (RedEx x s t) = return $ substitute x t s
-reduceStep t = return $ t
-
-traversPost :: (Monad m) => (Term -> m Term) -> Term -> m Term
-traversPost f (App t u) = do
- nt <- traversPost f t
- nu <- traversPost f u
- case App nt nu of
- l@(RedEx _ _ _) -> traversPost f =<< f l
- r -> return r
-traversPost f (Lambda x t) = return . Lambda x =<< traversPost f t
-traversPost f (Var x) = return $ (Var x)
+reduceStep :: Term -> Term
+reduceStep (RedEx x s t) = substitute x t s
+reduceStep t = t
data Z = R Term Z | L Z Term | ZL VarName Z | E
data D = Up | Down
-data Zip = Zip Z Term
+type TermZipper = (Term, Z, D)
+move :: TermZipper -> TermZipper
move (App l r, c, Down) = (l, L c r, Down)
move (Lambda x t, c, Down) = (t, ZL x c, Down)
move (Var x, c, Down) = (Var x, c, Up)
move (t, ZL x c, Up) = (Lambda x t, c, Up)
move (t, E, Up) = (t, E, Up)
+unmove :: TermZipper -> TermZipper
unmove (t, L c r, Down) = (App t r, c, Down)
unmove x = x
-getF (t, _, _) = t
+-- getTerm :: TermZipper -> Term
travPost :: (Monad m) => (Term -> m Term) -> Term -> m Term
travPost fnc term = tr fnc (term, E, Down)
where
- tr f (t@(RedEx _ _ _), c, Up) = do
+ tr f (t@RedEx{}, c, Up) = do
nt <- f t
- tr f $ (nt, c, Down)
- tr f (t, E, Up) = return t
+ tr f (nt, c, Down)
+ tr _ (t, E, Up) = return t
tr f (t, c, Up) = tr f $ move (t, c, Up)
tr f (t, c, Down) = tr f $ move (t, c, Down)
travPre :: (Monad m) => (Term -> m Term) -> Term -> m Term
travPre fnc term = tr fnc (term, E, Down)
where
- tr f (t@(RedEx _ _ _), c, Down) = do
+ tr f (t@RedEx{}, c, Down) = do
nt <- f t
tr f $ unmove (nt, c, Down)
- tr f (t, E, Up) = return t
+ tr _ (t, E, Up) = return t
tr f (t, c, Up) = tr f $ move (t, c, Up)
tr f (t, c, Down) = tr f $ move (t, c, Down)
-printT :: Term -> IO Term
-printT t = do
- print t
- return t
-
-- |
--
-- >>> toNormalForm Eager 100 cI
-- >>> toNormalForm Eager 100 $ App cI cI
-- Just (λx.x)
--
--- >>> toNormalForm Eager 1000 $ (App (App cK cI) cY)
+-- >>> toNormalForm Eager 100 $ (App (App cK cI) cY)
-- Nothing
--
--- >>> toNormalForm Lazy 1000 $ (App (App cK cI) cY)
+-- >>> toNormalForm Lazy 100 $ (App (App cK cI) cY)
-- Just (λx.x)
--
--- prop> (\ t u -> t == u || t == Nothing || u == Nothing) (toNormalForm Lazy 1000 x) (toNormalForm Eager 1000 x)
+-- prop> within 10000000 $ (\ t u -> t == u || t == Nothing || u == Nothing) (alphaNorm <$> toNormalForm Lazy 100 x) (alphaNorm <$> toNormalForm Eager 100 x)
+
+-- inf = tRead "(\\d.a ((\\d c.c d c) (\\x y z.x z (y z)) (\\f.(\\x.f (x x)) (\\x.f (x x))) e))"
+toNormalFormDebug :: Strategy -> Int -> Term -> Maybe Term
+toNormalFormDebug Eager n = flip evalStateT 0 . travPost (prnt >=> cnt >=> short n >=> return . reduceStep)
+toNormalFormDebug Lazy n = flip evalStateT 0 . travPre (prnt >=> cnt >=> short n >=> return . reduceStep)
+
toNormalForm :: Strategy -> Int -> Term -> Maybe Term
-toNormalForm Eager n = flip evalStateT 0 . travPost (cnt >=> short n >=> reduceStep)
-toNormalForm Lazy n = flip evalStateT 0 . travPre (cnt >=> short n >=> reduceStep)
+toNormalForm Eager n = flip evalStateT 0 . travPost (cnt >=> short n >=> return . reduceStep)
+toNormalForm Lazy n = flip evalStateT 0 . travPre (cnt >=> short n >=> return . reduceStep)
+
+prnt :: (Monad m) => Term -> StateT Int m Term
+prnt t = traceShow t $ return t
cnt :: (Monad m) => Term -> StateT Int m Term
-cnt t@(RedEx _ _ _) = do
+cnt t@RedEx{} = do
modify (+ 1)
return t
cnt t = return t
short :: Int -> Term -> StateT Int Maybe Term
-short max t = do
+short maxN t = do
n <- get
- if n > max
+ if n > maxN
then lift Nothing
else return t
projekty / fp.git / blobdiff