0 1 { i. 6

0 1

(<<0 1) { i. 6

0 1

Answer: the results are identical, but because the left rank of dyad { is 0, 0 1 { y applies dyad { twice, once for each atom of 0 1, and collects the results into an array, while (<<0 1) { y applies dyad { just once. The code for dyad { handles unboxed x efficiently, so which form you use is a matter of convenience.

Split String Into J Words: Monad ;:

Monad ;: splits a string of characters into J words, putting each word into a box of its own. Each word is a list of characters, so the result of monad ;: is a list of boxed lists:

;: 'Words, words; and more words.' +-----+-+-----+-+---+----+------+ |Words|,|words|;|and|more|words.| +-----+-+-----+-+---+----+------+

Monad ;: is a handy way to get boxed character strings, or to break an input stream into words if your language has word-formation rules similar to J's. Be aware that if the operand has an unmatched quote, monad ;: will fail.

Fetch From Structure: Dyad {::

Dyad {:: (this is a single primitive) has left rank 1, right rank infinite. It selects an atom from an array of boxes and opens it; it is therefore analogous to the . (class member) operator in C:

1 {:: 'abc';1 2 3; i. 2 2

1 2 3

Item 1 was selected and opened.

x {:: y can go through multiple levels of structure referencing at once. If x is a list of boxes, the first box must be a valid left argument to dyad {; it is used to select an item of y, which is then opened; the next box of x selects an item from that opened box of y, which item is then opened; and so on till x is exhausted:

Here we have a structure in which item 1 is another structure.

107

1 {:: struct2 +---+-----+ |abc|1 2 3| +---+-----+

We select and open item 1, resulting in the enclosed structure.

(1;1) {:: struct2 1 2 3

We select and open item 1 of struct2, and then open item 1 of the enclosed structure.

(1;<<1 0) {:: struct2 +-----+---+

|1 2 3|abc| +-----+---+

If the last selection specifies a list of items, as in this example, the selected boxes are not opened. Note that the Dictionary's description of dyad {:: incorrectly indicates that the boxes are opened.

(1;<<,1) {:: struct2 +-----+ |1 2 3| +-----+

Even if the list contains only one item, it is not opened.

Only the last box of x may specify selection of a list of boxes:

]a =. <"0 i. 3 3 +-+-+-+ |0|1|2| +-+-+-+ |3|4|5| +-+-+-+ |6|7|8| +-+-+-+

a is a 3×3 array of boxes.

(1;1) {:: a |rank error

| (1;1) {::a

The first selection took item 1 of a . This was a 3-item list of boxes, and it is inadmissible to open the list and perform further selections.

Note that if x is unboxed, dyad {:: first boxes it and then uses it for selection. The Dictionary's description does not mention the boxing step.

Note also that 0 {:: y is not allowed if y is a scalar. > 0 { y may be used instead.

Report Boxing Level: Monad L.

Monad L. has infinite rank and tells you the boxing level of its operand. Boxing level is defined recursively: if y is unboxed or empty, its boxing level is 0; otherwise its boxing level is one greater than the maximum of the boxing levels of its opened items:

108

1 ;< 2 ;< 3 ;< 4

| ||2|+-+-+||

| || ||3|4|||

L. 1 ;< 2 ;< 3 ;< 4

3

L. {. 1 ;< 2 ;< 3 ;< 4

1

You can use monad L. to decide how many levels of boxing to remove:

>^:L. <<<6

6

Note that an empty boxed list shows boxing level of 0, but the type revealed by 3!:0 is 'boxed'. Also, fill elements for an empty boxed list are the boxed fill element a: :

L. 0$a:

0

3!:0 (0$a:)

32

3 {. 0$a:

++++

||||

++++

109