C and Algol68

[Bartc]

The Wikipedia entry for C says the language was influenced by Algol68 but
gives no further details.

I'm intrigued: how exactly did Algol68 influence C, if at all?

Bart

[Mark Bluemel]

Bartc wrote:

The Wikipedia entry for C says the language was influenced by Algol68 but
gives no further details.

I'm intrigued: how exactly did Algol68 influence C, if at all?

http://cm.bell-labs.com/cm/cs/who/dmr/chist.html is "from the horse's
mouth". Try reading that.

[Tim Prince]

Bartc wrote:

The Wikipedia entry for C says the language was influenced by Algol68 but
gives no further details.

I'm intrigued: how exactly did Algol68 influence C, if at all?

How about most of the C syntax which was in Algol but not Fortran as
early as 1968? Much was passed on via Pascal, but that doesn't diminish
the reported influence.

[Chris Dollin]

Tim Prince wrote:

Bartc wrote:

>The Wikipedia entry for C says the language was influenced by Algol68 but
gives no further details.

I'm intrigued: how exactly did Algol68 influence C, if at all?

How about most of the C syntax which was in Algol but not Fortran as
early as 1968? Much was passed on via Pascal, but that doesn't diminish
the reported influence.

I would have thought via /BCPL/, not Pascal, thus accounting for {}-blocks
(not begin-end nor if-endif style) and `return` statements (rather than
assigning to function-identifiers).

--
Hewlett-Packard Limited registered no:
registered office: Cain Road, Bracknell, Berks RG12 1HN 690597 England

[Bartc]

"Mark Bluemel" <ma**********@pobox.comwrote in message
news:fj**********@aioe.org...

Bartc wrote:

>The Wikipedia entry for C says the language was influenced by Algol68 but
gives no further details.

I'm intrigued: how exactly did Algol68 influence C, if at all?

http://cm.bell-labs.com/cm/cs/who/dmr/chist.html is "from the horse's
mouth". Try reading that.

Ok, thanks. So it was syntax such as +:= which became +=.

The rest is pretty interesting too (for me as an amateur language designer)
and explains a few odd things about C.

[Bartc]

"Mark Bluemel" <ma**********@pobox.comwrote in message
news:fj**********@aioe.org...

Bartc wrote:

>I'm intrigued: how exactly did Algol68 influence C, if at all?

http://cm.bell-labs.com/cm/cs/who/dmr/chist.html is "from the horse's
mouth". Try reading that.

Oh, and the following is probably more significant than += ops:
"The scheme of type composition adopted by C owes considerable debt to Algol
68, although it did not, perhaps, emerge in a form that Algol's adherents
would approve of."

I think a few other people would agree with that sentiment too.

Bart

[Tim Prince]

Chris Dollin wrote:

Tim Prince wrote:

>Bartc wrote:

>>The Wikipedia entry for C says the language was influenced by Algol68 but
gives no further details.

I'm intrigued: how exactly did Algol68 influence C, if at all?

How about most of the C syntax which was in Algol but not Fortran as
early as 1968? Much was passed on via Pascal, but that doesn't diminish
the reported influence.

I would have thought via /BCPL/, not Pascal, thus accounting for {}-blocks
(not begin-end nor if-endif style) and `return` statements (rather than
assigning to function-identifiers).

Certainly correct, in terms of the original development of C. Slight
resemblance to Pascal certainly helped bring more people on board, as
BCPL was not known to many of us. All of the above are mentioned as
influences in

http://cm.bell-labs.com/cm/cs/who/dmr/chist.html

[Ben Bacarisse]

Chris Dollin <ch**********@hp.comwrites:

Tim Prince wrote:

>Bartc wrote:

>>The Wikipedia entry for C says the language was influenced by Algol68 but
gives no further details.

I'm intrigued: how exactly did Algol68 influence C, if at all?

How about most of the C syntax which was in Algol but not Fortran as
early as 1968? Much was passed on via Pascal, but that doesn't diminish
the reported influence.

