“shifted upper row” for those who use a keyboard
the design of which is optimized to being able
to write the word “typewriter” on that very row
and optimized to not be too fast to type on so the
typebars don’t get entangled … yes, we certainly
have that problem with computers; and no, we don’t
want to type fast, let alone healthily (ergonomics)
I have all of these on one layer [1]:
…_[]^ !<>=&
\/{}* ?()-:@ (home row)
#$|~` +%"';
so I don’t ever need to switch layers when writing
+:(]:@)
only two of which I have to leave the home row for
the language mustn’t be blamed for badly designed hardware
and you can always just
setxkbmap yourfavoritelayout
on a compliant system
No, the actual characters hardly matter.
(Written using NEO [1] on an Ergodox [2])
[1] neo-layout.org
[2] ergodox-ez.com
Am 04.10.21 um 21:43 schrieb 'Pascal Jasmin' via Programming:
Going to use reply to Pepe as a case for changing trains before its too late
(ie before they get used)
hook=. `(`:6) NB. (Equivalently, hook=. ``:6)
This is an excellent contribution that shows the CC hook (defined as duplicate
arguments: (u C1 v)(u C2 v) offers no benefits.
The only imaginable cases so far is to produce a hook, or to return (u n) or (v
m) to caller context.
the only possible use of u n over u y (which would occur without the CC) is
that it is possible to bind u or n partially in an expression, or if u n
returns a verb or modifier. There is no natural u which can legally do the
former.
It is possible to create a conjunction that replaces ` such that will accept
nouns or verbs as its arguments and produce gerunds. Without full definition,
my version is:
ti =: 2 : 0
if. -. u isgerundA do. u =. u ar end.
if. -. v isgerundA do. v =. v ar end.
u,v
)
a different conjunction is possible/needed if it is to allow quoted modifiers
to have their atomic representation included.
with h. =: ti`:6
with u ti n `:6 not legally capable of forming a verb or modifier, it is still
possible to create that functionality with u n producing a string, and
h.(1 :)
could then be used to turn that future string computation into an adverb.
C C -> ((u C1 v)C2)
has benefits compared to using workarounds... Benefits > no benefits.
In the case of A C -> adv: u A (C u)
the only "mainstream" benefit is the ability to make a conjunction "reflexive"
(]: C)
theoretical completeness aside, this is not a huge programming application,
though if you knew a different way to provide this in a quoteless manner, that
would be best to eliminate all benefits.
Even if some possiblity is created, benefits are inferior compared to this AC
definition:
A C -> u A (C v)
similar to A C A of A C ]:
The annoyance of A C A pattern is that (A A) C A must be explicit to have a
sane interpretation. More parentheses means more tedious annoyances in
writting code, and avoiding tedious annoyances is a benefit.
My total vision for the trains is that it is higher value to have auto
"pairing"/parenthesizing of "free" u and v's near Cs, than the general minimal
benefits that exist from the trains, although I will also support the explicit triple parenthesing
of as one example (V V C) as superceding the auto-pairing rules.
But forcing AA...A trains to now be parenthesized sometimes is a major tedium
downgrade compared to previous versions of J.
So, for sure I will always hate AC and CC if they persist past beta.
Reflexive conjunctions don't have the same mathematical symmetry of applying
well understood model/concepts of doubling, squaring, 0 and 1 which are so well
understood that they have their own primitives instead of using reflexive
forms. If you know you want a reflexive conjunction application, then you can
be forced into the tedious repetition of uACu or uCu.
Even though each potential implementation of AC creates tedium in some
applications, it is far more tedious to parenthesize many future AA trains then
to provide duplicate conjunction parameters which no built in conjunctions have
any meaningful conceptual frameworks for. Exception example:
quadruple =: +:(]:@) NB. requires 2 more "shifted upper row" typing characters
than +:@+. Reading requires looking up the never used (]:C) pattern.
--
----------------------
mail written using NEO
neo-layout.org
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
