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

lisp can sum a list of numbers with 2 parens and a +, can forth use loop to make something similar?

Started by	the_gavino_himself <visphatesjava@gmail.com>
First post	2015-01-22 19:34 -0800
Last post	2015-02-11 09:19 +0000
Articles	20 on this page of 40 — 19 participants

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

Page 2 of 2 — ← Prev page 1 [2]

#36179

From	lehs <skydda.barnen@gmail.com>
Date	2015-01-30 22:16 -0800
Message-ID	<a78d804b-aee8-441c-ad44-42ff8a6742b3@googlegroups.com>
In reply to	#36174

Den fredag 30 januari 2015 kl. 22:17:13 UTC+1 skrev Coos Haak:
> Op Fri, 30 Jan 2015 08:38:53 -0800 (PST) schreef lehs:
> 
> <snip>
> >: } STATE @
> >   IF POSTPONE RBR
> >      [COMPILE] '
> >      POSTPONE LITERAL
> >      POSTPONE EXC
> >   ELSE RBR ' EXC
> >   THEN
> > ; IMMEDIATE
> 
> If SP-FORTH is truly ANS FORTH 94 compatible, then ' (tick) is not
> immediate. Rewrite this as:
> : } STATE @
>   IF POSTPONE RBR
>      POSTPONE '
>      POSTPONE EXC
>   ELSE RBR ' EXC
>   THEN
> ; IMMEDIATE
> 
> -- 
> Coos
> 
> CHForth, 16 bit DOS applications
> http://home.hccnet.nl/j.j.haak/forth.html

You're right, tick wasn't immediate! But then [COMPILE] become a no-operation.
It should be:

: } STATE @
  IF POSTPONE RBR
     '
     POSTPONE LITERAL
     POSTPONE EXC
  ELSE RBR ' EXC
  THEN
; IMMEDIATE

I really don't know if SP-Forth is truly ANS FORTH 94. When I retired I tried to find a FIG-FORTH but couldn't find any. I found SP and like it.

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

#36188

From	Coos Haak <chforth@hccnet.nl>
Date	2015-02-01 00:23 +0100
Message-ID	<15p50maergwl7$.eta42s9d1z95$.dlg@40tude.net>
In reply to	#36179

Op Fri, 30 Jan 2015 22:16:48 -0800 (PST) schreef lehs:

> Den fredag 30 januari 2015 kl. 22:17:13 UTC+1 skrev Coos Haak:
>> Op Fri, 30 Jan 2015 08:38:53 -0800 (PST) schreef lehs:
>> 
>> <snip>
>>>: } STATE @
>>>   IF POSTPONE RBR
>>>      [COMPILE] '
>>>      POSTPONE LITERAL
>>>      POSTPONE EXC
>>>   ELSE RBR ' EXC
>>>   THEN
>>> ; IMMEDIATE
>> 
>> If SP-FORTH is truly ANS FORTH 94 compatible, then ' (tick) is not
>> immediate. Rewrite this as:
>>: } STATE @
>>   IF POSTPONE RBR
>>      POSTPONE '
>>      POSTPONE EXC
>>   ELSE RBR ' EXC
>>   THEN
>> ; IMMEDIATE
>> 
>> -- 
>> Coos
>> 
>> CHForth, 16 bit DOS applications
>> http://home.hccnet.nl/j.j.haak/forth.html
> 
> You're right, tick wasn't immediate! But then [COMPILE] become a no-operation.
> It should be:
> 
>: } STATE @
>   IF POSTPONE RBR
>      '
>      POSTPONE LITERAL
>      POSTPONE EXC
>   ELSE RBR ' EXC
>   THEN
> ; IMMEDIATE
> 
> I really don't know if SP-Forth is truly ANS FORTH 94. When I retired I tried to find a FIG-FORTH but couldn't find any. I found SP and like it.

It seems that the doubt I expressed was false. Stay with SP-Forth.
FIG-FORTH is too old (around 1977).
-- 
Coos

CHForth, 16 bit DOS applications
http://home.hccnet.nl/j.j.haak/forth.html

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

#36194

From	lehs <skydda.barnen@gmail.com>
Date	2015-02-01 00:35 -0800
Message-ID	<6815a5ee-cd6d-4934-9a1f-3bde6fd0f47f@googlegroups.com>
In reply to	#36188