I would have thought via /BCPL/, not Pascal, thus accounting for
{}-blocks

BCPL did not have {}. It used $( and $).

The most obvious Algol 68'isms are casts and compound assignments
(though B also had these, I think they originate in Algol 68). The
most obvious -- the void keyword -- is red-herring since it was not in
C-as-designed only in C-as-standardised.

Obviously I am ignoring the plain fact that all procedural languages
owe a lot to Algol (and thus indirectly to Algol 68).

--
Ben.

[Jean-Marc Bourguet]

Ben Bacarisse <be********@bsb.me.ukwrites:

Obviously I am ignoring the plain fact that all procedural languages
owe a lot to Algol (and thus indirectly to Algol 68).

I fail to understand how owing to Algol (ie. Algol 58 or Algol 60), means
than one owe to Algol 68 which is quite different (I'm not even sure they
share a common non trivial subset).

Yours,

--
Jean-Marc

[Dik T. Winter]

In article <dB******************@newssvr13.news.prodigy.nettp*****@nospamcomputer.org writes:

Bartc wrote:

The Wikipedia entry for C says the language was influenced by Algol68 but
gives no further details.

I'm intrigued: how exactly did Algol68 influence C, if at all?

How about most of the C syntax which was in Algol but not Fortran as
early as 1968? Much was passed on via Pascal, but that doesn't diminish
the reported influence.

Algol 68 did not really exist in 1968. But the C syntax comes mostly
from BCPL. In principle that is not very different. Both Pascal and
Algol 68 derive their syntax from Algol 60, and BCPL derives its syntax
from JOVIAL, a parallel development to Algol 60, from the initial, but
never implemented, Algol 58.
--
dik t. winter, cwi, kruislaan 413, 1098 sj amsterdam, nederland, [phone]
home: bovenover 215, 1025 jn amsterdam, nederland; http://www.cwi.nl/~dik/

[Dik T. Winter]

In article <CY*****************@fe2.news.blueyonder.co.uk"Bar tc" <ba***@freeuk.comwrites:

>
"Mark Bluemel" <ma**********@pobox.comwrote in message
news:fj**********@aioe.org...

Bartc wrote:

The Wikipedia entry for C says the language was influenced by Algol68 but
gives no further details.

I'm intrigued: how exactly did Algol68 influence C, if at all?

http://cm.bell-labs.com/cm/cs/who/dmr/chist.html is "from the horse's
mouth". Try reading that.

Ok, thanks. So it was syntax such as +:= which became +=.

Also the type system (as is written on that page). I think also the
concept of "void" comes from Algol 68 (although in Algol 60 "void"
variables actually could exist, they could have only a single value:
"empty").
--
dik t. winter, cwi, kruislaan 413, 1098 sj amsterdam, nederland, [phone]
home: bovenover 215, 1025 jn amsterdam, nederland; http://www.cwi.nl/~dik/

[Dik T. Winter]

In article <px*************@news.bourguet.orgJean-Marc Bourguet <[e-mail]:

Ben Bacarisse <be********@bsb.me.ukwrites:

Obviously I am ignoring the plain fact that all procedural languages
owe a lot to Algol (and thus indirectly to Algol 68).

I fail to understand how owing to Algol (ie. Algol 58 or Algol 60), means
than one owe to Algol 68 which is quite different (I'm not even sure they
share a common non trivial subset).

Not that. But Algol 68 was designed certainly with Algol 60 strongly in
mind. The early reports about Algol 68 showed much more similarity to
Algol 60 than later versions. I have seen some five or six versions
of the report, and each was deviating stronger from Algol 60.
--
dik t. winter, cwi, kruislaan 413, 1098 sj amsterdam, nederland, [phone]
home: bovenover 215, 1025 jn amsterdam, nederland; http://www.cwi.nl/~dik/

[CBFalconer]

Ben Bacarisse wrote:

Chris Dollin <ch**********@hp.comwrites:

>Tim Prince wrote:

>>Bartc wrote:

The Wikipedia entry for C says the language was influenced by
Algol68 but gives no further details.

