Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Inline comments follow... > I will have to think about that... > > First a few obvious notes: > > (1) I said "often" not "always". > (2) This is doubly recursive and ^: is more like tail recursion > One can always produce a tacit verb which performs the quicksort computations (or the computations

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

I will have to think about that... First a few obvious notes: (1) I said "often" not "always". (2) This is doubly recursive and ^: is more like tail recursion That said, we can do array traversal at each level of induction, which we might be able to use here. We might have to pay a little extra

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Can you show us the exact tacit induction or analytical fixed version of, quicksort=. (($:@(< # [) , (= # [) , $:@(> # [)) ({~ ?@#))^:(1 < #) ? No, I do not want to replace quicksort by /:~ . (Actually, I am, ultimately, interested in (quicksort=. (($:@(< # [) , (= # [) , $:@(> # [)) ({~ v@#))^

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

J does not have an explicit scope for $: (other than using an explicit verb for that purpose), but often you can use induction instead of recursion. (And, also - generally speaking - we can use analytic techniques - for example, sometimes recursive algorithms can be replaced with arithmetic.) Tha

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

" If the first example was in an equivalent to tacit code, it could not call f. It would have to be like this: 4 (.x).`(.y (. y , x + {: y ). x $: <: y). at .(.x < y). 8 It would be impossible to use in a larger tacit program and you'd need Jx to solve that, as far as I understand. Same problem as

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all! I created the page for Proposals and moved my request there, as agreed. http://code.jsoftware.com/wiki/System/Interpreter/Proposals Cheers, Erling Hellenäs Den 2017-09-26 kl. 21:20, skrev Eric Iverson: Erling, Henry pointed out that in my last para I meant inappropriate rather than

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

t: Re: [Jprogramming] Tacit Expressions with Explicit J Syntax Message-ID: Content-Type: text/plain; charset=utf-8; format=flowed ... What is that overhead?  In your examples using @, (1) parsing and (2) bookkeeping. Parsing: (3 :'-y')@- v is slow partly because every sentence of an explicit entity

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

: Sat, 30 Sep 2017 13:20:50 -0400 From: Henry Rich To:programm...@jsoftware.com Subject: Re: [Jprogramming] Tacit Expressions with Explicit J Syntax Message-ID: Content-Type: text/plain; charset=utf-8; format=flowed ... What is that overhead?  In your examples using @, (1) parsing and (2) bookke

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Changing noun values could be another reason to use the ". bind 'name' pattern, but another approach is to use a script with the noun definition preceding the verb definition. Sensitivity to timing is an unfortunate characteristic of many things with real world relevance. One approach, of course,

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

I just use @: by default and @ only when I really mean it. One extra character is a very small price to pay for clarity and insurance against potential performance mishaps as far as I am concerned; I even use, more often than not, the letter o (previously defined as o=. @:) instead of @:. On Fri,

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

That's true. But sometimes one forgets to redefine the tacit definition when the noun changes. On Oct 1, 2017 7:58 AM, "Raul Miller" wrote: > Note that that first "gotcha" can be reversed in contexts where it's a > problem and not a feature. This might also be desirable when dealing > with large

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Note that that first "gotcha" can be reversed in contexts where it's a problem and not a feature. This might also be desirable when dealing with large nouns. The pattern is: ". bind 'name' When you use (". bind 'name') you are using a verb whose result is always the value of that name. (The verb

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Tacit expressions are really quite simple. They are different from non-tacit expressions only by three simple rules. The fork, hook and chain rule. Tacit expressions are identified by the absence of arguments included in the expression. They are explained thoroughly in help, so there is no sense in

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Tacit J sometimes has a performance advantage over explicit J. Explicit J sometimes has a performance advantage over tacit J. That said, I find both useful as tools for my own thinking. They offer ways of expressing concepts and ways of experimenting with them. They are not my only tools, but I wo

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

The Curried adverb xi, produces tacit verbs (which might be higher-order verbs); however, in contrast to the tacit translator 13 : '...' , the product is not a translation to tacit code (i.e., it is not really a compiler). Instead, the product consists of a description of the position of the param

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! I'll try to summarize this thread so far. Explicit and tacit J can be used interchangeably for everything you can do in J. Tacit J has a slight performance advantage. This can be useful in time-critical applications or time-critical parts of applications. Tacit J does not have mutable

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Quick request as we're nearing 100 messages: How about splitting out questions about $: etc. into a new thread? I think it might be easier for everyone to follow. /M On Sat, Sep 30, 2017 at 1:35 PM, Erling Hellenäs wrote: > Hi all ! > > Is there a way to get $: to work with agenda and with expli

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! Is there a way to get $: to work with agenda and with explicit code?    f=: 4 : 'x (4 : ''x'')`(4 : ''s,y +{: s=.x f <: y'')@.(4 :''x < y'') y'    4 f 8 4 9 15 22 30    f=: 4 : 'x (4 : ''x'')`(4 : ''s,y +{: s=.x $: <: y'')@.(4 :''x < y'') y'    4 f 8 |stack error: f |   s,y+{:s=.x   

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

On 9/30/2017 3:38 PM, Erling Hellenäs wrote: So, tacit code creates composites of compiled code and explicit code is still interpreted each time it is called? Broadly, that's right.  But remember that interpretation embraces parsing and bookkeeping.  Tacit code still has the bookkeeping. There

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

It's hard to answer your question about whether explicit code can replace tacit because I think we are defining the words differently. Explicit code can replace tacit code anywhere, trivially.  If you have a tacit verb t, the explicit verb 3 : ('t y';':';'x t y')"t does the same as t. But t

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

So, tacit code creates composites of compiled code and explicit code is still interpreted each time it is called? There is nothing like a J JIT compiler? /Erling On 2017-09-30 21:22, Erling Hellenäs wrote: Hi all! OK. Yes. Considering this the differences seem very small. Long ago I remember

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all! OK. Yes. Considering this the differences seem very small. Long ago I remember looping programs I made 270 times faster by removing the loop and using some recursive tricks. Now the looping solution can often even be faster. No one want's to answer the question if explicit code can r

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Bill hit the nail on the head: > IMO it doesn't matter whether to use tacit or explicit, > the more important thing is to understand how J works. u@:v y  means 'Do v on y; then do u on that result'.  It is exactly the same as   (u v y). u@v y  means 'Do v on the first cell of y; then do v on

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

If the first example was in an equivalent to tacit code, it could not call f. It would have to be like this: 4 (.x).`(.y (. y , x + {: y ). x $: <: y).@.(.x < y). 8 It would be impossible to use in a larger tacit program and you'd need Jx to solve that, as far as I understand. Same problem as i

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

I really don't care which is faster. I use which is easier for what I want to do. I like tacit because it avoids repeating a name over and over as in non-tacit. I say non-tacit instead of explicit because explicit has to do with explicit definitions. Often I never even write an explicit definition

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! 4(f=. 4 : 'x (4 : ''x'')`(4 : ''s,y +{: s=.x f <: y'')@.(4 :''x < y'') y' )8 4 9 15 22 30 Here we have another example of the Henry syntax: 4(f=.(.x (.x).`(.y (. y , x + {: y ). x f <: y).@.(.x < y). y).)8 s is here the right unnamed operand of (. y , x + {: y ).  . As long as

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all! Yes, well,  I wanted to measure differences between tacit and explicit expressions as such, so I tried to avoid unrelated processing time. In case  you have significant operations, these differences disappear, of course, and the processing time in these operations dominate over interp

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

I think your approach was fine. Integer arithmetic, after all, has a recursive definition. (Which, thankfully, we mostly just assume exists rather than using as a technique to slow things down.) https://en.wikipedia.org/wiki/Peano_axioms Thanks, -- Raul On Sat, Sep 30, 2017 at 8:59 AM, Don Gui

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

I didn't realize that the solution was supposed to be recursive. I got tired of trying to figure out recursive or polynomial solutions for a series of numbers in Project Euler and found it easy to use matrix division when there is a polynomial solution. And given a polynomial solution for each term

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Since the time taking is small, better to run n times to obtain an average. + and - are scalar functions of rank-0, but J has integrated rank support so that there will be no performance penalty if its arguments are arrays. @ will inherent the rank of - , better to use @: in this case. 50 ts'

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! Can tacit and explicit J be interchangeably used everywhere ? Examples of use:    4 (3 :'- y')@:(4 :'x + y') 5 _9    3(4 :'(1: x + y)#''x'' ')`(4 :'(1: x + y)#''y'' ')@.(4 :'x < y')4 y What are the performance implications of using explicit J instead of tacit J? This little example

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

An additional comment. see below. /Erling On 2017-09-29 04:45, Henry Rich wrote: Taking your last sentence first, you would have to supply some evidence to make me believe that tacit forms have any intrinsic performance penalty. It is dawning on me that you want fast function definition, but

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Confirmed. Great !    ts=: 6!:2 , 7!:2@]    v=.v?v=.1000    #v 1000    10 {. v 5890540 3044422 4300710 5970936 7393626 1716018 5963044 1177509 5150028 3714108    ts'([:-[:-[:-[:-]) v' 0.119559 1.3422e8    ts'(-@:-@:-@:-@:]) v' 0.120559 1.3422e8    ts'(-@:(-@:(-@:(-@:] v' 0.121043 1.

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Running J8.06 64-bit, I find that your first 3 cases all use 1.3e8 bytes (which is the size of v). Version 8.05 and later does much less copying of data than previous versions. Henry Rich On 9/29/2017 10:41 AM, Erling Hellenäs wrote: Hi all ! Hopefully better examples this time.    v=.v?v

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

>> >> Regards >> >> >> >> >> >> >> >> >> >> On Fri, Sep 29, 2017 at 3:58 AM, 'Jon Hough' via Programming < >> >> programm...@jsoftware.com> wrote: >> >> >> >>> >Not

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

@ and @: have different meanings, in the general case. For common specific cases where they do not have different meanings, it's reasonable for special code to be used to speed up @ Specifically: u@v where u's ranks do not exceed v's ranks and where v's result shape is depends strictly on its arg

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

gt; >> > >> > >> > >> On Fri, Sep 29, 2017 at 3:58 AM, 'Jon Hough' via Programming < > >> programm...@jsoftware.com> wrote: > >> > >>> >Note for those who have not been using J for > >>> >more tha

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! Hopefully better examples this time.    v=.v?v=.1000    #v 1000    10 {. v 9257364 5642952 2724566 7608992 7025081 5624810 5911207 1606397 5366536 5408278 As we can see here, there is a space penalty for using @: compared to [: f ]. This space penalty is removed with proper

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Sorry, these were stupid examples. I'll come back. /Erling On 2017-09-29 15:53, Erling Hellenäs wrote: Hi all! From these simple examples it does not seem to be any difference in time and space requirements between the [:+] syntax and the +@:] syntax. Not even if we insert more brackets.   

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all! From these simple examples it does not seem to be any difference in time and space requirements between the [:+] syntax and the +@:] syntax. Not even if we insert more brackets. ts'(i.v) ([:+[:+[:+[:+]) i.v=.100' 0.00936323 1.67808e7 ts'(i.v) (+@:+@:+@:+@:]) i.v=.100'

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

>> >>> >Note for those who have not been using J for >>> >more than 10 years: the >>> >original tacit >>> >language allowed trains that produced modifiers. >>> >>> What is the latest J version that had this? Is it avail

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

m> wrote: > >> >Note for those who have not been using J for >> >more than 10 years: the >> >original tacit >> >language allowed trains that produced modifiers. >> >> What is the latest J version that had this? Is it available somewhere? >>

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

the latest J version that had this? Is it available somewhere? > > ---- > On Fri, 9/29/17, Henry Rich wrote: > > Subject: Re: [Jprogramming] Tacit Expressions with Explicit J Syntax > To: programm...@jsoftware.com > Date: Friday, September 29, 2017, 11:45 AM >

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

The important thing here is not any namespace but if we get copies of the data. If the data is copied into the ([: f ]) construction during execution. /Erling On 2017-09-29 05:31, Henry Rich wrote: It seems a bit much to ask Raul to track down a recent email thread. No, @: does not create a n

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

It seems a bit much to ask Raul to track down a recent email thread. No, @: does not create a namespace.  Only explicit entities have a namespace. Henry Rich On 9/28/2017 11:19 PM, Erling Hellenäs wrote: On 2017-09-29 04:59, Raul Miller wrote: I do not know of any definition of "namespace" s

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

On 2017-09-29 04:59, Raul Miller wrote: I do not know of any definition of "namespace" such that @: creates a namespace. Why do you think that @: creates a namespace? Thanks, As I said there was a discussion about this in a long thread recently. Maybe you can find it? This is from what I reme

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

It was introduced in J2 (1994), it listed about 40 rules for bident and trident in its J dictionary (a printed book). People may getting smart enough to understand and to use those trains by now. http://www.jsoftware.com/help/release/status.htm Чт, 28 сен 2017, Henry Rich написал(а): > It would h

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

On 2017-09-29 04:45, Henry Rich wrote: Taking your last sentence first, you would have to supply some evidence to make me believe that tacit forms have any intrinsic performance penalty. When you write @ instead of @: you can cause a loop which has a big performance penalty, according to measur

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

It's there under 5.01 Non-compatible changes (a euphemism!): http://www.jsoftware.com/help/release/noncpat.htm Henry Rich On 9/28/2017 11:12 PM, Raul Miller wrote: This? http://www.jsoftware.com/help/release/contents.htm I do not see any mention of [. or ]. or lev or dex or trains there... T

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

This? http://www.jsoftware.com/help/release/contents.htm I do not see any mention of [. or ]. or lev or dex or trains there... Thanks, -- Raul On Thu, Sep 28, 2017 at 11:08 PM, Henry Rich wrote: > It would have been in 5.01 then; look for 'Release Notes' rather than > "Implementation Status'

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

It would have been in 5.01 then; look for 'Release Notes' rather than "Implementation Status' Henry Rich On 9/28/2017 11:05 PM, Raul Miller wrote: Oddly, I do not see any mention of lev and dex being removed on http://www.jsoftware.com/help/release/status.htm I thought I remembered seeing the

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

- > On Fri, 9/29/17, Henry Rich wrote: > > Subject: Re: [Jprogramming] Tacit Expressions with Explicit J Syntax > To: programm...@jsoftware.com > Date: Friday, September 29, 2017, 11:45 AM > > Taking your last sentence first, > you would have

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

nal tacit >language allowed trains that produced modifiers. What is the latest J version that had this? Is it available somewhere? On Fri, 9/29/17, Henry Rich wrote: Subject: Re: [Jprogramming] Tacit Expressions with Explicit J Syntax To:

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

I do not know of any definition of "namespace" such that @: creates a namespace. Why do you think that @: creates a namespace? Thanks, -- Raul On Thu, Sep 28, 2017 at 10:57 PM, Erling Hellenäs wrote: > About this question: > f@:g@:h? > I think we had a long thread recently about how to write

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Rich wrote: Subject: Re: [Jprogramming] Tacit Expressions with Explicit J Syntax To: programm...@jsoftware.com Date: Friday, September 29, 2017, 11:45 AM Taking your last sentence first, you would have to supply some evidence to make me believe that tacit forms have any intrinsic perform

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

About this question: f@:g@:h? I think we had a long thread recently about how to write this. I think each @: will generate a namespace with ([: f ]) and that this means some more copies of variables than [: f [: g [: h ]. The interpreter does not handle @: directly from what I remember from thi

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Taking your last sentence first, you would have to supply some evidence to make me believe that tacit forms have any intrinsic performance penalty. It is dawning on me that you want fast function definition, but that you want it to produce tacit code.  You find the current tacit language diffi

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! Is improving explicit J the way forward? Or is tacit J and improving tacit J the way forward? I also think that "Henry's" proposal, which is similar to what I have been writing about for a long time, is great.  It is easy to do and have great benefits for people working in explicit J.

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

I also like Henry's suggestion of fast function definition. It's also unclear to me on how the Erling's suggestion improves upon that. On Thu, Sep 28, 2017 at 5:45 PM, Louis de Forcrand wrote: > I don't really understand what you wish to add either, Erling. > > If you want to use explicit J synt

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! I think my blog post describes my view: https://erlhelinfotech.wordpress.com/2016/08/01/jwithatwist-or-tacit-j/ It is in no way exhaustive in terms of problems  I find in tacit J, but I think it was more than enough for taking the decision. "The tacit J syntax is a total mess of utter

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Creating a new variable with the same name is equivalent to having a declared variable that you can change in other languages, a mutable variable? Thus, all variables in J are mutable? Not just some bitmap arrays which are in-place editied under certain conditions? /Erling On 2017-09-29 02:19,

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

There usually have to be exceptions. Does it mean that tacit J does not limit mutable state more than explicit J? It seems when you have no variables at least the variables are not mutable? /Erling On 2017-09-29 01:45, Raul Miller wrote: Tacit J can have mutable state. For example: set=:

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi Erling, Just want to suggest that statements like "we recognized tacit J is not useful" seem a little premature unless "we" is the royal "we" i.e. "I". Even then I suspect a more accurate statement would be "I don't see the benefits of tacit J". So far my understanding of your position is that

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Tacit J can have mutable state. For example: set=:1!:2&(<'state') get=:1!:1 bind (<'state') It's also possible implement mutable state in tacit J without using foreigns (nor the explicit conjunction), but (depending on your approach), it can get long. Thanks, -- Raul On Thu, Sep 28, 20

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all! See comments below. Cheers, Erling On 2017-09-28 23:45, Louis de Forcrand wrote: I don't really understand what you wish to add either, Erling. If you want to use explicit J syntax, you could write an explicit verb. The main difference between tacit J and explicit J, as I see it, is n

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

I don't really understand what you wish to add either, Erling. If you want to use explicit J syntax, you could write an explicit verb. You write: > Particularly to create what you most commonly need, a sequence of > monadic verbs, each acting on the result of the verb to the right. > Well, it is

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Jose's work is impressive, but I try to avoid it because of the extra complexity it creates when I want to (for example) provide a parameter in clauses for conjunctions like &. -- the extra complexity can be a nice mental exercise and maybe even a cure for boredom, but I feel that I have the right

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Sorry, this was obviously wrong, but I wondered about Tacit programming and it seems to be about things expressed here. https://en.wikipedia.org/wiki/Combinatory_logic#Examples_of_combinators /Erling On 2017-09-28 14:40, Erling Hellenäs wrote: The fork seems to be the S-combinator. https://en.w

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

The fork seems to be the S-combinator. https://en.wikipedia.org/wiki/Combinatory_logic#Examples_of_combinators /Erling On 2017-09-28 14:33, Erling Hellenäs wrote: Hi all ! I am very impressed by Jose's work and I think it is an excellent illustration to why we need the modification to J I pr

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! I am very impressed by Jose's work and I think it is an excellent illustration to why we need the modification to J I propose. It is extremely  complicated to do these things which should be simple, as I see it. Particularly to create what you most commonly need, a sequence of monadic

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi Erling, You are right, the adverb (At) produces tacit sentences but it is really an implementation of Dan's pipeline proposal using strand notation via a Curried adverb (aka, recurrent adverb and multiple adverb). However, I have written (tacitly) a tacit Curried adverb (xi) which, using a lam

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Tacit programming, wikipedia. https://en.wikipedia.org/wiki/Tacit_programming /Erling On 2017-09-27 13:34, Erling Hellenäs wrote: "A tacit expression is a sequence of J operations, which can be separated from its arguments." http://code.jsoftware.com/wiki/Essays/Tacit_Expressions *Tacit Defini

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! I think that as long as you don't use any mutable variables, what Henry want's to do might be very similar to what I'm asking for. It even has some functionality which is an improvement compared to tacit expressions and which still is within the bounds you try to stay within in modern

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! I think the main difference between explicit J and tacit expressions is that these do not have mutable state and I think they have no or rarely have side effects. Since you can't pass functions as results in runtime tacit expressions are not really functional, as I see it. They could

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! My request is only an equivalent to tacit J, but with right to left execution modified by parenthesis like in explicit J. I can't really do this investigation, but it was very interesting to see this paper. Fantastic how these expressions have evolved from the little FIX editor Ken

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Great. Erling, how does your proposal differ from the above (glossing over specifics like using [, ] etc.)? On Wed, Sep 27, 2017 at 9:06 AM, Henry Rich wrote: > You have my proposal right. It is like d-fns. There is no new added > functionality - in fact there can't be, because every (. ). fun

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

You have my proposal right.  It is like d-fns.  There is no new added functionality - in fact there can't be, because every (. ). function is converted to an explicit definition. The benefit is ease of creating explicit entities, even if they are anonymous, multiline, or nested within other en

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Simple question (avoiding the tacit-v, tacit-t etc. terminology so that we're all on the same page): Are you essentially proposing something akin to Dyalog's d-fns? See, for example, https://www.dyalog.com/uploads/documents/Papers/dfns.pdf. (We don't have lexical scope in J, so the comparison isn't

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

It's hard to understand what could possibly remain to explain. Well, lets see if something more happens in the discussion. I'll give up on the second and third question. /Erling On 2017-09-27 16:23, Henry Rich wrote: I am sorry, but I have not been able to make sense of the last several messag

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

I am sorry, but I have not been able to make sense of the last several messages.  JWithATwist is outside my area of interest.  If you can describe this idea fairly precisely, and explain why it should be implemented, I will try to understand it. To me, yes, what you can do with a language is t

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

So it would be relevant to discuss this request in terms of programmer productivity? Any opinions? /Erling? On 2017-09-27 16:01, Don Guinn wrote: If you want the most powerful programming language it has to be assembly. It can do everything that every other programming language can do and so mu

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

If you want the most powerful programming language it has to be assembly. It can do everything that every other programming language can do and so much more. But what is the purpose of languages like J and C++? They are to make people more productive, not computers. On Sep 27, 2017 7:34 AM, "Erlin

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! See comments below. There are still two unanswered questions. You are not required to answer them, of course. Cheers, Erling Hellenäs On 2017-09-27 13:36, Henry Rich wrote: The syntax is that of explicit J but missing some things, like control words and assignment, and perhaps the

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

To: programm...@jsoftware.com Sent: Wednesday, September 27, 2017 5:28 AM Subject: Re: [Jprogramming] Tacit Expressions with Explicit J Syntax Hi all! I am not sure I understood this fully, but I understand that I could create a parser in J so that I could write explicit J code and get a

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

The syntax is that of explicit J but missing some things, like control words and assignment, and perhaps the ability to write multiline expressions.  If it produces tacit J, it's also not going to be able to define modifiers. I just don't see that having a new way to write tacit verbs is a cha

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

"A tacit expression is a sequence of J operations, which can be separated from its arguments." http://code.jsoftware.com/wiki/Essays/Tacit_Expressions *Tacit Definition* Thedefinition of atacit verb

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! Here is a related blog post: https://erlhelinfotech.wordpress.com/2016/08/01/jwithatwist-or-tacit-j/ Cheers, Erling On 2017-09-27 12:25, Erling Hellenäs wrote: Hi all ! See comments below. Henry, you answered one of three questions. Cheers, Erling On 2017-09-27 11:09, Henry Rich

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! See comments below. Henry, you answered one of three questions. Cheers, Erling On 2017-09-27 11:09, Henry Rich wrote: I have trouble contributing to this because I don't understand your proposal as written.  One thing I don't understand is why you call your new verbs 'tacit'.  It ap

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

pared to {} (due to existing J meaning of those). Its a matter of reducing the annoyance of quotes IMO. It looks like you want to compile your t-v expressions into J code, and jpp is suited for this too. From: Erling Hellenäs To: programm...@jsoftware.com Sent: Tuesday, September 26, 2017 7:

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! Pascal, I will come back to your post later. Here is a little compiler written in Jx and compiling, as I understand it, tacit code with explicit J syntax into tacit J. I did not test it, I just read the post. http://www.jsoftware.com/pipermail/programming/2017-August/048143.html The

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

I have trouble contributing to this because I don't understand your proposal as written.  One thing I don't understand is why you call your new verbs 'tacit'.  It appeared to me that they used ] and [ as tokens indicating the input arguments.  That would make them explicit, by the definition of

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all! It seems like fast function definitions is only for creating explicit J verbs, adverbs and conjunctions? This means it is only vaguely related to my proposal of tacit verbs with explicit J syntax? Maybe the fast function definition discussion should therefore have it's own thread?

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Hi all ! Eric, since we link the request in this discussion, can I move it when the discussion is over? There is a blog at https://erlhelinfotech.wordpress.com/ and a twitter account at https://twitter.com/erlheldata where this is also discussed. If we did not care to block the possibility of

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Good point, colorization.  I never thought about that. The big difference between Fast Functions and 3 : functions is that Fast Functions are recognized when a script is loaded, instead of when the 3 : is executed.  It is the fact that 3 : is executed like any other conjunction that prevents n

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Prepass means essentially that this happens after word formation but before parsing. That does eliminate some problems, but creates new ones. It also suggests that you would be supporting explicit control words. But it also means that you need to put a lot more thought into how these would be repre

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

My idea is that (. and ). be handled before parsing, as a prepass.  Thus, the (. construct can be spread across multiple lines.  [Perhaps this would be supported ONLY for lines coming from a script, for ease of implementation.]  Normal function definition would look like name =: (. lines... ).

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

The line "Use (. ... ). to be recognized as m : '...' where m is chosen based on occurrence of xyuvmn" in http://code.jsoftware.com/wiki/System/Interpreter/Requests#Fast_Function_Definition suggests that we would use m : '...' for the display format of those function definitions. That said, (. x

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Erling, Henry pointed out that in my last para I meant inappropriate rather than appropriate. He also pointed out that perhaps we need 2 levels of requests. Those that are perhaps smaller, better defined, and less ambitious in scope and and thereby have a better chance of seeing the implemented l

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

Erling, I have read your proposal briefly. I can't comment on the merit, but I can definitely clarify that it is not in the spirit of the Interpreter/Requests page. That page is for straight forward proposals that are clearly and fairly completely stated, that extend the language in obvious ways,

Re: [Jprogramming] Tacit Expressions with Explicit J Syntax

tware.com Sent: Tuesday, September 26, 2017 7:26 AM Subject: [Jprogramming] Tacit Expressions with Explicit J Syntax Hi all ! I entered a request for tacit expressions with explicit J syntax. http://code.jsoftware.com/wiki/System/Interpreter/Requests#Tacit_expressions_with_explicit_J_syntax I

  1   2   >