我了解如何创建和评估简单的数据类型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
答案 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参数的噪音。