Representation
An Implementation of J
Atomic Representation
Boxed Representation
Tree Representation
Linear Representation
Atomic Representation
5!:1 is a verb that applies to a boxed name, and produces the atomic representation of the named object. Gerunds (results of the ` conjunction) are arrays of atomic representations. The adverb 5!:0 defines an object from its representation.
The atomic representation is a boxed list of two boxes:
noun symbol value verb symbol arguments dverb symbol arguments conjunction symbol arguments
The symbol is a string computed by function spellout in file ws.c. For a primitive with an assigned symbol (for example + or /.), the symbol is simply that word; for those without, the symbol is one of the following:
'0' noun '2' hook '3' fork '4' bonded conjunction '5' 2-element a-train or c-train '6' 3-element a-train or c-train
The "value" in the representation of a noun is just the noun itself; arguments in the representation of a verb, adverb, or conjunction are themselves atomic representations. If an object is uniquely identified by the symbol alone, then the second box is elided, and the representation is the boxed symbol alone.
The following examples illustrate atomic representation:
ar=: 5!:1
plus=: + sum=: +/ mean=: +/ % #
ar <'plus' ar <'sum' ar <'mean'
┌─┐ ┌───────┐ ┌─────────────────┐
│+│ │┌─┬───┐│ │┌─┬─────────────┐│
└─┘ ││/│┌─┐││ ││3│┌───────┬─┬─┐││
││ ││+│││ ││ ││┌─┬───┐│%│#│││
││ │└─┘││ ││ │││/│┌─┐││ │ │││
│└─┴───┘│ ││ │││ ││+│││ │ │││
└───────┘ ││ │││ │└─┘││ │ │││
││ ││└─┴───┘│ │ │││
││ │└───────┴─┴─┘││
│└─┴─────────────┘│
└─────────────────┘
+`(+/)`(+/ % #)
┌─┬───────┬─────────────────┐
│+│┌─┬───┐│┌─┬─────────────┐│
│ ││/│┌─┐│││3│┌───────┬─┬─┐││
│ ││ ││+││││ ││┌─┬───┐│%│#│││
│ ││ │└─┘│││ │││/│┌─┐││ │ │││
│ │└─┴───┘││ │││ ││+│││ │ │││
│ │ ││ │││ │└─┘││ │ │││
│ │ ││ ││└─┴───┘│ │ │││
│ │ ││ │└───────┴─┴─┘││
│ │ │└─┴─────────────┘│
└─┴───────┴─────────────────┘
a=: 5 xenos=: !:
ar <'a' ar <'xenos' ar <'ar'
┌─────┐ ┌──┐ ┌──────────────────┐
│┌─┬─┐│ │!:│ │┌──┬─────────────┐│
││0│5││ └──┘ ││!:│┌─────┬─────┐││
│└─┴─┘│ ││ ││┌─┬─┐│┌─┬─┐│││
└─────┘ ││ │││0│5│││0│1││││
││ ││└─┴─┘│└─┴─┘│││
││ │└─────┴─────┘││
│└──┴─────────────┘│
└──────────────────┘
lgamma=: ^.@!@<:
ar <'lgamma'
┌───────────────────┐
│┌─┬───────────────┐│
││@│┌──────────┬──┐││
││ ││┌─┬──────┐│<:│││
││ │││@│┌──┬─┐││ │││
││ │││ ││^.│!│││ │││
││ │││ │└──┴─┘││ │││
││ ││└─┴──────┘│ │││
││ │└──────────┴──┘││
│└─┴───────────────┘│
└───────────────────┘
Boxed Representation
5!:2 is a verb that applies to a boxed name, and produces the boxed representation of the named object. The representation can be modelled as follows:
ar =: 5!:1
boxed =: 32&=@(3!:0)
oarg =: >@(1&{)
bxroot =: (<1 0)&C.@,`] @. (e.&(,&.>'0123456789')@[)
bxx =: {. bxroot bx&.>@oarg
bxgl =: {. bxroot (bxx&.>@{. , bx &.>@}.)@oarg
bxgr =: {. bxroot (bx &.>@{. , bxx&.>@}.)@oarg
bxg =: bxgr`bxgl`bxx @. (i.&(<,'`')@oarg)
bxtil =: bxx`(oarg@>@{.@oarg) @. ((<,'0')&=@{.@>@{.@oarg)
bxcase =: oarg`bxgl`bxgl`bxg`bxtil`bxx @. ((;:'0@.`:4~')&i.@{.)
bx =: ]`bxcase @. boxed
brep =: ,@<`[ @. boxed @ bx @ > @ ar
brep <'brep'
┌───────────────────────────────────┬─┬──┐
│┌─────────────────────────────┬─┬─┐│@│ar│
││┌──────────────────────┬─┬──┐│@│>││ │ │
│││┌───────────┬──┬─────┐│@│bx││ │ ││ │ │
││││┌───────┬─┐│@.│boxed││ │ ││ │ ││ │ │
│││││┌─┬─┬─┐│[││ │ ││ │ ││ │ ││ │ │
││││││,│@│<││ ││ │ ││ │ ││ │ ││ │ │
│││││└─┴─┴─┘│ ││ │ ││ │ ││ │ ││ │ │
││││└───────┴─┘│ │ ││ │ ││ │ ││ │ │
│││└───────────┴──┴─────┘│ │ ││ │ ││ │ │
││└──────────────────────┴─┴──┘│ │ ││ │ │
│└─────────────────────────────┴─┴─┘│ │ │
└───────────────────────────────────┴─┴──┘The model is divided into groups of verbs. The first group are utilities:
ar atomic representation boxed 1 if boxed oarg open the second element of the list argument
bxroot produces an infix representation from a root r and its list of arguments a. If r is a digit, it denotes a primitive without an assigned word (e.g. '3' denotes a fork; see Atomic Representation), and the result of bxroot is a; otherwise, r bxroot a produces:
a,r if one argument
({.a),r,(}.a) if two arguments
r if no arguments (primitive)The other verbs named with the bx prefix apply to the opened atomic representation, and embody logic to effect "nice" displays for various special cases. The agenda items in bxcase are:
ID Agenda 0 oarg noun (leaf) @. bxgl gerundial left subtree `: bxgl gerundial left subtree 4 bxg bonded conjunction; gerundial left or right subtree ~ bxtil possible instance of evoke other bxx none of the above
brep is a model of 5!:2.
Tree Representation
5!:4 is a verb that applies to a boxed name, and produces a literal table of the tree representation of the named object. Thus:
tree=: connect @ > @ (,.&.>/) @ ('0'&root ; ]) @ (tr@>@ar)
5!:4 <'tree'
┌─ connect
┌─ @ ─┴─ >
┌─ @ ─┤ ┌─ ,.
│ └─ / ─── &. ────┴─ >
│
┌─ @ ─┤ ┌─ '0'
│ │ ┌─ & ─┴─ root
│ └─────┼─ ;
│ └─ ]
── @ ─┤
│ ┌─ tr
│ ┌─ @ ─┴─ >
└─ @ ─┴─ ar The tree representation can be modelled as follows:
ar =: 5!:1
lr =: 3 : '5!:5 <''y.'''
boxed =: 32&= @ (3!:0)
mt =: 0&e.@$
oarg =: >@(1&{)
shr =: |.!.''
shl =: 1&(|.!.'')
mat =: (1 1&}.)@(_1 _1&}.)@":@<
boxc =: {. 9!:6 ''
dash =: 10{boxc
extent =: (+./\ *. +./\.) @ (' '&~:) @: ({."1)
limb1 =: 1&|.@$ 1&~: }. (10 6 0{boxc)&,@($&(9{boxc))
limb =: -@(i.&1)@[ |. #@[ {. limb1@]
pfx =: (limb +/)@extent ,. ]
pad =: [ {. ] ,. dash&=@({:"1)@] { ' '&,:@($&dash)@(-&{: $)
take =: pad`($&' '@[) @. (mt@])
rc =: #@>@{."1 ; >./@:({:@$@>)
kernt =: (0{boxc)&=@shl@[ *. ' '&~:@]
kernb =: (6{boxc)&=@] *. ' '&~:@shl@[
kern =: (<0 0)&{&>"2 (kernt +./"1@:+. kernb) (<_1 0)&{&>"2
gap =: ,&.>"_1 {&((0 1$' ');1 1$' ')@kern
graft =: (pfx&.>@{. 0} ]) @ (,&.>/) @ gap @ ({@rc take&.> ])
lab =: ,: @ (2&|.) @ ((' ',dash,dash,' ')&,)
label =: lab`((,.dash)&[) @. (e.&'0123456789'@{.)
center =: ((i.&1) -@+ <.@-:@(+/))@] |. #@] {. [
root =: label@[ center extent@>@{.@]
leaf =: ,@<@(((,:dash,' ')&[ center $&1@#) ,. ])@mat@":
trx =: >@{. (root ; ]) graft@:(tr@>)@oarg
trgl =: >@{. (root ; ]) graft@:(trx@>@{. , tr @>@}.)@oarg
trgr =: >@{. (root ; ]) graft@:(tr @>@{. , trx@>@}.)@oarg
trg =: trgr`trgl`trx @. (i.&(<,'`')@oarg)
trtil =: trx`(leaf@oarg@>@{.@oarg) @. ((<,'0')&=@{.@>@{.@oarg)
trnoun =: leaf @ lr @ oarg
trcase =: trnoun`trgl`trgl`trg`trtil`trx @. ((;:'0@.`:4~')&i.@{.)
tr =: leaf`trcase @. boxed
rep =: [. & (((# i.@#)@,@) (@])})
right =: (5{boxc) rep (e.&(9{boxc) *. shr"1@(e.&dash))
cross =: (4{boxc) rep (e.&(5{boxc) *. shl"1@(e.&dash))
left =: (3{boxc) rep (e.&(9{boxc) *. shl"1@(e.&dash))
bot =: (7{boxc) rep (e.&(6{boxc) *. shr"1@(e.&dash))
connect =: bot @ left @ cross @ right
tree =: connect @ > @ (,.&.>/) @ ('0'&root ; ]) @ (tr@>@ar)The model is divided into groups of definitions (which are verbs unless indicated otherwise). The first group are utilities:
ar atomic representation
boxed 1 if boxed
mt 1 if empty
oarg open the second element of the list argument
shr shift right
shl shift left
mat a literal matrix image of the argument
boxc (noun) box drawing characters
dash (noun) the "dash" in the set of box drawing charactersA "generational tree" (GT) is a list of boxed literal tables having the same number of rows, such that nodes at the same depth are in the same box. For example, the GT for tree is:
┌──────┬──────┬──────┬──────┬──────────┬─────┐ │ │ │ │ │┌─ connect│ │ │ │ │ │┌─ @ ─│└─ > │ │ │ │ │┌─ @ ─││ │ │┌─ ,.│ │ │ ││ │└─ / ─│── &. ────│└─ > │ │ │ ││ │ │ │ │ │ │┌─ @ ─││ │ │┌─ '0' │ │ │ ││ ││ │┌─ & ─│└─ root │ │ │ ││ │└─────││─ ; │ │ │ │ ││ │ │└─ ] │ │ │ │── @ ─││ │ │ │ │ │ │ ││ │ │┌─ tr │ │ │ │ ││ │┌─ @ ─│└─ > │ │ │ │ │└─ @ ─│└─ ar │ │ │ │ └──────┴──────┴──────┴──────┴──────────┴─────┘
graft is the main verb in the next group. The argument is a table whose rows are GTs for the nodes at the same depth. The result is a GT.
root accepts a string left argument and a GT right argument. The result is a literal matrix with the string centered relative to the GT.
leaf computes a unitary (single-element) GT from its argument.
tr applies to the opened atomic representation of an object and produces a GT. The verbs named with the tr prefix embody logic to effect "nice" displays for various special cases. The agenda items in trcase are:
ID Agenda 0 leaf@oarg noun (leaf) @. trgl gerundial left subtree `: trgl gerundial left subtree 4 trg bonded conjunction; gerund left or right ~ trtil possible instance of evoke other trx none of the above
rep is a conjunction whose left argument is a single literal c and whose right argument is a proposition p, deriving a verb such that the phrase c rep p y replaces with c the positions in y marked by p y. connect substitutes ┴ (bot), ├ (left), ┼ (cross), and ┤ (right) at nexuses of the tree.
tree is a model of 5!:4.
Linear Representation
5!:5 is a verb that applies to a boxed name, and produces a literal list of the linear representation of the named object. Thus:
lrep=: lr @ > @ ar 5!:5 <'lrep' lr@>@ar $ 5!:5 <'lrep' 7
The linear representation can be modelled as follows:
ar =: 5!:1
boxed =: 32&= @ (3!:0)
oarg =: >@(1&{)
mtv =: i.@0:
paren =: ('('&,)@(,&')')
symb =: $&' '@(e.&'.:')@{. , ]
quote =: ''''
alp =: (,65 97+/i.26){a.
dig =: '0123456789'
slist =: $&','@(1&=)
shape =: mtv`slist`(,&'$'@":)@.(2&<.@#)`('i.'&,@":) @. (0&e.) @ $
vchar =: >:@(quote&=)@, quote&,@(,"e)@# ,
vbox =: }. @ ; @: (','&,@paren@('<'&,)@lnoun&.>)
value =: vchar`vbox`(":!.18@,) @. (2 32&i.@(type * *@(*/)@$))
lnoun =: shape , value
dotco =: 2&=@# *. e.&'.:'@{:
name =: e.&alp@{. *. *./@(e.&(alp,dig,'_'))@}: *. e.&(alp,dig,'_.:')@{:
num =: e.&(dig,'_')@{. *. *./@(e.&(dig,'_ .ejdr'))
qstr =: mtv -: -.@(~:/\)@(e."e) -."e@# ]
pstr =: -.@(0&e.)@}:@(+/\)@({&1 _1 0)@('()'&i.)
nopar =: 1&=@# +. dotco +. name +. num +. qstr +. pstr
cp =: paren`] @. nopar
bp =: ]`cp@.(' '&e.)
hfork =: }.@;@:(' '&,@bp&.>)@]
left =: bp@>@{.
right =: mtv`(cp@>@{:)@.(1&<@#)
ins =: left@] , symb@>@[ , right@]
act =: ;@:(cp&.>)@]
insert =: hfork`hfork`act`act`act`ins @. ('23456'&i.@{.@>@[)
lx =: {. insert lr&.>@oarg
ltie =: lr`(}.@;@:('`'&,@cp@lr&.>)@oarg) @. ((<,'0')&=@{.)
lgl =: {. insert (ltie&.>@{. , lr &.>@}.)@oarg
lgr =: {. insert (lr &.>@{. , ltie&.>@}.)@oarg
lg =: lgr`lgl`lx @. (i.&(<,'`')@oarg)
ltil =: lx`(oarg@>@{.@oarg) @. ((<,'0')&=@{.@>@{.@oarg)
lcase =: (cp@lnoun@oarg)`lgl`lgl`lg`ltil`lx @. ((;:'0@.`:4~')&i.@{.)
lr =: symb`lcase@.boxed
lrep =: lr @ > @ arNext • Previous • Index • Table of Contents