From J Wiki
Jump to: navigation, search

Back to: Vocabulary


Modifiers take one or two operands, which can be nouns or verbs, and produce a derived verb.

Actually, a modifier may produce any part of speech, but almost all modifiers produce verbs.

An adverb takes one operand, which is the verb or noun to its left.

A conjunction takes two operands: the verb or noun on each side.

The left-hand operand to a modifier is called u, or m if it is known to be a noun. The right-hand operand to a conjunction is called v, or n if it is known to be a noun.

Grouping And Order Of Execution

Modifiers grab the entire verb-phrase/noun-phrase on the left for use as u. Conjunctions also take the single verb/noun to the right for v.

A verb or noun phrase starts with a verb or noun that is not preceded by a conjunction.

   2 * %: @ + / @: *: 1 2 3
start of phrases:
   2 * %: @ + / @: *: 1 2 3
   | | |              |
parenthesized version:
   2 * (((%: @ +)/)@:*:) 1 2 3

   2 * %: @ (+ /) @: *: 1 2 3
start of phrases:
   2 * %: @ (+ /) @: *: 1 2 3
   | | |     |          |
parenthesized version:
   2 * ((%: @ (+/))@:*:) 1 2 3

Modifier Execution: Creating The Derived Verb

Consider the sentence

   +/ 1 2 3

Two executions were performed. First, the adverb / was executed, with its u set to +, to produce an anonymous derived verb. Then, the anonymous verb was executed on the noun argument 1 2 3 to produce the result 6.

Executing A Modifier Produces A Derived Verb

We can understand what's going on if we split the process in two. We will first execute the adverb / to produce a derived verb, but we will give that verb a name. Then we will use the named verb:

   SumItems =: +/
   SumItems 1 2 3

The modifier / was executed when +/ was encountered. This produced a derived verb. Then this verb value was assigned to the name SumItems.

In the second sentence, SumItems calls up this verb value for execution.

Strictly speaking, executing the sentence

   SumItems 1 2 3

does not execute any modifiers. / was executed when SumItems was defined.

The derived verb is guaranteed to execute according to the definition of the modifier. For example, monadic +/ produces a derived verb that adds all the items of y. Many combinations of verbs and modifiers are recognized and implemented with customized derived verbs.

Displaying The Derived Verb

As with all names, you can display the value of a derived verb by typing the name as its own sentence:


The display doesn't tell whether the verb is supported by special code. It is simply a description of what the verb will do. Verbs with the same display can have difference performance.

Executing The Derived Verb

The derived verb is executed like any other verb. It has a verb rank for each argument, which controls how the argument is split into cells. The rank of the derived verb is part of the description of a modifier. Sometimes the rank depends on the operands of the modifier.

User-Defined Modifiers

The : conjunction can create modifiers as well as verbs. 1 : 0 will create an adverb, and 2 : 0 will create a conjunction. Assign the resulting derived modifier to a name so you can use it later.

Executing the derived modifier will produce a derived verb. The u (and v, for a conjunction), and the body of the derived modifier, will be saved as the derived verb.

When the derived verb is executed, the names u (and v, for a conjunction) are set with the values that were saved when the derived modifier was executed. If a u and v is a noun, the name m or n is also set. y (and x for a dyadic verb) are also set, and then the body of the derived verb is executed sentence by sentence.

   NB. Adverb.  u is applied to y and creates a Boolean list of elements to keep.
   NB. Result is the culled y
   usedtocull =: 1 : 0
(u y) # y
   NB. verb to cull numbers less than 0
   cullminus =: >:&0 usedtocull
   cullminus _2 _1 0 1 2
0 1 2
   >:&0 usedtocull _2 _1 0 1 2
0 1 2

There are three executions here. Executing : creates a derived adverb, which is assigned to the name usedtocull.

Then usedtocull is given the left operand >:&0. This produces a derived verb, which contains the body of usedtocull, and the saved u value of >:&0.

Finally, the derived verb is executed on a noun argument.