more work on HM interpreter

[fp.git] / src / Lambda.hs

diff --git a/src/Lambda.hs b/src/Lambda.hs
index 5165bb8..428ac99 100644 (file)
--- a/src/Lambda.hs
+++ b/src/Lambda.hs
@@ -1,51 +1,50 @@
-{-# OPTIONS_GHC -fno-warn-unused-do-bind #-}
-
-module Lambda where
-
-import Data.Text as T
-import Data.Attoparsec.Text
-import Control.Applicative
-
-type VarName = String
-data Term = Var VarName | Lambda VarName Term | App Term Term
-
-instance Show Term where
-  show (Var x) = x
-  show (Lambda x t) = "\\" ++ x ++ "." ++ show t
-  show (App t r) = "(" ++ show t ++ " " ++ show r ++ ")"
-
---instance Read Term where
-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 '\\'
-  (Var x) <- parseVar
-  char '.'
-  t <- parseTerm
-  return $! Lambda x t
-
-parseApp :: Parser Term
-parseApp = do
-  char '('
-  t <- parseTerm
-  char ' '
-  r <- parseTerm
-  char ')'
-  return $! App t r
-
-parseTerm :: Parser Term
-parseTerm = parseVar <|> parseLambda <|> parseApp
-
--------------------------------------------------
+{-# LANGUAGE PatternSynonyms #-}
+
+-- |
+-- Module      :  Lambda
+-- Copyright   :  Tomáš Musil 2014
+-- License     :  BSD-3
+--
+-- Maintainer  :  tomik.musil@gmail.com
+-- Stability   :  experimental
+--
+-- This is a toy λ-calculus implementation.
+
+module Lambda 
+  ( -- * Types
+    VarName
+  , Term(..)
+  , pattern RedEx
+    -- * Reduction
+  , alphaNorm
+  , reduce
+  , toNormalForm
+  , Strategy(..)
+  ) where
+
+import Control.Monad.State 
+
+import Lambda.Term
+
+import Debug.Trace
+import Lambda.Parser.Fancy ()
+
+-- $setup
+-- >>> import Control.Applicative
+-- >>> import Lambda.Parser.Fancy
+-- >>> import Test.Term
+-- >>> import Test.QuickCheck
+
+varnames :: [VarName]
+varnames = map (:[]) ['a'..'z'] ++ [c : s | s <- varnames, c <- ['a'..'z']]
+
+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


@@ -66,9 +65,102 @@ substitute a b (Lambda x t)
   | otherwise = Lambda x (substitute a b t)
 substitute a b (App t u) = App (substitute a b t) (substitute a b u)
 
   | otherwise = Lambda x (substitute a b t)
 substitute a b (App t u) = App (substitute a b t) (substitute a b u)
 

+-- | Reduce λ-term
+--
+-- >>> reduce $ tRead "(\\x.x x) (g f)"
+-- g f (g f)
+

 reduce :: Term -> Term
 reduce (Var x) = Var x
 reduce (Lambda x t) = Lambda x (reduce t)
 reduce (App t u) = app (reduce t) u
   where app (Lambda x v) w = reduce $ substitute x w v
         app a b = App a (reduce b)
 reduce :: Term -> Term
 reduce (Var x) = Var x
 reduce (Lambda x t) = Lambda x (reduce t)
 reduce (App t u) = app (reduce t) u
   where app (Lambda x v) w = reduce $ substitute x w v
         app a b = App a (reduce b)

+
+data Strategy = Eager | Lazy
+
+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
+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
+
+-- 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
+      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> 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 >=> 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
+  modify (+ 1)
+  return t
+cnt t = return t
+
+short :: Int -> Term -> StateT Int Maybe Term
+short maxN t = do
+  n <- get
+  if n > maxN
+    then lift Nothing
+    else return t