src/Lambda.hs

   1 {-# OPTIONS_GHC -fno-warn-unused-do-bind #-}
   2 {-# LANGUAGE PatternSynonyms #-}
   3
   4 -- |
   5 -- Module      :  Lambda
   6 -- Copyright   :  Tomáš Musil 2014
   7 -- License     :  BSD-3
   8 --
   9 -- Maintainer  :  tomik.musil@gmail.com
  10 -- Stability   :  experimental
  11 --
  12 -- This is a toy λ-calculus implementation.
  13
  14 module Lambda
  15   ( -- * Types
  16     VarName
  17   , Term(..)
  18     -- * Parsing terms
  19   , parseTerm
  20   , tRead
  21     -- * Reduction
  22   , reduce
  23   , toNormalForm
  24   , Strategy(..)
  25   ) where
  26
  27
  28 import Data.Text as T hiding (map)
  29 import Data.Attoparsec.Text
  30 import Control.Applicative
  31 import Control.Monad.State
  32
  33 -- $setup
  34 -- >>> import Test.QuickCheck
  35 -- >>> import Control.Applicative
  36 -- >>> let aVarName = oneof . map (pure . (:[])) $ ['a'..'e']
  37 -- >>> let aVar = liftA Var aVarName
  38 -- >>> let aComb = oneof . map pure $ [cS, cK, cI, cY]
  39 -- >>> let aTerm 0 = aVar
  40 -- >>> let aTerm n = oneof [aVar, aComb, liftA2 Lambda aVarName $ aTerm (n - 1), liftA2 App (aTerm (n `div` 2)) (aTerm (n `div` 2))]
  41 -- >>> instance Arbitrary Term where arbitrary = sized aTerm
  42 --
  43 -- TODO: shrink Terms
  44
  45 cP :: Term
  46 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)"
  47
  48 cY :: Term
  49 cY = tRead "λf.(λx.f (x x)) (λx.f (x x))"
  50
  51 cI :: Term
  52 cI = tRead "λx.x"
  53
  54 cK :: Term
  55 cK = tRead "λx y.x"
  56
  57 cS :: Term
  58 cS = tRead "λx y z.x z (y z)"
  59
  60 type VarName = String
  61
  62 -- |
  63 -- >>> print $ Lambda "x" (Var "x")
  64 -- (λx.x)
  65
  66 data Term = Var VarName | Lambda VarName Term | App Term Term deriving (Eq)
  67
  68 varnames :: [VarName]
  69 varnames = map (:[]) ['a'..'z'] ++ [c : s | s <- varnames, c <- ['a'..'z']]
  70
  71 alphaNorm :: Term -> Term
  72 alphaNorm t = alpha varnames t
  73   where
  74     alpha (v:vs) (Lambda x t) = Lambda v . alpha vs $ substitute x (Var v) t
  75     alpha vs (App u v) = App (alpha vs u) (alpha vs v)
  76     alpha vs (Var x) = Var x
  77
  78 pattern RedEx x t s = App (Lambda x t) s
  79 pattern AppApp a b c = App a (App b c)
  80 pattern EmLambda x y t = Lambda x (Lambda y t)
  81
  82
  83 instance Show Term where
  84   show (Var x) = x
  85   show (EmLambda x y t) = show (Lambda (x ++ " " ++ y) t)
  86   show (Lambda x t) = "(λ" ++ x ++ "." ++ show t ++ ")"
  87   show (AppApp a b c) = show a ++ " " ++ braced (App b c)
  88   show (App t r) = show t ++ " " ++ show r
  89
  90 braced :: Term -> String
  91 braced t = "(" ++ show t ++ ")"
  92
  93 -- |
  94 -- prop> t == tRead (show (t :: Term))
  95
  96 tRead :: String -> Term
  97 tRead s = case parseOnly (parseTerm <* endOfInput) (T.pack s) of
  98     (Right t) -> t
  99     (Left e) -> error e
 100
 101 parseVar :: Parser Term
 102 parseVar = do
 103   x <- many1 (letter <|> digit)
 104   return $! Var x
 105
 106 parseLambda :: Parser Term
 107 parseLambda = do
 108   char '\\' <|> char 'λ'
 109   vars <- sepBy1 parseVar (char ' ')
 110   char '.'
 111   t <- parseTerm
 112   return $! createLambda vars t
 113
 114 createLambda :: [Term] -> Term -> Term
 115 createLambda (Var x : vs) t = Lambda x $ createLambda vs t
 116 createLambda [] t = t
 117 createLambda _ _ = error "createLambda failed"
 118
 119 parseApp :: Parser Term
 120 parseApp = do
 121   aps <- sepBy1 (parseBraces <|> parseLambda <|> parseVar) (char ' ')
 122   return $! createApp aps
 123
 124 createApp :: [Term] -> Term
 125 createApp [t] = t
 126 createApp (t:ts:tss) = createApp (App t ts : tss)
 127 createApp [] = error "empty createApp"
 128
 129 parseBraces :: Parser Term
 130 parseBraces = do
 131   char '('
 132   t <- parseTerm
 133   char ')'
 134   return t
 135
 136 parseTerm :: Parser Term
 137 parseTerm = parseApp <|>
 138             parseBraces <|>
 139             parseLambda <|>
 140             parseVar
 141
 142 -------------------------------------------------
 143
 144 isFreeIn :: VarName -> Term -> Bool
 145 isFreeIn x (Var v) = x == v
 146 isFreeIn x (App t u) = x `isFreeIn` t || x `isFreeIn` u
 147 isFreeIn x (Lambda v t) = x /= v && x `isFreeIn` t
 148
 149 rename :: Term -> Term
 150 rename (Lambda x t) = Lambda n (substitute x (Var n) t)
 151   where n = rnm x
 152         rnm v = if (v ++ "r") `isFreeIn` t then rnm (v ++ "r") else v ++ "r"
 153 rename _ = error "TODO vymyslet reprezentaci, kde pujde udelat fce, ktera bere jen Lambdy"
 154
 155 substitute :: VarName -> Term -> Term -> Term
 156 substitute a b (Var x) = if x == a then b else Var x
 157 substitute a b (Lambda x t)
 158   | x == a = Lambda x t
 159   | x `isFreeIn` b = substitute a b $ rename (Lambda x t)
 160   | otherwise = Lambda x (substitute a b t)
 161 substitute a b (App t u) = App (substitute a b t) (substitute a b u)
 162
 163 -- | Reduce λ-term
 164 --
 165 -- >>> reduce $ tRead "(\\x.x x) (g f)"
 166 -- g f (g f)
 167
 168 reduce :: Term -> Term
 169 reduce (Var x) = Var x
 170 reduce (Lambda x t) = Lambda x (reduce t)
 171 reduce (App t u) = app (reduce t) u
 172   where app (Lambda x v) w = reduce $ substitute x w v
 173         app a b = App a (reduce b)
 174
 175 data Strategy = Eager | Lazy
 176
 177 reduceStep :: (Monad m) => Term -> m Term
 178 reduceStep (RedEx x s t) = return $ substitute x t s
 179 reduceStep t = return $ t
 180
 181 data Z = R Term Z | L Z Term | ZL VarName Z | E
 182 data D = Up | Down
 183 type TermZipper = (Term, Z, D)
 184
 185 move :: TermZipper -> TermZipper
 186 move (App l r, c, Down) = (l, L c r, Down)
 187 move (Lambda x t, c, Down) = (t, ZL x c, Down)
 188 move (Var x, c, Down) = (Var x, c, Up)
 189 move (t, L c r, Up) = (r, R t c, Down)
 190 move (t, R l c, Up) = (App l t, c, Up)
 191 move (t, ZL x c, Up) = (Lambda x t, c, Up)
 192 move (t, E, Up) = (t, E, Up)
 193
 194 unmove :: TermZipper -> TermZipper
 195 unmove (t, L c r, Down) = (App t r, c, Down)
 196 unmove x = x
 197
 198 travPost :: (Monad m) => (Term -> m Term) -> Term -> m Term
 199 travPost fnc term = tr fnc (term, E, Down)
 200   where
 201     tr f (t@(RedEx _ _ _), c, Up) = do
 202       nt <- f t
 203       tr f $ (nt, c, Down)
 204     tr _ (t, E, Up) = return t
 205     tr f (t, c, Up) = tr f $ move (t, c, Up)
 206     tr f (t, c, Down) = tr f $ move (t, c, Down)
 207
 208 travPre :: (Monad m) => (Term -> m Term) -> Term -> m Term
 209 travPre fnc term = tr fnc (term, E, Down)
 210   where
 211     tr f (t@(RedEx _ _ _), c, Down) = do
 212       nt <- f t
 213       tr f $ unmove (nt, c, Down)
 214     tr _ (t, E, Up) = return t
 215     tr f (t, c, Up) = tr f $ move (t, c, Up)
 216     tr f (t, c, Down) = tr f $ move (t, c, Down)
 217
 218 printT :: Term -> IO Term
 219 printT t = do
 220   print t
 221   return t
 222
 223 -- |
 224 --
 225 -- >>> toNormalForm Eager 100 cI
 226 -- Just (λx.x)
 227 --
 228 -- >>> toNormalForm Eager 100 $ App cI cI
 229 -- Just (λx.x)
 230 --
 231 -- >>> toNormalForm Eager 100 $ (App (App cK cI) cY)
 232 -- Nothing
 233 --
 234 -- >>> toNormalForm Lazy 100 $ (App (App cK cI) cY)
 235 -- Just (λx.x)
 236 --
 237 -- prop> (\ t u -> t == u || t == Nothing || u == Nothing) (alphaNorm <$> toNormalForm Lazy 1000 x) (alphaNorm <$> toNormalForm Eager 1000 x)
 238
 239
 240 toNormalForm :: Strategy -> Int -> Term -> Maybe Term
 241 toNormalForm Eager n = flip evalStateT 0 . travPost (cnt >=> short n >=> reduceStep)
 242 toNormalForm Lazy  n = flip evalStateT 0 . travPre  (cnt >=> short n >=> reduceStep)
 243
 244 cnt :: (Monad m) => Term -> StateT Int m Term
 245 cnt t@(RedEx _ _ _) = do
 246   modify (+ 1)
 247   return t
 248 cnt t = return t
 249
 250 short :: Int -> Term -> StateT Int Maybe Term
 251 short maxN t = do
 252   n <- get
 253   if n > maxN
 254     then lift Nothing
 255     else return t