如何在Haskell中计算表达式

时间：2014-04-25 14:55:15

标签： haskell functional-programming

我了解如何创建和评估简单的数据类型Expr。例如：

data Expr = Lit Int | Add Expr Expr | Sub Expr Expr | [...]

eval :: Expr -> Int
eval (Lit x) = x
eval (Add x y) = eval x + eval y
eval (Sub x y) = eval x - eval y

所以这是我的问题：如何将变量添加到此Expr类型，应该针对其指定值进行评估？它应该是这样的：

data Expr = Var Char | Lit Int | Add Expr Expr [...]
type Assignment = Char -> Int

eval :: Expr -> Assignment -> Int

我现在如何为（Var Char）和（Add Expr Expr）执行我的eval功能？我想我已经找到了最简单的，如何为Lit做这件事。

eval (Lit x) _ = x

对于（Var Char）我尝试了很多，但是我无法从作业中获得一个Int ..想想它会像这样工作：

eval (Var x) (varname number) = number

3 个答案:

答案 0 :(得分：6)

您需要将赋值函数应用于变量名称以获取Int：

eval (Var x) f = f x

这可以使用f :: Char -> Int和x:: Char，因此您可以f x来获取Int。 令人满意的是，这将适用于一组变量名称。

实施例

ass :: Assignment
ass 'a' = 1
ass 'b' = 2

意思是

