Haskell-解析表达式中变量的状态（变量是否绑定？）

Question

Hi so I got a function that takes a string and calculates the value, either an int or an bool. The string can be ie: " * let X = 3 in + X 1 2 ", which represent " (let X = 3 in (X + 1)) * 2 ". Which will give me 8 or false if I ask for a bool. Simple enough. But I also want to check the state of bound variables in the parser. Ie if I use a string like this " * let X = 3 in + X 1 X " as input, it will represent " (let X = 3 in (X + 1)) * X " which makes the last X unbound. This will then give me an error saying that the variable A is unbound or something. If someone could give me any ideas on how I could do this, I would be very much appreciated!

Expample of parsed string:

((let X = 3 in (X + 1)) * 2)

Will give me:

(Mul (Let (Vari X) (Lit (Single 3)) (Sum (Vari X) (Lit (Single 1)))) (Vari X))

So my question is basiclly how I can check if the parsed string has any unbound variables.

data Number = Single Int | Many Int Number deriving (Eq, Show)

data Expr = Vari Chara | Lit Number | Sub Expr | Sum Expr Expr | Mul Expr Expr | Let Expr Expr Expr | If Expr Expr Expr deriving (Eq, Show)

Answer 1

Recurse down the parsed expression, holding a set of bound variables. Every time you come across a Let , record it, every time you come across a Var , check that it's in your set, and every time you come across something else, check its subexpressions.

checkVars' :: Set String -> Expr -> Bool
checkVars' bound (Var v) = S.member v set
checkVars' bound (Let var val expr) = checkVars' bound val && checkVars' (insert var bound) expr
checkVars' bound (Mul expr1 expr2) = checkVars' bound expr1 && checkVars' bound expr2
-- Similar for other ctors...

checkVars :: Expr -> Bool
checkVars = checkVars' S.empty

You can also work in the opposite direction, building up a set of free variables from the bottom up, and removing variables whenever you see them bound by Let . (This feels more natural.)

freeVars :: Expr -> Set String
freeVars (Var v) = S.singleton v
freeVars (Let var val expr) = S.union (freeVars val) $ S.delete var $ freeVars expr
freeVars (Add expr1 expr2) = S.union expr1 expr2
-- etc.

checkVars :: Expr -> Bool
checkVars = S.null . freeVars

-- With recursion-schemes
data ExprF a = Add a a
             | Mul a a
             | Let String a a
             | Var String
             | Lit Int
             deriving (Eq, Show, Read, Functor, Foldable, Traversable)

type Expr = Fix ExprF

freeVars :: Expr -> Set String
freeVars = cata go -- -XLambdaCase, anyone?
  where go :: ExprF (Set String) -> Set String
        go (Var var) = S.singleton var
        go (Let var val expr) = S.union val $ S.delete var expr
        go e = foldl S.union S.empty e -- Handle everything else

Answer 2

I recommend using a locally nameless representation for variables (such as that provided by the extraordinarily useful bound library ) in a syntax with binding. In a locally nameless representation, bound variables are represented using de Bruijn indices, and unbound variables are represented using a name. This saves you a whole lot of effort when it comes to things like alpha-equivalence and capture-avoiding substitution, and answering the question "is this variable bound?" becomes very straightforward.

Typically a locally nameless representation is the output of a scope-checking operation on a surface syntax tree. We can adjust the code from @HNTW's answer to produce a checked term instead of a Bool :

data Scoped a = SVar a
              | SLet (Scoped a) (Scope () Scoped a)  -- The expression being let-bound, and the subexpression with the new variable in scope
              | SLit Number
              | SSub (Scoped a)
              | SSum (Scoped a) (Scoped a)
              | SMul (Scoped a) (Scoped a)
              | SIf (Scoped a) (Scoped a) (Scoped a)
              deriving (Functor, Foldable, Traversable)

instance Applicative Scoped where
    pure = SVar
    (<*>) = ap

instance Monad Scoped where
    return = SVar
    SVar a >>= g = g a
    SLet expr scope >>= g = SLet (expr >>= g) (scope >>>= g)
    SLit x >>= g = SLit x
    SSub x >>= g = SSub (x >>= g)
    SSum x y >>= g = SSum (x >>= g) (y >>= g)
    SMul x y >>= g = SMul (x >>= g) (y >>= g)
    SIf cond t f >>= g = SIf (cond >>= g) (t >>= g) (f >>= g)

scoped :: Expr -> Scoped Char
scoped (Var x) = SVar x
scoped (Let name expr sub) = SLet (scope expr) (abstract1 name $ scoped sub)
scoped (Lit x) = SLit x
scoped (Sub s) = SSub (scoped s)
scoped (Sum x y) = SSum (scoped x) (scoped y)
scoped (Mul x y) = SMul (scoped x) (scoped y)
scoped (If cond t f) = SIf (scoped cond) (scoped t) (scoped f)

bound views an expression as a "container" of names a . The Monad instance performs substitution ( (>>=) :: Scoped a -> (a -> Scoped b) -> Scoped b takes a function mapping names a to terms Scoped b and grafts them together), and the bound library makes use of this substitution operation to implement tools like abstract1 , which binds a variable in a subexpression, producing a new subexpression in a locally nameless form.

(It wouldn't be unreasonable to do away with the separate Expr type, and just produce a Scoped Char directly as the output of your parser.)

Scoped 's Foldable and Traversable instances let you find all the unbound variables in an expression.

unboundVariables :: Scoped a -> [a]
unboundVariables = toList

bound 's isClosed combinator does just what you wanted: it returns False if the expression has any free variables.

If, as you walk under a scope, you need to know if a particular variable is bound or free, you can either pattern-match on Var 's B and F constructors, or use the supplied Prism s :

isBound :: Var b f -> Bool
isBound = is _B

For more on how bound works, see this blog post or these slides .