Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Tutorial on Closure Conversion and Lambda Lifting
This is my short-ish tutorial on how to implement closures in
a simple functional language: Foo.
First, some boilerplate.
> {-# LANGUAGE DeriveFunctor, TypeFamilies #-}
> import Control.Applicative
> import Control.Monad.Gen
> import Control.Monad.Writer
> import Data.Functor.Foldable
To actually run this code, you'll need `Control.Monad.Gen`, which is
part of my monad-gen package. It's just a thin wrapper over the state
monad to give us fresh variable names later on.
Foo will consistent of a few core primops, numbers, and lambdas. In Haskell,
we can represent Foo expressions as
> data Var = Gen Integer | Name String -- Gen for generated variables
> deriving(Eq, Show)
>
> data Primop = Plus | Sub | Mult | Div
> deriving Show
>
> data Exp = Var Var
> | App Exp Exp
> | Lam [Var] Exp
> | Prim Primop
> | Lit Int
> deriving Show
We allow lambdas to have multiple arguments, but we're treating even
them as sugar for the manually curried form, like we do in Haskell.
Now, let's write a little boilerplate to use recursion-schemes.
> data ExpF a = VarF Var
> | AppF a a
> | LamF [Var] a
> | PrimF Primop
> | LitF Int
> | PAppF Primop a a
> deriving Functor
> type instance Base Exp = ExpF
> instance Foldable Exp where
> project (Var v) = VarF v
> project (App l r) = AppF l r
> project (Lam vs e) = LamF vs e
> project (Prim p) = PrimF p
> project (Lit i) = LitF i
> instance Unfoldable Exp where
> embed (VarF v) = Var v
> embed (AppF l r) = App l r
> embed (LamF v e) = Lam v e
> embed (PrimF p) = Prim p
> embed (LitF i) = Lit i
Now, programs in Foo are a series of mutually recursive definitions,
just like Haskell. To represent this, we'll write a new type
> data Def = Def Var [Var] Exp
> deriving Show
Now, on to closure conversion!
As a brief refresher, a closure is a lambda with references to
variables outside of its scope that aren't global variables.
If you write Haskell, then you use closures all the time! In fact
every multiple argument function is closures.
For example
> add x y = x + y
This is really
> add' = \x -> \y -> x + y
Now look at the inner lamda `\ y -> x + y`. here the reference to
x isn't bound in the lambda's argument list, and it's not defined on
the top level. Closures give rise to currying, partial application, and
can even be used to fake message passing stateful objects!
Now the problem is, almost all compilation targets don't support
closures! Or nested functions at all for that matter. Therefore,
one of the many things a compiler for Foo most do is convert all
closures and anonymous functions into normal, top level functions.
To do this, each lambda needs to be retrofitted to take a bunch of extra
arguments. For example our `add` from would become something like
> add'' = \x -> (\x y -> x + y) x
Now each lambda is "closed" and contains no reference to outside variables.
The next step will be to lift our inner lambda to its own top level definition
so that translation to something like C, STG, or LLVM IR would be pretty straight
forward.
> extra = \x y -> x + y -- Ignore the fact that this desugars to add'' for a moment
> add''' = \x -> extra x
Obviously, this is not optimal code! We'll talk about how to optimize this later.
For now though, we can write a simple algorithm for closure conversion and lambda
lifting.
First some helper functions and types
> without :: Eq a => [a] -> [a] -> [a]
> without = foldr (filter . (/=)) -- Like \\ but removes all occurrences
>
> freeVars :: Exp -> [Var] -- Grab all the unbound variables in an expression
> freeVars = cata folder
> where folder (VarF v) = [v]
> folder (AppF l r) = l ++ r
> folder (LamF vs e) = e `without` vs
> folder (PrimF _) = []
> folder (LitF _) = []
>
> applyTo :: Exp -> [Var] -> Exp
> applyTo e (a : as) = applyTo (App e $ Var a) as
> applyTo e [] = e
Now, the actual closure conversion pass is quite simple
> closConv :: [Var] -> Exp -> Exp
> closConv globals = cata folder
> where folder (LamF vs e) =
> let vars = freeVars e `without` (globals ++ vs)
> in Lam (vars ++ vs) e `applyTo` vars
> folder e = embed e
Yep, that's it! Now we can take a Foo expression like
> -- testExp foo = foo (\bar -> bar foo)
> testExp = Lam [foo] $ App (Var foo) (Lam [bar] $ App (Var bar) (Var foo))
> where [foo, bar] = map Name ["foo", "bar"]
And convert it to an expression like
> -- converted foo = foo ((\foo bar -> bar foo) foo)
> converted :: Exp
> converted = closConv [] testExp
Next we can lift everything to its own top level. This
is another small pass.
> type ClosM = WriterT [Def] (Gen Integer)
> liftLam :: Exp -> ClosM Exp
> liftLam = cata folder
> where folder (AppF l r) = App <$> l <*> r
> folder (VarF v) = return $ Var v
> folder (PrimF p) = return $ Prim p
> folder (LitF i) = return $ Lit i
> folder (LamF vs e) = do
> fresh <- Gen <$> gen
> Def fresh vs <$> e >>= tell . return
> return $ Var fresh
Now we can chain these two steps together
> eliminateLams :: [Var] -> Def -> [Def]
> eliminateLams globals (Def nm vs e) = Def nm vs e' : defs
> where (e', defs) = runGenInt . runWriterT . liftLam $ closConv globals e
>
And that's it!
Now, one simple optimization we can do during this whole process is to mash lambdas
together. Currently, if we had something like
> slow = Lam [Name "a"] $ Lam [Name "b"] $ undefined
This could get lifted into two separate, equivalent, top levels! We saw this
before with `add`. To fix this we can traverse each expression, and lambdas
like these together. This can be done with one simple pass
> smash :: Exp -> Exp
> smash = cata folder
> where folder (LamF vs (Lam vs' e)) = Lam (vs ++ vs') e
> folder e = embed e
If we plug this into `eliminateLam`, we end up with much more efficient
generated code.
In fact, there's a whole host of clever tricks to play during closure
conversion and lambda lifting, especially in lazy languages.
For more on this, check out SPJ's [book]
(http://research.microsoft.com/en-us/um/people/simonpj/papers/slpj-book-1987/)
@funrep

This comment has been minimized.

Copy link

funrep commented Jun 19, 2014

Maybe I'm mistaken, but shouldn't

let vars = freeVars e `without` (globals ++ vars)

be...

let vars = freeVars e `without` (globals ++ vs)

?

Thanks for the tutorial (really need to learn about those recursion-schemes, I think its exactly something like that I've been longing for while working on my closure conversion based on below blog post)! For reference here's some other useful resources I've found:

http://matt.might.net/articles/closure-conversion/
and it's also covered in Appel's book (Compiling with continuations) (which you suggested :P, not read that particular chapter yet though) (but in CPS form I think?) and there's also fairly readable implementation of it in Scheme in CHICKEN's source file compiler.scm, function perform-closure-conversion. May I ask, if its correct that Appel's approach is to closure convert AFTER CPSing, is there any down-sides/up-sides you know of?

@jozefg

This comment has been minimized.

Copy link
Owner Author

jozefg commented Jun 21, 2014

Quite right about vars vs vs.

As far as CwC goes, I think you have to closure convert/lambda lift after CPS since CPS generates a ton of closures! A smarter thing to do might be to CPS generate, and run a pass over the code and convert

(\x' -> ...) x

into something like

magical_let x' = x in ....

And then do closure conversion and lift. Since otherwise there's a world of pain involved in making CPSed code not generate tons of lambdas.

@funrep

This comment has been minimized.

Copy link

funrep commented Jun 21, 2014

Makes sense, thanks.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.