I took a look at some J that I wrote, looking for uses of }
In about 18k of code, I'm just shy of a dozen uses of }
Here's one example (beware line wrap):
fname2date=: [: todayno _".' ' 4
7}"1(('20[0-9][0-9]-[01][0-9]-[0-3][0-9]') (rxmatch ;@rxfrom ]) ]) S:0
Generally, I seem to use it where "patching a value" seems to make
sense. In no case is it strictly necessary (for example, I could have
used rplc in the above example), but that's a different issue.
Thanks,
-
Raul
On 7/7/14, 'Pascal Jasmin' via Programming <[email protected]> wrote:
> a database. A moderate to large application is likely to track a data
> structure that needs item/row updates. It may be smelly to have to do such
> updates, but someone has to :P
>
> Though more (or rather additionally) useful/workable for me than } is this
> conjunction (though it can generally be achieved with a gerund version of })
> that provides verb based amend.
>
> amend_z_ =: 2 : 0
> s=. v"_ y
> (u (s{y)) (s}) y
> :
> s=. v"_ y
> (x u (s{y)) (s}) y
> )
>
>
> ----- Original Message -----
> From: Dan Bron <[email protected]>
> To: "[email protected]" <[email protected]>
> Cc:
> Sent: Monday, July 7, 2014 8:23:54 PM
> Subject: Re: [Jprogramming] Tacit J and indexed replacement
>
> Do you have examples, in practice, where you've wanted to modify one item
> (or a sublist) from a data structure?
>
> Would you say those circumstances are the exception or the rule? (I'm asking
> because it's definitely the exception in my own experience, and more often
> than not a "code smell").
>
> -Dan
>
> Please excuse typos; sent from a phone.
>
>> On Jul 7, 2014, at 8:14 PM, "'Pascal Jasmin' via Programming"
>> <[email protected]> wrote:
>>
>> I think } (dyadic amend) is pretty essential. The obvious use is amending
>> one (or sublist) item from a data structure.
>>
>> Item amend maybe a little more esoteric, but I find it easy to
>> conceptualize, and use the "verbified" form 4 : 'x}y' as a "natural" way
>> of implementing the example in this thread.
>>
>>
>> ----- Original Message -----
>> From: Dan Bron <[email protected]>
>> To: [email protected]
>> Cc:
>> Sent: Monday, July 7, 2014 7:42:35 PM
>> Subject: Re: [Jprogramming] Tacit J and indexed replacement
>>
>> Pepe, I'm with Ian and Henry on this one: questions of efficiency aside,
>> I
>> rarely find a call for } . The only place I really use it is in the
>> expression ('A'&=)`(,:&'B') } to make scalar substitutions. So I'm
>> interested in where you find uses for it.
>>
>> Do you have specific examples? Would you say you reach for } when
>> efficiency is a concern, even if the thought could be expressed more
>> conveniently using some other tool, or that you've found places where }
>> is the best way to say what you want to say? If the latter (} is the
>> word
>> you want), are there any particular characteristics that tie those use
>> cases together?
>>
>> I personally find (bearing in mind that I'm a J hobbyist, and [no longer]
>> a
>> professional) that I mostly think in terms of items, and modifying
>> anything below the level of an item would be quite unusual in my code,
>> and
>> make me suspicious. Similarly, I almost always treat all items
>> identically, and a consistent need to treat just some items specially
>> would make me suspicious, and I'd wonder whether I should be structuring
>> my data differently.
>>
>> With that said, I certainly (especially in my "professional J-ing" days)
>> see the benefit of } for performance. But I'm wondering if you've
>> invented or discovered generally beneficial uses of } unrelated to
>> performance. I'd be very interested in that, if so ('cause the only one
>> I
>> ever invented or discovered was, as I said, scalar substitution).
>>
>> -Dan
>>
>> ----- Original Message ---------------
>>
>> Subject: Re: [Jprogramming] Tacit J and indexed replacement
>> From: Jose Mario Quintana <[email protected]>
>> Date: Mon, 7 Jul 2014 19:12:55 -0400
>> To: Programming forum <[email protected]>
>>
>> Ian wrote:
>> "
>> And the reason for that has less to do with finding it "hard to get my
>> head
>> round Amend" than the fact that "in-place array modification" is a
>> technique that goes hand-in-hand with a scalar approach to
>> problem-solving,
>> which is not what J is designed to do well.
>> "
>>
>> How come? In the form (x m} y), x, y and m are all allowed to be
>> arrays,
>> are they not?
>>
>> Ian wrote:
>> "
>> I still
>> stand firmly by what Henry and I wrote in the NuVoc page on Amend:
>>
>> x m} y is used in J much less than you would think, considering the
>> importance of in-place array modification in other languages.
>> "
>>
>> I also stand firm by what I wrote (no offense):
>>
>> "I find the forms <@:v N} ] and v N} ] extremelly useful for writing
>> tacitly."
>>
>> That is, when the task at hand goes beyond to dealing with one or two
>> (tacit) arguments and joggling intermediate results with forks or alike
>> (and the tacit sentence (paragraph, chapter, section, book,...) is meant
>> to
>> be efficient).
>>
>> :)
>>
>> Actually, I think, both statements (yours and mine) can stand because few
>> J
>> users are willing to go that far tacitly.
>>
>>
>>
>>> On Mon, Jul 7, 2014 at 3:22 AM, Ian Clark <[email protected]> wrote:
>>>
>>> Thanks, guys, keep the ideas coming. There's enough been said in this
>>> thread to enable me to substantially improve the NuVoc presentation of
>>> Amend in http://www.jsoftware.com/jwiki/Vocabulary/curlyrt#dyadic -
>>> which
>>> I
>>> think most would agree doesn't present Amend in the most appealing
>>> light.
>>> Perhaps unfairly so.
>>>
>>> In particular, I like Aai's idea:
>>>
>>> zero =: 0:`[`]}
>>> 3 5 zero i.9
>>> 0 1 2 0 4 0 6 7 8
>>>
>>> (BTW I realize this not the form he delivered it in)
>>>
>>> which I think ought to replace the present cumbersome NuVoc example.
>>>
>>> Raul asks, as usual, "what am I trying to do?" Adopting the role of a J
>>> novice, I have to reply "learn J of course" - by the expedient of
>>> learning
>>> the utility and usage of J's primitives, viewed as a toolkit. But if I
>>> come
>>> clean about my own personal motives, it's to write a good NuVoc page
>>> which
>>> helps a complete J novice understand Amend and what it's good for - if
>>> anything.
>>>
>>> I reject the insinuation that I use Amend less than I might because I'm
>>> not
>>> smart enough. A J novice, experienced in another language, would feel
>>> patronized by such a suggestion. Moreover she would find it hard to
>>> resist
>>> the impression that J-jocks were covering up for a grave defect in the
>>> language. And I was lying when I said I didn't have much use for Amend.
>>> But
>>> I wanted to play devil's advocate in support of Erling's criticism,
>>> because
>>> I believe he speaks for most newcomers trained on a "scalar" language
>>> like
>>> C.
>>>
>>> For all the splendid, creative ways of force-feeding Amend into
>>> submission
>>> I've seen in this thread (e.g. by using a gerund for operand "m") I
>>> still
>>> stand firmly by what Henry and I wrote in the NuVoc page on Amend:
>>>
>>> x m} y is used in J much less than you would think, considering the
>>> importance of in-place array modification in other languages.
>>>
>>> And the reason for that has less to do with finding it "hard to get my
>>> head
>>> round Amend" than the fact that "in-place array modification" is a
>>> technique that goes hand-in-hand with a scalar approach to
>>> problem-solving,
>>> which is not what J is designed to do well. So Raul's question "what am
>>> I
>>> trying to do?" turns out to be appropriate after all, when it comes to
>>> using Amend. Or using something else - like (*) or (#) with a Boolean
>>> list.
>>>
>>>
>>>> On Mon, Jul 7, 2014 at 4:58 AM, Raul Miller <[email protected]>
>>>> wrote:
>>>>
>>>> Since it'w nagging at me (and this is still unteted code :/), here's
>>>> what I currently think i should have said:
>>>> amend=: (0:{::])`(1:{::])`(2:{::])}~
>>>>
>>>> The trailing ~ because I need the dyad from the resulting verb, and
>>>> the trailing ] on each because those verbs need to ignore one of the
>>>> resulting arguments.
>>>>
>>>> Sadly, my fingers (and "quick memory") keep forgetting this.
>>>>
>>>> Thanks,
>>>>
>>>> --
>>>> Raul
>>>>
>>>>> On 7/6/14, Raul Miller <[email protected]> wrote:
>>>>> Meh, no, that won't work.
>>>>>
>>>>> Stick with Jose's version.
>>>>>
>>>>> (I also don't have the feature enabled which lets me cancel sending an
>>>>> email after "sending" it.)
>>>>>
>>>>> I'll just go do some "practical" work now...
>>>>>
>>>>> Sorry for the noise.
>>>>>
>>>>> --
>>>>> Raul
>>>>>
>>>>>> On 7/6/14, Raul Miller <[email protected]> wrote:
>>>>>> Oops, yes. Sorry about that.
>>>>>>
>>>>>> I should have said:
>>>>>> amend=: (0:{::)`(1:{::)`(2:{::)}~
>>>>>>
>>>>>> (I'm working right now from a machine where J doesn't run, and I
>>>>>> forget details when I don't test my code.)
>>>>>>
>>>>>> Thanks,
>>>>>>
>>>>>> --
>>>>>> Raul
>>>>>>
>>>>>>> On 7/6/14, Jose Mario Quintana <[email protected]>
>>>>>>> wrote:
>>>>>>> Raul wrote:
>>>>>>> "
>>>>>>> For example:
>>>>>>> amend=: 0&{::`(1&{::)`(2&{::)}
>>>>>>> amend 0;2 3 5;7#9
>>>>>>> 9 9 0 0 9 0 9
>>>>>>> "
>>>>>>>
>>>>>>> Actually,
>>>>>>>
>>>>>>> JVERSION
>>>>>>> Installer: j602a_win.exe
>>>>>>> Engine: j701/2011-01-10/11:25
>>>>>>> Library: 6.02.023
>>>>>>>
>>>>>>> amend=: 0&{::`(1&{::)`(2&{::)}
>>>>>>> amend 0;2 3 5;7#9
>>>>>>> |rank error: amend
>>>>>>> | amend 0;2 3 5;7#9
>>>>>>> |[-3]
>>>>>>>
>>>>>>> However,
>>>>>>>
>>>>>>> amend=. _: 0&{::@]`(1&{::@])`(2&{::@])} ]
>>>>>>> amend 0;2 3 5;7#9
>>>>>>> 9 9 0 0 9 0 9
>>>>>>>
>>>>>>> I use a slight variation of this verb occasionally; yet, I find the
>>>>>>> forms
>>>>>>> <@:v N} ] and v N} ] extremelly useful for writing tacitly (and I
>>> write
>>>>>>> tacitly all the time).
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> On Sun, Jul 6, 2014 at 6:42 AM, Raul Miller <[email protected]>
>>>>>>> wrote:
>>>>>>>
>>>>>>>> I would agree that amend is seldom useful in much the same way that
>>>>>>>> computers are seldom useful. That is: it depends on what you mean
>>>>>>>> by
>>>>>>>> "seldom" (and, for that matter, "useful").
>>>>>>>>
>>>>>>>> Generally speaking, } is one of the less common characters that I
>>> use
>>>>>>>> when I write in J, but I do use it.
>>>>>>>>
>>>>>>>> Also, in addition to the very fine 0:`[`]} which behaves something
>>>> like
>>>>>>>> this:
>>>>>>>>
>>>>>>>> 2 3 5 0:`[`]} 7#9
>>>>>>>> 9 9 0 0 9 0 9
>>>>>>>>
>>>>>>>> (Aside: note that in the above expression 2 3 5 is a word, and 0:
>>> is a
>>>>>>>> separate word. Try ;:'2 3 5 0:`[`]} 7#9' if you want proof.)
>>>>>>>>
>>>>>>>> ... in addition to that approach, you can also arrange so that all
>>>>>>>> arguments are given in an argument list, if you use
>>>>>>>> 0&{::`(1&{::)`(2&{::)}
>>>>>>>>
>>>>>>>> For example:
>>>>>>>> amend=: 0&{::`(1&{::)`(2&{::)}
>>>>>>>> amend 0;2 3 5;7#9
>>>>>>>> 9 9 0 0 9 0 9
>>>>>>>>
>>>>>>>> But, as with everything, whether this is a good thing or not
>>>>>>>> depends
>>>>>>>> on what you are trying to do...
>>>>>>>>
>>>>>>>> Which leads back to the question: what are you trying to do?
>>>>>>>>
>>>>>>>> Thanks,
>>>>>>>>
>>>>>>>> --
>>>>>>>> Raul
>>>>>>>>
>>>>>>>>> On 7/6/14, Ric Sherlock <[email protected]> wrote:
>>>>>>>>> I don't agree that Amend is seldom useful. I do agree that it
>>> isn't
>>>>>>>>> the
>>>>>>>>> easiest thing to get your head around (perhaps why you have found
>>>>>>>>> other
>>>>>>>>> ways to getting stuff done).
>>>>>>>>>
>>>>>>>>> Aai has shown how to tacitly use Amend so it seems that 13 : is
>>> not
>>>>>>>>> smart
>>>>>>>>> enough to give you a tacit equivalent. I suspect the reason Amend
>>>> has
>>>>>>>> been
>>>>>>>>> defined as an adverb is that it requires 3 arguments: the array to
>>>>>>>>> amend,
>>>>>>>>> the indicies to amend, the replacement data. Compare that to From
>>>>>>>>> which
>>>>>>>>> only requires 2 bits of info (the array, the indicies).
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> On Sun, Jul 6, 2014 at 7:53 PM, Ian Clark <[email protected]>
>>>>>>>>> wrote:
>>>>>>>>>
>>>>>>>>>> I think Erling is quite right, if you take what he says
>>> literally:
>>>>>>>> "Amend
>>>>>>>>>> is seldom useful for indexed replacement when you write tacit J".
>>>>>>>>>>
>>>>>>>>>> I'd go further and say "Amend is seldom useful." Period. I write
>>> a
>>>>>>>>>> lot
>>>>>>>> of
>>>>>>>>>> J
>>>>>>>>>> code and I hardly ever use it.
>>>>>>>>>>
>>>>>>>>>> To someone coming from C (say), this cries out for explanation.
>>> In
>>>>>>>>>> C,
>>>>>>>> just
>>>>>>>>>> about everything is done by keyhole surgery, i.e. by tinkering
>>> with
>>>>>>>>>> whatever happens to be at the end of a pointer (read: index). In
>>> J,
>>>>>>>>>> just
>>>>>>>>>> about nothing is done that way.
>>>>>>>>>>
>>>>>>>>>> Let me give an example. Suppose I want to write a verb to zero
>>> the
>>>>>>>>>> x'th
>>>>>>>>>> element of a list y ...
>>>>>>>>>> I can easily write it as an explicit verb:
>>>>>>>>>>
>>>>>>>>>> zero=: 4 : '0 x} y'
>>>>>>>>>> 3 zero i.6
>>>>>>>>>> 0 1 2 0 4 5
>>>>>>>>>>
>>>>>>>>>> But "13 :" refuses to give me an equivalent tacit verb ...
>>>>>>>>>>
>>>>>>>>>> 13 : '0 x}y'
>>>>>>>>>> 4 : '0 x}y'
>>>>>>>>>>
>>>>>>>>>> Is this just a shortcoming of "13 :" ? Does anyone know a "nice"
>>>>>>>>>> tacit
>>>>>>>>>> equivalent? I don't.
>>>>>>>>>>
>>>>>>>>>> Contrast this with what happens if I switch round 0 and x
>>> (...which
>>>>>>>> gives
>>>>>>>>>> me a verb to replace the first element of a list y with x). In
>>> this
>>>>>>>>>> case
>>>>>>>>>> "13 :" does deliver me a nice simple tacit equivalent ...
>>>>>>>>>>
>>>>>>>>>> 13 : 'x 0}y'
>>>>>>>>>> 0}
>>>>>>>>>>
>>>>>>>>>> So why doesn't 13 : '0 x}y' do something equally as nice? It's
>>>> all
>>>>>>>>>> explained in
>>>>>>>>>> http://www.jsoftware.com/jwiki/Vocabulary/curlyrt#dyadic
>>>>>>>>>> .
>>>>>>>>>> But
>>>>>>>>>> that doesn't really explain to a newcomer why Amend was designed
>>> as
>>>>>>>>>> an
>>>>>>>>>> adverb:
>>>>>>>>>> x m} y
>>>>>>>>>> with (index) m as an *operand*, not an *argument*.
>>>>>>>>>>
>>>>>>>>>> Yes, I can write a tacit verb to zero the x'th element of list y
>>>> ...
>>>>>>>>>>
>>>>>>>>>> zero2=: 13 : 'y * y~:x'
>>>>>>>>>> 3 zero2 i.6
>>>>>>>>>> 0 1 2 0 4 5
>>>>>>>>>> zero2
>>>>>>>>>> ] * ~:
>>>>>>>>>>
>>>>>>>>>> ... but not by using Amend, which is quite simply not useful in
>>>> that
>>>>>>>> role.
>>>>>>>>>> Though I'm not claiming it can't be done - in fact there's a
>>> worked
>>>>>>>>>> example
>>>>>>>>>> in: http://www.jsoftware.com/jwiki/Vocabulary/curlyrt#dyadic
>>> under
>>>>>>>> "More
>>>>>>>>>> Information". But I wouldn't call it "nice".
>>>>>>>>>>
>>>>>>>>>> This illustrates the J approach to programming:
>>>>>>>>>> http://www.jsoftware.com/jwiki/Vocabulary/Loopless -and how it
>>>>>>>> contrasts
>>>>>>>>>> with the C approach. Henry would explain it far better than I
>>> can,
>>>>>>>>>> but
>>>>>>>>>> he's
>>>>>>>>>> busy.
>>>>>>>>>>
>>>>>>>>>> IanClark
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> On Sat, Jul 5, 2014 at 8:59 PM, Erling Hellenäs <
>>>>>>>> [email protected]>
>>>>>>>>>> wrote:
>>>>>>>>>>
>>>>>>>>>>> Hi all !
>>>>>>>>>>>
>>>>>>>>>>> When you write tacit code, the index m used by Amend, syntax
>>>>>>>> description
>>>>>>>>>>> x m} y, is a constant?
>>>>>>>>>>> Normally you have a variable you want to use for indexing? This
>>>>>>>>>>> means
>>>>>>>>>>> Amend is seldom useful for indexed replacement when you write
>>>>>>>>>>> tacit
>>>>>>>>>>> J?
>>>>>>>>>>> Are there any descriptions of nice ways to do indexed
>>> replacement
>>>>>>>>>>> in
>>>>>>>>>> tacit
>>>>>>>>>>> J?
>>>>>>>>>>> As with Amend, the result has to be a new variable, of course.
>>>>>>>>>>>
>>>>>>>>>>> Cheers,
>>>>>>>>>>>
>>>>>>>>>>> Erling Hellenäs
>>>> ----------------------------------------------------------------------
>>>>>>>>>>> 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
>> ----------------------------------------------------------------------
>> 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