Den söndag 1 februari 2015 kl. 00:34:28 UTC+1 skrev Coos Haak:
> Op Fri, 30 Jan 2015 22:16:48 -0800 (PST) schreef lehs:
> 
> > Den fredag 30 januari 2015 kl. 22:17:13 UTC+1 skrev Coos Haak:
> >> Op Fri, 30 Jan 2015 08:38:53 -0800 (PST) schreef lehs:
> >> 
> >> <snip>
> >>>: } STATE @
> >>>   IF POSTPONE RBR
> >>>      [COMPILE] '
> >>>      POSTPONE LITERAL
> >>>      POSTPONE EXC
> >>>   ELSE RBR ' EXC
> >>>   THEN
> >>> ; IMMEDIATE
> >> 
> >> If SP-FORTH is truly ANS FORTH 94 compatible, then ' (tick) is not
> >> immediate. Rewrite this as:
> >>: } STATE @
> >>   IF POSTPONE RBR
> >>      POSTPONE '
> >>      POSTPONE EXC
> >>   ELSE RBR ' EXC
> >>   THEN
> >> ; IMMEDIATE
> >> 
> >> -- 
> >> Coos
> >> 
> >> CHForth, 16 bit DOS applications
> >> http://home.hccnet.nl/j.j.haak/forth.html
> > 
> > You're right, tick wasn't immediate! But then [COMPILE] become a no-operation.
> > It should be:
> > 
> >: } STATE @
> >   IF POSTPONE RBR
> >      '
> >      POSTPONE LITERAL
> >      POSTPONE EXC
> >   ELSE RBR ' EXC
> >   THEN
> > ; IMMEDIATE
> > 
> > I really don't know if SP-Forth is truly ANS FORTH 94. When I retired I tried to find a FIG-FORTH but couldn't find any. I found SP and like it.
> 
> It seems that the doubt I expressed was false. Stay with SP-Forth.
> FIG-FORTH is too old (around 1977).
> -- 
> Coos
> 
> CHForth, 16 bit DOS applications
> http://home.hccnet.nl/j.j.haak/forth.html

No! FIG-FORTH would be perfect for me. No prohibitions! Everything was possible and FORTH Dimension was filled with smart routines that extended the compiler. Those were the days!

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

#36198

From	Coos Haak <chforth@hccnet.nl>
Date	2015-02-01 14:20 +0100
Message-ID	<18ffuhdt5a5yg.5wb1a5ckeryo$.dlg@40tude.net>
In reply to	#36194

Op Sun, 1 Feb 2015 00:35:16 -0800 (PST) schreef lehs:

> No! FIG-FORTH would be perfect for me. No prohibitions! Everything was possible and FORTH Dimension was filled with smart routines that extended the compiler. Those were the days!

But you run in a lot of problems: WORD does not leave an address, you can't
use CREATE in interpretive mode, ' is immediate and like FIND leaves the
address of the parameter field not the execution token. VOCABULARYs are
immediate for no obvious reason, CELL+ and CELLS do not exist...

-- 
Coos

CHForth, 16 bit DOS applications
http://home.hccnet.nl/j.j.haak/forth.html

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

#36200

From	lehs <skydda.barnen@gmail.com>
Date	2015-02-01 07:42 -0800
Message-ID	<db866e62-e873-474b-85d6-6141b6ff9686@googlegroups.com>
In reply to	#36198

Den söndag 1 februari 2015 kl. 14:29:03 UTC+1 skrev Coos Haak:
> Op Sun, 1 Feb 2015 00:35:16 -0800 (PST) schreef lehs:
> 
> > No! FIG-FORTH would be perfect for me. No prohibitions! Everything was possible and FORTH Dimension was filled with smart routines that extended the compiler. Those were the days!
> 
> But you run in a lot of problems: WORD does not leave an address, you can't
> use CREATE in interpretive mode, ' is immediate and like FIND leaves the
> address of the parameter field not the execution token. VOCABULARYs are
> immediate for no obvious reason, CELL+ and CELLS do not exist...
> 
> -- 
> Coos
> 
> CHForth, 16 bit DOS applications
> http://home.hccnet.nl/j.j.haak/forth.html

Are you joking? How can such things be problems for a hobbyist? I'm in it for fun and FIG-Forth was so simple that I could understand and overview the whole system. Not so efficient but fun.

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

#36203

From	albert@spenarnc.xs4all.nl (Albert van der Horst)
Date	2015-02-01 17:24 +0000
Message-ID	<54ce613f$0$6874$e4fe514c@dreader36.news.xs4all.nl>
In reply to	#36194

In article <6815a5ee-cd6d-4934-9a1f-3bde6fd0f47f@googlegroups.com>,
lehs  <skydda.barnen@gmail.com> wrote:
>Den söndag 1 februari 2015 kl. 00:34:28 UTC+1 skrev Coos Haak:
>> Op Fri, 30 Jan 2015 22:16:48 -0800 (PST) schreef lehs:
>>
>> > Den fredag 30 januari 2015 kl. 22:17:13 UTC+1 skrev Coos Haak:
>> >> Op Fri, 30 Jan 2015 08:38:53 -0800 (PST) schreef lehs:
>> >>
>> >> <snip>
>> >>>: } STATE @
>> >>>   IF POSTPONE RBR
>> >>>      [COMPILE] '
>> >>>      POSTPONE LITERAL
>> >>>      POSTPONE EXC
>> >>>   ELSE RBR ' EXC
>> >>>   THEN
>> >>> ; IMMEDIATE
>> >>
>> >> If SP-FORTH is truly ANS FORTH 94 compatible, then ' (tick) is not
>> >> immediate. Rewrite this as:
>> >>: } STATE @
>> >>   IF POSTPONE RBR
>> >>      POSTPONE '
>> >>      POSTPONE EXC
>> >>   ELSE RBR ' EXC
>> >>   THEN
>> >> ; IMMEDIATE
>> >>
>> >> --
>> >> Coos
>> >>
>> >> CHForth, 16 bit DOS applications
>> >> http://home.hccnet.nl/j.j.haak/forth.html
>> >
>> > You're right, tick wasn't immediate! But then [COMPILE] become a
>no-operation.
>> > It should be:
>> >
>> >: } STATE @
>> >   IF POSTPONE RBR
>> >      '
>> >      POSTPONE LITERAL
>> >      POSTPONE EXC
>> >   ELSE RBR ' EXC
>> >   THEN
>> > ; IMMEDIATE
>> >
>> > I really don't know if SP-Forth is truly ANS FORTH 94. When I
>retired I tried to find a FIG-FORTH but couldn't find any. I found SP
>and like it.
>>
>> It seems that the doubt I expressed was false. Stay with SP-Forth.
>> FIG-FORTH is too old (around 1977).
>> --
>> Coos
>>
>> CHForth, 16 bit DOS applications
>> http://home.hccnet.nl/j.j.haak/forth.html
>
>No! FIG-FORTH would be perfect for me. No prohibitions! Everything was
>possible and FORTH Dimension was filled with smart routines that
>extended the compiler. Those were the days!

