Please enable JavaScript.

Coggle requires JavaScript to display documents.

CLOSURE, Tail Call Optimization (TCO) - Coggle Diagram

- - - - Variable reference like x or hello;
        
        1
      - Abstraction with anonymous function (lambda), like (λx.x) or (λx.y) where x is a parameter and y is a result - (notice that the expression body can contain external variables like y);
        
        2
      - Application with function application (f x) where x is applied to f.
        
        3
        
        (Think of it as a function call, where f is the function and x is its only parameter)
    - - λx.x/y+2
        
        x is bound
        
        the symbol x is bound by the lambda abstraction λx.
        
        y is free
        
        We don't know what it is and where it comes from, so we don't know what it means and what value it represents, and therefore we cannot evaluate that expression until we figure out what y means.
      - Free Symbols
        
        You can think of the free symbols as defined somewhere else, outside the expression, in its "surrounding context", which is called its environment. The environment might be a bigger expression that this expression is a part of, or in some library, or in the language itself (as a primitive).
      - lambda expressions
        
        CLOSED
        
        every symbol that occurs in these expressions is bound by some lambda abstraction. In other words, they are self-contained; they don't require any surrounding context to be evaluated. They are also called combinators.
        
        OPEN
        
        some symbols in these expressions are free and they require some external information, and thus they cannot be evaluated until you supply the definitions of these symbols.
      - λx.x+1
        
        λ
        
        The abstraction operator
        
        x+1
        
        body of the abstraction
        
        λx
        
        Binder
        
        Lambda expression
      - Closure
        
        The closure of a lambda expression is this particular set of symbols defined in the outer context (environment) that give values to the free symbols in this expression, making them non-free anymore. It turns an open lambda expression, which still contains some "undefined" free symbols, into a closed one, which doesn't have any free symbols anymore.
        
        !
        
        the closure of a lambda expression is the subset of definitions in its environment that give values to the free variables contained in that lambda expression, effectively closing the expression (turning an open lambda expression, which cannot be evaluated yet, into a closed lambda expression, which can then be evaluated, since all the symbols contained in it are now defined).