I'm intrigued: how exactly did Algol68 influence C, if at all?

How about most of the C syntax which was in Algol but not
Fortran as early as 1968? Much was passed on via Pascal, but
that doesn't diminish the reported influence.

I would have thought via /BCPL/, not Pascal, thus accounting for
{}-blocks

BCPL did not have {}. It used $( and $).

The most obvious Algol 68'isms are casts and compound assignments
(though B also had these, I think they originate in Algol 68).
The most obvious -- the void keyword -- is red-herring since it
was not in C-as-designed only in C-as-standardised.

Obviously I am ignoring the plain fact that all procedural
languages owe a lot to Algol (and thus indirectly to Algol 68).

I think that Algol 60 probably was the more influential. Algol 68
is generally considered to be a backwards step. Pascal was one of
the protests against it.

--
Chuck F (cbfalconer at maineline dot net)
<http://cbfalconer.home.att.net>
Try the download section.

--
Posted via a free Usenet account from http://www.teranews.com

[Chris Dollin]

Ben Bacarisse wrote:

Chris Dollin <ch**********@hp.comwrites:

>Tim Prince wrote:

>>Bartc wrote:
The Wikipedia entry for C says the language was influenced by Algol68
but gives no further details.

I'm intrigued: how exactly did Algol68 influence C, if at all?

How about most of the C syntax which was in Algol but not Fortran as
early as 1968? Much was passed on via Pascal, but that doesn't diminish
the reported influence.

I would have thought via /BCPL/, not Pascal, thus accounting for
{}-blocks

BCPL did not have {}. It used $( and $).

Yes. (Oxford BCPL used section-brackets, actually, and I hacked a
BCPL compiler to use {} as well as $().)

It was the use of symbol-brackets-rather-than-begin-end that
chris@hp was referring to.

The most obvious Algol 68'isms are casts and compound assignments
(though B also had these, I think they originate in Algol 68).

Algol 60, IIRC, had compound assignments, and BCPL had compound
assignments of a different (and in my view more useful) form.

Obviously I am ignoring the plain fact that all procedural languages
owe a lot to Algol (and thus indirectly to Algol 68).

Yes to the former, but for the latter I think it's rather less
clear.

--
Far-Fetched Hedgehog
"Who do you serve, and who do you trust?" /Crusade/

[Richard Tobin]

In article <47***************@yahoo.com>,
CBFalconer <cb********@maineline.netwrote:

>I think that Algol 60 probably was the more influential. Algol 68
is generally considered to be a backwards step. Pascal was one of
the protests against it.