Inasfar FIG-Forth has advantages, they can be retained while slightly
modifying a FIG-Forth implementation to make it more ISO compatible.
- The implementation model need not be changed substantially in
    order to have e.g. 32 bit integers.
- BUILD / DOES> is not essentially more powerful than CREATE / DOES.
- ACCEPT is merely a cleaned up version of EXCEPT .
- etc

A compatibility harness can be used to run your extremely valuable
thoroughly debugged FIG-Forth programs. These kind of programs
come with a regression test, such that the compatibility harness
can be certified easily.

Groetjes Albert
-- 
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]

#36204

From	lehs <skydda.barnen@gmail.com>
Date	2015-02-01 09:58 -0800
Message-ID	<e04935d7-4fcf-457e-8fc7-e035e5adacf7@googlegroups.com>
In reply to	#36203

Den söndag 1 februari 2015 kl. 18:24:16 UTC+1 skrev Albert van der Horst:
> In article <6815a5ee-cd6d-4934-9a1f-3bde6fd0f47f@googlegroups.com>,
> lehs  <skydda.barnen@gmail.com> wrote:
> >Den söndag 1 februari 2015 kl. 00:34:28 UTC+1 skrev Coos Haak:
> >> Op Fri, 30 Jan 2015 22:16:48 -0800 (PST) schreef lehs:
> >>
> >> > Den fredag 30 januari 2015 kl. 22:17:13 UTC+1 skrev Coos Haak:
> >> >> Op Fri, 30 Jan 2015 08:38:53 -0800 (PST) schreef lehs:
> >> >>
> >> >> <snip>
> >> >>>: } STATE @
> >> >>>   IF POSTPONE RBR
> >> >>>      [COMPILE] '
> >> >>>      POSTPONE LITERAL
> >> >>>      POSTPONE EXC
> >> >>>   ELSE RBR ' EXC
> >> >>>   THEN
> >> >>> ; IMMEDIATE
> >> >>
> >> >> If SP-FORTH is truly ANS FORTH 94 compatible, then ' (tick) is not
> >> >> immediate. Rewrite this as:
> >> >>: } STATE @
> >> >>   IF POSTPONE RBR
> >> >>      POSTPONE '
> >> >>      POSTPONE EXC
> >> >>   ELSE RBR ' EXC
> >> >>   THEN
> >> >> ; IMMEDIATE
> >> >>
> >> >> --
> >> >> Coos
> >> >>
> >> >> CHForth, 16 bit DOS applications
> >> >> http://home.hccnet.nl/j.j.haak/forth.html
> >> >
> >> > You're right, tick wasn't immediate! But then [COMPILE] become a
> >no-operation.
> >> > It should be:
> >> >
> >> >: } STATE @
> >> >   IF POSTPONE RBR
> >> >      '
> >> >      POSTPONE LITERAL
> >> >      POSTPONE EXC
> >> >   ELSE RBR ' EXC
> >> >   THEN
> >> > ; IMMEDIATE
> >> >
> >> > I really don't know if SP-Forth is truly ANS FORTH 94. When I
> >retired I tried to find a FIG-FORTH but couldn't find any. I found SP
> >and like it.
> >>
> >> It seems that the doubt I expressed was false. Stay with SP-Forth.
> >> FIG-FORTH is too old (around 1977).
> >> --
> >> Coos
> >>
> >> CHForth, 16 bit DOS applications
> >> http://home.hccnet.nl/j.j.haak/forth.html
> >
> >No! FIG-FORTH would be perfect for me. No prohibitions! Everything was
> >possible and FORTH Dimension was filled with smart routines that
> >extended the compiler. Those were the days!
> 
> Inasfar FIG-Forth has advantages, they can be retained while slightly
> modifying a FIG-Forth implementation to make it more ISO compatible.
> - The implementation model need not be changed substantially in
>     order to have e.g. 32 bit integers.
> - BUILD / DOES> is not essentially more powerful than CREATE / DOES.
> - ACCEPT is merely a cleaned up version of EXCEPT .
> - etc
> 
> A compatibility harness can be used to run your extremely valuable
> thoroughly debugged FIG-Forth programs. These kind of programs
> come with a regression test, such that the compatibility harness
> can be certified easily.
> 
> Groetjes Albert
> -- 
> 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

