toNormalForm Eager

[fp.git] / src / Lambda.hs

diff --git a/src/Lambda.hs b/src/Lambda.hs
index 5165bb8..f89cc7e 100644 (file)
--- a/src/Lambda.hs
+++ b/src/Lambda.hs
@@ -1,20 +1,66 @@
 {-# OPTIONS_GHC -fno-warn-unused-do-bind #-}
+{-# LANGUAGE PatternSynonyms #-}
 
-module Lambda where
+-- |
+-- 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(..)
+    -- * Parsing terms
+  , parseTerm
+  , tRead
+    -- * Reduction
+  , reduce
+  ) 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 = 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
-data Term = Var VarName | Lambda VarName Term | App Term Term
+
+-- | 
+-- >>> 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 (Lambda x t) = "\\" ++ x ++ "." ++ show t
-  show (App t r) = "(" ++ show t ++ " " ++ show r ++ ")"
+  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
+
+braced :: Term -> String
+braced t = "(" ++ show t ++ ")"
+
+-- |
+-- prop> t == tRead (show (t :: Term))
 
---instance Read Term where
 tRead :: String -> Term
 tRead s = case parseOnly (parseTerm <* endOfInput) (T.pack s) of
     (Right t) -> t
@@ -27,23 +73,39 @@ parseVar = do
 
 parseLambda :: Parser Term
 parseLambda = do
-  char '\\'
-  (Var x) <- parseVar
+  char '\\' <|> char 'λ'
+  vars <- sepBy1 parseVar (char ' ')
   char '.'
   t <- parseTerm
-  return $! Lambda x t
+  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 ' '
-  r <- parseTerm
   char ')'
-  return $! App t r
+  return t 
 
 parseTerm :: Parser Term
-parseTerm = parseVar <|> parseLambda <|> parseApp
+parseTerm = parseApp <|>
+            parseBraces <|>
+            parseLambda <|>
+            parseVar
 
 -------------------------------------------------
 
@@ -66,9 +128,49 @@ 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)
 
+-- | 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)
+
+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
+  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
+
+toNormalForm :: Strategy -> Int -> Term -> Maybe Term
+toNormalForm Eager n = flip evalStateT 0 . traversPost (short n >=> cnt >=> reduceStep)
+
+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 max t = do
+  n <- get
+  if n == max
+    then lift Nothing
+    else return t