Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.forth > #50446 > unrolled thread

Rosetta Code: Catamorphism

Back to article view | Back to comp.lang.forth

Contents

  Rosetta Code: Catamorphism "WJ" <w_a_x_man@yahoo.com> - 2016-08-24 15:27 +0000
    Rosetta Code: Catamorphism Julian Fondren <julian.fondren@gmail.com> - 2016-08-24 12:43 -0700
      Re: Rosetta Code: Catamorphism anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2016-08-25 09:53 +0000
        Re: Rosetta Code: Catamorphism Julian Fondren <julian.fondren@gmail.com> - 2016-08-25 06:41 -0700
          Re: Rosetta Code: Catamorphism Andrew Haley <andrew29@littlepinkcloud.invalid> - 2016-08-25 16:06 -0500
            Re: Rosetta Code: Catamorphism foxaudioresearch@gmail.com - 2016-08-25 20:40 -0700
              Rosetta Code ( was Re: Rosetta Code: Catamorphism) "HAA" <someone@microsoft.com> - 2016-08-29 12:06 +1000
                Re: Rosetta Code ( was Re: Rosetta Code: Catamorphism) Andrew Haley <andrew29@littlepinkcloud.invalid> - 2016-08-29 01:41 -0500
          Re: Rosetta Code: Catamorphism anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2016-08-27 10:01 +0000
            Re: Rosetta Code: Catamorphism hughaguilar96@gmail.com - 2016-08-29 01:21 -0700
              Re: Rosetta Code: Catamorphism hughaguilar96@gmail.com - 2016-08-29 01:36 -0700
                Re: Rosetta Code: Catamorphism Julian Fondren <ayrnieu@gmail.com> - 2016-08-29 07:23 -0700
                  Re: Rosetta Code: Catamorphism anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2016-08-29 16:58 +0000
                    Re: Rosetta Code: Catamorphism peter.m.falth@gmail.com - 2016-08-29 13:15 -0700
                      Re: Rosetta Code: Catamorphism anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2016-08-29 20:53 +0000
                        Re: Rosetta Code: Catamorphism peter.m.falth@gmail.com - 2016-08-30 04:47 -0700
                          Re: Rosetta Code: Catamorphism anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2016-09-05 07:13 +0000
                      Re: Rosetta Code: Catamorphism "HAA" <someone@microsoft.com> - 2016-08-30 11:54 +1000
                  Re: Rosetta Code: Catamorphism "HAA" <someone@microsoft.com> - 2016-08-31 12:34 +1000
              Re: Rosetta Code: Catamorphism "HAA" <someone@microsoft.com> - 2016-08-29 18:44 +1000
                Re: Rosetta Code: Catamorphism hughaguilar96@gmail.com - 2016-09-01 23:47 -0700
                  Re: Rosetta Code: Catamorphism Coos Haak <htrofhc@gmail.com> - 2016-09-02 12:42 +0200
                    Re: Rosetta Code: Catamorphism anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2016-09-02 11:45 +0000
                      Re: Rosetta Code: Catamorphism Coos Haak <htrofhc@gmail.com> - 2016-09-02 15:01 +0200
                        Re: Rosetta Code: Catamorphism anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2016-09-02 16:04 +0000
                      Re: Rosetta Code: Catamorphism albert@cherry.spenarnc.xs4all.nl (Albert van der Horst) - 2016-09-02 16:23 +0200
              Re: Rosetta Code: Catamorphism Bruce Axtens <bruce.axtens@gmail.com> - 2016-08-29 18:29 +0800
                Re: Rosetta Code: Catamorphism Ron Aaron <rambamist@gmail.com> - 2016-08-29 13:41 +0300
                  Re: Rosetta Code: Catamorphism Bruce Axtens <bruce.axtens@gmail.com> - 2016-08-31 09:24 +0800
                    Standard or Forth? "HAA" <someone@microsoft.com> - 2016-09-01 13:45 +1000
                      Re: Standard or Forth? hughaguilar96@gmail.com - 2016-09-02 21:54 -0700
                        Re: Standard or Forth? Gerry Jackson <gerry@jackson9000.fsnet.co.uk> - 2016-09-04 07:35 +0100
                          Re: Standard or Forth? hughaguilar96@gmail.com - 2016-09-04 00:41 -0700
                            Re: Standard or Forth? Julian Fondren <julian.fondren@gmail.com> - 2016-09-04 02:55 -0700
                            Re: Standard or Forth? Gerry Jackson <gerry@jackson9000.fsnet.co.uk> - 2016-09-04 13:26 +0100
                              Re: Standard or Forth? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2016-09-04 13:59 +0000
                              Re: Standard or Forth? hughaguilar96@gmail.com - 2016-09-04 23:09 -0700
                                Re: Standard or Forth? Ron Aaron <rambamist@gmail.com> - 2016-09-05 09:55 +0300
                                Re: Standard or Forth? Gerry Jackson <gerry@jackson9000.fsnet.co.uk> - 2016-09-05 08:39 +0100
                          Re: Standard or Forth? hughaguilar96@gmail.com - 2016-09-04 01:25 -0700
                            Re: Standard or Forth? Gerry Jackson <gerry@jackson9000.fsnet.co.uk> - 2016-09-04 14:13 +0100
                              Re: Standard or Forth? Coos Haak <htrofhc@gmail.com> - 2016-09-04 23:16 +0200
                              Re: Standard or Forth? hughaguilar96@gmail.com - 2016-09-04 22:33 -0700
                                Re: Standard or Forth? Ron Aaron <rambamist@gmail.com> - 2016-09-05 09:03 +0300
                                  Re: Standard or Forth? hughaguilar96@gmail.com - 2016-09-06 23:23 -0700
                                    Re: Standard or Forth? Ron Aaron <rambamist@gmail.com> - 2016-09-07 10:14 +0300
                                      Re: Standard or Forth? hughaguilar96@gmail.com - 2016-09-07 01:01 -0700
                                        Re: Standard or Forth? Ron Aaron <rambamist@gmail.com> - 2016-09-07 11:18 +0300
                                        Re: Standard or Forth? Cecil Bayona <cbayona@cbayona.com> - 2016-09-07 08:47 -0500
                                Re: Standard or Forth? Gerry Jackson <gerry@jackson9000.fsnet.co.uk> - 2016-09-05 09:20 +0100
                                  Re: Standard or Forth? hughaguilar96@gmail.com - 2016-09-05 02:21 -0700
                              Re: Standard or Forth? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2016-09-05 08:10 +0000
                                Re: Standard or Forth? Gerry Jackson <gerry@jackson9000.fsnet.co.uk> - 2016-09-05 10:51 +0100
                      Re: Standard or Forth? "Elizabeth D. Rather" <erather@forth.com> - 2016-09-03 08:05 +0200
                        Re: Standard or Forth? Andrew Haley <andrew29@littlepinkcloud.invalid> - 2016-09-03 03:00 -0500
                        Re: Standard or Forth? "HAA" <someone@microsoft.com> - 2016-09-03 22:48 +1000
                          Re: Standard or Forth? Alex <alex@rivadpm.com> - 2016-09-03 15:05 +0100
                          Re: Standard or Forth? Julian Fondren <julian.fondren@gmail.com> - 2016-09-03 07:46 -0700
                          Re: Standard or Forth? "Elizabeth D. Rather" <erather@forth.com> - 2016-09-03 23:53 +0200
                          Re: Standard or Forth? stephen@mpeforth.com (Stephen Pelc) - 2016-09-03 22:37 +0000
                            Re: Standard or Forth? hughaguilar96@gmail.com - 2016-09-03 21:17 -0700
                            Re: Standard or Forth? "HAA" <someone@microsoft.com> - 2016-09-05 02:35 +1000
                              Re: Standard or Forth? albert@cherry.spenarnc.xs4all.nl (Albert van der Horst) - 2016-09-05 03:18 +0200
                                Re: Standard or Forth? "HAA" <someone@microsoft.com> - 2016-09-08 22:04 +1000
                                  Re: Standard or Forth? Paul Rubin <no.email@nospam.invalid> - 2016-09-08 12:41 -0700
                                    Re: Standard or Forth? "HAA" <someone@microsoft.com> - 2016-09-09 12:51 +1000
                                      Re: Standard or Forth? Paul Rubin <no.email@nospam.invalid> - 2016-09-08 21:50 -0700
                                        Re: Standard or Forth? "HAA" <someone@microsoft.com> - 2016-09-12 17:16 +1000
                                          Re: Standard or Forth? anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2016-09-12 16:59 +0000
                                            Re: Standard or Forth? "HAA" <someone@microsoft.com> - 2016-09-15 13:38 +1000
                                    Re: Standard or Forth? hughaguilar96@gmail.com - 2016-09-08 23:33 -0700
                              Re: Standard or Forth? Gerry Jackson <gerry@jackson9000.fsnet.co.uk> - 2016-09-05 08:41 +0100
                                Re: Standard or Forth? hughaguilar96@gmail.com - 2016-09-05 01:42 -0700
            Re: Rosetta Code: Catamorphism albert@cherry.spenarnc.xs4all.nl (Albert van der Horst) - 2016-08-29 16:03 +0200
              Re: Rosetta Code: Catamorphism anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2016-08-29 16:04 +0000