But my problem is that ANS-Forth is a stranger while FIG-Forth was not. The new systems are to complicated for me. The speed is wonderful but I valued the simplicity in the old systems.

Hälsningar Lars-Erik Svahn

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

#36211

From	albert@spenarnc.xs4all.nl (Albert van der Horst)
Date	2015-02-02 00:46 +0000
Message-ID	<54cec8cc$0$15926$e4fe514c@dreader35.news.xs4all.nl>
In reply to	#36204

In article <e04935d7-4fcf-457e-8fc7-e035e5adacf7@googlegroups.com>,
lehs  <skydda.barnen@gmail.com> wrote:
>Den söndag 1 februari 2015 kl. 18:24:16 UTC+1 skrev Albert van der Horst:
>> In article <6815a5ee-cd6d-4934-9a1f-3bde6fd0f47f@googlegroups.com>,
>> lehs  <skydda.barnen@gmail.com> wrote:
>> >Den söndag 1 februari 2015 kl. 00:34:28 UTC+1 skrev Coos Haak:
>> >> Op Fri, 30 Jan 2015 22:16:48 -0800 (PST) schreef lehs:
>> >>
>> >> > Den fredag 30 januari 2015 kl. 22:17:13 UTC+1 skrev Coos Haak:
>> >> >> Op Fri, 30 Jan 2015 08:38:53 -0800 (PST) schreef lehs:
>> >> >>
>> >> >> <snip>
>> >> >>>: } STATE @
>> >> >>>   IF POSTPONE RBR
>> >> >>>      [COMPILE] '
>> >> >>>      POSTPONE LITERAL
>> >> >>>      POSTPONE EXC
>> >> >>>   ELSE RBR ' EXC
>> >> >>>   THEN
>> >> >>> ; IMMEDIATE
>> >> >>
>> >> >> If SP-FORTH is truly ANS FORTH 94 compatible, then ' (tick) is not
>> >> >> immediate. Rewrite this as:
>> >> >>: } STATE @
>> >> >>   IF POSTPONE RBR
>> >> >>      POSTPONE '
>> >> >>      POSTPONE EXC
>> >> >>   ELSE RBR ' EXC
>> >> >>   THEN
>> >> >> ; IMMEDIATE
>> >> >>
>> >> >> --
>> >> >> Coos
>> >> >>
>> >> >> CHForth, 16 bit DOS applications
>> >> >> http://home.hccnet.nl/j.j.haak/forth.html
>> >> >
>> >> > You're right, tick wasn't immediate! But then [COMPILE] become a
>> >no-operation.
>> >> > It should be:
>> >> >
>> >> >: } STATE @
>> >> >   IF POSTPONE RBR
>> >> >      '
>> >> >      POSTPONE LITERAL
>> >> >      POSTPONE EXC
>> >> >   ELSE RBR ' EXC
>> >> >   THEN
>> >> > ; IMMEDIATE
>> >> >
>> >> > I really don't know if SP-Forth is truly ANS FORTH 94. When I
>> >retired I tried to find a FIG-FORTH but couldn't find any. I found SP
>> >and like it.
>> >>
>> >> It seems that the doubt I expressed was false. Stay with SP-Forth.
>> >> FIG-FORTH is too old (around 1977).
>> >> --
>> >> Coos
>> >>
>> >> CHForth, 16 bit DOS applications
>> >> http://home.hccnet.nl/j.j.haak/forth.html
>> >
>> >No! FIG-FORTH would be perfect for me. No prohibitions! Everything was
>> >possible and FORTH Dimension was filled with smart routines that
>> >extended the compiler. Those were the days!
>>
>> Inasfar FIG-Forth has advantages, they can be retained while slightly
>> modifying a FIG-Forth implementation to make it more ISO compatible.
>> - The implementation model need not be changed substantially in
>>     order to have e.g. 32 bit integers.
>> - BUILD / DOES> is not essentially more powerful than CREATE / DOES.
>> - ACCEPT is merely a cleaned up version of EXCEPT .
>> - etc
>>
>> A compatibility harness can be used to run your extremely valuable
>> thoroughly debugged FIG-Forth programs. These kind of programs
>> come with a regression test, such that the compatibility harness
>> can be certified easily.
>>
>> Groetjes Albert
>> --
>> 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
>
>But my problem is that ANS-Forth is a stranger while FIG-Forth was not.
>The new systems are to complicated for me. The speed is wonderful but I
>valued the simplicity in the old systems.

Then you may be interested in yourforth. Check it out. It is my effort
to make the simplest possible Forth and it is quite similar to FIG-Forth.

>
>Hälsningar Lars-Erik Svahn

Groetjes Albert
-- 
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]

#36206

From	"Elizabeth D. Rather" <erather@forth.com>
Date	2015-02-01 08:59 -1000
Message-ID	<heSdnQ9M8Lji6lPJnZ2dnUU7-YWdnZ2d@supernews.com>
In reply to	#36194

