Pascal, I could not reply sooner but the following is a quick comment... > h is interesting. But I would reverse argument, and use scalars rather than "codes" for the argument to }
My motivation for the name of the conjunction h (as a shorthand for hold) and the order of the arguments was to use it as a tacit counterpart of the local copula (=.). As I mentioned in a reply to Raul (posted after your post) my version of h handles both, proverbs (codes) and indices (scalars). These utilities, together with another one (named local), not only allow one to write any verb tacitly (in principle) but also facilitates the transcription of explicit verbs into tacit verbs. I intend to write another post later, entertaining an example, in the Chat Forum since that involves the use of the Tacit Toolkit that requires j807 or other earlier versions of the interpreter. (Just in case, a subscription is not necessary to access the posts of any forum, one can just use the search page Forum Search (jsoftware.com) <https://www.jsoftware.com/forumsearch.htm>. Moreover, just clicking the search button will produce the links to all the posts of all the forums listed in reverse chronological order.) On Wed, Sep 15, 2021 at 2:48 PM 'Pascal Jasmin' via Programming < programm...@jsoftware.com> wrote: > > A framework with G =: (&{::)(@]) > > and G0 G1 G2 defined as 0 G, 1 G, 2 G > > has the readability advantage of G0 being a fork term that looks like and is a verb, while 0 G requires pre-knowledge by the reader that G is an adverb. > > Your f (multiple arguments to G but with { instead of {::) can be constructed easily with (G0 ; G1) or if they could be joined unboxed (G0 , G1) > > h is interesting. But I would reverse argument, and use scalars rather than "codes" for the argument to } > > h =: 2 : '<@:u v} ]' NB. version where verb determines boxing may be preferred/useful option. > > > (B +/ .* D) h 2 > <@:(B +/ .* D) 2} ] > > > > Some other useful utility approaches > > MakeGs =: 1 : 'for_i. (i. m) do. (''G'' ,&": i) =: i G end.' > > 5 MakeGs > > G2 > > 2&({::)@] > > and then friendly fieldname accessors can also be generated in similar way > > accessors =: 1 : 'for_i. (;: m) ([ ,. <"0@]) (i. # ;: m) do. (, G0 i ) =: (G1 i) G end.' > > 'A B C D E' accessors > > which with longer names might help document code and structure of y. > > > 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
