> … and “Wicked J”, thanks to you.
> ...
> (si tacuisses philosophus mansisses)
... and Latin. :)
(A former colleague, well versed in Latin, once told me that thinking in
Latin compels one to think more clearly. I had not realized that this
phenomenon was applicable not only to some artificial languages (or
dialects) but also to certain natural languages.)
On Thu, Sep 16, 2021 at 4:48 AM Hauke Rehr <hauke.r...@uni-jena.de> wrote:
>
> … 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
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
