# Inlining in Joy

## John Cowan — 2001-04-27 20:24:20

    (Manfred, you and I seem to be talking to ourselves, but what

    the hell...)

    Joy lends itself to extremely easy inlining:  when defining a

    word, you can simply replace any user-defined word in the body

    with *its* body, recursively, but watching for references to

    words already being inlined (so that you do not get into an

    infinite expansion).  The implementation should be extremely

    easy.

    However, I can think of at least three policies for deciding

    whether to inline or not:

    1) Mark inlineable words (e.g. by starting the definition

    with INLINE instead of DEFINE/LIBRA).  Any word so marked

    is always inlined when it is used in a definition, subject

    to the caveat above.

    2) Have a global mode: when on, we do inlining on every

    definition; when off, we don't inline during definition.

    (Once a definition is inlined, it stays inlined regardless

    of the mode.)

    3) Just inline everything.

    In any case we also need a small dependency tracker so that

    we can decide what definitions get broken when a definition

    that they inline gets changed.

    Any thoughts, anyone?  Do Forth compilers inline?  What

    about dependency tracking?

    --

    There is / one art             || John Cowan <jcowan@...>

    no more / no less              || http://www.reutershealth.com

    to do / all things             || http://www.ccil.org/~cowan

    with art- / lessness           \\ -- Piet Hein

## Mark van Gulik — 2001-05-05 23:55:21

    If you do choose to use "(" and ")" for grouping disjuncts, I suggest that

    fail be the special case "()".  Think of it as zero disjuncts, and hence

    impossible to satisfy.

    -Mark

## Manfred von Thun — 2001-05-08 01:56:58

    On Sat, 5 May 2001, Mark van Gulik wrote:

     > If you do choose to use "(" and ")" for grouping disjuncts, I suggest that

    > fail be the special case "()".  Think of it as zero disjuncts, and hence

    > impossible to satisfy.

     Nice idea -- at least if disjunction is the only other binary

    operator apart from (the implicit) concatenation (operator).

    Otherwise there is bound to be trouble. Also, the use of

    parentheses to override precedences is the only use (apart

    from the four others in, say Pascal, and the Lisp/Scheme use)

    where  (..)  is entirely equivalent to ((..))  .

      - Manfred