reenable tests

[fp.git] / src / Lambda.hs

diff --git a/src/Lambda.hs b/src/Lambda.hs
index f89cc7e..b3a25ce 100644 (file)
--- a/src/Lambda.hs
+++ b/src/Lambda.hs
@@ -1,4 +1,3 @@
-{-# OPTIONS_GHC -fno-warn-unused-do-bind #-}

 {-# LANGUAGE PatternSynonyms #-}
 
 -- |
 {-# LANGUAGE PatternSynonyms #-}
 
 -- |


@@ -15,99 +14,33 @@ module Lambda
   ( -- * Types
     VarName
   , Term(..)
   ( -- * Types
     VarName
   , Term(..)

-    -- * Parsing terms
-  , parseTerm
-  , tRead

     -- * Reduction
     -- * Reduction

+  , alphaNorm

   , reduce
   , reduce

+  , toNormalForm
+  , Strategy(..)

   ) where
   ) where

-  

 
 

-import Data.Text as T
-import Data.Attoparsec.Text
-import Control.Applicative

 import Control.Monad.State 
 
 import Control.Monad.State 
 

+import Lambda.Term
+

 -- $setup
 -- $setup

--- >>> import Test.QuickCheck

 -- >>> import Control.Applicative
 -- >>> import Control.Applicative

--- >>> let aTerm 0 = pure $ Var "x"
--- >>> let aTerm n = oneof [pure (Var "x"), liftA (Lambda "x") $ aTerm (n - 1), liftA2 App (aTerm (n `div` 2)) (aTerm (n `div` 2))] 
--- >>> instance Arbitrary Term where arbitrary = sized aTerm
-
-type VarName = String
-
--- | 
--- >>> print $ Lambda "x" (Var "x")
--- (λx.x)
-
-data Term = 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)
-
-
-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
+-- >>> 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
-  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
 
 isFreeIn :: VarName -> Term -> Bool
 isFreeIn x (Var v) = x == v


@@ -144,33 +77,75 @@ data Strategy = Eager | Lazy
 
 reduceStep :: (Monad m) => Term -> m Term
 reduceStep (RedEx x s t) = return $ substitute x t s
 
 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
-  f (App nt nu)
-traversPost f (Lambda x t) = f . Lambda x =<< traversPost f t
-traversPost f (Var x) = f (Var x)
-
-printT :: Term -> IO Term
-printT t = do
-  print t
-  return t
+reduceStep t = return t
+
+data Z = R Term Z | L Z Term | ZL VarName Z | E
+data D = Up | Down
+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, L c r, Up) = (r, R t c, Down)
+move (t, R l c, Up) = (App l t, 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
+
+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
+      nt <- f 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
+      nt <- f t
+      tr f $ unmove (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)
+
+-- |
+--
+-- >>> toNormalForm Eager 100 cI
+-- Just (λx.x)
+--
+-- >>> toNormalForm Eager 100 $ App cI cI
+-- Just (λx.x)
+--
+-- >>> toNormalForm Eager 100 $ (App (App cK cI) cY)
+-- Nothing
+--
+-- >>> toNormalForm Lazy 100 $ (App (App cK cI) cY)
+-- Just (λx.x)
+--
+-- prop> (\ t u -> t == u || t == Nothing || u == Nothing) (alphaNorm <$> toNormalForm Lazy 1000 x) (alphaNorm <$> toNormalForm Eager 1000 x)
+

 
 toNormalForm :: Strategy -> Int -> Term -> Maybe Term
 
 toNormalForm :: Strategy -> Int -> Term -> Maybe Term

-toNormalForm Eager n = flip evalStateT 0 . traversPost (short n >=> cnt >=> reduceStep)
+toNormalForm Eager n = flip evalStateT 0 . travPost (cnt >=> short n >=> reduceStep)
+toNormalForm Lazy  n = flip evalStateT 0 . travPre  (cnt >=> short n >=> reduceStep)

 
 cnt :: (Monad m) => Term -> StateT Int m Term
 
 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
   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
   n <- get

-  if n == max
+  if n > maxN

     then lift Nothing
     else return t
     then lift Nothing
     else return t