I'm not sure about that "generally". Certainly some people at the
time didn't like Algol 68, and it was considered hard to implement
(though easy by today's standards). I can't see how you can describe
it as a backward step though: can you give an example?

-- Richard
--
:wq

[Ben Bacarisse]

Chris Dollin <[e-mail]:

Ben Bacarisse wrote:

>Chris Dollin <ch**********@hp.comwrites:

>>Tim Prince wrote:

Bartc wrote:
The Wikipedia entry for C says the language was influenced by Algol68
but gives no further details.
>
I'm intrigued: how exactly did Algol68 influence C, if at all?

How about most of the C syntax which was in Algol but not Fortran as
early as 1968? Much was passed on via Pascal, but that doesn't diminish
the reported influence.

I would have thought via /BCPL/, not Pascal, thus accounting for
{}-blocks

BCPL did not have {}. It used $( and $).

Yes. (Oxford BCPL used section-brackets, actually, and I hacked a
BCPL compiler to use {} as well as $().)

and I see that "modern" BCPL uses them to the exclusion of the old ${
and $}. Still, I doubt they were in BCPL when it was influencing B &
C, but I accept that you intended:

It was the use of symbol-brackets-rather-than-begin-end that
chris@hp was referring to.

>The most obvious Algol 68'isms are casts and compound assignments
(though B also had these, I think they originate in Algol 68).

Algol 60, IIRC, had compound assignments, and BCPL had compound
assignments of a different (and in my view more useful) form.

Algol 60 actually re-dates me! I had a book about it as historical
curiosity when I started in 1977 but I don't recall any of the syntax.

BCPL did not have compound assignments, at least at first. Neither
the original spec nor the reference manual I have from about 1979
shows them, but you are quite right that they are in there now (I did
not know, so thanks for bringing me up-to-date). I note, though, that
I can find only 6 uses (in one program) out of more than 113,000 lines
of BCPL in Martin Richard's examples. I don't think they were there
early enough to have got into B from BCPL, but I have no date for
their addition into BCPL.

>Obviously I am ignoring the plain fact that all procedural languages
owe a lot to Algol (and thus indirectly to Algol 68).

Yes to the former, but for the latter I think it's rather less
clear.

Agreed. The last part of my statement is close to meaningless. It
was late!

<even more off-topic digression>
One version of Algol 68 (Algol 68C) added displacement operators.
They did the same as +:= (etc.) but returned the old value, so you got
a range of expressions like C's postfix ++ and -- but for all
operators. E.g. (trying to remember the syntax) x &:=: 1 masks all
but the bottom bit in x but returns what x used to have in it.
</digression>

--
Ben.

[CBFalconer]

Richard Tobin wrote:

CBFalconer <cb********@maineline.netwrote:

>I think that Algol 60 probably was the more influential. Algol
68 is generally considered to be a backwards step. Pascal was
one of the protests against it.

I'm not sure about that "generally". Certainly some people at
the time didn't like Algol 68, and it was considered hard to
implement (though easy by today's standards). I can't see how
you can describe it as a backward step though: can you give an
example?

No, I am just supplying things from long dumped memory.

--
Chuck F (cbfalconer at maineline dot net)
<http://cbfalconer.home.att.net>
Try the download section.
--
Posted via a free Usenet account from http://www.teranews.com

[Richard Tobin]

In article <47***************@yahoo.com>,
CBFalconer <cb********@maineline.netwrote:

>>I think that Algol 60 probably was the more influential. Algol
68 is generally considered to be a backwards step. Pascal was
one of the protests against it.

>I'm not sure about that "generally". Certainly some people at
the time didn't like Algol 68, and it was considered hard to
implement (though easy by today's standards). I can't see how
you can describe it as a backward step though: can you give an
example?

>No, I am just supplying things from long dumped memory.

I suspect that your view may have been common 25 years ago, but today
I think that Algol 68 can be seen as being in the main line of
programming language history, with Pascal as a dead end. This may
just reflect my ignorance of Pascal however.

-- Richard

--
:wq

[Chris Dollin]

Ben Bacarisse wrote:

BCPL did not have compound assignments, at least at first. Neither
the original spec nor the reference manual I have from about 1979
shows them,

I'm pretty sure they were there there by 1975/6, which is when I was
introduced to BCPL.

(Did you mean 19/6/9?)

I note, though, that
I can find only 6 uses (in one program) out of more than 113,000 lines
of BCPL in Martin Richard's examples.

Sadly I no longer have source to hand. The bad thing about BCPL's
compound assignment (for those late to class, it permits the LHS
and RHS to have several elements each, and assigns corresponding
elements) is that the evaluation rules are not quite good enough
for it to be /really/ useful; one wants some kind of guarantee about
when the addresses of targets are computed and when the assignments
happen.)

--
Well-Specified Hedgehog
"Life is full of mysteries. Consider this one of them." Sinclair, /Babylon 5/

[Dik T. Winter]

In article <XV******************@fe1.news.blueyonder.co.ukChr is Dollin <[e-mail]:
....

Algol 60, IIRC, had compound assignments,

You remember incorrectly. The only compounds you could build with
Algol 60 were arrays, and you had no array assignments.
--
dik t. winter, cwi, kruislaan 413, 1098 sj amsterdam, nederland, [phone]
home: bovenover 215, 1025 jn amsterdam, nederland; http://www.cwi.nl/~dik/

[Dik T. Winter]

In article <fj***********@pc-news.cogsci.ed.ac.ukri*****@cogsci.ed.ac.uk (Richard Tobin) writes:

In article <47***************@yahoo.com>,
CBFalconer <cb********@maineline.netwrote:

I think that Algol 60 probably was the more influential. Algol 68
is generally considered to be a backwards step. Pascal was one of
the protests against it.

I'm not sure about that "generally". Certainly some people at the
time didn't like Algol 68, and it was considered hard to implement
(though easy by today's standards).

I still wonder at that. In (I think) 1976 CDC had an Algol 68 compiler,
full-fledged (not restricted like Algol 68-R). The compiler had been
built in a few years by a team of five people without any previous
experience in compiler building. I think many people had problems with
the definition through a 2-level grammar. On the other hand, that made
the features in the language fully orthogonal in many cases, and allowed
what is now many times seen as a semantic error (e.g. type mismatch on
assignment) a syntactic error.

BTW, the same has been said about Algol 60. I have still, somewhere, a
report from Princeton that describes how to handle arrays in Algol 60.

I can't see how you can describe
it as a backward step though: can you give an example?

I liked Algol 68 very much and have done quite a lot in it. It gave
full-fledged operator overloading, including user defined operators,
which could make the description of mathematical problems very simple.
--
dik t. winter, cwi, kruislaan 413, 1098 sj amsterdam, nederland, [phone]
home: bovenover 215, 1025 jn amsterdam, nederland; http://www.cwi.nl/~dik/

[Ben Bacarisse]

Chris Dollin <[e-mail]:

Algol 60, IIRC, had compound assignments, and BCPL had compound
assignments of a different (and in my view more useful) form.

Prompted by a different message else thread I think we have crossed
wires. If you mean the form:

a, b, c := 1, 2, 99

then, yes, that was there even in the 1969 MIT version of BCPL (but I
don't remember that in Algol 60). But of course, that form of
multiple assignment never made it into B or C so I missed your point.

I was meaning assignment operators that are "compounded" with a binary
operator. Probably not the right terminology at all, but I don't know
what they are called in general. I was saying that these probably got
into B from Algol 68. There were not in the early BCPL (but do seem
to have added at some point).

--
Ben.

[Dik T. Winter]

In article <87************@bsb.me.ukBen Bacarisse <be********@bsb.me.ukwrites:
....

<even more off-topic digression>
One version of Algol 68 (Algol 68C) added displacement operators.
They did the same as +:= (etc.) but returned the old value, so you got
a range of expressions like C's postfix ++ and -- but for all
operators. E.g. (trying to remember the syntax) x &:=: 1 masks all
but the bottom bit in x but returns what x used to have in it.
</digression>

You did not need Algol 68C for that. You could define them in Algol 68
proper.
'op' &:= = (('ref' 'bits' i, 'bits' j) 'bits':
(i := i & j; i);
is the definition for the standard operator, while
'op' &:=: = (('ref' 'bits' i, 'bits' j) 'bits':
('bits' k := i; i := i & j; k);
would do what you describe.
--
dik t. winter, cwi, kruislaan 413, 1098 sj amsterdam, nederland, [phone]
home: bovenover 215, 1025 jn amsterdam, nederland; http://www.cwi.nl/~dik/

[Richard Tobin]

In article <Js********@cwi.nl>, Dik T. Winter <Di********@cwi.nlwrote:

>I think many people had problems with
the definition through a 2-level grammar.

I've heard other people say that, though it surprises me that people
who might consider implementing it would be put off by that.
It's certainly interesting to compare the grammar in the Algol-68R
Users Guide with that of the Revised Report - it's very simple (and
not I think just because of the restrictions).

-- Richard
--
:wq

[Chris Dollin]

Dik T. Winter wrote:

In article <XV******************@fe1.news.blueyonder.co.ukChr is Dollin
<[e-mail]: ...

Algol 60, IIRC, had compound assignments,

You remember incorrectly. The only compounds you could build with
Algol 60 were arrays, and you had no array assignments.

Wrong sense of "compound assignment"; it's the assignments that are
compound, not the values: `a := b := c;`. If I'm remembering correctly.

--
Both Real And Imaginary Hedgehog
"I just wonder when we're going to have to sit down and re-evaluate
our decision-making paradigm." /Sahara/

[Chris Dollin]

Ben Bacarisse wrote:

Chris Dollin <[e-mail]:

>Algol 60, IIRC, had compound assignments, and BCPL had compound
assignments of a different (and in my view more useful) form.

Prompted by a different message else thread I think we have crossed
wires. If you mean the form:

a, b, c := 1, 2, 99

then, yes, that was there even in the 1969 MIT version of BCPL (but I
don't remember that in Algol 60). But of course, that form of
multiple assignment never made it into B or C so I missed your point.

I was meaning assignment operators that are "compounded" with a binary
operator. Probably not the right terminology at all, but I don't know
what they are called in general. I was saying that these probably got
into B from Algol 68. There were not in the early BCPL (but do seem
to have added at some point).

Aaaaaaaaaaaaaaaaah!

OK, we have an agreement: I did mean the multiple form you exhibit
above. Terminology is responsible for too many wars ...

--
Oops Hedgehog
A rock is not a fact. A rock is a rock.

[NevilleDNZ]

On Dec 9, 4:09 am, [e-mail] (Richard Tobin) wrote:

In article <[e-mail]>,

CBFalconer <[e-mail]:

>I think thatAlgol60 probably was the more influential. Algol
68 is generally considered to be a backwards step. Pascal was
one of the protests against it.
I'm not sure about that "generally". Certainly some people at
the time didn't likeAlgol68, and it was considered hard to
implement (though easy by today's standards). I can't see how
you can describe it as a backward step though: can you give an
example?

No, I am just supplying things from long dumped memory.

I suspect that your view may have been common 25 years ago, but today
I think thatAlgol68 can be seen as being in the main line of
programming language history, with Pascal as a dead end. This may
just reflect my ignorance of Pascal however.

-- Richard

--
:wq

Here are some published references:
* http://cm.bell-labs.com/cm/cs/who/dmr/chist.pdf
* http://groups.google.co.uk/group/com...7b6f5c81502cf5

Since K&R C, with the advent of C99 a few more bits of what was
ALGOL68 has move into C. For example the procedure argument
declarations.

In regard to K&R C, don't forget that Steve Bourne was imported by
AT&T from Cambridge University where he worked on the ALGOL68C
compiler. amoung other things he worked on an ALGOL68 Compiler at
AT&T (I would expect it was a port of ALGOL68C). I believe he
create the Algol Debugger for Unix, what we now know as "adb".
( http://www.roesler-ac.de/wolfram/acro/credits.htm#adb )

What is equally interesting is the influence of ALGOL68 on Python via
Lambert Meertens' ABC programming language.
Adriaan van Wijngaarden was the "party ideologist" for ALGOL-68, and
was also based in Mathematisch Centrum Amsterdam. Lambert Meertens'
worked with Wijngaarden on the first revision of ALGOL-68.

Other notable people from this center include along with Guido van
Rossum. Here is his comment on ALGOL68 http://www.amk.ca/python/writing/gvr-interview
(1998).

ALGOL-X: IMHO ALGOL-60 was much more Fortran like, certainly better
the Fortran IV. The proponents of ALGOL-60 went on to propose ALGOL-
X, and eventually created ALGOL-W.

ALGOL-Y: I believe that ALGOL-68 grew from the ALGOL Y branch. ALGOL-
Y apparently included some functional programming techniques that
didn't make it into ALGOL-68. But to be clear, I have never seen the
ALGOL-Y suggestions.

N

[NevilleDNZ]

On Dec 9, 10:42 am, "Dik T. Winter" <[e-mail]:

'op' &:= = (('ref' 'bits' i, 'bits' j) 'bits':
(i := i & j; i);
is the definition for the standard operator, while
'op' &:=: = (('ref' 'bits' i, 'bits' j) 'bits':
('bits' k := i; i := i & j; k);
would do what you describe.

BTW: I just discovered that gcc has implemented some more feature from
ALGOL-68.

ALGOL 68:
INT result := ( INT sum; FOR i TO 100 sum+:=i OD; sum )

C: (gcc)
int result = ({ int sum,i; for(i=1; i<=100; i++)sim+=i; sum; })

deja-vu?

N

[Dik T. Winter]

In article <41******************@fe3.news.blueyonder.co.ukChr is Dollin <[e-mail]:

Dik T. Winter wrote:

In article <XV******************@fe1.news.blueyonder.co.ukChr is Dollin
<[e-mail]: ...

Algol 60, IIRC, had compound assignments,

You remember incorrectly. The only compounds you could build with
Algol 60 were arrays, and you had no array assignments.

Wrong sense of "compound assignment"; it's the assignments that are
compound, not the values: `a := b := c;`. If I'm remembering correctly.

But also Fortran had that.
--
dik t. winter, cwi, kruislaan 413, 1098 sj amsterdam, nederland, [phone]
home: bovenover 215, 1025 jn amsterdam, nederland; http://www.cwi.nl/~dik/

[Dik T. Winter]

In article <Cd******************@fe2.news.blueyonder.co.ukChr is Dollin <[e-mail]:

Ben Bacarisse wrote:

Chris Dollin <[e-mail]:

Algol 60, IIRC, had compound assignments, and BCPL had compound
assignments of a different (and in my view more useful) form.

Prompted by a different message else thread I think we have crossed
wires. If you mean the form:
a, b, c := 1, 2, 99
then, yes, that was there even in the 1969 MIT version of BCPL (but I
don't remember that in Algol 60).

....

OK, we have an agreement: I did mean the multiple form you exhibit
above. Terminology is responsible for too many wars ...

And that form was not present in Algol 60.
--
dik t. winter, cwi, kruislaan 413, 1098 sj amsterdam, nederland, [phone]
home: bovenover 215, 1025 jn amsterdam, nederland; http://www.cwi.nl/~dik/

[Dik T. Winter]

In article <9c**********************************@b40g2000prf. googlegroups.comNevilleDNZ <ne********@gmail.comwrites:

On Dec 9, 10:42 am, "Dik T. Winter" <[e-mail]:

'op' &:= = (('ref' 'bits' i, 'bits' j) 'bits':
(i := i & j; i);
is the definition for the standard operator, while
'op' &:=: = (('ref' 'bits' i, 'bits' j) 'bits':
('bits' k := i; i := i & j; k);
would do what you describe.

BTW: I just discovered that gcc has implemented some more feature from
ALGOL-68.

ALGOL 68:
INT result := ( INT sum; FOR i TO 100 sum+:=i OD; sum )

Yes, nearly every statement could be used as an expression.

C: (gcc)
int result = ({ int sum,i; for(i=1; i<=100; i++)sim+=i; sum; })

deja-vu?

Indeed.
--
dik t. winter, cwi, kruislaan 413, 1098 sj amsterdam, nederland, [phone]
home: bovenover 215, 1025 jn amsterdam, nederland; http://www.cwi.nl/~dik/

[Richard Tobin]

In article <9c**********************************@b40g2000prf. googlegroups.com>,
NevilleDNZ <ne********@gmail.comwrote:

>BTW: I just discovered that gcc has implemented some more feature from
ALGOL-68.

ALGOL 68:
INT result := ( INT sum; FOR i TO 100 sum+:=i OD; sum )

C: (gcc)
int result = ({ int sum,i; for(i=1; i<=100; i++)sim+=i; sum; })

I wouldn't assume that was taken from Algol 68. The idea that
arbitrary code can be wrapped up in an expression is more or less
universal now. Algol 68 may have been an influence in that of course,
but it didn't invent the idea. Consider Lisp for example.

-- Richard

--
:wq

[NevilleDNZ]

On Dec 10, 11:03 pm, [e-mail] (Richard Tobin) wrote:

I wouldn't assume that was taken from Algol 68. The idea that
arbitrary code can be wrapped up in an expression is more or less
universal now. Algol 68 may have been an influence in that of course,
but it didn't invent the idea. Consider Lisp for example.

It certainly is deja-vu thou.

It has taken some 31 years for such ideas to get into C99?
These features were recognised in the 1960s.

BTW: I forgot to initialise sum in the example above.... :(

N

[Richard Tobin]

In article <0d**********************************@s19g2000prg. googlegroups.com>,
NevilleDNZ <ne********@gmail.comwrote:

>I wouldn't assume that was taken from Algol 68. The idea that
arbitrary code can be wrapped up in an expression is more or less
universal now. Algol 68 may have been an influence in that of course,
but it didn't invent the idea. Consider Lisp for example.

>It certainly is deja-vu thou.

It has taken some 31 years for such ideas to get into C99?

That feature (using arbitrary statements as expressions) is not in
C99.

>These features were recognised in the 1960s.

That's not much of an argument in itself. C doesn't have to have
every feature, no matter how long ago it was invented. On the
other hand, this particular feature is very useful and would be
easy enough to implement.

-- Richard
--
:wq

[David Thompson]

On Mon, 10 Dec 2007 00:24:27 GMT, "Dik T. Winter" <Di********@cwi.nl>
wrote:

In article <41******************@fe3.news.blueyonder.co.ukChr is Dollin <[e-mail]:

Dik T. Winter wrote:
>

In article <XV******************@fe1.news.blueyonder.co.ukChr is Dollin
<[e-mail]: ...
Algol 60, IIRC, had compound assignments,

You remember incorrectly. The only compounds you could build with
Algol 60 were arrays, and you had no array assignments.

>
Wrong sense of "compound assignment"; it's the assignments that are
compound, not the values: `a := b := c;`. If I'm remembering correctly.

But also Fortran had that.

No it didn't, and it still doesn't. (Well, Fortran doesn't have := at
all, but I assume you meant the obvious equivalent using =.)
Nor do Pascal and Ada, and COBOL, and PL/I. (In COBOL you can MOVE a
single item or value to multiple destinations -- but each separately,
not converting to the first and then that to the second etc.)

But I don't call that compound; I call it chained.

Fortran (now) and PL/I and Ada have array and structure assignments,
which generically I call aggregate or composite. There's also (rarer)
quasi-composite multivalue or tuple assignment e.g. (X,Y,Z):=(1,2,3).

C uses 'compound' (and so do I) for forms like x -= 3, which AIUI A68
had as already noted elsethread. And FWLIW COBOL has some specific
(simple) cases though not the general operators.

- formerly david.thompson1 || achar(64) || worldnet.att.net

[Dik T. Winter]

In article <44********************************@4ax.comDavid Thompson <da************@verizon.netwrites:

On Mon, 10 Dec 2007 00:24:27 GMT, "Dik T. Winter" <Di********@cwi.nl>
wrote:

....

Wrong sense of "compound assignment"; it's the assignments that are
compound, not the values: `a := b := c;`. If I'm remembering correctly.

But also Fortran had that.

No it didn't, and it still doesn't. (Well, Fortran doesn't have := at
all, but I assume you meant the obvious equivalent using =.)

Indeed, and I remembered wrong. Probably because I never was a real
user of Fortran.

But I don't call that compound; I call it chained.

Fortran (now) and PL/I and Ada have array and structure assignments,
which generically I call aggregate or composite.

You could also define them in Algol 68. The assignment was there, but you
can define other operators, including compound operators, and operators
on compounds.

C uses 'compound' (and so do I) for forms like x -= 3, which AIUI A68
had as already noted elsethread.

It is simply a consequence of how operators are handled in the syntax of
Algol 68.
--
dik t. winter, cwi, kruislaan 413, 1098 sj amsterdam, nederland, [phone]
home: bovenover 215, 1025 jn amsterdam, nederland; http://www.cwi.nl/~dik/