编写递归函数来重命名 lambda 演算中的项

Question

I've made an attempt at writing a function that will rename variable names in a Lambda calculus term. The renaming operation is M[y/x] (M with x renamed to y).

The problem lies, in these lines of code, | z == x = y | z == x = y , where newN = rename(n) , where newZ1 = rename(newZ1) and newZ2 = rename(newZ2) .

| z == x = y | z == x = y comes up with a type error Expected type: Term Actual type: Var . Please can you help me to understand why I get this error?

The other three errors come from when I attempt to recursively call the rename function. I get the error • Probable cause: 'rename' is applied to too few arguments . When I was writing this I thought that it would rename the Variable to according to the case which was set for a Variable. How do I do this correctly, cheers.

type Var = String

data Term =
    Variable Var
  | Lambda   Var  Term
  | Apply    Term Term
--  deriving Show

instance Show Term where
  show = pretty

example :: Term
example = Lambda "a" (Lambda "x" (Apply (Apply (Lambda "y" (Variable "a")) (Variable "x")) (Variable "b")))


pretty :: Term -> String
pretty = f 0
    where
      f i (Variable x) = x
      f i (Lambda x m) = if i /= 0 then "(" ++ s ++ ")" else s where s = "\\" ++ x ++ ". " ++ f 0 m 
      f i (Apply  n m) = if i == 2 then "(" ++ s ++ ")" else s where s = f 1 n ++ " " ++ f 2 m

rename :: Var -> Var -> Term -> Term
rename x y (Variable z)     
    | z == x    = y
    | otherwise = (Variable z)

rename x y (Lambda z n)
    | z == x    = (Lambda z n)
    | otherwise = (Lambda z newN)
                  where newN = rename(n)

rename x y (Apply  n m) = (Apply newZ1 newZ2)
    where newZ1 = rename(newZ1)
          newZ2 = rename(newZ2)

Answer 1

The reasons for the errors are exactly as the messages say. I'll go through them, after quoting the whole of the faulty definition:

rename :: Var -> Var -> Term -> Term
rename x y (Variable z)     
    | z == x    = y
    | otherwise = (Variable z)

rename x y (Lambda z n)
    | z == x    = (Lambda z n)
    | otherwise = (Lambda z newN)
                  where newN = rename(n)

rename x y (Apply  n m) = (Apply newZ1 newZ2)
    where newZ1 = rename(newZ1)
          newZ2 = rename(newZ2)

The first error, as you report, is type error Expected type: Term Actual type: Var , on the line | z == x = y | z == x = y .

This is entirely due to the return value in that case, y , which is of type Var . Yet your signature says the return value must have type Term . This can be fixed by replacing y with Variable y , exactly as you have done with z on the following line.

As for the other ones, again GHC's suggestion seems to me to be spot on: you haven't applied rename to enough arguments when making your recursive calls. rename has type Var -> Var -> Term -> Term , which means when applied to a single argument (presumed to be of type Var ), as in your rename(n) (which can be more concisely written as rename n ), you get a value of type Var -> Term -> Term , not one of type Term as you clearly want. To get that, you have to apply rename to 3 arguments (of the appropriate types), not just 1.

The following will fix the mentioned errors - although I haven't tested it to see if there are any more errors, nor am I totally sure I've understood the intended behaviour of your function (although I am somewhat confident on that).

I have also removed some unnecessary parentheses, and redefined newZ1 and newZ2 to be what I believed you intended, rather than being defined in terms of themselves.

rename :: Var -> Var -> Term -> Term
rename x y (Variable z)     
    | z == x    = Variable y
    | otherwise = Variable z

rename x y (Lambda z n)
    | z == x    = Lambda z n
    | otherwise = Lambda z newN
                  where newN = rename x y n

rename x y (Apply  n m) = Apply newZ1 newZ2
    where newZ1 = rename x y n
          newZ2 = rename x y m