-{-# 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(..)
+ -- * Reduction
+ , alphaNorm
+ , reduce
+ , toNormalForm
+ , Strategy(..)
+ ) where
+
+
+import Control.Monad.State
+
+import Lambda.Term
+
+-- $setup
+-- >>> import Test.QuickCheck
+-- >>> import Control.Applicative
+-- >>> import Lambda.Parser.Fancy
+-- >>> import Lambda.Term
+-- >>> let cP = tRead "(λa d c.(λa.e) b (λc.d)) ((λa.(λd.a) (λd c.b ((λa.a) a)) (a ((λa.(λd.e) ((λe.(λd b.a) (λa c.(λa a d.(λd.b (λa d.c) e) (λb b.c a (a d (λb d d e a.d (λb b.d))))) ((λb.a) c)) (d ((λc.(λd.a (λe.e)) (c d)) ((λe.b) a))) c (λa.d (e (λe.(λd c.b) a))) (c (b a)) a (λe.(λa b e b a.d) b)) ((λe.b) (λa.b)) ((λe d.b) b) e) b) ((λc c.a e) (λb.(λb.e) a)))) (λe.e) b (λd c e e c a.c)) a)"
+-- >>> cY = tRead "λf.(λx.f (x x)) (λx.f (x x))"
+-- >>> cI = tRead "λx.x"
+-- >>> cK = tRead "λx y.x"
+-- >>> cS = tRead "λx y z.x z (y z)"
+-- >>> let aVarName = oneof . map (pure . (:[])) $ ['a'..'e']
+-- >>> let aVar = liftA Var aVarName
+-- >>> let aComb = oneof . map pure $ [cS, cK, cI, cY]
+-- >>> let aTerm 0 = aVar
+-- >>> let aTerm n = oneof [aVar, aComb, liftA2 Lambda aVarName $ aTerm (n - 1), liftA2 App (aTerm (n `div` 2)) (aTerm (n `div` 2))]
+-- >>> instance Arbitrary Term where arbitrary = sized aTerm
+--
+-- TODO: shrink Terms
+
+varnames :: [VarName]
+varnames = map (:[]) ['a'..'z'] ++ [c : s | s <- varnames, c <- ['a'..'z']]
+
+alphaNorm :: Term -> Term
+alphaNorm t = alpha varnames t
+ 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
| 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
+
+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)
+
+{-
+printT :: Term -> IO Term
+printT t = do
+ print t
+ return t
+-}
+
+-- |
+--
+-- >>> 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 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 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
projekty / fp.git / blobdiff