On 1/31/15 10:35 PM, lehs wrote:
> Den söndag 1 februari 2015 kl. 00:34:28 UTC+1 skrev Coos Haak:
...
>>> I really don't know if SP-Forth is truly ANS FORTH 94. When I retired I tried to find a FIG-FORTH but couldn't find any. I found SP and like it.
>>
>> It seems that the doubt I expressed was false. Stay with SP-Forth.
>> FIG-FORTH is too old (around 1977).
>> --
>> Coos
>>
>> CHForth, 16 bit DOS applications
>> http://home.hccnet.nl/j.j.haak/forth.html
>
> No! FIG-FORTH would be perfect for me. No prohibitions! Everything was possible and FORTH Dimension was filled with smart routines that extended the compiler. Those were the days!
>

There are no prohibitions in ANS Forth or Forth200x. What these 
standards *do* offer is *guarantees* of portability of application code 
if you follow their recommendations. If you have no interest in porting 
your application code to other Forth systems, you can do whatever you 
want to.

The standards (and systems that follow them) also include a lot of smart 
stuff and additional ways to facilitate extending the compiler. Also 
modern systems tend to be faster and better documented.

Cheers,
Elizabeth

-- 
==================================================
Elizabeth D. Rather   (US & Canada)   800-55-FORTH
FORTH Inc.                         +1 310.999.6784
5959 West Century Blvd. Suite 700
Los Angeles, CA 90045
http://www.forth.com

"Forth-based products and Services for real-time
applications since 1973."
==================================================

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

#36208

From	lehs <skydda.barnen@gmail.com>
Date	2015-02-01 12:06 -0800
Message-ID	<b1276284-5283-47b0-8314-92bfffb1d50a@googlegroups.com>
In reply to	#36206

Den söndag 1 februari 2015 kl. 19:59:12 UTC+1 skrev Elizabeth D. Rather:
> On 1/31/15 10:35 PM, lehs wrote:
> > Den söndag 1 februari 2015 kl. 00:34:28 UTC+1 skrev Coos Haak:
> ...
> >>> I really don't know if SP-Forth is truly ANS FORTH 94. When I retired I tried to find a FIG-FORTH but couldn't find any. I found SP and like it.
> >>
> >> It seems that the doubt I expressed was false. Stay with SP-Forth.
> >> FIG-FORTH is too old (around 1977).
> >> --
> >> Coos
> >>
> >> CHForth, 16 bit DOS applications
> >> http://home.hccnet.nl/j.j.haak/forth.html
> >
> > No! FIG-FORTH would be perfect for me. No prohibitions! Everything was possible and FORTH Dimension was filled with smart routines that extended the compiler. Those were the days!
> >
> 
> There are no prohibitions in ANS Forth or Forth200x. What these 
> standards *do* offer is *guarantees* of portability of application code 
> if you follow their recommendations. If you have no interest in porting 
> your application code to other Forth systems, you can do whatever you 
> want to.
> 
> The standards (and systems that follow them) also include a lot of smart 
> stuff and additional ways to facilitate extending the compiler. Also 
> modern systems tend to be faster and better documented.
> 
> Cheers,
> Elizabeth
> 
> -- 
> ==================================================
> Elizabeth D. Rather   (US & Canada)   800-55-FORTH
> FORTH Inc.                         +1 310.999.6784
> 5959 West Century Blvd. Suite 700
> Los Angeles, CA 90045
> http://www.forth.com
> 
> "Forth-based products and Services for real-time
> applications since 1973."
> ==================================================

I don't think that the development of FORTH is bad as such, just that it doesn't suit me that good. The less advanced FIG-Forth was much easier for me to play around with. 

One good thing is that I do a lot more "extrovert" programs today, that is, using Forth for other reasons than exploring Forth.

I have reasons to be very grateful to you and Charles Moore for creating Forth and spreading it out in the world. Thank you very much!

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

#36402

From	hughaguilar96@gmail.com
Date	2015-02-08 18:43 -0800
Message-ID	<49b60a1a-8aba-431b-b18a-e4417432325f@googlegroups.com>
In reply to	#36206

On Sunday, February 1, 2015 at 11:59:12 AM UTC-7, Elizabeth D. Rather wrote:
> There are no prohibitions in ANS Forth or Forth200x. What these 
> standards *do* offer is *guarantees* of portability of application code 
> if you follow their recommendations. 

LOL --- you are a super-salesperson! --- nobody else in the world could deliver a preposterous statement like this with a straight face.

ANS-Forth is a complete failure at portability. Throughout the ANS-Forth document, we read that a feature may work one way or may work another way, may be available or may not be available. ANS-Forth is a standard that doesn't standardize anything --- pretty much any non-trivial program is going to be vendor-specific (and the programmer will think that it is ANS-Forth until he actually tries to compile and run it on another Forth system).

I made the novice package ANS-Forth, so it will work under any ANS-Forth system, but this was not easy. Supposedly FFL is ANS-Forth, but I haven't verified this. Anton Ertl himself says that there is no way to determine if Forth code is ANS-Forth or not, except by testing it under a variety of ANS-Forth systems --- and a lot of the differences between the systems are subtle, so a casual test may not find the dependency, but it will show up eventually. Also, I have found bugs in all of the major ANS-Forth implementations (SwiftForth, Gforth, Win32Forth and VFX), so portable ANS-Forth code needs to work around these bugs (I've seen Anton Ertl post code that will crash SwiftForth-v2; in all likelihood, he only tests his code under Gforth). Anyway, FFL lacks a lot of features that my novice package has, so I don't have any motivation to spend the considerable amount of time needed to test FFL --- in my experience, getting code to work on all major ANS-Forth systems takes up the majority of the time involved in developing the novice package.

