On Wed, Aug 29, 2012 at 4:04 AM, Linda Alvord <lindaalv...@verizon.net> wrote:
> My question is from an earlier version:
>
> 1j1#"1&|:(25{.(u:,2#65 97+/i.26)(>:@i.}.[)])"0 'L'
> M N O P Q R S T U V W X Y Z A B C D E F G H I J K
>
> In this phrase, what does the identity [ stand for?
>
> >:@i.}.[
First off... "stand for" itself has several potential meanings. It
could be that you are asking "what is the definition of the verb". It
could also mean that you are asking "what is the result of the verb".
Anyways, to answer this question, I'm going to go through the sort of
steps I might go through, if I was trying to understand it from
scratch. Some of this will be issues you already know, but at some
point before the actual answer appears I think some relevant issues
should appear for you.
Anyways, we should probably first remove the lefthand part of that expression.
In other words,
1j1#"1&|:(25{.(u:,2#65 97+/i.26)(>:@i.}.[)])"0 'L'
M N O P Q R S T U V W X Y Z A B C D E F G H I J K
has an intermediate result
(25{.(u:,2#65 97+/i.26)(>:@i.}.[)])"0 'L'
MNOPQRSTUVWXYZABCDEFGHIJK
Also, since 'L' is just a single letter, we can remove the "0 without
altering the result:
(25{.(u:,2#65 97+/i.26)(>:@i.}.[)]) 'L'
MNOPQRSTUVWXYZABCDEFGHIJK
At this point, we have a long train that we are dealing with --
syntactically, it's a nested sequence of forks. I'll space them out,
so that this aspect is clear:
(25 {. (u:,2#65 97+/i.26) (>:@i.}.[) ])
The odd verbs (counting from the right, but since it's all forks it
doesn't matter if we count from the right or the left) get the noun
arguments. So:
25 -- is just itself
(u:,2#65 97+/i.26) -- is the two alphabets
] -- is the letter 'L'
This leaves us with:
25 {. alphabets (>:@i.}.[) 'L'
So we know that the left argument for (>:@i.}.[) will be our alphabets
and the right argument will be the letter 'L'
So, now let's look at (>:@i.}.[) -- if we have linear representation
turned on (for displaying things like verbs), the interpreter does a
nice job of spacing this out:
(>:@i.}.[)
>:@i. }. [
So, it's a fork.
And, since it has two arguments, the definition used for [ will be the
dyadic definition.
In other words, its result will be the two alphabets: u:,2#65 97+/i.26)
I can think of several potential sources of misdirection, which might
have lead you to believe it was an 'L':
First, [ was in close proximity to a ] which did get the value 'L'
Second, since the whole thing was smashed together (since we are
trying to keep character count down) your eyes might have thought that
(>:@i.}.[) was a hook.
Third, you might have been thinking that the context surrounding
(>:@i.}.[) was a hook (or you might have not gotten to the point where
you realized that (>:@i.}.[) itself was an even verb in a fork) which
would suggest that you would be using (>:@i.}.[)'s monadic definition.
(And, of course, you might have been thinking something else. The
above mistakes are the kinds of mistakes I can imagine myself making,
but there's no requirement that you think like I do.)
Anyways, I hope that you can see enough about the process you were
using to be comfortable about how you would approach a similar issue
in the future.
Or: I hope this helps,
--
Raul
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
