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