As the chairperson of the ANS-Forth committee, you should give me a medal for being the only person on comp.lang.forth who has written code that can actually compile and run under any ANS-Forth system --- nobody else puts in the time and effort needed to do this --- also, everybody else is writing pretty trivial code (judging from their comments regarding the control-flow stack, it is obvious that Alex McDonald and Andrew Haley have never written a meta-compiling word in their entire Forth careers).

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

#36406

From	Ron Aaron <rambamist@gmail.com>
Date	2015-02-09 08:36 +0200
Message-ID	<mb9kgb$t54$1@dont-email.me>
In reply to	#36402

On 02/09/2015 04:43, hughaguilar96@gmail.com wrote:
> ANS-Forth is a complete failure at portability. Throughout the ANS-Forth document, we read that a feature may work one way or may work another way,...

FWIW, ANS-Forth is about as portable as C.  Similar caveats apply with C
programs: a "standard library" function may or may not be available, the
CPU may be of different endianness, the int size may be 2 or 4 or 8
bytes, etc.

That's why there are preprocessor directives in C and similar
environmental queries in ANS-Forth.  If you *want* your code to be
portable between vendors, you have to be aware of where the differences
are, and code for them.  It does not mean that your code will run
"vanilla" without any changes.

I've had a ton of experience with C and portability; it can be a
nightmare.  So in Reva Forth and now in 8th, I made no attempt
whatsoever to be ANS compliant, since that was not a priority for me.
Other people, other needs.

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

#36159

From	anton@mips.complang.tuwien.ac.at (Anton Ertl)
Date	2015-01-30 16:27 +0000
Message-ID	<2015Jan30.172753@mips.complang.tuwien.ac.at>
In reply to	#36142

skydda.barnen@gmail.com writes:
>Den fredag 23 januari 2015 kl. 04:34:36 UTC+1 skrev the_gavino_himself:
>> can forth do something similar with loop and the return stack?
>> 
>> (+ 3 4 5 6 7 8)
>> 
>> seems nicer than
>> 
>> 3 4 5 6 7 8 + + + + + .
>> 
>> it seems loop and the stack could be made to do something like lisp does
>
>VARIABLE SSP
>: { DEPTH SSP ! ;
>: } DEPTH SSP @ - ' SSP ! 1 DO SSP @ EXECUTE LOOP ;
>
>{ 1 2 3 4 5 } * gives 120
>{ 1 2 3 4 5 } + gives 15

Next: make it work for the nested case:

{ 9 8 { 7 6 5 } + 4 } *

should give 5184.  Making it work in compile state is an advanced
topic (as Alex McDonald requested), because it opens a can of worms.

- 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 2014: http://www.euroforth.org/ef14/

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

#36195

From	lehs <skydda.barnen@gmail.com>
Date	2015-02-01 01:24 -0800
Message-ID	<d5338be4-3d07-4771-a66c-0209b78eded6@googlegroups.com>
In reply to	#36159

Den fredag 30 januari 2015 kl. 17:31:16 UTC+1 skrev Anton Ertl:
> skydda.barnen@gmail.com writes:
> >Den fredag 23 januari 2015 kl. 04:34:36 UTC+1 skrev the_gavino_himself:
> >> can forth do something similar with loop and the return stack?
> >> 
> >> (+ 3 4 5 6 7 8)
> >> 
> >> seems nicer than
> >> 
> >> 3 4 5 6 7 8 + + + + + .
> >> 
> >> it seems loop and the stack could be made to do something like lisp does
> >
> >VARIABLE SSP
> >: { DEPTH SSP ! ;
> >: } DEPTH SSP @ - ' SSP ! 1 DO SSP @ EXECUTE LOOP ;
> >
> >{ 1 2 3 4 5 } * gives 120
> >{ 1 2 3 4 5 } + gives 15
> 
> Next: make it work for the nested case:
> 
> { 9 8 { 7 6 5 } + 4 } *
> 
> should give 5184.  Making it work in compile state is an advanced
> topic (as Alex McDonald requested), because it opens a can of worms.
> 
> - 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 2014: http://www.euroforth.org/ef14/

I didn't notice your answer, but you are right about the nestling. It needs local variables or an extra stack. Unfortunately I can't use the R-stack as above on SP-FORTH, but it is easy to define a small X-stack:

CELL NEGATE CONSTANT -CELL
 Ok
CREATE XST HERE , 0x100 ALLOT ALIGN
 Ok
: >X ( x -- ) CELL XST +! XST @ ! ;
 Ok
: X ( -- x ) XST @ @ ;
 Ok
: X> ( -- x ) X -CELL XST +! ;
 Ok
: { DEPTH >X ;
 Ok
: EXC >X 1 DO X EXECUTE LOOP X> DROP ;
 Ok
: RBR DEPTH X> - ;
 Ok
: } STATE @
  IF POSTPONE RBR
     '
     POSTPONE LITERAL
     POSTPONE EXC
  ELSE RBR ' EXC
  THEN
