Note that that first "gotcha" can be reversed in contexts where it's a
problem and not a feature. This might also be desirable when dealing
with large nouns.
The pattern is: ". bind 'name'
When you use (". bind 'name') you are using a verb whose result is
always the value of that name. (The verb has infinite rank and always
ignores any argument(s).)
Thanks,
--
Raul
On Sun, Oct 1, 2017 at 9:43 AM, Don Guinn <[email protected]> wrote:
> Tacit expressions are really quite simple. They are different from
> non-tacit expressions only by three simple rules. The fork, hook and chain
> rule. Tacit expressions are identified by the absence of arguments included
> in the expression. They are explained thoroughly in help, so there is no
> sense in revisiting that. But these rules only affect how multiple verbs
> interact. The modifiers, i.e. adverbs and conjunctions work identically in
> tacit and non-tacit expressions. It is the modifiers that give much of the
> power to J.
>
> People writing tacit tend to use modifiers a lot. They provide tremendous
> flexibility in writing concise, compact code. Many find it unreadable.
> Modifiers are used less in non-tacit expressions. Why I don't know. But
> they could be used a lot more than they are in non-tacit expressions.
> Perhaps as people learn the power of modifiers they tend to write more
> tacit expressions.
>
> Some think that nouns cannot appear in tacit expressions. That is untrue.
> They can be attached to verbs in tacit expressions, only not as arguments
> to the entire expression.
>
> Notice that I refer to tacit and non-tacit expressions. That is because
> they can be mixed in definitions. Explicit definitions can contain a
> mixture of tacit and non-tacit expressions, even on a line of code. Tacit
> definitions can contain explicit definitions as well.
>
> There are some gotchas in tacit.
>
> Tacit definitions use the values of nouns and user definitions at the time
> of definition. Not the time of use. Say you use a noun named "abc" in a
> tacit definition. Then later change the value of "abc" and use the tacit
> definition. Oops! The definition still has the old value of "abc".
>
> Modifiers do not change how they work between tacit and non-tacit, but when
> combined with verbs they define new verbs. Those new verbs now follow the
> three rules of tacit. It looks like the modifiers are working differently,
> but it is the new verb that is actually working differently.
>
> Tacit expressions can contain tacit expressions. When this happens it can
> be a bit confusing figuring out what the arguments to the contained
> expression are.
>
> Using very large nouns in a tacit definition can result in very large
> definitions causing memory problems as the noun is copied into the
> definition. This can cause problems, but it has interesting possibilities
> for performance. Consider using (i.) inside a (for.) loop in an explicit
> definition. Make a local tacit definition before the loop attaching the
> huge noun to (i.) like this: (search=.hugenoun&i.). Then use (search) in
> the loop. The overhead of preparing the search, including possibly building
> a hash table is outside the loop. And the huge definition goes away when
> the explicit definition completes.
>
> There are interesting possibilities when one considers using explicit verb
> definitions in a tacit expression. Now you have a chance to do all those
> naughty tricks like saving intermediate results to global names.
>
> To me it's not tacit that causes so many problems, it is the tremendous
> flexibility provided by modifiers that provide a richness, complexity and
> power to J.
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
