|| A procedure that takes one int argument (x) and returns
|| an int.
{define-proc {triple x:int}:int
    || Define an anonymous procedure that takes one int
    || argument and returns an int.
    let my-proc:{proc-type {int}:int} =
        {proc {b:int}:int
            || Return the value of the variable x multiplied
            || by the value of the argument (b).  The
            || anonymous procedure accesses variables in the
            || scope of the code block containing the
            || anonymous procedure.
            {return x * b}
        }
    || The body of the main procedure... return the value
    || of a call to my-proc with the argument 3.
    {return {my-proc 3}}
}

{value
    || Call the procedure triple with the value 9 as the
    || argument.
    {triple 9}
}

|| A procedure that takes one int argument (x) and returns
|| a procedure.
{define-proc {adder x:int}:{proc-type {int}:int}
    || Return an anonymous procedure.
    {return
        {proc {y:int}:int
            || The anonymous procedure returns the sum of
            || the argument to "adder" that originally
            || creates the anonymous procedure (x) and the
            || argument to the anonymous procedure call (y).
            {return x + y}
        }
    }
}

{value
    || Define a variable whose data type is a procedure.
    || Initialize the variable with the return value from a
    || call to adder with an argument of 3.
    let add3:{proc-type {int}:int} = {adder 3}
    || This essentially creates a variable that is a handle
    || for a procedure that adds 3 to the value of a supplied
    || argument.

    || Call the variable with the argument 5.
    {add3 5}
}

|| A procedure that takes one argument (an int) and returns
|| two values (both any).  The two return values are, in
|| fact, anonymous procedures.
{define-proc {new-counter val:int}:(any, any)
    {return
        || An anonymous procedure that returns the original
        || argument.
        {proc {}:int {return val}},
        || An anonymous procedure that sets the value of the
        || original argument.
        {proc {new:int}:void {set val = new}}}}

|| Define two variables my-getter and my-setter to be anys.
|| Initialize the two variables with the return values of
|| a call to new-counter with 2 as the argument.
{let (my-getter:any, my-setter:any) = {new-counter 2}}
|| Define two variables your-getter and your-setter to be anys.
|| Initialize the two variables with the return values of
|| a call to new-counter with 3 as the argument.
{let (your-getter:any, your-setter:any) = {new-counter 3}}

|| A call to my-getter should return the original
|| argument (2).
{my-getter}

|| A call to your-getter should return the original
|| argument (3).
{your-getter}

|| A call to my-setter should change the original argument.
{my-setter 7}
|| And now a call to my-getter should return the updated
|| argument.
{my-getter}

|| A call to your-getter should still return the original
|| argument (3).
{your-getter}

|| A call to your-setter should change the original argument.
{your-setter -1}
|| And now a call to your-getter should return the updated
|| argument.
{your-getter}

|| And finally, a call to my-getter should return 7.
{my-getter}

|| A procedure that takes a procedure argument and returns a
|| procedure.
{define-proc {twice f:{proc-type {int}:int}}:{proc-type {int}:int}
    || Returns an anonymous procedure.
    || The anonymous procedure calls the procedure that is
    || supplied as an argument two times.  First, it calls the
    || procedure with the value of the integer parameter to the
    || anonymous procedure.  Then, it calls the procedure with
    || the result of the previous call.
    {return
        {proc {x:int}:int
            {return {f {f x}}}
        }
    }
}

{value
    || Define a variable whose data type is a procedure.
    || Initialize the variable with an anonymous procedure.
    || The anonymous procedure takes one integer argument and
    || returns an integer value that is double the value of
    || the argument.
    let double-proc:{proc-type {int}:int} =
        {proc {y:int}:int
            {return 2 * y}
        }

    || Define a variable whose data type is a procedure.
    || Initialize the variable with a call to the procedure
    || "twice" with the procedure "double-proc" as an argument to
    || the call.
    let quadruple-proc:{proc-type {int}:int} = {twice double-proc}

    {quadruple-proc 3}
}

|| A procedure that takes a procedure and returns a new
|| procedure.
{define-proc {twice f}
    || Returns an anonymous procedure.
    || The anonymous procedure calls the procedure that is
    || supplied as an argument two times.  First, it calls the
    || procedure with the value of the integer parameter to the
    || anonymous procedure.  Then, it calls the procedure with
    || the result of the previous call.
    {return {proc {x:int}:int
                {return {f {f x}}}
            }
    }
}

{value
    || Define a variable and initialize it with an anonymous
    || procedure.  The anonymous procedure takes one integer
    || argument and returns an integer value that is double
    || the value of the argument.
    let double-proc = {proc {y:int}:int
                          {return 2 * y}
                      }

    || Define a variable and initialize it with a call to the
    || procedure "twice" with the procedure "double-proc" as an
    || argument to the call.
    let quadruple-proc = {twice double-proc}

    {quadruple-proc 3}
}