(I thought that this was documented behavior?)
Thanks,
—
Raul
On Wednesday, August 22, 2018, 'Pascal Jasmin' via Programming <
[email protected]> wrote:
You've brought up another undocumented feature.
'' $ 1
1
'' $ , 1
1
'' $ i.2 2
0 1
'' $ 1 2
1
'' $ ,: 1 2
1 2
'' $ i.0
|length error
'' $ y returns the first item of y if one exists. The difference with {.
is that the latter will fill if no item exists.
On Tuesday, August 21, 2018, 5:12:37 p.m. EDT, Jose Mario Quintana <
[email protected]> wrote:
> (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
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
