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
