… and “Wicked J”, thanks to you.
I had written a long reply but you’re right:
sometimes it’s better not to ask questions
(si tacuisses philosophus mansisses)
Hauke
[
still I can’t help but write a comment:
Let’s hope for both English and J not to share
the fate of German being “simplified” by crimes
such as the German “spelling reform” driving us
into an Orwellian society (yes, an exaggeration,
but not as much of one as you might think).
]
Am 16.09.21 um 00:03 schrieb Jose Mario Quintana:
Neat! There are always opportunities to learn J (and English) in this
forum.
Thanks
On Wed, Sep 15, 2021 at 5:40 PM Raul Miller <rauldmil...@gmail.com> wrote:
Belatedly, I realized that I could have shortened that to:
mne=: {{)a
".@(('{:]`',[,'=:',],'&{::'"_)&":&>i.@#);:'()'-.~5!:5 <'u'
}}
Thanks,
--
Raul
On Wed, Sep 15, 2021 at 5:38 PM Raul Miller <rauldmil...@gmail.com> wrote:
I am not sure how you got your gerunds to display the linear rep of
the verb. For me, the gerund display always shows the atomic rep of
verbs. Is this a personal mod to your version of J?
But, anyways, here's an explicit version of mne which returns the
corresponding gerund:
mne=: {{)a
,".@(('}.]`',[,'=:',],'&{::'"_)&":&>i.@#);:'()'-.~5!:5 <'u'
}}
Thanks,
--
Raul
On Wed, Sep 15, 2021 at 5:27 PM Jose Mario Quintana
<jose.mario.quint...@gmail.com> wrote:
You might prefer your definitions to be
1&{::@]
This allows intuitive dyadic use case for y, and allows B~ to access
x
argument fields.
I seldom have to refer precisely to the left or right arguments when
using
pointer proverbs because I use them typically just to sequentially
update a
state when writing complex tacit verbs. However, sporadically I have
done
that and I just redefine the suitable pointer proverbs as I go using
the
result of mne (see my comment to Raul's post). For example, since
(Y V N)mne
┌───────┬───────┬───────┐
│0&({::)│1&({::)│2&({::)│
└───────┴───────┴───────┘
I can write,
(Y`V`N)=. (Y V N)mne at&.> ]<adv
Y
0&({::)@:]
V
1&({::)@:]
N
2&({::)@:]
Similarly,
(X`U`M)=. (X U M)mne at&.> [<adv
X
0&({::)@:[
M
2&({::)@:[
(The functionality of adv and at is the same as those in the j807 Tacit
Toolkit; namely, <adv boxes its argument, even if it is a verb, and at
is
@: verbed)
Something equivalent could be done legally if mne returns the
corresponding
gerund. Perhaps Raul, you, or someone else can show us how this can be
accomplished. (A long long time ago it would have been very very easy
(sometimes it is better not to ask questions ;)
[Jprogramming] @'' (jsoftware.com)
<
http://www.jsoftware.com/pipermail/programming/2006-October/003568.html>
nevertheless, Dan's DOOG [0],
User:Dan Bron/Snippets/DOOG - J Wiki (jsoftware.com)
<https://code.jsoftware.com/wiki/User:Dan_Bron/Snippets/DOOG>
or similar could become handy)
On Wed, Sep 15, 2021 at 8:25 AM 'Pascal Jasmin' via Programming <
programm...@jsoftware.com> wrote:
Perhaps one should consider that, rightly or otherwise, 0.
currently
has a
meaning according to the interpreters (e.g., j902),
Not that long ago, it used to give an error. Never noticed the
change.
A problem that comes up enough to be annoying when defining 3.. or
other
. : inflections to numbers is that
;: '3.. 2'
┌─────┐
│3.. 2│
└─────┘
subsequent numbers is the same word.
Avoiding this problem, is a pretty easy change to ;: parser, and
costs
"nothing" when 3. is a J error, but when 3. was previously valid code,
can
create new problems. Still worth the change for me (as a dsl) though.
You might prefer your definitions to be
1&{::@]
This allows intuitive dyadic use case for y, and allows B~ to access
x
argument fields.
On Tuesday, September 14, 2021, 07:31:21 p.m. EDT, Jose Mario
Quintana <
jose.mario.quint...@gmail.com> wrote:
0. to 9. and/or _9. would make good additions to language.
Perhaps one should consider that, rightly or otherwise, 0. currently
has a
meaning according to the interpreters (e.g., j902),
0.
0
Often I use an adverb (mne) to define undefined names, or redefine
existing
proverbs, as pointers to fetch a corresponding content of a box
within a
state consisting of a list of boxes. For example,
(A B C D)mne
would, as a side effect, define A as 0&({::), ... D as 3&({::).
Thus,
C
2&({::)
Another adverb (f) allows one to use the proverbs to get multiple
boxes
from the state,
(B C)f
1 2&{
and a conjunction (h) allows one to amend the contents of the state
in
terms of the proverbs,
(A B) h ((B C)f)
1 2&{ 0 1} ]
or
C h (B +/ .* D)
<@:(B +/ .* D) 2} ]
The following illustrates their use,
( S=. 0 ; 1 2 ; '...' ; 1j1*(i.2 3) )
┌─┬───┬───┬───────────┐
│0│1 2│...│ 0 1j1 2j2│
│ │ │ │3j3 4j4 5j5│
└─┴───┴───┴───────────┘
C S
...
(B C)f S
┌───┬───┐
│1 2│...│
└───┴───┘
(A B) h ((B C)f) S
┌───┬───┬───┬───────────┐
│1 2│...│...│ 0 1j1 2j2│
│ │ │ │3j3 4j4 5j5│
└───┴───┴───┴───────────┘
C h (B +/ .* D) S
┌─┬───┬─────────────┬───────────┐
│0│1 2│6j6 9j9 12j12│ 0 1j1 2j2│
│ │ │ │3j3 4j4 5j5│
└─┴───┴─────────────┴───────────┘
I define tacitly mne, f, and h (moreover, mne f and h themselves are
tacit
entities) via the unorthodox methods using a fork of J which I have
mentioned in the past. However, I cannot see any reason why mne, f,
and h
could not be defined (explicitly, when necessary) using the latest
public
interpreters.
On Tue, Sep 14, 2021 at 1:18 PM 'Pascal Jasmin' via Programming <
programm...@jsoftware.com> wrote:
in jpp project,
I use 0. as shortcut for (0 {:: ]) and 1. as shortcut for (1 {:: ])
The adverb G =: 1 : 'u {:: ]' is the same.
0.~ or 0 G~ can be used to access fields of x argument.
"State of something complicated" can simply be several boxed
fields in x
or y argument.
What easy accessors do is also permits "intermediate tacit
results" by
prepending a calculated box to the y argument, with easy unpacking
later
in
the verb.
0. to 9. and/or _9. would make good additions to language.
On Tuesday, September 14, 2021, 12:06:37 p.m. EDT, Michal Wallace <
michal.wall...@gmail.com> wrote:
Let me amend what I was just saying about name:: ...
I have been experimenting with a tacit style where the y "argument"
represents the state of some big complicated object or system...
for
example, the state of a parser or a virtual machine.
I've found that "accessor" verbs are really handy, and allow you to
decouple your tacit code from the actual implementation of the
object.
An accessor 'gsn' (for "get/set 'n'") is a ambivalent verb that
works
like
this:
gsn y -> ignore y and return S
x gsn y -> ignore y. sets n to x and return S
S here indicates whatever the "state of the whole system" is...
'gsn' here is a pronoun (proverb?) -- If you had three state
variables
n0,n1,n2,
you would make three such verbs, gsn0, gsn1, gsn2.
This is quite flexible. If you want to store the state of your
system in
an
object or namespace,
you can implement gsn like so:
gsn0 =: {{ n0__state }} :: {{ n0__state =: x }}
Then the y argument you pass is just '' or whatever you want,
since it's
ignored.
Or you can choose to implement the state as some physical array
structure,
which gets accessed and modified in place:
gsn1 =: {{ 1 { y }} :: {{ x 1 } y }}
It would be nice if these accessors could be created automatically.
For example, (if we weren't about to be using the syntax for 'self
effacing
names', we might
use name:: to work as the accessor)... And then:
name:: y could:
- invoke name__y if y is a reference
- extract they value for key 'name' from y if y is some kind of
dictionary
- extract n { y if 'name' is defined as a constant number
x name:: y would do the analagous things for setting the value to
x.
Many object-oriented languages (python, C#, javascript) give you
the
ability to define such accessors either for specific names, *or* to
design
generic accessors that take the name as a parameter.
For example, in python, you can arrange for y.x = n to do any of
the
following:
1. explicitly set the x attribute of object y to n (no accessor
defined)
2. call a specific y.set_x(n) method
3. call a generic y.__setattr__(key='x', value=n) method
My proposal is that x name:: y would have similar range of
features,
depending on the presence of certain handler verbs in the implicit
locale
(if y -: '') or on y itself.
Likewise, 0:: 1:: _1:: etc could be recognized as 'index
accessors'
when y is an array.
If you wanted to get really crazy, then ( index ):: could produce
an
explicit accessor function, where index is some noun that could be
passed
as m in m { y.
This final form could perhaps even use the incredibly convenient
"subarray
notation" of x ;. 0 y , (which is an amazing "getter" but AFAICT,
has no
"setter" equivalent )
https://code.jsoftware.com/wiki/Vocabulary/semidot0#dyadic
Here is some example code (parser combinators) that uses the "y is
a
structure" concept, where the pattern makes it very handy to
implement
backtracking.
https://github.com/sabren/b4/blob/master/j/parseco.ijs
Here is another example (virtual machine) using the "y is ignored"
style,
where the accessors get and set locale variables.
https://github.com/sabren/b4/blob/master/j/b4.ijs
This one in particular uses the idea to partition the virtual
machine
instructions into two sections.
The "microcode" provides accessor functions that get and set
registers,
and
then
the "instruction set" is defined in terms of these operations.
This way I can decouple the instruction set from the actual
implementation
of the virtual machine's internals.
Right now it just stores registers and memory cells in separate
variables,
but an alternate implementation might instead store everything in
one
big
memory-mapped file, so the machine state could persist on disk or
be
shared
between different processes, and this would only require swapping
out
the
"microcode" layer.
Anyway, I know the syntax part of this is still a half-baked
proposal,
but
the actual idea is very usable now, and pretty fun to use.
----------------------------------------------------------------------
For information about J forums see
http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see
http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see
http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see
http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
--
----------------------
mail written using NEO
neo-layout.org
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
