Haskell-查找未声明的变量
AST:Haskell-查找未声明的变量,haskell,functional-programming,Haskell,Functional Programming,AST: data AST = Nr Int | Sum AST AST | Mul AST AST | Min AST | If AST AST AST | Let String AST AST | Var String deriving (Eq, Show) 嗨!我需要一些帮助来查找输入中未声明的变量。我的问题是,我不能简单地在我的评估器中这样做: eval :: Env -> AST -> Int eval env (Nr nr) = nr eval env (Sum xs
data AST = Nr Int | Sum AST AST | Mul AST AST | Min AST | If AST AST AST |
Let String AST AST | Var String deriving (Eq, Show)
嗨!我需要一些帮助来查找输入中未声明的变量。我的问题是,我不能简单地在我的评估器中这样做:
eval :: Env -> AST -> Int
eval env (Nr nr) = nr
eval env (Sum xs xss) = eval env xs + eval env xss
eval env (Mul xs xss) = eval env xs * eval env xss
eval env (Min xs ) = - eval env xs
eval env (If x xs xss) = if (eval env x == 0)
then eval env xs
else eval env xss
eval env (Let s xs xss) = eval ((s, (eval env xs)) : env) xss
eval env (Var x) = case lookup x env of
Just n -> n
Nothing -> error ("Variable " ++ x ++ " is undeclared!")
如果有任何未声明的变量,我需要在解析时给出一个包含所有未声明变量列表的适当错误,或者在计算之前对我的AST进行后期处理。我不知道从哪里开始。下面是一个解析表达式的示例:
parse "let X = + 1 2 in * X + 2 - X"
Let "X" (Sum (Nr 1) (Nr 2)) (Mul (Var "X") (Sum (Nr 2) (Min (Var "X"))))
parse :: AST -> Result Int
parse (Nr nr) = pure nr
parse (Sum xs xss) = (+) <$> parse xs <*> parse xss
parse (Mul xs xss) = (*) <$> parse xs <*> parse xss
parse (Min xs ) = negate <$> parse xs
parse (If x xs xss) = jnz <$> parse x <*> parse xs <*> parse xss
where jnz a b c = if a == 0 then b else c
parse (Let s xs xss) = Result ks h
where Result is f = parse xs
Result js g = parse xss
ks = is ++ delete s js
h env = g ((s,f env):env)
parse (Var x) = Result [x] $ \env -> case lookup x env of
Just n -> n
Nothing -> error ("Variable " ++ x ++ " is undeclared!")
让我们从类型开始: 如果有任何未声明的变量,我需要在解析时给出一个包含所有未声明变量列表的适当错误 一个函数
eval
会给你们一个未声明变量的列表,或者一个Int
(若并没有未声明变量的话)怎么样
我们现在需要将原始数字包装在右侧
中:
eval env (Nr nr) = Right nr
对于Var
案例中声明的变量,情况也是如此,
当一个未声明的变量被包装在一个列表中时,一个左
:
eval env (Var x) = case lookup x env of
Just n -> Right n
Nothing -> Left [x]
对于Min
情况,我们不能再否定递归调用,因为
没有为或[Identifier]Int
定义否定
我们可以进行模式匹配,看看我们得到了什么:
eval env (Min xs ) = case eval env xs of
Left err -> Left err
Right x -> Right (-x)
但这相当冗长,与使用e
的函子实例中的fmap
完全相同:
eval env (Min xs ) = fmap negate (eval env xs)
类似地,对于Sum
,我们可以在两个参数上进行模式匹配:
eval env (Sum xs xss) = case (eval env xs, eval env xss) of
(Left err, Left err') -> Left (err ++ err')
(Left err, Right _) -> Left err
(Right _, Left err') -> Left err'
(Right a, Right b) -> Right (a + b)
请注意,如果两个子项都包含未声明的变量,我们如何将它们串联起来,以获得总和下的未声明变量列表
对于其余的构造函数,这是同样的技巧。然而,我不想每次都要像那样键入一个巨大的case
语句。这是一个小增加了很多工作!如果
和让有八个案例
让我们制作一个帮助函数来为我们实现这一点:
apply :: Either [Identifier] (a -> b) -> Either [Identifier] a -> Either [Identifier] b
apply (Left err) (Left err') = Left (err ++ err')
apply (Left err) (Right _) = Left err
apply (Right _) (Left err') = Left err'
apply (Right f) (Right a) = Right (f a)
现在定义Sum
、Mul
和If
的案例要容易得多:
eval env (Sum xs xss) = fmap (+) (eval env xs) `apply` eval env xss
eval env (Mul xs xss) = fmap (*) (eval env xs) `apply` eval env xss
eval env (If x xs xss) = fmap jnz (eval env x) `apply` eval env xs `apply` eval env xss
where jnz i a a' = if i == 0 then a else a'
Let
略有不同:
eval env (Let s xs xss) = fmap second v `apply` eval env' xss
where val = eval env xs
env' = (s,val) : env
getRight (Right a) = a
getRight (Left _) = 0
second _ a = a
请注意,当第一个术语包含未声明的变量时,我们如何通过向环境提供第二个术语的假值来“欺骗”。因为我们不打算使用任何Int
值,所以第二项在这种情况下可能会产生,这是可以的
一旦您进一步了解Haskell,您可能会注意到
apply
看起来非常像Applicative
中的
。我们之所以不使用它,是因为e
的Applicative
实例不能按我们希望的方式工作。它不会聚合错误,而是在遇到第一个错误时退出:
>>> Left ["foo"] `apply` Left ["bar", "baz"]
Left ["foo", "bar", "baz"]
>>> Left ["foo"] <*> Left ["bar", "baz"]
Left ["foo"]
一种可能使
Let
的大小写不那么麻烦的方法是将eval
的返回类型从的[Identifier]Int
更改为([Identifier],(Identifier,Int)]->Int)
-让它返回表达式中所有自由变量的列表,以及在给定这些变量的绑定时计算表达式的方法
type Identifier = String
eval :: Env -> AST -> Either [Identifier] Int
如果我们为该类型命名:
data Result a = Result { freeVariables :: [Identifier], eval :: [(Identifier,Int)] -> a }
我们可以为它定义Functor
和Applicative
实例:
instance Functor Result where
fmap f (Result is g) = Result is (f . g)
instance Applicative Result where
pure a = Result [] (const a)
Result is ff <*> js fa = Result (is ++ js) (ff <*> js)
实例函子结果,其中
fmap f(结果为g)=结果为(f.g)
实例应用结果在哪里
纯a=结果[](常数a)
结果为ff js fa=Result(is++js)(ff js)
并使用它们轻松定义一个函数来解析自由变量和一个eval表达式:
parse "let X = + 1 2 in * X + 2 - X"
Let "X" (Sum (Nr 1) (Nr 2)) (Mul (Var "X") (Sum (Nr 2) (Min (Var "X"))))
parse :: AST -> Result Int
parse (Nr nr) = pure nr
parse (Sum xs xss) = (+) <$> parse xs <*> parse xss
parse (Mul xs xss) = (*) <$> parse xs <*> parse xss
parse (Min xs ) = negate <$> parse xs
parse (If x xs xss) = jnz <$> parse x <*> parse xs <*> parse xss
where jnz a b c = if a == 0 then b else c
parse (Let s xs xss) = Result ks h
where Result is f = parse xs
Result js g = parse xss
ks = is ++ delete s js
h env = g ((s,f env):env)
parse (Var x) = Result [x] $ \env -> case lookup x env of
Just n -> n
Nothing -> error ("Variable " ++ x ++ " is undeclared!")
parse::AST->Result Int
解析(Nr)=纯Nr
parse(Sum xs xss)=(+)parse xs parse xss
parse(Mul-xs-xss)=(*)parse-xs parse-xss
parse(minxs)=否定parse xs
parse(如果x xs xss)=jnz parse x parse xs parse xss
其中jnz a b c=如果a==0,则b else c
parse(让s xs xss)=结果ks h
其中,结果是f=parse xs
结果jsg=parse xss
ks=is++delete s js
h环境=g((s,f环境):环境)
parse(Var x)=结果[x]$\env->案例查找x的env
只是n->n
Nothing->error(“变量“++x++”未声明!”)
哇,谢谢!我以前从未使用过这两种方法,但我会尝试在我的解决方案中使用它。