; IMMEDIATE
 Ok
{ 2 3 5 7 } *
 Ok ( 210 )
: TEST { 2 3 5 7 } + ; TEST
 Ok ( 210 17 )
{ 9 8 { 7 6 5 } + 4 } *
 Ok ( 210 17 5184 )

No! I don't think that the Forth-compiler includes a can of worms. Any other compiler might, but not a Forth-compiler. Charles Moore really invented something that time. The snaky thing about Forth is that you may be encouraged to make utterly useless routines as mine above, instead making sound Forth routines as above mine.

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

#36202

From	anton@mips.complang.tuwien.ac.at (Anton Ertl)
Date	2015-02-01 16:13 +0000
Message-ID	<2015Feb1.171340@mips.complang.tuwien.ac.at>
In reply to	#36195

lehs <skydda.barnen@gmail.com> writes:
>Den fredag 30 januari 2015 kl. 17:31:16 UTC+1 skrev Anton Ertl:
>> Next: make it work for the nested case:
>>=20
>> { 9 8 { 7 6 5 } + 4 } *
>>=20
>> should give 5184.
...
>I didn't notice your answer, but you are right about the nestling. It needs=
> local variables or an extra stack.

It's possible to do it without extra stack, by storing the old value
of SSP on the data stack.  Implementing this is left as an exercise
for the reader.

>: } STATE @
>  IF POSTPONE RBR
>     '
>     POSTPONE LITERAL
>     POSTPONE EXC
>  ELSE RBR ' EXC
>  THEN
>; IMMEDIATE
...
>No! I don't think that the Forth-compiler includes a can of worms.

Using STATE is a pretty good indication that the can is open.  You may
not have noticed the worms yet, but they are there.

- 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 2014: http://www.euroforth.org/ef14/

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

#36205

From	lehs <skydda.barnen@gmail.com>
Date	2015-02-01 10:54 -0800
Message-ID	<eb3f572b-05af-41b3-a307-9f390d62b450@googlegroups.com>
In reply to	#36202

Den söndag 1 februari 2015 kl. 17:19:20 UTC+1 skrev Anton Ertl:
> lehs <skydda.barnen@gmail.com> writes:
> >Den fredag 30 januari 2015 kl. 17:31:16 UTC+1 skrev Anton Ertl:
> >> Next: make it work for the nested case:
> >>=20
> >> { 9 8 { 7 6 5 } + 4 } *
> >>=20
> >> should give 5184.
> ...
> >I didn't notice your answer, but you are right about the nestling. It needs=
> > local variables or an extra stack.
> 
> It's possible to do it without extra stack, by storing the old value
> of SSP on the data stack.  Implementing this is left as an exercise
> for the reader.
> 
> >: } STATE @
> >  IF POSTPONE RBR
> >     '
> >     POSTPONE LITERAL
> >     POSTPONE EXC
> >  ELSE RBR ' EXC
> >  THEN
> >; IMMEDIATE
> ...
> >No! I don't think that the Forth-compiler includes a can of worms.
> 
> Using STATE is a pretty good indication that the can is open.  You may
> not have noticed the worms yet, but they are there.
> 
> - 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 2014: http://www.euroforth.org/ef14/

I'm aware of that it often is better with an other kind of solution, but I have really never seen any "worm-problems" with those constructions.

Will you please explain?

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

#36401

From	hughaguilar96@gmail.com
Date	2015-02-08 18:07 -0800
Message-ID	<c9ec21de-7731-4590-a84e-249688c6916a@googlegroups.com>
In reply to	#35964

On Thursday, January 22, 2015 at 8:34:36 PM UTC-7, the_gavino_himself wrote:
> can forth do something similar with loop and the return stack?
> 
> (+ 3 4 5 6 7 8)
> 
> seems nicer than
> 
> 3 4 5 6 7 8 + + + + + .
> 
> it seems loop and the stack could be made to do something like lisp does