eval ((Add (Var 'a') (Var 'b')) ass
= eval (Var 'a') ass + eval (Var 'b') ass
= ass 'a'            + ass 'b'
= 1 + 2
= 3

将分配功能传递给eval

的其他呼叫

你需要继续传递赋值函数，直到得到整数：

eval (Add x y) f = eval x f + eval y f

不同的顺序？

如果您允许更改类型，那么将赋值函数放在第一位且数据放在第二位似乎更符合逻辑：

eval :: Assignment -> Expr -> Int
eval f (Var x) = f x
eval f (Add x y) = eval f x + eval f y

...但我想你可以把它看作一个带有变量变量的常量表达式（感觉势在必行），而不是一系列表达式中的一组常量值（感觉就像参照透明度）。

答案 1 :(得分：6)

好吧，如果你把你的环境建模为

type Env = Char -> Int

然后你拥有的就是

eval (Var c) env = env c

但这不是真的＆＃34;正确＆＃34;。首先，未绑定变量会发生什么？所以也许更准确的类型是

type Env = Char -> Maybe Int
emptyEnv = const Nothing

现在我们可以看到变量是否未绑定

eval (Var c) env = maybe handleUnboundCase id (env c)

现在我们可以使用handleUnboundCase做一些事情，例如分配默认值，炸毁程序，或让猴子爬出你的耳朵。

要问的最后一个问题是＆＃34;变量如何约束？＆＃34;。如果你在哪里寻找＆＃34;让＆＃34;就像我们在Haskell中所说的那样，我们可以使用一种叫做HOAS（高阶抽象语法）的技巧。

data Exp = ... | Let Exp (Exp -> Exp)

HOAS位是（Exp - > Exp）。基本上我们使用Haskell的名称绑定来实现我们的语言。现在评估我们做的let表达式

eval (Let val body) = body val

这让我们依靠Haskell解析变量名称来躲避Var和Assignment。

此样式中的let语句示例可能是

 Let 1 $ \x -> x + x
 -- let x = 1 in x + x

这里最大的缺点是建模可变性是一种巨大的痛苦，但依赖于Assignment类型与具体地图的情况已经是这种情况了。

答案 2 :(得分：3)

我建议您使用Map中的Data.Map。你可以实现类似

的东西 
import Data.Map (Map)
import qualified Data.Map as M  -- A lot of conflicts with Prelude
-- Used to map operations through Maybe
import Control.Monad (liftM2)

data Expr
    = Var Char
    | Lit Int
    | Add Expr Expr
    | Sub Expr Expr
    | Mul Expr Expr
    deriving (Eq, Show, Read)

type Assignment = Map Char Int

eval :: Expr -> Assignment -> Maybe Int
eval (Lit x) _      = Just x
eval (Add x y) vars = liftM2 (+) (eval x vars) (eval y vars)
eval (Sub x y) vars = liftM2 (-) (eval x vars) (eval y vars)
eval (Mul x y) vars = liftM2 (*) (eval x vars) (eval y vars)
eval (Var x)   vars = M.lookup x vars

但这看起来很笨重，而且每次添加操作时我们都必须继续使用liftM2 op。让我们用一些助手清理一下

(|+|), (|-|), (|*|) :: (Monad m, Num a) => m a -> m a -> m a
(|+|) = liftM2 (+)
(|-|) = liftM2 (-)
(|*|) = liftM2 (*)
infixl 6 |+|, |-|
infixl 7 |*|

eval :: Expr -> Assignment -> Maybe Int
eval (Lit x) _      = return x  -- Use generic return instead of explicit Just
eval (Add x y) vars = eval x vars |+| eval y vars
eval (Sub x y) vars = eval x vars |-| eval y vars
eval (Mul x y) vars = eval x vars |*| eval y vars
eval (Var x)   vars = M.lookup x vars

那更好，但我们仍然需要到处传递vars，这对我来说很难看。相反，我们可以使用mtl包中的ReaderT monad。 ReaderT monad（和非变换器Reader）是一个非常简单的monad，它公开了一个函数ask，它返回你在运行时传入的值，其中你所能做的只是＆＃34;阅读＆＃34;此值，通常用于运行具有静态配置的应用程序。在这种情况下，我们的＆＃34;配置＆＃34;是Assignment。

这是liftM2运营商真正派上用场的地方

-- This is a long type signature, let's make an alias
type ExprM a = ReaderT Assignment Maybe a

-- Eval still has the same signature
eval :: Expr -> Assignment -> Maybe Int
eval expr vars = runReaderT (evalM expr) vars

-- evalM is essentially our old eval function
evalM :: Expr -> ExprM Int
evalM (Lit x)   = return x
evalM (Add x y) = evalM x |+| evalM y
evalM (Sub x y) = evalM x |-| evalM y
evalM (Mul x y) = evalM x |*| evalM y
evalM (Var x)   = do
    vars <- ask  -- Get the static "configuration" that is our list of vars
    lift $ M.lookup x vars
-- or just
-- evalM (Var x) = ask >>= lift . M.lookup x

我们真正改变的唯一事情是，每当遇到Var x时我们都需要做一些额外的事情，我们删除了vars参数。我认为这会使evalM非常优雅，因为我们只在需要时访问Assignment，我们甚至不必担心失败，它完全照顾到Monad的{​​{1}}个实例。整个算法中没有一行错误处理逻辑，但如果Maybe中没有变量名，它将优雅地返回Nothing。

另外，考虑以后是否要切换到Assignment并添加除法，但您还要返回错误代码，以便确定是否存在除以0错误或查找错误。您可以使用Double

来代替Maybe Double 
Either ErrorCode Double

然后你可以把这个模块写成

data ErrorCode
    = VarUndefinedError
    | DivideByZeroError
    deriving (Eq, Show, Read)

现在我们确实有明确的错误处理，但它并不坏，我们已经能够使用data Expr = Var Char | Lit Double | Add Expr Expr | Sub Expr Expr | Mul Expr Expr | Div Expr Expr deriving (Eq, Show, Read) type Assignment = Map Char Double data ErrorCode = VarUndefinedError | DivideByZeroError deriving (Eq, Show, Read) type ExprM a = ReaderT Assignment (Either ErrorCode) a eval :: Expr -> Assignment -> Either ErrorCode Double eval expr vars = runReaderT (evalM expr) vars throw :: ErrorCode -> ExprM a throw = lift . Left evalM :: Expr -> ExprM Double evalM (Lit x) = return x evalM (Add x y) = evalM x |+| evalM y evalM (Sub x y) = evalM x |-| evalM y evalM (Mul x y) = evalM x |*| evalM y evalM (Div x y) = do x' <- evalM x y' <- evalM y if y' == 0 then throw DivideByZeroError else return $ x' / y' evalM (Var x) = do vars <- ask maybe (throw VarUndefinedError) return $ M.lookup x vars 来避免在maybe和{{1}上明确匹配}。

这比你真正需要解决这个问题的信息要多得多，我只是想提出一个使用Just和Nothing的monadic属性来提供简单错误处理和使用的替代解决方案。 Maybe清除在任何地方传递Either参数的噪音。

相关问题
最新问题