> (2097152 = 3!:0) is undocumented magic that detects a verb (phrase). Is
there any similar magic number that > would detect a string/ar
representation of modifiers?
Yes, I normally mask the standard library verb datatype (datatype_z_) with
this alternative version,
datatype=. (<;._1
'|boolean|literal|integer|floating|complex|boxed|extended|rational|sparse
boolean |sparse literal|sparse integer|sparse floating|sparse
complex|sparse boxed |symbol
|unicode|unicode4|?|?|verb|adverb|conjunction') >@{~ 1 2 4 8 16 32 64 128
1024 2048 4096 8192 16384 32768 65536 131072 262144 524288 1048576 2097152
4194304 8388608 i. 3!:0
Wrap=. -@:[ ]\ 5!:5@<@:]
66 Wrap 'datatype'
(<;._1 '|boolean|literal|integer|floating|complex|boxed|extended|r
ational|sparse boolean |sparse literal|sparse integer|sparse float
ing|sparse complex|sparse boxed |symbol |unicode|unicode4|?|?|verb
|adverb|conjunction') >@{~ 1 2 4 8 16 32 64 128 1024 2048 4096 819
2 16384 32768 65536 131072 262144 524288 1048576 2097152 4194304 8
388608 i. 3!:0
(changing what needs to be changed for early interpreters). ;)
So,
datatype 0j1
complex
datatype 'I am a literal...'
literal
I_am_an_unassigned_verb
|value error: I_am_an_unassigned_verb
|[-3]
I_am_an_unassigned_verb datatype adv
verb
datatype datatype adv
verb
datatype o train <'/'
adverb
datatype o train <'adv'
adverb
datatype o train <'&'
conjunction
datatype o train <'bind'
conjunction
> works, but '' tie + will just return a fork.
> '' $ ... portion of the fork in ART does not have an obvious purpose.
> ART2=. (an`('' tie~ ]))@.(2097152 = 3!:0) adv NB. seems to work in
examples.
>
> regarding your comments about (`'') not a real gerund,
Both remarks are related; first, allow me to clarify that (`'') produces
"real" gerunds. My actual comment was "the gerundial representation
produced by (`'') technically is not an ar [atomic representation]." An
atomic representation, as its name implies, is an atom (i.e., it has rank
0); in contrast, for a verb argument, (`'') produces a gerund having rank 1
which is not an atom. That is the reason why both,
(toJ f.)AR D
((10{a.) I.@(e.&(13{a.))@]} ])@:(#~ -.@((13 10{a.)&E.@,))
and
(toJ f.)ART D
((10{a.) I.@(e.&(13{a.))@]} ])@:(#~ -.@((13 10{a.)&E.@,))
work (i.e., produce atomic representations confirmed by D); but, both
(toJ f.)(`'') D
|rank error: D
| (toJ f.)(`'') D
and
(toJ f.)ART2 D
|rank error: D
| (toJ f.)ART2 D
fail and report a rank error.
On Mon, Aug 20, 2018 at 8:52 PM, 'Pascal Jasmin' via Programming <
[email protected]> wrote:
> awesome Pepe,
> just some additional explanations if it helps others, (and some questions)
> tie is a verb version of ` . In:
> ART=. (an`('' $ '' tie~ ]))@.(2097152 = 3!:0) adv
>
> the left side of @. must be verbs.
> (2097152 = 3!:0) is undocumented magic that detects a verb (phrase). Is
> there any similar magic number that would detect a string/ar representation
> of modifiers?
>
>
> - tie&'' adv
>
> ┌─┐
>
> │-│
>
> └─┘
>
> works, but '' tie + will just return a fork.
> '' $ ... portion of the fork in ART does not have an obvious purpose.
> ART2=. (an`('' tie~ ]))@.(2097152 = 3!:0) adv NB. seems to work in
> examples.
>
>
> regarding your comments about (`'') not a real gerund,
>
> ({. +@- (`'')) 5!:0 NB. adds a shape.
> +@-
> +@- (`'') {. adv D NB. alternate of above
>
>
> ( +@- (`'')) `:6 NB `:6 not fooled
>
> +@-
>
>
> On Monday, August 20, 2018, 7:40:39 p.m. EDT, Jose Mario Quintana <
> [email protected]> wrote:
>
> In the related thread "[Jprogramming] Applying an adverb to a list/gerund
> of verbs" (see the trailing post) Pascal wrote:
>
> > Thank you Jose,
>
> You are welcome Pascal (feel free to call me Pepe which is Jose's
> nickname).
>
>
> > Would you by any chance have figured out a way to make AR tacit?
> > *: AR is so much easier to "call"/type than ar '*:'
> > (`'') almost works, though "fails" with nouns, but is useful for an
> argument that can be verb or gerund.
>
> I had not produced a tacit version of AR because, personally, I did not
> have the need despite the fact that I use the atomic representation (ar) of
> words (nouns, verbs, adverbs, and conjunctions) directly from time to
> time. (Why I do not need a tacit AR? More on that later). I will mention
> some things, which I am sure you know, for the potential benefit of other
> members of the forum. As usual, one could always go the hard orthodox way
> (in principle, at least). However, I like the easy wicked way because I am
> naturally lazy.
>
> First a word of caution, the wicked way relies on an apparent internal
> design architecture feature of the J interpreters ( which treats J words
> the same in a fairly general sense) to perform illegal operations; this
> makes possible to produce any kind of adverb in a tacit form, including
> verb producing adverbs that refer (tacitly, of course) to the arguments of
> the verbs produced.
>
> I have followed the wicked way for several years using different versions
> of J interpreters; but, as Martin Nietzel put it recently "We are in twisty
> little maze of J versions, all alike." I have noticed a slight erosion of
> the aforementioned feature in the J805 and j06 interpreters. A more
> significant deterioration happened from J807 beta-e to beta-g. The J804,
> J805, J805 and J807 beta-e interpreters just bend and comply while running
> the J Wicked Toolkit script [0]; in contrast, the J807 beta-g interpreter
> snaps. Likely, the wicked way will be somewhat compromised in future
> official stable versions of the interpreter. Perhaps, the wicked way will
> be banned altogether and no black magic will be allowed. (It is black
> magic in J but it is white magic in many other programming languages that
> embrace higher-order functions).
>
> The above notwithstanding, what follows runs fine even on the J807 beta-g
> interpreter.
>
> Henceforth I am assuming that the sentences of the post below, up to the
> production of AR, have been run: that is,
>
> (9!:3) 5 2 NB. Box and linear representations...
> .
> .
> .
> AR=: 1 : '5!:1 <''u'''
>
> We can begin with the simple case when the argument of AR is noun,
>
> D=. 5!:0 NB. DoJ: Define. 5!:0 is an adverb and provides a complete inverse
> of 5!:1. ( T=. i.2 3 ) 0 1 2 3 4 5 ar'T' ┌─────────┐ │┌─┬─────┐│ ││0│0 1
> 2││ ││ │3 4 5││ │└─┴─────┘│ └─────────┘ (ar'T') D 0 1 2 3 4 5
>
> A tacit version of AR is,
>
> ART=. an f.adv T ART ┌─────────┐ │┌─┬─────┐│ ││0│0 1 2││ ││ │3 4 5││
> │└─┴─────┘│ └─────────┘ (i.2 3) ART ┌─────────┐ │┌─┬─────┐│ ││0│0 1 2││ ││
> │3 4 5││ │└─┴─────┘│ └─────────┘ (i.2 3) ART D 0 1 2 3 4 5
>
> Of course, if the argument of ART is a verb then we will need something
> more elaborated... Actually, that is not necessarily the case! For
> instance,
>
> +/@:*: ART
>
> ┌──────────┐
>
> │┌─┬──────┐│
>
> ││0│+/@:*:││
>
> │└─┴──────┘│
>
> └──────────┘
>
>
> is an illegal noun; yet, as far as the interpreter is concerned, it is an
> ar of +/@:*:
>
>
> +/@:*: ART D
> +/@:*:
> ┌─────┬──┬──┐
> │┌─┬─┐│@:│*:│
> ││+│/││ │ │
> │└─┴─┘│ │ │
> └─────┴──┴──┘
>
> and it can be used, as a whole, in place of the actual ar (not tested it
> much with the beta interpreters); for example,
>
>
> (+/@:*: ART`:6) 1 2 3 14
>
> There are instances where one might require the real thing for internal
> inspection and modification of a verb structure (for example, to replace
> the all its components of the form [: u v by (u@:v)).
>
>
> In that case, the following version should work,
>
> tie=. (<'`') (0:`)(,^:)
>
> ART=. (an`('' $ '' tie~ ]))@.(2097152 = 3!:0) adv
>
> (use 262144 instead of 2097152 for earlier versions of the interpreter if
> necessary); for example,
>
> (i.2 3) ART
> ┌─────────┐
> │┌─┬─────┐│
> ││0│0 1 2││
> ││ │3 4 5││
> │└─┴─────┘│
> └─────────┘
>
> u@:v AR
> ┌──────────┐
> │┌──┬─────┐│
> ││@:│┌─┬─┐││
> ││ ││u│v│││
> ││ │└─┴─┘││
> │└──┴─────┘│
> └──────────┘
>
> u@:v ART D
> u@:v
> ┌─┬──┬─┐
> │u│@:│v│
> └─┴──┴─┘
>
> (toCRLF f.ART) -: (toCRLF f.AR)
> 1
>
> By the way, the gerundial representation produced by (`'') technically is
> not an ar; for example,
>
> u@:v (`'') D
> |rank error: D
> | u@:v(`'') D
>
> PS. I had not produced ART before because I have access to a custom
> foreign which allows to use verbs that require named words (e.g. (4!:0),
> (5!:1), (5!:2), etc.) namelessly.
>
> Reference
>
> [0] J Wicked Toolkit
> http://www.2bestsystems.com/foundation/j/Jx.zip
> \Jx\J\J Wicked Toolkit.ijs
>
>
>
>
>
> On Thu, Aug 16, 2018 at 11:21 PM, 'Pascal Jasmin' via Programming <
> [email protected]> wrote:
>
> > Thank you Jose,
> > Would you by any chance have figured out a way to make AR tacit?
> > *: AR is so much easier to "call"/type than ar '*:'
> > (`'') almost works, though "fails" with nouns, but is useful for an
> > argument that can be verb or gerund.
> > On Thursday, August 16, 2018, 7:48:47 p.m. EDT, Jose Mario Quintana <
> > [email protected]> wrote:
> >
> > One the one hand, I find your adverb neat and clever. On the other
> hand,
> > I
> > like them beautiful and powerful. ;)
> >
> > Powerful?
> >
> > (9!:3) 5 2 NB. Box and linear representations...
> >
> >
> > o=. @:
> > c=. "_
> >
> > ar=. 5!:1@:<
> > an=. <@:((,'0') ,&:< ])f. NB. Atomizing (monadic verb)
> >
> > d=. (a0=. `'') (a1=. (@:[) ((<'&')`) (`:6)) (a2=. (`(<(":0);_)) (`:6))
> > av=. ((ar'a0')`) (`(ar'a1')) (`(ar'a2') ) (`:6)
> > NB. Adverbing a monadic verb (adv)
> > assert 1 4 9 -: 1 2 3 *: av
> >
> > train=. (<'`:') (0:`)(,^:)&6
> > fix=. (<'f.') (0:`)(,^:)
> >
> > af=. an o fix f. NB. Atomizing after fixing a word (monadic verb)
> > aw=. < o ((0;1;0)&{::) NB. Fetching the atomic representation (monadic
> > verb)
> > a3=. (o (train o aw f.)) ('av'f.)
> > NB. train o aw gets the (noun or verb) argument
> >
> > adv=. train o ((af'c') ; ] ; (af'a3')c) f.av
> >
> > The motivation for producing the tacit adverb adv was to reduce directly
> > the production of tacit adverbs to the production of tacit verbs,
> >
> > ag=. (0:`)(,^:) (<@:) (@:(train f.))("0) (train f.@:([ ; (,<,',') ;
> > ])&>/@:)
> >
> > A=. @:]
> >
> > Ad=. ag adv
> >
> > v1`v2`v3`v4 (ar'A')Ad
> > v1@:] , v2@:] , v3@:] , v4@:]
> > ┌─────────┬─┬─────────────────────────────────────┐
> > │┌──┬──┬─┐│,│┌─────────┬─┬───────────────────────┐│
> > ││v1│@:│]││ ││┌──┬──┬─┐│,│┌─────────┬─┬─────────┐││
> > │└──┴──┴─┘│ │││v2│@:│]││ ││┌──┬──┬─┐│,│┌──┬──┬─┐│││
> > │ │ ││└──┴──┴─┘│ │││v3│@:│]││ ││v4│@:│]││││
> > │ │ ││ │ ││└──┴──┴─┘│ │└──┴──┴─┘│││
> > │ │ ││ │ │└─────────┴─┴─────────┘││
> > │ │ │└─────────┴─┴───────────────────────┘│
> > └─────────┴─┴─────────────────────────────────────┘
> >
> > AR=: 1 : '5!:1 <''u'''
> > advE =: 1 : 'AR(u`)(`:6)'
> >
> > AdE=. ag advE
> >
> > v1`v2`v3`v4 (ar'A')AdE
> > v1@:] , v2@:] , v3@:] , v4@:]
> > ┌─────────┬─┬─────────────────────────────────────┐
> > │┌──┬──┬─┐│,│┌─────────┬─┬───────────────────────┐│
> > ││v1│@:│]││ ││┌──┬──┬─┐│,│┌─────────┬─┬─────────┐││
> > │└──┴──┴─┘│ │││v2│@:│]││ ││┌──┬──┬─┐│,│┌──┬──┬─┐│││
> > │ │ ││└──┴──┴─┘│ │││v3│@:│]││ ││v4│@:│]││││
> > │ │ ││ │ ││└──┴──┴─┘│ │└──┴──┴─┘│││
> > │ │ ││ │ │└─────────┴─┴─────────┘││
> > │ │ │└─────────┴─┴───────────────────────┘│
> > └─────────┴─┴─────────────────────────────────────┘
> >
> > (By the way, you might appreciate that both adv and advE, in this
> context,
> > are acting as triple (Curried) adverbs.)
> >
> > The end result is the same; however, one important difference is that
> > (ar'A')Ad is tacit but (ar'A')Ad is not (because AR is not tacit).
> Recall,
> > Piet Google was asking for "a (tacit) way to apply an adverb to each of a
> > list of verbs."
> >
> > Furthermore, adv has the implicit tacit power (provided by (0:`)(,^:)) to
> > perform forbidden tricks that advE cannot; adv actually applies its
> > argument verb to the argument of the resulting adverb even if that
> argument
> > happens to be a verb; for example,
> >
> > *: <adv
> > ┌──┐
> > │*:│
> > └──┘
> >
> > boxes *:,
> >
> > > *: <adv 1 2 3
> > 1 4 9
> >
> > In contrast,
> >
> > *: <advE
> > < *:
> > ┌─┬──┐
> > │<│*:│
> > └─┴──┘
> > > *: <advE 1 2 3
> > 0 1 1
> >
> >
> > On Thu, Aug 16, 2018 at 3:11 PM, 'Pascal Jasmin' via Programming <
> > [email protected]> wrote:
> >
> > > A simpler version of your usual adv definition, that seems pretty
> clean
> > > (without my usual processing)
> > >
> > > AR=: 1 : '5!:1 <''u'''
> > > adv =: 1 : 'AR(u`)(`:6)'
> > >
> > >
> > > 1 2 3 *: adv
> > >
> > > 1 4 9
> > >
> > > not sure if this works with all your utilities.
> >
> >
> ----------------------------------------------------------------------
> 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
