LOCAL-FUNCTION
====

A variant of named-let of Scheme language, which supports following special features;

* `NO-RETURN`
* `GLOBAL-EXIT-FROM-LOCAL-FUNCTION`

## description:
`LOCAL-FUNCTION` enables to describe and execute recuresive local function
which is similar to the named-let in Scheme language.

`LOCAL-FUNCTION` supports `NO-RETURN` function call feature, which will be translated into a `GO` expression.
`NO-RETUREN` can be located anywhere upon local-function body.

NOTE: just on this implementation, `NO-RETURN` not supported to call other functions.

NOTE: TCO for non `NO-RETURN` style recursive call is not guaranteed.

`LOCAL-FUNCTION` also supports `GLOBAL-EXIT-FROM-LOCAL-FUNCTION`, similar to `RETURN`, for global exit from a local function.

## example:

    (defun fx (x)
      (declare (integer x))
      (local-function f ((i x)) (sum 0)
        (declare (integer i sum))
        (when (> i 0)
          (no-return (f (the integer (1- i)) (the integer (+ sum i)))) )
        (format t \"~&SUM is ~a~%\" sum)
        (global-exit-from-local-function sum) ))  ; or, just sum

will be expanded to

    (defun fx (x)
      (declare (integer x))
      (block #1=#:G1
        (labels
          ((f (#3=#:G3 #4=#:G4)
             (declare (integer #3# #4#))
             (tagbody #2=#:G2
               (let ((i #3#) (sum #4#))
                 (declare (integer i sum))
                 (return-from f
                   (progn
                     (if (> i 0)
                       (progn
                         (psetq i (the integer (1- i))
                                sum (the integer (+ sum i)))
                         (go #2#) ))
                     (format t \"~&SUM is ~a~%\" sum)
                     (return-from #1# sum) ))))))    ; or, just sum
          (f x 0) )))

and enable to execute pseudo recursive call deeper than deeper.

    > (fx 100000000)
    SUM is 5000000050000000
    5000000050000000
    >

## License:
Under MIT license.

Add markdown version of readme
Add markdown version of readme