Page 2 of 4 — ← Prev page 1 [2] 3 4  Next page →

#50605

On Monday, August 29, 2016 at 1:43:57 AM UTC-7, HAA wrote:
> hughaguilar96@gmail.com wrote:
> > On Saturday, August 27, 2016 at 3:53:59 AM UTC-7, Anton Ertl wrote:
> > > Anyway, let's see what the code above looks like with ]]...[[ and BOUNDS:
> > >
> > > : map< ( -- ) ]] cells bounds ?do i @ [[ ; immediate
> > > : >map ( -- ) ]] 1 +loop [[ ; immediate
> >
> > This is how they look with MACRO: from the novice-package (it is ANS-Forth, as is
> > everything in the novice-package):
> >
> > macro: map< ( -- )
> >     cells bounds ?do  i @ ;
> >
> > macro: >map ( -- )
> >     1 +loop ;
> >
> > Personally, I find ]] and [[ to be very hard to read, mostly because they are being
> > used as brackets but they are backwards (pointing outward rather than pointing inward).
> >
> > I'm not familiar with ]] and [[ --- are these ANS-Forth? --- or are these Forth-200x?
> 
> As they're not standard, they could be anything.  But since they're in GForth
> and GForth has a presence on 200x, they may become standard :)
> 
>  ]] xx yy zz [[  is equivalent to POSTPONE xx POSTPONE yy POSTPONE zz
> 
> A possible implementation is
> 
> : ]]  \ multiple POSTPONE handler
>   begin
>     >in @  bl word count  ?dup if
>       s" [[" compare if
>         >in !  postpone postpone  true
>       else  drop  false  then
>     else  2drop  refill  then  0=
>   until ; immediate

Well, I tested your definition under VFX:

: ]]  \ multiple POSTPONE handler  
  begin  
    >in @  bl word count  ?dup if  
      s" [[" compare if  
        >in !  postpone postpone  true  
      else  drop  false  then  
    else  2drop  refill  then  0=  
  until ; immediate   ok

: test ]] s" Howdy!" [[ ; immediate 
Err# -13 ERR: Undefined word.
 -> : test ]] s" Howdy!" [[ ; immediate
                        ^
: test2 ]] 5 . [[ ; immediate  ok
: test22 test2 ;  ok
test22 5  ok

I predicted that TEST was not going to work. 

I am baffled as to how TEST2 could work --- we are doing a POSTPONE of 5 and this works??? --- POSTPONE is defined in the ANS-Forth document (section 6.1.2033) like this:
---------------------------------------------------------------------------
Skip leading space delimiters. Parse name delimited by a space. Find name. Append the compilation semantics of name to the current definition. An ambiguous condition exists if name is not found.
---------------------------------------------------------------------------
How do you "find" a number??? That this works is just a non-standard VFX feature.

Anyway, I don't care. I have had MACRO: working since 2009 and I'm happy with it --- I think the ]] ... [[ brackets are extremely hard to read because they point outwards rather than inwards like brackets usually do, so I don't have any interest in implementing them --- I also just don't have the patience anymore to figure out ANS-Forth (if I did get ]] to work on particular ANS-Forth compilers, I wouldn't have confidence that it actually was ANS-Forth and would work on other ANS-Forth compilers).

You are right though that "GForth has a presence on 200x" (Anton Ertl is the chair-person of the Forth-200x committee, and Bernd Paysan is a committee member) --- so ]] will likely get put in Forth-200x despite being ugly --- my MACRO: has zero chance of getting put in Forth-200x because it is not "common practice" anywhere other than the novice-package where it is used routinely.

BTW: This is where I came up with the MACRO: definition:
https://groups.google.com/forum/#!searchin/comp.lang.forth/lc53%7Csort:relevance/comp.lang.forth/wP5nw1ClzsM/E-TV9v2y9RoJ
I originally had a macro that did FIND to obtain the xt values, and saved these --- so it was early-binding --- but it didn't work because FIND was broken, so I switched over to saving the source-code which is late-binding.

I also knew that the early-binding version would have to special-case all the immediate words like S" that take data out of the input stream, and this seemed like a big hassle (this is what I had done in MFX) --- also, this doesn't work because the user may have his own words like that which aren't being special-cased.

Late-binding is problematic because the definition might change --- I've been using MACRO: for years however, and this problem hasn't stung me yet --- it is not such a big deal as some people (Anton Ertl) suppose that it is (he has criticized my MACRO: because it uses late-binding).

[toc] | [prev] | [next] | [standalone]

#50613

