26 Apr
2020
26 Apr
'20
12:03 a.m.
From: Rob Pike
To make chaining of calls simpler. Write
f()->g()->h()->i()
the other way
You mean:
(*f)((*g)((*h)((*i)())))
I dunno, it doesn't seem that much worse to me.
What I like about the explicit notation (i.e. (*f) ()) is that it forces the
programmer to recognize what's going on.
On the other hand, I guess, the whole concept of compiled languages is to get
the programmer's nose out of the low-level details, so they can focus on the
high level. So I guess one could see allowing f() in place of (*f)() as an
instance of that.
Then again, down that road you find a lot of modern code, where a programmer
writes something that is e.g. horribly inefficient and slow, precisely because
they are so divorced from the low-level of what the code they wrote turns into...
Still, I'd be a little worried about a program doing (*f)((*g)((*h)((*i)()))),
no matter what the notation was; it would be awfully hard to recognize what
all the possible call chains are. But then again I guess a lot of e.g. AI code
does things like that...
Noel
26 Apr
26 Apr
2:11 a.m.
New subject: v7 K&R C
On 25 Apr 2020 14:03 -0400, from jnc(a)mercury.lcs.mit.edu (Noel Chiappa):
Then again, down that road you find a lot of modern
code, where a programmer
writes something that is e.g. horribly inefficient and slow, precisely because
they are so divorced from the low-level of what the code they wrote turns into...
...and then there's an exceptionally complicated CPU execution
pipeline in which code is rearranged to try to allow the CPU to
execute it as fast as possible while preserving "observable" behavior.
As we know, down that road lies... security vulnerabilities.
That said, I agree; I don't know how many times I've nearly headdesked
coming across code that looks like someone typed the first thing that
entered their mind, instead of actually thinking the problem through
first and _then_ coding a solution. I'm almost certainly not innocent
there myself, either, although I do try.
--
Michael Kjörling • https://michael.kjorling.se • michael(a)kjorling.se
“Remember when, on the Internet, nobody cared that you were a dog?”
3:27 a.m.
New subject: v7 K&R C
On Saturday, April 25, 2020, 04:11:58 PM EDT, Michael Kjörling
<michael(a)kjorling.se> wrote:
That said, I agree; I don't know how many times
I've nearly headdesked
coming across code that looks like someone typed the first thing that
entered their mind, instead of actually thinking the problem through
first and _then_ coding a solution. I'm almost certainly not innocent
there myself, either, although I do try.
I know that feeling all too well. I try to think of it in
the same terms as "Let him who is without sin cast
the first stone." But students coming to me with code
that is clearly created using the random walk method
of programming lead to me not always being as patient
with my counsel as I should be.
BLS
27 Apr
27 Apr
1:37 a.m.
New subject: v7 K&R C
On Sat, Apr 25, 2020 at 02:03:57PM -0400, Noel Chiappa wrote:
No, I think he means something like:
(*((*((*((*f)()->g))()->h))()->i))()
but I can't recall the relative priority of '*' and '->' in
the above, so I may have added unnecessary parens.
Or was he thinking of having to use '.' as well to access
the member pointers within the structs?
DF
From: Rob Pike
To make chaining of calls simpler. Write
f()->g()->h()->i()
the other way
You mean:
(*f)((*g)((*h)((*i)())))
I dunno, it doesn't seem that much worse to me.
2:10 a.m.
New subject: v7 K&R C
On Sun, Apr 26, 2020 at 08:37:04PM +0100, Derek Fawcus wrote:
No, I think he means something like:
(*((*((*((*f)()->g))()->h))()->i))()
but I can't recall the relative priority of '*' and '->' in
the above, so I may have added unnecessary parens.
Actually trying it, while the above does the right thing,
I can also get the following to compile with a modern compiler
(*(*(*(*f)()->g)()->h)()->i)();
So maybe that was the answer?
I guess I'd have to question why someone would wish to write
such a construct, as error handling seems awkward. Even in
the modern form.
DF
3:59 a.m.
New subject: v7 K&R C
On Apr 26, 2020, at 13:10, Derek Fawcus wrote:
I guess I'd have to question why someone would wish to write such a construct,
as error handling seems awkward.
FWIW, I do most of my programming these days in Elixir. It's a functional
programming language with pervasive pattern matching, Rubyish syntax, and
Lispish macros. It runs on the Erlang virtual machine, so it has a good
story for Actor-based concurrency, distribution, etc. For details, see:
https://en.wikipedia.org/wiki/Elixir_(programming_language)
Anyway, compilation is mostly handled by Lispish macros, so it can support
some fairly cool metaprogramming. In particular, I can write things like:
out_map = inp_list |>
Enum.filter(filter_fn) |>
Enum.map(map_fn) |>
Enum.reduce(%{}, reduce_fn)
Piped values are handed in as the first argument to each function and most
functions expect this behavior. For extra credit, there is a set of Stream
functions (really, macros) that process one element at a time and handle
errors in a reasonable manner.
-r
4:38 a.m.
New subject: v7 K&R C
Tom Cargill makes (made) frequent use of this construction in 'pi'
(process inspector, first in Eight Edition), e.g.,
asm.c: _asm->core->process()->openmemory(addr);
frame.c: return core->process()->frame(level-1)->regloc((int)v->range.lo,
v->type.size_of());
phrase.c: frame->symtab()->core()->process()->openmemory(expr->val.lng);
On Mon, Apr 27, 2020 at 6:11 AM Derek Fawcus <
dfawcus+lists-tuhs(a)employees.org> wrote:
On Sun, Apr 26, 2020 at 08:37:04PM +0100, Derek Fawcus
wrote:
No, I think he means something like:
(*((*((*((*f)()->g))()->h))()->i))()
but I can't recall the relative priority of '*' and '->' in
the above, so I may have added unnecessary parens.
Actually trying it, while the above does the right thing,
I can also get the following to compile with a modern compiler
(*(*(*(*f)()->g)()->h)()->i)();
So maybe that was the answer?
I guess I'd have to question why someone would wish to write
such a construct, as error handling seems awkward. Even in
the modern form.
DF
5:57 a.m.
New subject: v7 K&R C
On 04/26/20 16:10, Derek Fawcus wrote:
On Sun, Apr 26, 2020 at 08:37:04PM +0100, Derek Fawcus
wrote:
K&R 1, Sect. 6.2. (with no mention of Rob Pike's influence).
N.
No, I think he means something like:
(*((*((*((*f)()->g))()->h))()->i))()
but I can't recall the relative priority of '*' and '->' in
the above, so I may have added unnecessary parens.
Actually trying it, while the
above does the right thing,
I can also get the following to compile with a modern compiler
(*(*(*(*f)()->g)()->h)()->i)();
So maybe that was the answer?
I guess I'd have to question why someone would wish to write
such a construct, as error handling seems awkward. Even in
the modern form.
DF
9:38 a.m.
New subject: v7 K&R C
Yes, that's the issue, which arose in C++ programs. The question at the
time was whether C would allow the same syntax.
Nothing to do with me.
-rob
On Mon, Apr 27, 2020 at 9:58 AM Nemo Nusquam <cym224(a)gmail.com> wrote:
On 04/26/20 16:10, Derek Fawcus wrote:
On Sun, Apr 26, 2020 at 08:37:04PM +0100, Derek
Fawcus wrote:
K&R 1, Sect. 6.2. (with no mention of Rob Pike's influence).
N.
No, I think he means something like:
(*((*((*((*f)()->g))()->h))()->i))()
but I can't recall the relative priority of '*' and '->' in
the above, so I may have added unnecessary parens.
Actually trying it, while the
above does the right thing,
I can also get the following to compile with a modern compiler
(*(*(*(*f)()->g)()->h)()->i)();
So maybe that was the answer?
I guess I'd have to question why someone would wish to write
such a construct, as error handling seems awkward. Even in
the modern form.
DF
1700
days inactive
1702
days old
10 comments
9 participants
participants (9)
-
Brian L. Stuart -
Derek Fawcus -
emanuel stiebler -
jnc＠mercury.lcs.mit.edu -
Michael Kjörling -
Nemo Nusquam -
Noel Hunt -
Rich Morin -
Rob Pike