# 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.