Op Thu, 1 Sep 2016 23:47:37 -0700 (PDT) schreef hughaguilar96@gmail.com:
<snip>
> 
> Well, I tested your definition under VFX:
> 
>: ]]  \ multiple POSTPONE handler  
>   begin  
>     >in @  bl word count  ?dup if  
>       s" [[" compare if  
>         >in !  postpone postpone  true  
>       else  drop  false  then  
>     else  2drop  refill  then  0=  
>   until ; immediate   ok
> 
>: test ]] s" Howdy!" [[ ; immediate 
> Err# -13 ERR: Undefined word.
>  -> : test ]] s" Howdy!" [[ ; immediate

You stupid child, in essence you do the same as
: test postpone s" Howdy!" ;
You have learned that s" is a parsing word.
You may compile it, but no real Forth programmer
expects that it will compile the following string
during the compilation of test.

groet Coos

[toc] | [prev] | [next] | [standalone]

#50614

Coos Haak <htrofhc@gmail.com> writes:
>Op Thu, 1 Sep 2016 23:47:37 -0700 (PDT) schreef hughaguilar96@gmail.com:
><snip>
>>: test ]] s" Howdy!" [[ ; immediate 
>> Err# -13 ERR: Undefined word.
>>  -> : test ]] s" Howdy!" [[ ; immediate
>
>You stupid child, in essence you do the same as
>: test postpone s" Howdy!" ;
>You have learned that s" is a parsing word.
>You may compile it, but no real Forth programmer
>expects that it will compile the following string
>during the compilation of test.

Whatever a "real Forth programmer" may be.

The idea of S" is actually to behave in interpretation and compilation
state as if the string was part of the word (unlike, e.g., ').  So you
can write

: foo s" abc" ;
s" abc"

and both will parse 'abc"' at parse time, and push the string
descriptor at run-time.

The idea of ]]...[[ is to provide something like a postpone state, so
ideally ]] s" abc" [[ should parse 'abc"' at parse time, and push the
descriptor at run-time, too.  That does not work because of the
details of S" and ]]...[[, but ideally it would.  And with the string
recognizer, it actually does (tested with the development version of
Gforth):

: test ]] "Howdy!" [[ ; immediate  ok
: foo test ;  ok
foo type Howdy! ok

- anton
-- 
M. Anton Ertl  http://www.complang.tuwien.ac.at/anton/home.html
comp.lang.forth FAQs: http://www.complang.tuwien.ac.at/forth/faq/toc.html
     New standard: http://www.forth200x.org/forth200x.html
   EuroForth 2016: http://www.euroforth.org/ef16/

[toc] | [prev] | [next] | [standalone]

#50617

Op Fri, 02 Sep 2016 11:45:48 GMT schreef Anton Ertl:

> Coos Haak <htrofhc@gmail.com> writes:
>>Op Thu, 1 Sep 2016 23:47:37 -0700 (PDT) schreef hughaguilar96@gmail.com:
>><snip>
>>>: test ]] s" Howdy!" [[ ; immediate 
>>> Err# -13 ERR: Undefined word.
>>>  -> : test ]] s" Howdy!" [[ ; immediate
>>
>>You stupid child, in essence you do the same as
>>: test postpone s" Howdy!" ;
>>You have learned that s" is a parsing word.
>>You may compile it, but no real Forth programmer
>>expects that it will compile the following string
>>during the compilation of test.
> 
> Whatever a "real Forth programmer" may be.
> 
> The idea of S" is actually to behave in interpretation and compilation
> state as if the string was part of the word (unlike, e.g., ').  So you
> can write
> 
>: foo s" abc" ;
> s" abc"
> 
> and both will parse 'abc"' at parse time, and push the string
> descriptor at run-time.
> 
> The idea of ]]...[[ is to provide something like a postpone state, so
> ideally ]] s" abc" [[ should parse 'abc"' at parse time, and push the
> descriptor at run-time, too.  That does not work because of the
> details of S" and ]]...[[, but ideally it would.  And with the string
> recognizer, it actually does (tested with the development version of
> Gforth):
> 
>: test ]] "Howdy!" [[ ; immediate  ok
>: foo test ;  ok
> foo type Howdy! ok
> 
> - anton

My Forth does not have recognizers, but can do the same:

want ]]  ok
: test ]] "Howdy!" [[ ; immediate  ok
: foo test ;  ok
foo type Howdy! ok

groet Coos

[toc] | [prev] | [next] | [standalone]

#50622

Coos Haak <htrofhc@gmail.com> writes:
>Op Fri, 02 Sep 2016 11:45:48 GMT schreef Anton Ertl:
>> And with the string
>> recognizer, it actually does (tested with the development version of
>> Gforth):
>> 
>>: test ]] "Howdy!" [[ ; immediate  ok
>>: foo test ;  ok
>> foo type Howdy! ok
>> 
>> - anton
>
>My Forth does not have recognizers, but can do the same:
>
>want ]]  ok
>: test ]] "Howdy!" [[ ; immediate  ok
>: foo test ;  ok
>foo type Howdy! ok

Your Forth may not have user-defined recognizers (at least not in the
RfD sense), but it obviously has a string recognizer: a part of the
text interpreter that recognizes strings.

- anton
-- 
M. Anton Ertl  http://www.complang.tuwien.ac.at/anton/home.html
comp.lang.forth FAQs: http://www.complang.tuwien.ac.at/forth/faq/toc.html
     New standard: http://www.forth200x.org/forth200x.html
   EuroForth 2016: http://www.euroforth.org/ef16/

[toc] | [prev] | [next] | [standalone]

#50618

In article <2016Sep2.134548@mips.complang.tuwien.ac.at>,
Anton Ertl <anton@mips.complang.tuwien.ac.at> wrote:
>Coos Haak <htrofhc@gmail.com> writes:
>>Op Thu, 1 Sep 2016 23:47:37 -0700 (PDT) schreef hughaguilar96@gmail.com:
>><snip>
>>>: test ]] s" Howdy!" [[ ; immediate
>>> Err# -13 ERR: Undefined word.
>>>  -> : test ]] s" Howdy!" [[ ; immediate
>>
>>You stupid child, in essence you do the same as
>>: test postpone s" Howdy!" ;
>>You have learned that s" is a parsing word.
>>You may compile it, but no real Forth programmer
>>expects that it will compile the following string
>>during the compilation of test.
>
>Whatever a "real Forth programmer" may be.
>
>The idea of S" is actually to behave in interpretation and compilation
>state as if the string was part of the word (unlike, e.g., ').  So you
>can write
>
>: foo s" abc" ;
>s" abc"
>
>and both will parse 'abc"' at parse time, and push the string
>descriptor at run-time.
>
>The idea of ]]...[[ is to provide something like a postpone state, so
>ideally ]] s" abc" [[ should parse 'abc"' at parse time, and push the
>descriptor at run-time, too.  That does not work because of the
>details of S" and ]]...[[, but ideally it would.  And with the string
>recognizer, it actually does (tested with the development version of
>Gforth):
>
>: test ]] "Howdy!" [[ ; immediate  ok
>: foo test ;  ok
>foo type Howdy! ok

I rejected the idea of POSTPONE ing numbers for a long time as
ridiculous, but now you make me think.

This is how POSTPONE looked like in my simple Forth
(NAME FOUND replaces BL WORD FIND )
\ ' LIT CONSTANT 'LIT     ' , CONSTANT ',
: POSTPONE
    NAME FOUND \ DUP 0= 15 ?ERROR
    DUP >FFA @ IMM_FLAG AND 0= IF 'LIT , THEN ,
    ', ,
    ; IMMEDIATE

So the execution token is commaed in, for non-immediate words
preceded by LIT.
In the presence of denotations (numbers) I exclude
any prefixes by using PRESENT instead of FOUND
that requires that the name found and the name in the dictionary
have the same length,like so.

: PRESENT
    DUP >R FOUND DUP IF
        DUP >NFA @ @ R@ = AND   \ Name field address
    THEN RDROP ;
So prefixes give error 15  : CANNOT FIND WORD TO BE POSTPONED
Instead of forbidding, I could detect this third case in POSTPONE
and POSTPONE numbers. Crazy. Forth keeps on surprising us.

This is a bit tricky, for prefixes we need some form of EXECUTE
because (during the POSTPONE action!) it must do some parsing
that results in one or more constants.

>
>- anton
-- 
Albert van der Horst, UTRECHT,THE NETHERLANDS
Economic growth -- being exponential -- ultimately falters.
albert@spe&ar&c.xs4all.nl &=n http://home.hccnet.nl/a.w.m.van.der.horst

[toc] | [prev] | [next] | [standalone]

#50548

Hugh,

When is Straight Forth due? I'm not interested in ANS Forth for most of 
the reasons you have outlined in many earlier posts.

[toc] | [prev] | [next] | [standalone]

#50549

On 08/29/2016 13:29, Bruce Axtens wrote:

> When is Straight Forth due? 

Probably right after Get Bent Forth is released...

[toc] | [prev] | [next] | [standalone]

#50571

On 29/08/2016 6:41 PM, Ron Aaron wrote:
>
>
> On 08/29/2016 13:29, Bruce Axtens wrote:
>
>> When is Straight Forth due?
>
> Probably right after Get Bent Forth is released...
>
The way Hugh goes on, you'd think ANS Forth was the bent one.

[toc] | [prev] | [next] | [standalone]

#50589 — Standard or Forth?

Bruce Axtens wrote:
> On 29/08/2016 6:41 PM, Ron Aaron wrote:
> >
> >
> > On 08/29/2016 13:29, Bruce Axtens wrote:
> >
> >> When is Straight Forth due?
> >
> > Probably right after Get Bent Forth is released...
> >
> The way Hugh goes on, you'd think ANS Forth was the bent one.

As does Chuck: "I had reservations about ANSI. I worried that it would
be a disaster and not merely a dubious advantage. All of my fears of
the standard and none of the advantages of the standard have come
to pass. Any spirit of innovation has been thoroughly quelched.
Underground Forths are still needed."

[toc] | [prev] | [next] | [standalone]

#50632 — Re: Standard or Forth?

On Wednesday, August 31, 2016 at 8:45:09 PM UTC-7, HAA wrote:
> Bruce Axtens wrote:
> > On 29/08/2016 6:41 PM, Ron Aaron wrote:
> > >
> > >
> > > On 08/29/2016 13:29, Bruce Axtens wrote:
> > >
> > >> When is Straight Forth due?
> > >
> > > Probably right after Get Bent Forth is released...
> > >
> > The way Hugh goes on, you'd think ANS Forth was the bent one.
> 
> As does Chuck: "I had reservations about ANSI. I worried that it would
> be a disaster and not merely a dubious advantage. All of my fears of
> the standard and none of the advantages of the standard have come
> to pass. Any spirit of innovation has been thoroughly quelched.
> Underground Forths are still needed."

It is pretty sad when the inventor of a programming language is opposed to the Standard for that language and encourages "underground" versions --- Forth was totally hijacked!

I suspect that there is some kind of court order prohibiting Charles Moore from competing against Forth Inc. --- it is very strange that he abandoned Forth Inc. after founding the company, and he abandoned Forth language design after inventing Forth --- people don't voluntarily abandon everything they care about and then encourage underground resistance to it.

Anyway, to answer Bruce Axtens' question about when Straight Forth will come out: not anytime soon. I am still learning. For example, knowing that ANS-Forth lacks support for text, and writing code to support text, are two different things. I wrote STRING-STACK.4TH and I will put that in Straight Forth as an extension. Similarly, I recently wrote an OOP package with the intention of putting it it Straight Forth, but I haven't experimented with it enough yet to know if it is what I want (I would have to write one or two non-trivial programs using my OOP package to know this). I have a lot to learn about language design before I feel comfortable releasing my language publicly.

I am dreading releasing my language publicly. I am going to get flamed by the ANS-Forth cult members. I will be called a "stupid child" etc.. Ugh! This is what Charles Moore was referring to when he said: "Any spirit of innovation has been thoroughly squelched." At the time that Straight Forth is released, when the ANS-Forth cult is striving mightily to squelch it, I will have difficulty in fixing any mistakes that made it into the design, because doing so will involve admitting that I was wrong about something --- it is best if I wait until I'm absolutely sure that there are no mistakes --- I should really write one or two non-trivial programs in Straight Forth before I even consider releasing it publicly.

ANS-Forth was pushed through ANSI without having a reference compiler written and hence without being tested. This lack of testing is why there are so many mistakes in ANS-Forth. Also, it was designed by a committee, which is why there is so much ambiguity in allowing contradictory features. The first ANS-Forth compiler was SwiftForth released in 1997, which was 3 years after ANS-Forth was made Standard, and SwiftForth was so bug-ridden as to be unusable (not until version-3 could you use (LOCAL) without crashing the system). I don't want to go public with Straight Forth without first doing extensive testing, or I will just be doing the same thing as was done in ANS-Forth (standardizing half-baked ideas and outright bugs).

There is no hurry. Forth-200x is now Forth-201x, and will be Forth-202x pretty soon, and will likely be Forth-203x when it is finally completed --- Forth-200x just gets more and more complicated every year! --- there are extremely bad ideas already in Forth-200x, such as recognizers and Paysan-faked quotations, and these bad ideas have already doomed Forth-200x to failure.

[toc] | [prev] | [next] | [standalone]

#50650 — Re: Standard or Forth?

On 03/09/2016 05:54, hughaguilar96@gmail.com wrote:
> This is what Charles Moore was referring to when he said:
>"Any spirit of innovation has been thoroughly squelched."
> At the time that Straight Forth is released, when the
> ANS-Forth cult is striving mightily to squelch it, I will
> have difficulty in fixing any mistakes that made it into
> the design, because doing so will involve admitting that
> I was wrong about something --- it is best if I wait until
> I'm absolutely sure that there are no mistakes --- I
> should really write one or two non-trivial programs in
> Straight Forth before I even consider releasing it publicly.

Very wise, nothing kills an interest in software than finding it is 
bug-ridden. However this requires more than just a couple of non-trivial 
programs to be written before release, it requires a comprehensive set 
of test programs which test, not only the basic features but corner 
cases, and include them with the system. This is also true for 
applications and libraries. Few people seem to do this even though it is 
in the developers' interest to do so.

> There is no hurry. Forth-200x is now Forth-201x, and will be
> Forth-202x pretty soon, and will likely be Forth-203x when it
> is finally completed --- Forth-200x just gets more and more
> complicated every year! --- there are extremely bad ideas
> already in Forth-200x, such as recognizers and Paysan-faked
> quotations, and these bad ideas have already doomed Forth-200x
> to failure.

Aren't quotations and recognisers innovations for Forth and you are 
doing your best to squelch them. It seems to me that you and others in 
the anti-ANS/Forth200X brigade do the vast majority of any squelching 
that is going on, without much apparent success though. I see little 
squelching from the supporters of Forth 200X, they seem to mostly ignore 
you, particularly the ones you regularly insult.

-- 
Gerry

[toc] | [prev] | [next] | [standalone]

#50651 — Re: Standard or Forth?

On Saturday, September 3, 2016 at 11:35:44 PM UTC-7, Gerry wrote:
> On 03/09/2016 05:54, hughaguilar96@gmail.com wrote:
> > There is no hurry. Forth-200x is now Forth-201x, and will be
> > Forth-202x pretty soon, and will likely be Forth-203x when it
> > is finally completed --- Forth-200x just gets more and more
> > complicated every year! --- there are extremely bad ideas
> > already in Forth-200x, such as recognizers and Paysan-faked
> > quotations, and these bad ideas have already doomed Forth-200x
> > to failure.
> 
> Aren't quotations and recognisers innovations for Forth and you are 
> doing your best to squelch them. It seems to me that you and others in 
> the anti-ANS/Forth200X brigade do the vast majority of any squelching 
> that is going on, without much apparent success though. 

The Paysan-faked quotations aren't an innovation --- they are just :NONAME with syntactic sugar --- I have never used :NONAME for anything and I consider it to be pretty much useless.

Forth-200x calls these "quotations" but they aren't quotations at all, because they don't have access to the parent function's local variables. They ruin the word "quotation" by using it wrong. If I say that I have quotations, everybody will reply: "You Forth programmers' quotations aren't quotations --- they are fake --- all Forth programmers are fakes!" Then I have to struggle to show that I'm using the word correctly, but it is too late because Forth-200x has given the entire Forth community a reputation for being fakes. This is very similar to what was described in the book, "1984," in which the words' meanings was changed --- "peace" meant "war," "freedom" meant "slavery," etc. --- Forth-200x is doing the same thing here, changing the meaning of "quotation" to mean "syntactic sugar for :NONAME" --- it would really be better if you didn't fake this stuff --- just be honest and admit that you don't know how to implement quotations. Straight Forth will have quotations using a fat-xt --- this is trivial to implement --- with a 64-bit cell there is room for a 32-bit cfa and a 32-bit local-frame pointer (all addresses are 32-bit, and only 4GB is supported, despite it being a 64-bit system).

As for recognizers, that is not an innovation either --- that is an extremely bad idea. You are going to have a mish-mash of incompatible recognizers. If you have X sets of recognizers, and they all clash with each other (meaning that the order they are loaded is significant), then you have X! versions of Forth-200x syntax. The problem with ANS-Forth is too much ambiguity, but with recognizers in Forth-200x you are making the problem worse. With 5 sets of recognizers that clash with each other, you have 120 incompatible versions of Forth-200x syntax. Programs are not going to be portable, because they all  expect a different syntax. Also, it will be difficult for a person reading the source-code to figure out what it does. Normally, if a person sees a word that he doesn't know, then he can look it up in the documentation. With recognizers however, the person is going to see a lot of words which are interpreted by the recognizer but which aren't in the dictionary and aren't in the documentation either, so he doesn't know what the word means without learning how the recognizers work and mentally applying the recognizer to the word that is confusing him. All in all, I think that recognizers are such a bad idea that they totally doom Forth-200x to failure --- this is really the worst idea ever --- this will kill Forth.

The name "Straight Forth" implies that it is straightforward --- recognizers aren't straightforward --- I'm really not going to allow everybody to have their own syntax.

People are going to have to find another outlet for their creativity rather than inventing their own syntax which is incompatible with everybody else's syntax. The Forth-200x crowd are not writing programs in Forth. Instead, they are spending their time dinking around with recognizers and other nonsense. This is why Forth-200x is a toy language --- inventing your own syntax is a science-fair project --- this is not useful for writing programs.

The purpose of Straight Forth is to support cross-compilers. People can apply their creativity to writing a cross-compiler for a new micro-controller. Forth-200x is squelching cross-compilers by refusing to provide the support needed. Specifically, it is necessary to be able to determine from an xt what its attributes are (what word-list it is in, immediate or not, smudged or not, smudge-ready or not) and also to change these attributes. There are some other features also needed for a cross-compiler, but everything needed for a cross-compiler is trivial to implement and straightforward to document. Forth-200x refuses to support cross-compilers because they don't want the common Forth programmer to write a cross-compiler in competition with MPE and Forth Inc..

> I see little 
> squelching from the supporters of Forth 200X, they seem to mostly ignore 
> you, particularly the ones you regularly insult.

Thanks for not calling me a "stupid child" as Coos Haak did earlier in this thread --- I get insulted like this routinely from the ANS-Forth cult members --- it gets on my nerves.

[toc] | [prev] | [next] | [standalone]

#50653 — Re: Standard or Forth?

On Sunday, September 4, 2016 at 2:41:40 AM UTC-5, hughag...@gmail.com wrote:
> On Saturday, September 3, 2016 at 11:35:44 PM UTC-7, Gerry wrote:
> > On 03/09/2016 05:54, hughaguilar96@gmail.com wrote:
> > > There is no hurry. Forth-200x is now Forth-201x, and will be
> > > Forth-202x pretty soon, and will likely be Forth-203x when it
> > > is finally completed --- Forth-200x just gets more and more
> > > complicated every year! --- there are extremely bad ideas
> > > already in Forth-200x, such as recognizers and Paysan-faked
> > > quotations, and these bad ideas have already doomed Forth-200x
> > > to failure.
> > 
> > Aren't quotations and recognisers innovations for Forth and you are 
> > doing your best to squelch them. It seems to me that you and others in 
> > the anti-ANS/Forth200X brigade do the vast majority of any squelching 
> > that is going on, without much apparent success though. 
> 
> I have never used :NONAME for anything and I consider it to be pretty much useless.

1. has never written higher-order code of his own, ever  (except for
   painfully contrived examples where the technique is basically used
   only for control flow within a definition)
2. has very strong opinions about how it should be done.
3. is not bothered by opposition from all who do write such code.

#JustHughThings

> If I say that I have quotations, everybody will reply: "You Forth
> programmers' quotations aren't quotations --- they are fake --- all
> Forth programmers are fakes!"

1. distressed over Forth's reputation and how its programmers are seen
2. "how's your language?  ours has an evil plot to keep people from
   writing cross compilers.  Forth is a crippled language!"

#JustHughThings

> As for recognizers, that is not an innovation either --- that is an
> extremely bad idea. You are going to have a mish-mash of
> incompatible recognizers. If you have X sets of recognizers, and
> they all clash with each other (meaning that the order they are
> loaded is significant), 

"wordlists are bad", the post.

> Normally, if a person sees a word that he doesn't know, then he can
> look it up in the documentation. With recognizers however, the
> person is going to see a lot of words which are interpreted by the
> recognizer but which aren't in the dictionary and aren't in the
> documentation either,

Tune in tomorrow for more of this show, "adventures of the man telling
people as they're actively doing things why what they're already
successfully doing is impossible and will lead to certain disaster."

Alternate-history Hugh: 

  Forth is bad!  In Forth you can make a word like SD(*FSDFJSDFIJ <-
  actual possible word in Forth.  That's impossible to read!  Thus,
  Forth must be impossible to read.  I bet it's all SDPO)(*DF(* and
  *SDUF_-f/ and S(DF*JSDJJASIDJJ all the time, because words like that
  can be used in Forth.  Forth code probably turns people into stone
  faster than Medusa!  Forth people are idiots for using such words!

> The Forth-200x crowd are not writing programs in Forth. Instead,
> they are spending their time dinking around with recognizers and
> other nonsense. This is why Forth-200x is a toy language ---
> inventing your own syntax is a science-fair project --- this is not
> useful for writing programs.

Clearly, more useful programs should be submitted for
standardization...

> Thanks for not calling me a "stupid child" as Coos Haak did earlier
> in this thread --- I get insulted like this routinely from the
> ANS-Forth cult members --- it gets on my nerves.

What rude people--getting on your nerves, like that.  You are so careful to
avoid anyone else's nerves.


-- Julian

[toc] | [prev] | [next] | [standalone]

#50654 — Re: Standard or Forth?

On 04/09/2016 08:41, hughaguilar96@gmail.com wrote:
> On Saturday, September 3, 2016 at 11:35:44 PM UTC-7, Gerry wrote:
>> On 03/09/2016 05:54, hughaguilar96@gmail.com wrote:
>>> There is no hurry. Forth-200x is now Forth-201x, and will be
>>> Forth-202x pretty soon, and will likely be Forth-203x when it
>>> is finally completed --- Forth-200x just gets more and more
>>> complicated every year! --- there are extremely bad ideas
>>> already in Forth-200x, such as recognizers and Paysan-faked
>>> quotations, and these bad ideas have already doomed Forth-200x
>>> to failure.
>>
>> Aren't quotations and recognisers innovations for Forth and you are
>> doing your best to squelch them. It seems to me that you and others in
>> the anti-ANS/Forth200X brigade do the vast majority of any squelching
>> that is going on, without much apparent success though.
>
> The Paysan-faked quotations aren't an innovation --- they are just :NONAME with syntactic sugar --- I have never used :NONAME for anything and I consider it to be pretty much useless.

Squelch 1

Quotations are an innovation in ANS Forth, they provide the first 
mechanism for nesting definitions inside another definition.
  So they are not "just :NONAME with syntactic sugar".


I don't use floating point, so should I be campaigning to get the 
Floating Point wordset deleted from Forth 200X on the grounds that I 
find it useless?

>
> Forth-200x calls these "quotations" but they aren't quotations at all, because they don't have access to the parent function's local variables. They ruin the word "quotation" by using it wrong. If I say that I have quotations, everybody will reply: "You Forth programmers' quotations aren't quotations --- they are fake --- all Forth programmers are fakes!" Then I have to struggle to show that I'm using the word correctly, but it is too late because Forth-200x has given the entire Forth community a reputation for being fakes. This is very similar to what was described in the book, "1984," in which the words' meanings was changed --- "peace" meant "war," "freedom" meant "slavery," etc. --- Forth-200x is doing the same thing here, changing the meaning of "quotation" to mean "syntactic sugar for :NONAME"

Squelch 2

Is there an industry standard definition of the term 'quotations'? I 
couldn't find one.

> --- it would really be better if you didn't fake this stuff --- just be honest and admit that you don't know how to implement quotations.

But I do know how to. I remember sending you some code a year or two 
back that did so, explaining how it worked and you said you liked it!

>
> As for recognizers, that is not an innovation either --- that is an extremely bad idea.

Squelch 3  part 1

Whether recognisers are a bad idea or not it's still an innovation for 
Forth.

> You are going to have a mish-mash of incompatible recognizers. If you have X sets of recognizers, and they all clash with each other (meaning that the order they are loaded is significant), then you have X! versions of Forth-200x syntax.

Why should they clash with each other any more than, say, libraries or 
wordlists do. If the recognisers are supplied with the system, they 
shouldn't clash. if they are defined by the user and they clash, that's 
the user's fault.

> The problem with ANS-Forth is too much ambiguity, but with recognizers in Forth-200x you are making the problem worse. With 5 sets of recognizers that clash with each other, you have 120 incompatible versions of Forth-200x syntax. Programs are not going to be portable, because they all  expect a different syntax. Also, it will be difficult for a person reading the source-code to figure out what it does. Normally, if a person sees a word that he doesn't know, then he can look it up in the documentation. With recognizers however, the person is going to see a lot of words which are interpreted by the recognizer but which aren't in the dictionary and aren't in the documentation either, so he doesn't know what the word means without learning how the recognizers work and mentally applying the recognizer to the word that is confusing him. All in all, I think that recognizers are such a bad idea that they totally doom Forth-200x to failure --- this is really the worst idea ever --- this w
ill kill Forth.

Squelch 3 part 2

But Forth has always been able to create it's own syntax - it's one of 
its strong points. You do it in your Novice package.

>
> Thanks for not calling me a "stupid child"

You're welcome, it's actually easy to not insult people, it takes less 
time too.

-- +-
Gerry

[toc] | [prev] | [next] | [standalone]

#50656 — Re: Standard or Forth?

Gerry Jackson <gerry@jackson9000.fsnet.co.uk> writes:
>Is there an industry standard definition of the term 'quotations'? I 
>couldn't find one.

Googlintg for "quotations programming" does not bring up anything in
that direction.  We have the term from Factor.  Not sure where Factor
has it from.  BTW, I have not heard from the Factor people in a while.
Have they abandoned Usenet?

- anton
-- 
M. Anton Ertl  http://www.complang.tuwien.ac.at/anton/home.html
comp.lang.forth FAQs: http://www.complang.tuwien.ac.at/forth/faq/toc.html
     New standard: http://www.forth200x.org/forth200x.html
   EuroForth 2016: http://www.euroforth.org/ef16/

[toc] | [prev] | [next] | [standalone]

#50678 — Re: Standard or Forth?

On Sunday, September 4, 2016 at 5:26:23 AM UTC-7, Gerry wrote:
> On 04/09/2016 08:41, hughaguilar96@gmail.com wrote:
> > On Saturday, September 3, 2016 at 11:35:44 PM UTC-7, Gerry wrote:
> >> On 03/09/2016 05:54, hughaguilar96@gmail.com wrote:
> >>> There is no hurry. Forth-200x is now Forth-201x, and will be
> >>> Forth-202x pretty soon, and will likely be Forth-203x when it
> >>> is finally completed --- Forth-200x just gets more and more
> >>> complicated every year! --- there are extremely bad ideas
> >>> already in Forth-200x, such as recognizers and Paysan-faked
> >>> quotations, and these bad ideas have already doomed Forth-200x
> >>> to failure.
> >>
> >> Aren't quotations and recognisers innovations for Forth and you are
> >> doing your best to squelch them. It seems to me that you and others in
> >> the anti-ANS/Forth200X brigade do the vast majority of any squelching
> >> that is going on, without much apparent success though.
> >
> > The Paysan-faked quotations aren't an innovation --- they are just :NONAME with syntactic sugar --- I have never used :NONAME for anything and I consider it to be pretty much useless.
> 
> Squelch 1
> 
> Quotations are an innovation in ANS Forth, they provide the first 
> mechanism for nesting definitions inside another definition.
>   So they are not "just :NONAME with syntactic sugar".
> 
> I don't use floating point, so should I be campaigning to get the 
> Floating Point wordset deleted from Forth 200X on the grounds that I 
> find it useless?
> 
> >
> > Forth-200x calls these "quotations" but they aren't quotations at all, because they don't have access to the parent function's local variables. They ruin the word "quotation" by using it wrong. If I say that I have quotations, everybody will reply: "You Forth programmers' quotations aren't quotations --- they are fake --- all Forth programmers are fakes!" Then I have to struggle to show that I'm using the word correctly, but it is too late because Forth-200x has given the entire Forth community a reputation for being fakes. This is very similar to what was described in the book, "1984," in which the words' meanings was changed --- "peace" meant "war," "freedom" meant "slavery," etc. --- Forth-200x is doing the same thing here, changing the meaning of "quotation" to mean "syntactic sugar for :NONAME"
> 
> Squelch 2
> 
> Is there an industry standard definition of the term 'quotations'? I 
> couldn't find one.

The term comes from Factor.

You keep saying that I'm opposed to quotations. WTF??? I'm not opposed to quotations --- I'm the only person around who is promoting quotations --- I'm opposed to Paysan-faked quotations.

In regard to your analogy about floating-point --- if the floating-point wordset was fake (for example: using double-precision integers but faking them up to look like floats by allowing the decimal-point to be used), then you should be campaigning against the floating-point wordset --- if any feature is going to be put in the Standard, then it should be done correctly (the Paysan-faked quotations are totally fake; these aren't quotations at all).

I mean: "If it is worth doing, then it is worth doing right."

Are you aware that I wrote some code for rquotations (a slight upgrade on HumptyDumpty's rquotations implementation) that pretty-much works? This is not as good as the fat-xt implementation that will be in Straight Forth, but it does pretty-much work under VFX and SwiftForth. I say "pretty-much" because there are some limitations --- the HOF has to have locals and there can only be one HOF under the parent function --- these limitations are not restrictive however, and should not be a problem in the majority of usages.

I thought that my rquotations really killed the Paysan-faked quotations because they worked pretty well, whereas the Paysan-faked quotations didn't work at all. I just implemented the rquotations as a joke though --- I knew that the Paysan-faked quotations were destined to get accepted into Forth-200x  (they were promoted by Anton Ertl, the chair-person of Forth-200x) --- it just seemed funny to provide code that works juxtaposed against Paysan's ridiculous non-working code.

> > --- it would really be better if you didn't fake this stuff --- just be honest and admit that you don't know how to implement quotations.
> 
> But I do know how to. I remember sending you some code a year or two 
> back that did so, explaining how it worked and you said you liked it!

I liked your code, but it was inefficient --- my rquotations are more efficient, although with some limitations --- my fat-xt in Straight Forth is also efficient, and it doesn't have any limitations.

> > As for recognizers, that is not an innovation either --- that is an extremely bad idea.
> 
> Squelch 3  part 1
> 
> Whether recognisers are a bad idea or not it's still an innovation for 
> Forth.

There is absolutely no way that I would ever allow recognizers in Straight Forth --- the name "Straight Forth" implies that the users can't play games with changing the syntax --- recognizers are not an innovation, recognizers are the devil.

The whole idea with Straight Forth is that it is a very simple Forth (about half the size of ANS-Forth) that is very easy to understand --- Straight Forth itself is not innovative --- Straight Forth is a platform for programming, and the programs are (hopefully) innovative.

> > You are going to have a mish-mash of incompatible recognizers. If you have X sets of recognizers, and they all clash with each other (meaning that the order they are loaded is significant), then you have X! versions of Forth-200x syntax.
> 
> Why should they clash with each other any more than, say, libraries or 
> wordlists do. If the recognisers are supplied with the system, they 
> shouldn't clash. if they are defined by the user and they clash, that's 
> the user's fault.

The psychology of the Forth-200x crowd is that all of them want to be creative, but none of them have any meaningful ideas. They are wanna-be artists.

There are going to be a lot of recognizers written --- mostly late at night and fueled by alcohol --- I guarantee that you are going to have portability problems because every program specifies a mish-mash of recognizers that are used on one Forth-200x system, but which aren't used on another Forth-200x system.

It is very likely that more Forth-200x enthusiasts will write recognizers, than will write programs.

[toc] | [prev] | [next] | [standalone]

#50680 — Re: Standard or Forth?

On 09/05/2016 09:09, hughaguilar96@gmail.com wrote:
> There is absolutely no way that I would ever allow recognizers in Straight Forth --- the name "Straight Forth" implies that the users can't play games with changing the syntax...

Hmm. In 2011 you said, 'In case you didn't get it, I call my language
"Straight Forth" to distinguish it from Forth-200x, which I will refer
to as "Gay Forth."'. (ref:
https://groups.google.com/d/msg/comp.lang.forth/tKeVZajFD04/Gw3EhlFlE1YJ)

So what caused you to change the reason for the name?


> The whole idea with Straight Forth is that it is a very simple Forth (about half the size of ANS-Forth) that is very easy to understand --- Straight Forth itself is not innovative --- Straight Forth is a platform for programming, and the programs are (hopefully) innovative.

So, big boy, when will we finally get to see "Straight Forth" ?  You've
been going on about it since 2011.  That should be sufficient, even for
you, to write something useful.  Five years and counting!
(ref:
https://groups.google.com/d/msg/comp.lang.forth/Vc1vLRE16t0/0SnRSBWn7_AJ)

You keep on saying "Straight Forth *is*".  I don't think the word "is"
means what you think it means...

[toc] | [prev] | [next] | [standalone]

#50681 — Re: Standard or Forth?

On 05/09/2016 07:09, hughaguilar96@gmail.com wrote:
> On Sunday, September 4, 2016 at 5:26:23 AM UTC-7, Gerry wrote:
>> On 04/09/2016 08:41, hughaguilar96@gmail.com wrote:
>>> On Saturday, September 3, 2016 at 11:35:44 PM UTC-7, Gerry wrote:
>>>> On 03/09/2016 05:54, hughaguilar96@gmail.com wrote:
>>> The Paysan-faked quotations aren't an innovation --- they are just :NONAME with syntactic sugar --- I have never used :NONAME for anything and I consider it to be pretty much useless.
>>
>> Quotations are an innovation in ANS Forth, they provide the first
>> mechanism for nesting definitions inside another definition.
>>    So they are not "just :NONAME with syntactic sugar".
>>
>> I don't use floating point, so should I be campaigning to get the
>> Floating Point wordset deleted from Forth 200X on the grounds that I
>> find it useless?
>>
>>>
>>> Forth-200x calls these "quotations" but they aren't quotations at all, because they don't have access to the parent function's local variables. They ruin the word "quotation" by using it wrong. If I say that I have quotations, everybody will reply: "You Forth programmers' quotations aren't quotations --- they are fake --- all Forth programmers are fakes!" Then I have to struggle to show that I'm using the word correctly, but it is too late because Forth-200x has given the entire Forth community a reputation for being fakes. This is very similar to what was described in the book, "1984," in which the words' meanings was changed --- "peace" meant "war," "freedom" meant "slavery," etc. --- Forth-200x is doing the same thing here, changing the meaning of "quotation" to mean "syntactic sugar for :NONAME"
>>
>> Is there an industry standard definition of the term 'quotations'? I
>> couldn't find one.
>
> The term comes from Factor.

So it's not a standard software term so the Forth community is free to 
define its own meaning of the word as a (possible) subset of Factor's 
meaning (I don't know full details of Factor's definition). Anyway you 
miss the point that Forth quotations could be extended in the future to 
match your expectations should sufficient people in the Forth community 
support the idea, which doesn't seem to be true at present.

>
> You keep saying that I'm opposed to quotations. WTF??? I'm not opposed to quotations

You've lost me there - I don't believe I have ever said that, I 
certainly don't think it.

> --- I'm the only person around who is promoting quotations --- I'm opposed to Paysan-faked quotations.

Well it's a step in the right direction. People can then try them and if 
they find them too limited, then they may come around to support an 
extension. It's the incremental strategy. You miss or deliberately 
ignore the point that if the Forth community does not support an idea 
then there is no point in including it in the standard as it will never 
be widely supported. That's why CfV's are issued.

>
> In regard to your analogy about floating-point --- if the floating-point wordset was fake (for example: using double-precision integers

But the floating point wordset, or indeed the whole standard itself, 
avoids specifying implementation details like that so what you say is 
inapplicable. Anyway I was using that as an ludicrous application of 
your logic which seems to be - "I don't find a feature useful, therefore 
it is totally useless for everybody."

> I mean: "If it is worth doing, then it is worth doing right."
>
> Are you aware that I wrote some code for rquotations (a slight upgrade on HumptyDumpty's rquotations implementation)

Yes, but as they were a joke I didn't take much notice other than to see 
they relied on non-standard return stack manipulation.

> I thought that my rquotations really killed the Paysan-faked quotations because they worked pretty well, whereas the Paysan-faked quotations didn't work at all. I just implemented the rquotations as a joke though --- I knew that the Paysan-faked quotations were destined to get accepted into Forth-200x  (they were promoted by Anton Ertl, the chair-person of Forth-200x) --- it just seemed funny to provide code that works juxtaposed against Paysan's ridiculous non-working code.
>

>>> As for recognizers, that is not an innovation either --- that is an extremely bad idea.
>>
>> Whether recognisers are a bad idea or not it's still an innovation for
>> Forth.
>
> There is absolutely no way that I would ever allow recognizers in Straight Forth

As the inventor of Straight Forth that's your prerogative.

> recognizers are not an innovation, recognizers are the devil.

Well then I'll be sure to use a long spoon.

> There are going to be a lot of recognizers written --- mostly late at night and fueled by alcohol --- I guarantee that you are going to have portability problems because every program specifies a mish-mash of recognizers that are used on one Forth-200x system, but which aren't used on another Forth-200x system.

But if the standard for recognisers just provides the primitives for 
programmers to write their own recognisers, won't they include the 
recogniser code with their programs. If that clashes with somebody 
else's recognisers, then its up to the user to choose. In principle it's 
the same situation with software libraries where there may be name clashes.

>
> It is very likely that more Forth-200x enthusiasts will write recognizers, than will write programs.

Sure, some people keep writing string stack libraries instead of using 
existing ones, despite knowing they exist.

-- 
Gerry

[toc] | [prev] | [next] | [standalone]

#50652 — Re: Standard or Forth?

On Saturday, September 3, 2016 at 11:35:44 PM UTC-7, Gerry wrote:
> On 03/09/2016 05:54, hughaguilar96@gmail.com wrote:
> > This is what Charles Moore was referring to when he said:
> >"Any spirit of innovation has been thoroughly squelched."
> > At the time that Straight Forth is released, when the
> > ANS-Forth cult is striving mightily to squelch it, I will
> > have difficulty in fixing any mistakes that made it into
> > the design, because doing so will involve admitting that
> > I was wrong about something --- it is best if I wait until
> > I'm absolutely sure that there are no mistakes --- I
> > should really write one or two non-trivial programs in
> > Straight Forth before I even consider releasing it publicly.
> 
> Very wise, nothing kills an interest in software than finding it is 
> bug-ridden. However this requires more than just a couple of non-trivial 
> programs to be written before release, it requires a comprehensive set 
> of test programs which test, not only the basic features but corner 
> cases, and include them with the system. This is also true for 
> applications and libraries. Few people seem to do this even though it is 
> in the developers' interest to do so.

I wasn't really worried about bugs. I generally write pretty bug-free code. I was more interested in design issues. For example, there is my OOP package:
https://groups.google.com/forum/#!topic/comp.lang.forth/cH-pGXhBCfE
This is bug-free. It is short and simple. It was easy to test.

Is it useful though? That is more difficult to determine. This is what I meant when I said that I needed to write one or two non-trivial programs using the OOP package.

I read Bernd Paysan's page discussing Mini-OOF:
https://bernd-paysan.de/mini-oof.html

He says: "Gerry Jackson wrote a larger example, LexGen. This example extends Mini-OOF slightly, but it shows that with these small changes, Mini-OOF can be used for real-world applications."

Why did you write your LexGen using Mini-OOF??? It is obvious that Mini-OOF is typical Paysan code! This is his METHOD definer:

: method ( m v -- m' v ) Create  over , swap cell+ swap
  DOES> ( ... o -- ... ) @ over @ + @ execute ;

That is horribly inefficient! Any code that uses CREATE DOES> is going to be inefficient. My method calls are about 10 times more efficient under SwiftForth (SwiftForth is particularly inefficient with CREATE DOES> words) and about 3 times more efficient under VFX.

So, why did you use Mini-OOF when it is obviously no good? I think that you did this because Mini-OOF was written by Bernd Paysan who is a Forth-200x committee member --- you are being loyal to Forth-200x --- you don't care about efficiency at all, but you are treating Forth as a toy language suitable only for science-fair projects.

I'm really not going to tolerate gross inefficiency in Straight Forth --- to me, a Forth standard has to support efficient code --- efficiency is necessary if anybody is going to consider Forth to be suitable for writing commercial programs.

All in all, I think that Forth-200x is doomed to failure. None of the people involved are actually Forth programmers, in the sense that they write Forth programs --- all of them are involved because they want to be big experts who set the Standard for the entire community --- they are exercising their creativity on nonsense such as recognizers that are not useful for writing programs.

[toc] | [prev] | [next] | [standalone]

Page 2 of 4 — ← Prev page 1 [2] 3 4  Next page →

Back to top | Article view | comp.lang.forth

csiph-web