In the novice package (http://www.forth.org/novice.html) I have RATIO.4TH (and RATIO.TXT as documentation). This allows arithmetic on lists of rational numbers (the numbers are a numerator and denominator pair). Because these are lists of values, they do pretty much what you are describing --- the syntax is not Lisp-like though, which seems to be what you want.

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

#36408 — Re: lisp can sum a list of numbers with 2 parens and a +, can forth useloop to make something similar?

From	"WJ" <w_a_x_man@yahoo.com>
Date	2015-02-09 08:55 +0000
Subject	Re: lisp can sum a list of numbers with 2 parens and a +, can forth useloop to make something similar?
Message-ID	<mb9sme$le0$1@dont-email.me>
In reply to	#35964

the_gavino_himself wrote:

> can forth do something similar with loop and the return stack?
> 
> (+ 3 4 5 6 7 8)
> 
> seems nicer than
> 
> 3 4 5 6 7 8 + + + + + .
> 
> it seems loop and the stack could be made to do something like lisp does 

Calculate the average of the numbers in a list, traversing
it only once and making no assignments to a variable:

Gauche Scheme:

(define (average numbers)
  (apply /
    (fold (lambda (x accum) (map + (list x 1) accum))
          '(0 0)
          numbers)))

(define numbers `(,@(iota 9 -9 2) 633 ,@(iota 9 22)))
numbers
 ===>
(-9 -7 -5 -3 -1 1 3 5 7 633 22 23 24 25 26 27 28 29 30)

(average numbers)
 ===>
858/19

(inexact (average numbers))
 ===>
45.1578947368421


The easy way would be

(/. (apply + numbers) (length numbers))
 ===>
45.1578947368421

but that traverses the list twice: once to add up the numbers
and once to determine the length of the list.

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

#36412 — Re: lisp can sum a list of numbers with 2 parens and a +, can forth useloop to make something similar?

From	Doug Hoffman <glidedog@gmail.com>
Date	2015-02-09 08:00 -0500
Subject	Re: lisp can sum a list of numbers with 2 parens and a +, can forth useloop to make something similar?
Message-ID	<54d8af54$0$282$14726298@news.sunsite.dk>
In reply to	#36408

On 2/9/15 3:55 AM, WJ wrote:

> Calculate the average of the numbers in a list, traversing
> it only once and making no assignments to a variable:
>
> Gauche Scheme:
>
> (define (average numbers)
>    (apply /
>      (fold (lambda (x accum) (map + (list x 1) accum))
>            '(0 0)
>            numbers)))
>
> (define numbers `(,@(iota 9 -9 2) 633 ,@(iota 9 22)))
> numbers
>   ===>
> (-9 -7 -5 -3 -1 1 3 5 7 633 22 23 24 25 26 27 28 29 30)
>
> (average numbers)
>   ===>
> 858/19
>
> (inexact (average numbers))
>   ===>
> 45.1578947368421
>
>
> The easy way would be
>
> (/. (apply + numbers) (length numbers))
>   ===>
> 45.1578947368421
>
> but that traverses the list twice: once to add up the numbers
> and once to determine the length of the list.


: ave{ 0e 0
   begin parse-name 2dup s" }" compare
   while >float drop f+ 1+
   repeat 2drop s>f f/ f. ;

ave{ -9 -7 -5 -3 -1 1 3 5 7 633 22 23 24 25 26 27 28 29 30 }
45.1578947368421 ok

\ the easier way would be to use library code:
f{ -9 -7 -5 -3 -1 1 3 5 7 633 22 23 24 25 26 27 28 29 30 }
average: f. 45.1578947368421 ok

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

#36466 — Re: lisp can sum a list of numbers with 2 parens and a +, can forth useloop to make something similar?

From	Unknown <dog@gmail.com>
Date	2015-02-11 09:19 +0000
Subject	Re: lisp can sum a list of numbers with 2 parens and a +, can forth useloop to make something similar?
Message-ID	<pan.2015.02.11.09.28.06@gmail.com>
In reply to	#36412

On Mon, 09 Feb 2015 08:00:02 -0500, Doug Hoffman wrote:

> On 2/9/15 3:55 AM, WJ wrote:
> 
>> Calculate the average of the numbers in a list, traversing it only once
>> and making no assignments to a variable:
>>
>> Gauche Scheme:
>>
>> (define (average numbers)
>>    (apply /
>>      (fold (lambda (x accum) (map + (list x 1) accum))
>>            '(0 0)
>>            numbers)))
>>
>> (define numbers `(,@(iota 9 -9 2) 633 ,@(iota 9 22))) numbers
>>   ===>
>> (-9 -7 -5 -3 -1 1 3 5 7 633 22 23 24 25 26 27 28 29 30)
>>
>> (average numbers)
>>   ===>
>> 858/19
>>
>> (inexact (average numbers))
>>   ===>
>> 45.1578947368421
>>
>>
>> The easy way would be
>>
>> (/. (apply + numbers) (length numbers))
>>   ===>
>> 45.1578947368421
>>
>> but that traverses the list twice: once to add up the numbers and once
>> to determine the length of the list.
> 
> 
> : ave{ 0e 0
>    begin parse-name 2dup s" }" compare
>    while >float drop f+ 1+
>    repeat 2drop s>f f/ f. ;
> 
> ave{ -9 -7 -5 -3 -1 1 3 5 7 633 22 23 24 25 26 27 28 29 30 }
> 45.1578947368421 ok
> 
> \ the easier way would be to use library code: f{ -9 -7 -5 -3 -1 1 3 5 7
> 633 22 23 24 25 26 27 28 29 30 } average: f. 45.1578947368421 ok

Computing is no longer 'about computors' it's about human cognition:
saving effort. Yes, minimal text is part of saving-effort.
But recognise & select [ie. menu] instead of 'coding' is cheaper.
Also color economically adds cognitive power.
Where's the VISUAL forth?

[toc] | [prev] | [standalone]

Page 2 of 2 — ← Prev page 1 [2]

csiph-web

lisp can sum a list of numbers with 2 parens and a +, can forth use loop to make something similar?

Contents

#36179

#36188

#36194

#36198

#36200

#36203

#36204

#36211

#36206

#36208

#36402

#36406

#36159

#36195

#36202

#36205

#36401

#36408 — Re: lisp can sum a list of numbers with 2 parens and a +, can forth useloop to make something similar?

#36412 — Re: lisp can sum a list of numbers with 2 parens and a +, can forth useloop to make something similar?

#36466 — Re: lisp can sum a list of numbers with 2 parens and a +, can forth useloop to make something similar?