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
