Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.lang.c > #133735 > unrolled thread
| Started by | skybuck2000@hotmail.com |
|---|---|
| First post | 2018-08-13 12:53 -0700 |
| Last post | 2018-10-10 18:24 -0700 |
| Articles | 20 on this page of 354 — 27 participants |
Back to article view | Back to comp.lang.c
>< swap operator skybuck2000@hotmail.com - 2018-08-13 12:53 -0700
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-08-13 16:05 -0400
Re: >< swap operator fir <profesor.fir@gmail.com> - 2018-08-13 13:46 -0700
Re: >< swap operator Anton Shepelev <anton.txt@g{oogle}mail.com> - 2018-08-14 11:19 +0300
Re: >< swap operator skybuck2000@hotmail.com - 2018-08-14 06:16 -0700
Re: >< swap operator bart4858@gmail.com - 2018-08-14 07:50 -0700
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-08-14 16:59 +0200
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-08-14 10:46 -0700
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-08-14 20:03 +0200
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-08-14 11:37 -0700
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-08-14 21:16 +0200
Re: >< swap operator fir <profesor.fir@gmail.com> - 2018-08-14 11:32 -0700
Re: >< swap operator bart4858@gmail.com - 2018-08-14 16:24 -0700
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-08-15 11:32 +0200
Re: >< swap operator skybuck2000@hotmail.com - 2018-10-01 07:46 -0700
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-02 05:20 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-02 13:58 +0100
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-02 14:08 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-02 09:16 -0400
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-02 15:35 +0200
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-02 09:43 -0400
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-02 10:51 -0700
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-02 09:08 -0400
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-02 15:26 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-02 10:52 -0400
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-02 17:57 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-02 13:27 -0400
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-02 11:52 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-02 20:48 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-02 15:56 -0400
Re: >< swap operator Thiago Adams <thiago.adams@gmail.com> - 2018-10-02 13:05 -0700
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-02 13:26 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-02 21:36 +0100
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-02 13:47 -0700
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-03 11:14 +0200
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-02 16:37 -0400
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-02 22:02 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-02 17:16 -0400
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-03 11:25 +0200
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-03 10:52 +0100
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-03 14:29 +0200
Re: >< swap operator Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2018-10-03 05:52 -0700
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-03 21:31 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-03 16:47 -0400
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-04 03:43 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-03 22:47 -0400
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-04 04:25 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-03 20:44 -0700
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-04 11:53 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-04 05:15 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-04 13:48 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-04 10:56 -0400
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-04 17:47 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-04 11:01 -0700
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-04 22:15 +0200
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-04 16:19 -0400
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-04 21:42 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-04 15:01 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-04 23:59 +0100
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-05 09:54 +0200
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-05 18:03 +0100
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-05 21:08 +0200
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-05 20:31 +0100
Re: >< swap operator Lew Pitcher <lew.pitcher@digitalfreehold.ca> - 2018-10-05 15:59 -0400
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-05 21:18 +0100
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-06 03:51 +0100
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-06 12:19 +0100
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-06 19:49 +0100
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-07 12:25 +0100
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-07 14:19 +0100
Re: >< swap operator Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2018-10-07 06:56 -0700
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-07 16:30 +0100
Re: >< swap operator Wouter Verhelst <w@uter.be> - 2018-10-09 13:17 +0200
C idioms (Was: >< swap operator) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-09 13:07 +0000
Re: C idioms (Was: >< swap operator) Bart <bc@freeuk.com> - 2018-10-09 14:27 +0100
Re: C idioms Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-10 00:05 +0100
Re: C idioms Bart <bc@freeuk.com> - 2018-10-10 02:03 +0100
Re: C idioms Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-11 01:05 +0100
Re: C idioms Bart <bc@freeuk.com> - 2018-10-11 02:09 +0100
Re: C idioms Bart <bc@freeuk.com> - 2018-10-11 12:39 +0100
Re: C idioms Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-11 16:24 +0100
Re: C idioms scott@slp53.sl.home (Scott Lurndal) - 2018-10-11 15:55 +0000
Re: C idioms Keith Thompson <kst-u@mib.org> - 2018-10-11 09:42 -0700
Re: C idioms Wouter Verhelst <w@uter.be> - 2018-10-11 19:23 +0200
Re: C idioms jameskuyper@alumni.caltech.edu - 2018-10-11 11:11 -0700
Re: C idioms Keith Thompson <kst-u@mib.org> - 2018-10-11 12:05 -0700
Re: C idioms Bart <bc@freeuk.com> - 2018-10-11 17:53 +0100
Re: C idioms Keith Thompson <kst-u@mib.org> - 2018-10-11 10:38 -0700
Re: C idioms Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-12 00:14 +0100
Re: C idioms Bart <bc@freeuk.com> - 2018-10-11 19:26 +0100
Re: C idioms (Was: >< swap operator) David Brown <david.brown@hesbynett.no> - 2018-10-09 16:38 +0200
Re: C idioms (Was: >< swap operator) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-09 15:23 +0000
Re: C idioms (Was: >< swap operator) David Brown <david.brown@hesbynett.no> - 2018-10-09 20:31 +0200
Re: C idioms (Was: >< swap operator) Bart <bc@freeuk.com> - 2018-10-09 20:18 +0100
Re: C idioms (Was: >< swap operator) David Brown <david.brown@hesbynett.no> - 2018-10-09 22:11 +0200
Re: C idioms (Was: >< swap operator) scott@slp53.sl.home (Scott Lurndal) - 2018-10-09 20:50 +0000
Re: C idioms (Was: >< swap operator) David Brown <david.brown@hesbynett.no> - 2018-10-09 22:58 +0200
Re: C idioms (Was: >< swap operator) Bart <bc@freeuk.com> - 2018-10-09 22:34 +0100
Re: C idioms (Was: >< swap operator) David Brown <david.brown@hesbynett.no> - 2018-10-10 08:10 +0200
Re: C idioms (Was: >< swap operator) jameskuyper@alumni.caltech.edu - 2018-10-09 14:45 -0700
Re: C idioms (Was: >< swap operator) David Brown <david.brown@hesbynett.no> - 2018-10-10 08:07 +0200
Hmmm... (Was: C idioms (Was: >< swap operator)) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-10 07:56 +0000
Re: Hmmm... (Was: C idioms (Was: >< swap operator)) David Brown <david.brown@hesbynett.no> - 2018-10-10 10:32 +0200
Re: Hmmm... (Was: C idioms (Was: >< swap operator)) Ike Naar <ike@iceland.freeshell.org> - 2018-10-10 13:44 +0000
Re: Hmmm... (Was: C idioms (Was: >< swap operator)) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-10 14:52 +0000
Re: Hmmm... (Was: C idioms (Was: >< swap operator)) Wouter Verhelst <w@uter.be> - 2018-10-10 17:47 +0200
Re: Hmmm... (Was: C idioms (Was: >< swap operator)) David Brown <david.brown@hesbynett.no> - 2018-10-10 17:18 +0200
Re: Hmmm... (Was: C idioms (Was: >< swap operator)) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-10 15:22 +0000
Re: Hmmm... (Was: C idioms (Was: >< swap operator)) David Brown <david.brown@hesbynett.no> - 2018-10-10 23:58 +0200
Re: Hmmm... Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2018-10-10 07:51 -0600
Re: Hmmm... gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-10 14:53 +0000
Re: Hmmm... David Brown <david.brown@hesbynett.no> - 2018-10-10 17:21 +0200
Re: C idioms (Was: >< swap operator) scott@slp53.sl.home (Scott Lurndal) - 2018-10-10 12:57 +0000
Re: C idioms (Was: >< swap operator) James Kuyper <jameskuyper@alumni.caltech.edu> - 2018-10-10 12:29 -0400
Re: C idioms (Was: >< swap operator) David Brown <david.brown@hesbynett.no> - 2018-10-11 00:07 +0200
Re: C idioms (Was: >< swap operator) Keith Thompson <kst-u@mib.org> - 2018-10-09 14:50 -0700
Re: C idioms (Was: >< swap operator) David Brown <david.brown@hesbynett.no> - 2018-10-10 08:13 +0200
Re: C idioms (Was: >< swap operator) scott@slp53.sl.home (Scott Lurndal) - 2018-10-10 12:56 +0000
Re: C idioms (Was: >< swap operator) David Brown <david.brown@hesbynett.no> - 2018-10-10 15:55 +0200
Re: C idioms (Was: >< swap operator) Bart <bc@freeuk.com> - 2018-10-10 15:17 +0100
Re: C idioms (Was: >< swap operator) scott@slp53.sl.home (Scott Lurndal) - 2018-10-10 14:49 +0000
Fall-through in switch statements... (Was: C idioms (Was: >< swap operator)) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-10 14:59 +0000
Re: Fall-through in switch statements... (Was: C idioms (Was: >< swap operator)) Bart <bc@freeuk.com> - 2018-10-10 16:09 +0100
Re: Fall-through in switch statements... (Was: C idioms (Was: >< swap operator)) nobody@example.org (Scott) - 2018-10-10 17:29 +0000
Re: C idioms (Was: >< swap operator) Bart <bc@freeuk.com> - 2018-10-10 16:01 +0100
Re: C idioms (Was: >< swap operator) David Brown <david.brown@hesbynett.no> - 2018-10-10 17:29 +0200
Re: C idioms (Was: >< swap operator) Wouter Verhelst <w@uter.be> - 2018-10-10 17:55 +0200
Re: C idioms (Was: >< swap operator) Bart <bc@freeuk.com> - 2018-10-10 17:11 +0100
Re: C idioms Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-10 23:15 +0100
Re: C idioms (Was: >< swap operator) David Brown <david.brown@hesbynett.no> - 2018-10-11 00:16 +0200
Re: C idioms (Was: >< swap operator) Bart <bc@freeuk.com> - 2018-10-10 23:23 +0100
Re: C idioms (Was: >< swap operator) Keith Thompson <kst-u@mib.org> - 2018-10-10 16:31 -0700
Re: C idioms (Was: >< swap operator) Keith Thompson <kst-u@mib.org> - 2018-10-10 15:32 -0700
Re: C idioms (Was: >< swap operator) Keith Thompson <kst-u@mib.org> - 2018-10-10 16:24 -0700
Re: C idioms (Was: >< swap operator) David Brown <david.brown@hesbynett.no> - 2018-10-11 10:52 +0200
Re: C idioms Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2018-10-10 09:59 -0600
Re: C idioms (Was: >< swap operator) David Brown <david.brown@hesbynett.no> - 2018-10-10 17:26 +0200
Re: C idioms (Was: >< swap operator) scott@slp53.sl.home (Scott Lurndal) - 2018-10-10 14:48 +0000
Return values of fork() (Was: C idioms (Was: >< swap operator)) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-10 14:51 +0000
Re: Return values of fork() (Was: C idioms (Was: >< swap operator)) scott@slp53.sl.home (Scott Lurndal) - 2018-10-10 15:20 +0000
You know that and I know that, but ... (Was: Return values of fork() (Was: C idioms (Was: >< swap operator))) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-10 15:28 +0000
Re: You know that and I know that, but ... (Was: Return values of fork() (Was: C idioms (Was: >< swap operator))) David Brown <david.brown@hesbynett.no> - 2018-10-11 00:23 +0200
Re: You know that and I know that, but ... (Was: Return values of fork() (Was: C idioms (Was: >< swap operator))) scott@slp53.sl.home (Scott Lurndal) - 2018-10-11 13:22 +0000
Re: You know that and I know that, but ... (Was: Return values of fork() (Was: C idioms (Was: >< swap operator))) David Brown <david.brown@hesbynett.no> - 2018-10-11 15:58 +0200
Re: You know that and I know that, but ... (Was: Return values of fork() (Was: C idioms (Was: >< swap operator))) scott@slp53.sl.home (Scott Lurndal) - 2018-10-11 14:17 +0000
Re: You know that and I know that, but ... (Was: Return values of fork() (Was: C idioms (Was: >< swap operator))) David Brown <david.brown@hesbynett.no> - 2018-10-11 16:42 +0200
Re: You know that and I know that, but ... (Was: Return values of fork() (Was: C idioms (Was: >< swap operator))) Wouter Verhelst <w@uter.be> - 2018-10-11 16:53 +0200
Re: You know that and I know that, but ... (Was: Return values of fork() (Was: C idioms (Was: >< swap operator))) David Brown <david.brown@hesbynett.no> - 2018-10-11 20:11 +0200
Re: Return values of fork() (Was: C idioms (Was: >< swap operator)) David Brown <david.brown@hesbynett.no> - 2018-10-11 00:20 +0200
Re: Return values of fork() (Was: C idioms (Was: >< swap operator)) Keith Thompson <kst-u@mib.org> - 2018-10-10 16:15 -0700
Re: Return values of fork() Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2018-10-11 14:42 -0600
Re: C idioms Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2018-10-09 16:18 -0600
Re: C idioms gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-09 22:28 +0000
Re: C idioms scott@slp53.sl.home (Scott Lurndal) - 2018-10-10 12:58 +0000
Re: C idioms (Was: >< swap operator) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2018-10-09 07:48 -0700
Re: C idioms Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-09 16:42 +0100
Re: C idioms (Was: >< swap operator) Wouter Verhelst <w@uter.be> - 2018-10-09 19:40 +0200
Re: C idioms (Was: >< swap operator) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2018-10-09 12:38 -0700
Re: C idioms (Was: >< swap operator) Wouter Verhelst <w@uter.be> - 2018-10-09 23:41 +0200
Re: C idioms (Was: >< swap operator) Wouter Verhelst <w@uter.be> - 2018-10-09 19:38 +0200
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-07 15:04 +0100
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-07 16:37 +0100
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-07 16:58 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-07 12:17 -0400
Grammar police! (Was: >< swap operator) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-07 20:37 +0000
Re: >< swap operator jameskuyper@alumni.caltech.edu - 2018-10-07 09:31 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-07 18:09 +0100
Re: >< swap operator jameskuyper@alumni.caltech.edu - 2018-10-07 14:05 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-07 22:35 +0100
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-08 02:56 +0100
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-08 10:48 +0200
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-08 12:09 +0100
Re: >< swap operator Ike Naar <ike@iceland.freeshell.org> - 2018-10-08 16:00 +0000
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-08 17:44 +0100
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-08 10:39 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-08 20:08 +0100
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-09 11:22 +0200
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-09 09:25 -0700
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-09 20:43 +0200
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-09 20:15 +0100
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-09 22:26 +0200
Re: >< swap operator Ike Naar <ike@iceland.freeshell.org> - 2018-10-08 21:09 +0000
Re: >< swap operator David Kleinecke <dkleinecke@gmail.com> - 2018-10-08 15:18 -0700
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-08 07:55 -0700
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-09 11:24 +0200
Re: >< swap operator jameskuyper@alumni.caltech.edu - 2018-10-08 07:19 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-08 16:26 +0100
Re: >< swap operator jameskuyper@alumni.caltech.edu - 2018-10-10 10:59 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-08 19:53 +0100
Re: >< swap operator James Kuyper <jameskuyper@alumni.caltech.edu> - 2018-10-07 18:00 -0400
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-07 17:10 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-08 01:25 +0100
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-08 02:51 +0100
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-08 11:29 +0100
Re: >< swap operator mark.bluemel@gmail.com - 2018-10-08 04:41 -0700
Re: >< swap operator jameskuyper@alumni.caltech.edu - 2018-10-08 07:56 -0700
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-08 08:36 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-08 17:34 +0100
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-08 21:35 +0100
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-08 22:00 +0100
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-09 00:47 +0100
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-09 01:11 +0100
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-09 02:47 +0100
Re: >< swap operator mark.bluemel@gmail.com - 2018-10-09 00:49 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-09 11:28 +0100
Re: >< swap operator gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-09 13:00 +0000
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-08 10:28 -0700
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-08 10:49 -0700
Re: >< swap operator Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2018-10-07 20:00 -0600
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-06 13:07 -0700
Re: >< swap operator gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-05 23:35 +0000
Re: >< swap operator Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2018-10-06 03:49 -0700
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-06 16:18 +0200
Re: >< swap operator scott@slp53.sl.home (Scott Lurndal) - 2018-10-06 14:48 +0000
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-06 12:53 -0700
Re: >< swap operator scott@slp53.sl.home (Scott Lurndal) - 2018-10-07 16:38 +0000
Re: >< swap operator James Kuyper <jameskuyper@alumni.caltech.edu> - 2018-10-07 15:56 -0400
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-07 16:53 -0700
Re: >< swap operator David Kleinecke <dkleinecke@gmail.com> - 2018-10-07 17:07 -0700
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-07 17:24 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-08 01:30 +0100
Re: >< swap operator Joe Pfeiffer <pfeiffer@cs.nmsu.edu> - 2018-10-07 19:12 -0600
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-06 18:26 +0100
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-06 19:41 +0100
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-06 13:05 -0700
Re: >< swap operator Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2018-10-07 02:24 -0700
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-07 12:41 +0200
100% of the user base... (Was: >< swap operator) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-06 00:22 +0000
Re: 100% of the user base... (Was: >< swap operator) Bart <bc@freeuk.com> - 2018-10-06 01:55 +0100
Re: 100% of the user base... (Was: >< swap operator) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2018-10-06 03:58 -0700
Re: 100% of the user base... (Was: >< swap operator) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-06 11:51 +0000
Re: 100% of the user base... (Was: >< swap operator) Bart <bc@freeuk.com> - 2018-10-06 13:09 +0100
Re: 100% of the user base... (Was: >< swap operator) "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-06 05:26 -0700
Re: 100% of the user base... (Was: >< swap operator) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2018-10-06 05:40 -0700
Re: 100% of the user base... (Was: >< swap operator) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-06 12:46 +0000
Re: 100% of the user base... (Was: >< swap operator) Melzzzzz <Melzzzzz@zzzzz.com> - 2018-10-06 12:46 +0000
Re: 100% of the user base... (Was: >< swap operator) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-06 12:49 +0000
Re: 100% of the user base... (Was: >< swap operator) "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-06 06:27 -0700
Re: 100% of the user base... (Was: >< swap operator) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-07 12:47 +0000
Re: 100% of the user base... (Was: >< swap operator) "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-07 09:03 -0400
Re: 100% of the user base... (Was: >< swap operator) scott@slp53.sl.home (Scott Lurndal) - 2018-10-07 16:47 +0000
Re: >< swap operator Wouter Verhelst <w@uter.be> - 2018-10-05 10:17 +0200
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-05 09:20 +0200
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-05 10:58 +0100
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-05 12:09 +0200
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-05 03:11 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 07:56 -0400
Re: >< swap operator Wouter Verhelst <w@uter.be> - 2018-10-05 14:25 +0200
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 08:39 -0400
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-05 15:47 +0100
Re: >< swap operator Wouter Verhelst <w@uter.be> - 2018-10-05 17:30 +0200
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 11:41 -0400
Re: >< swap operator Wouter Verhelst <w@uter.be> - 2018-10-05 17:56 +0200
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 12:00 -0400
Re: >< swap operator Richard Damon <Richard@Damon-Family.org> - 2018-10-05 12:34 -0400
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 12:48 -0400
Re: >< swap operator Richard Damon <Richard@Damon-Family.org> - 2018-10-05 13:55 -0400
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-05 11:20 -0700
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 14:45 -0400
Re: >< swap operator Richard Damon <Richard@Damon-Family.org> - 2018-10-05 21:39 -0400
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-07 08:51 -0400
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-11-25 14:18 -0800
Re: >< swap operator Anton Shepelev <anton.txt@g{oogle}mail.com> - 2018-10-05 15:46 +0300
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 06:05 -0700
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 06:16 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-05 15:09 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 10:18 -0400
Re: >< swap operator Anton Shepelev <anton.txt@g{oogle}mail.com> - 2018-10-05 17:32 +0300
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 10:34 -0400
Of course it is crazy! (Was: >< swap operator) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-05 15:17 +0000
Re: >< swap operator gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-05 18:30 +0000
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 14:48 -0400
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 15:06 -0400
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-05 13:55 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 06:14 -0700
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-05 16:18 +0200
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 10:21 -0400
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-05 17:27 +0200
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-05 15:26 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 10:28 -0400
Re: >< swap operator gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-05 14:46 +0000
When pigs fly... (Was: >< swap operator) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-05 16:10 +0000
Re: >< swap operator Anton Shepelev <anton.txt@g{oogle}mail.com> - 2018-10-05 17:35 +0300
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 10:46 -0400
Re: >< swap operator gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-05 15:15 +0000
6K years??? (Was: >< swap operator) gazelle@shell.xmission.com (Kenny McCormack) - 2018-10-05 13:20 +0000
Re: 6K years??? (Was: >< swap operator) "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 09:28 -0400
Re: 6K years??? (Was: >< swap operator) Wouter Verhelst <w@uter.be> - 2018-10-05 17:53 +0200
Re: 6K years??? (Was: >< swap operator) "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 11:56 -0400
Re: 6K years??? (Was: >< swap operator) David Brown <david.brown@hesbynett.no> - 2018-10-05 18:17 +0200
Re: 6K years??? (Was: >< swap operator) "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 09:21 -0700
Re: 6K years??? (Was: >< swap operator) David Brown <david.brown@hesbynett.no> - 2018-10-05 18:50 +0200
Re: 6K years??? (Was: >< swap operator) "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 12:52 -0400
Re: 6K years??? (Was: >< swap operator) "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-05 13:05 -0400
Re: 6K years??? (Was: >< swap operator) Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2018-10-06 03:42 -0700
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-05 15:59 +0200
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-06 03:45 +0100
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-04 11:22 -0700
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-04 20:35 +0100
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-04 13:28 +0100
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-10-04 17:59 +0100
Re: >< swap operator John Bode <jfbode1029@gmail.com> - 2018-10-04 09:56 -0700
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-03 06:03 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-03 14:37 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-03 09:51 -0400
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-03 15:39 +0200
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-03 10:05 -0400
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-03 10:09 -0400
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-03 16:22 +0200
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-03 10:29 -0400
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-03 20:52 +0200
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-03 14:57 -0400
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-02 16:06 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-03 00:09 +0100
Re: >< swap operator Lew Pitcher <lew.pitcher@digitalfreehold.ca> - 2018-10-02 19:21 -0400
Re: >< swap operator David Brown <david.brown@hesbynett.no> - 2018-10-03 11:21 +0200
Re: >< swap operator Thiago Adams <thiago.adams@gmail.com> - 2018-10-02 13:43 -0700
Re: >< swap operator scott@slp53.sl.home (Scott Lurndal) - 2018-10-02 21:01 +0000
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-02 14:29 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-02 22:37 +0100
Re: >< swap operator Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2018-10-03 05:07 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-02 21:01 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-02 16:06 -0400
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-02 21:45 +0100
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-02 17:09 -0400
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-02 16:11 -0400
Re: >< swap operator "Rick C. Hodgin" <rick.c.hodgin@gmail.com> - 2018-10-02 16:22 -0400
Re: >< swap operator Thiago Adams <thiago.adams@gmail.com> - 2018-10-02 13:17 -0700
Re: >< swap operator Thiago Adams <thiago.adams@gmail.com> - 2018-10-02 13:24 -0700
Re: >< swap operator scott@slp53.sl.home (Scott Lurndal) - 2018-10-02 15:04 +0000
Re: >< swap operator Niles Rogoff <eternal-september@niles.xyz> - 2018-10-03 18:28 +0000
Re: >< swap operator Thiago Adams <thiago.adams@gmail.com> - 2018-08-14 11:50 -0700
Re: >< swap operator Siri Cruise <chine.bleu@yahoo.com> - 2018-08-14 17:07 -0700
Re: >< swap operator fir <profesor.fir@gmail.com> - 2018-08-15 02:22 -0700
Re: >< swap operator fir <profesor.fir@gmail.com> - 2018-08-15 02:34 -0700
Re: >< swap operator fir <profesor.fir@gmail.com> - 2018-08-15 03:09 -0700
Re: >< swap operator fir <profesor.fir@gmail.com> - 2018-08-15 03:24 -0700
Re: >< swap operator fir <profesor.fir@gmail.com> - 2018-08-15 04:51 -0700
Re: >< swap operator fir <profesor.fir@gmail.com> - 2018-08-15 05:06 -0700
Re: >< swap operator Siri Cruise <chine.bleu@yahoo.com> - 2018-08-15 04:21 -0700
Re: >< swap operator Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-08-15 14:43 +0100
Re: >< swap operator fir <profesor.fir@gmail.com> - 2018-08-15 07:08 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-08-15 16:52 +0100
Re: >< swap operator Ike Naar <ike@iceland.freeshell.org> - 2018-08-15 15:51 +0000
Re: >< swap operator John Bode <jfbode1029@gmail.com> - 2018-10-01 14:59 -0700
Re: >< swap operator Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2018-10-02 03:06 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-02 11:43 +0100
Re: >< swap operator John Bode <jfbode1029@gmail.com> - 2018-10-02 07:27 -0700
Re: >< swap operator Bart <bc@freeuk.com> - 2018-10-02 15:43 +0100
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-02 11:01 -0700
Re: >< swap operator Keith Thompson <kst-u@mib.org> - 2018-10-02 10:54 -0700
Re: >< swap operator Thiago Adams <thiago.adams@gmail.com> - 2018-10-02 12:39 -0700
Re: >< swap operator skybuck2000@hotmail.com - 2018-10-10 18:10 -0700
Re: >< swap operator skybuck2000@hotmail.com - 2018-10-10 18:24 -0700
Page 16 of 18 — ← Prev page 1 … 14 15 [16] 17 18 Next page →
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-10-04 17:59 +0100 |
| Message-ID | <8736tlps0d.fsf@bsb.me.uk> |
| In reply to | #136182 |
Bart <bc@freeuk.com> writes: > On 04/10/2018 11:53, Ben Bacarisse wrote: > >> (By the way, if I were going to provide both operators I'd make them >> mirrors of each other, for example =>< and ><=. However, I don't think >> there is much value in having both.) >> >> Here it is in C++ using << and >> for the two versions of swap. You can >> do it with a swap function in C, but (a) I wanted to illustrate it with >> operators, (b) in C you have to use pointers so there is no direct >> analogue of the lvalue. > >>snip< > >> a << b << c; >> std::cout << a << " " << b << " " << c << "\n"; >> a << b << c; >> std::cout << a << " " << b << " " << c << "\n"; >> a << b << c; >> std::cout << a << " " << b << " " << c << "\n"; > > > Hmm, those "<<" seem to clash don't they? Yes. C++ does not allow you to define new operator symbols so I had to pick one that already exists. In fact I started with == but there is not way to make the into a pair of similar-looking operators. > (BTW these appear to be just the same two lines repeated three times > in all.) Yes, that's right. It did not seem worth putting them into a loop. <snip> > Rotation is more easily done with multiple assignment. Yes, though (as you note) it's not without its own problems. This all started with Malcolm saying there no reason for the expression to have a value, so I just threw out the possibility that it could have a value that is of more use than simply returning one or other operand (as an rvalue). <snip> -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | John Bode <jfbode1029@gmail.com> |
|---|---|
| Date | 2018-10-04 09:56 -0700 |
| Message-ID | <98118d23-e8c0-4543-acb3-8b046e9897cc@googlegroups.com> |
| In reply to | #136164 |
On Wednesday, October 3, 2018 at 9:43:46 PM UTC-5, Ben Bacarisse wrote:
> "Rick C. Hodgin" <rick.c.hodgin@gmail.com> writes:
>
> > On 10/3/2018 4:31 PM, Ben Bacarisse wrote:
> >> If a swap expression were to be an lvalue then
> >> a >< b >< c;
> >>
> >> gets a natural meaning: it rotates the values in a, b and c. The main
> >> argument against defining it like this is that the operator is no longer
> >> symmetric, despite being written with a symmetric symbol.
> >
> > The"a >< b >< c;" expression would return this result:
>
> You are free to define it any way you like, but what you write below
> suggests you are not talking about my suggestion. If a >< b is an
> lvalue expression (that's the way the C standard uses the term) then
> there are only two reasonable lvalues to consider -- the left hand side
> or the right hand side.
>
I went down this rabbit hole elsethread.
What would be really fun would be expressions like
a >< b = c
That is, swap a and b, then assign c to the result of the swap (whether that's a or b). Just
imagine the kind of mayhem (or at least Perl levels of unintelligibility) you could cause with
that. Note that a swap operator would *have* to introduce a sequence point after
evaluating each operand in order to work in the first place.
[toc] | [prev] | [next] | [standalone]
| From | "Rick C. Hodgin" <rick.c.hodgin@gmail.com> |
|---|---|
| Date | 2018-10-03 06:03 -0700 |
| Message-ID | <c298af63-a610-4bc1-9784-f6cb89c3f7a2@googlegroups.com> |
| In reply to | #136081 |
On Wednesday, October 3, 2018 at 5:52:56 AM UTC-4, Bart wrote:
> Not even Rick will know when he comes across:
> a><f()??#(b):b>:c
I would never write code like that ... and for that reason.
The purpose of having ><, ?#, and the others, is to have
them available for use in places where it would be clear.
That sometimes means writing less-efficient code knowing
the compiler will come along behind you and make it more
efficient for you.
> Using normal identifiers, that would be:
> swap(a,f())?sizeof(b):min(b,c) // or it might be max
>
> This is not that meaningful as it applies swap() in a weird manner that
> only makes sense to Rick, but at least you can now see what operations
> are being used.
In cases like your example I would write it like this, which
removes the issue no matter the syntax:
t = swap(a, f());
// Then use it as:
((t) ? sizeof(b) : min(b, c))
Or to use my syntax:
// Swap a and f()'s result, store f() into t
t = a >< f();
// Then use it as:
((t) ? sizeof(b) : min(b, c))
The comment would explain what it's doing there, but I would
add the extra formatting and spacing so it's more visual,
along with the extra comments.
--
Rick C. Hodgin
[toc] | [prev] | [next] | [standalone]
| From | Bart <bc@freeuk.com> |
|---|---|
| Date | 2018-10-03 14:37 +0100 |
| Message-ID | <tC3tD.503677$T%2.126282@fx06.am4> |
| In reply to | #136105 |
On 03/10/2018 14:03, Rick C. Hodgin wrote:
> On Wednesday, October 3, 2018 at 5:52:56 AM UTC-4, Bart wrote:
>> Not even Rick will know when he comes across:
>> a><f()??#(b):b>:c
>
> I would never write code like that ... and for that reason.
>
> The purpose of having ><, ?#, and the others, is to have
> them available for use in places where it would be clear.
> That sometimes means writing less-efficient code knowing
> the compiler will come along behind you and make it more
> efficient for you.
>
>> Using normal identifiers, that would be:
>> swap(a,f())?sizeof(b):min(b,c) // or it might be max
>>
>> This is not that meaningful as it applies swap() in a weird manner that
>> only makes sense to Rick, but at least you can now see what operations
>> are being used.
>
> In cases like your example I would write it like this, which
> removes the issue no matter the syntax:
>
> t = swap(a, f());
>
> // Then use it as:
> ((t) ? sizeof(b) : min(b, c))
>
> Or to use my syntax:
>
> // Swap a and f()'s result, store f() into t
> t = a >< f();
>
> // Then use it as:
> ((t) ? sizeof(b) : min(b, c))
>
> The comment would explain what it's doing there, but I would
> add the extra formatting and spacing so it's more visual,
> along with the extra comments.
>
So when would you use ?#(b) or b>:c?
Why /wouldn't/ you combine them when they occur in the same expression?
And where did 'min' suddenly come from?
I thought you didn't have min at all except as a suggestion, for those
do didn't like >:, to use #define min(a,b) ...
With my example (which doesn't actually mean anything, but would be
legal using your proposals), that would more typically be written as:
a><f() ? ?#(b) : b >: c
The first part using swap or ><, is being used in a way you proposed
where you update a variable while returning its old variable. For that
reason, it needs to part of the expression. Other you don't need >< at all:
t = a;
a = f();
t ? ?#(b) : b >: c
(Phew, that's still quite a mix of shifted/unshifted punctuation in that
final line. C seriously needs even more punctuation....)
--
bart
[toc] | [prev] | [next] | [standalone]
| From | "Rick C. Hodgin" <rick.c.hodgin@gmail.com> |
|---|---|
| Date | 2018-10-03 09:51 -0400 |
| Message-ID | <pp2hgl$am0$1@dont-email.me> |
| In reply to | #136107 |
On 10/3/2018 9:37 AM, Bart wrote:
> So when would you use ?#(b) or b>:c?
I forgot they existed. :-)
> Why /wouldn't/ you combine them when they occur in the same expression?
> And where did 'min' suddenly come from?
>
> I thought you didn't have min at all except as a suggestion, for those do
> didn't like >:, to use #define min(a,b) ...
I don't remember that. It's possible, but it's not coming
back to me just now.
> With my example (which doesn't actually mean anything, but would be legal
> using your proposals), that would more typically be written as:
>
> a><f() ? ?#(b) : b >: c
If I were to do as you suggest here, I would write it as:
((a >< f()) ? (?#(b)) : (b >: c))
It would break out each section, and indicate it clearly.
However, the reason why you'd use ?#(x) is when you have a
space issue, like on a long for ( ; ; ) line. If you don't
have the space constraint, then there's no reason not to use
the sizeof(x).
> The first part using swap or ><, is being used in a way you proposed where
> you update a variable while returning its old variable. For that reason, it
> needs to part of the expression. Other you don't need >< at all:
>
> t = a;
> a = f();
> t ? ?#(b) : b >: c
I don't think so. >< returned the left-side value. ><=
returned the right-side value.
> (Phew, that's still quite a mix of shifted/unshifted punctuation in that
> final line. C seriously needs even more punctuation....)
I would never write code like that even though it could be
written like that.
The goal of having these new features is they are another tool
in the tool box, but as I've used as a common reference for
describing when to use which tool, it's possible to rebuild an
engine using end-wrenches and crescent wrenches. But, it's
not advisable. It's better to have more specialized tools
like 6-point sockets, torque wrenches, breaker bars, etc.
The same is true for coding, Bart. You don't write code the
way you can just because you can. You write what makes sense,
is easy to read, easy to maintain, is clear, etc. I would
never actually write this either:
((a >< f()) ? (?#(b)) : (b >: c))
I would probably write it thusly:
t = a >< f();
size = ?#(b);
maxVal = (b >: c);
((t) ? size : maxVal)
Or, I would write this:
// Based on a, store sizeof(b) or use max of b,c
((a >< f()) ? (?#(b)) : (b >: c))
It would depend on the situation, and what other code nearby
is doing. If I've already added a comment up above explaining
how these things work, then I wouldn't add additional comments.
If it is part of a known sequence of operations, then I wouldn't
add an additional comment, etc.
It's all situational, Bart. Fluid. Flexible. You have to have
a type of philosophy of understanding to know what to use where,
and why you're doing it is intuitive, not rigorously mechanical.
--
Rick C. Hodgin
[toc] | [prev] | [next] | [standalone]
| From | David Brown <david.brown@hesbynett.no> |
|---|---|
| Date | 2018-10-03 15:39 +0200 |
| Message-ID | <pp2gqi$6b9$1@dont-email.me> |
| In reply to | #136105 |
On 03/10/18 15:03, Rick C. Hodgin wrote: > On Wednesday, October 3, 2018 at 5:52:56 AM UTC-4, Bart wrote: >> Not even Rick will know when he comes across: >> a><f()??#(b):b>:c > > I would never write code like that ... and for that reason. > > The purpose of having ><, ?#, and the others, is to have > them available for use in places where it would be clear. > That sometimes means writing less-efficient code knowing > the compiler will come along behind you and make it more > efficient for you. I fully agree with the idea of writing code based on clarity, and letting the compiler turn it into efficient object code. I simply disagree that your new operators are in any way a benefit to clarity. > >> Using normal identifiers, that would be: >> swap(a,f())?sizeof(b):min(b,c) // or it might be max >> >> This is not that meaningful as it applies swap() in a weird manner that >> only makes sense to Rick, but at least you can now see what operations >> are being used. > > In cases like your example I would write it like this, which > removes the issue no matter the syntax: > > t = swap(a, f()); > > // Then use it as: > ((t) ? sizeof(b) : min(b, c)) > > Or to use my syntax: > > // Swap a and f()'s result, store f() into t > t = a >< f(); I still don't understand what it would mean to "swap a and f()'s result", unless you language supports references and f() returns a reference. > > // Then use it as: > ((t) ? sizeof(b) : min(b, c)) > > The comment would explain what it's doing there, but I would > add the extra formatting and spacing so it's more visual, > along with the extra comments. > As a general point, if you ever feel you need to write a comment to say what a line of code /does/ (as distinct from /why/ it does it), then your code is not clear enough.
[toc] | [prev] | [next] | [standalone]
| From | "Rick C. Hodgin" <rick.c.hodgin@gmail.com> |
|---|---|
| Date | 2018-10-03 10:05 -0400 |
| Message-ID | <pp2iam$fkp$1@dont-email.me> |
| In reply to | #136108 |
On 10/3/2018 9:39 AM, David Brown wrote:
> On 03/10/18 15:03, Rick C. Hodgin wrote:
>> // Swap a and f()'s result, store f() into t
>> t = a >< f();
>
> I still don't understand what it would mean to "swap a and f()'s
> result", unless you language supports references and f() returns a
> reference.
This particular use of the >< function returns the value of a,
so it would be the same as this operation:
t = a;
a = f();
> As a general point, if you ever feel you need to write a comment to say
> what a line of code /does/ (as distinct from /why/ it does it), then
> your code is not clear enough.
I have a goal in developing code, David, which is to be able
to single-step through comments, not code, because, to be
honest, I don't really care what the code is doing so long
as it's working. It should be doing what the comments say.
Having this feature allows lesser programmers the ability to
go in and debug complex code. They don't have to know what
it's doing mechanically, but the operation.
// Load the largest value into x
x = { .. multi-line complex code here .. };
When they they see that in the comment single-step debugger,
they can get to the "Load the largest value into x" line, and
see the operation and know that it should be doing what is
says.
They can test x and see if it's the largest of what they know
was the input. If not, they may not know how to fix it, but
they can add an issue ticket to the project saying, "Hey, on
lines such-and-such in program xyz, I noticed it says that x
should be the largest value, but it isn't."
The developers can then go in and look at that code and figure
out what it's not working.
The CFSCA model I've had since the late 90s is always there in
the back of my mind, driving this thinking more than the type
of guidance you give me here.
CFSCA = Comments, Flow chart, Source Code, Assembly
Envision a window with parallel panes:
+-+-+----------------+-+
|C|F|Source Code |A|
+-+-+----------------+-+
| | |#include <io.h> | |
| | | | |
| | |int main() | |
| | |{ | |
| | | return 0; | |
| | |} | |
+-+-+----------------+-+
In the combination editor/debugger, you're able to hit Ctrl+
Alt+Left/Right to navigate between panes. You can look at
the source code primarily, but also single-step through your
code at the Flow chart or Comments level, or if there's a
real issue, go down into assembly and single-step there.
The ability to move in thoughts, in concepts, in ideas,
rather than the minutia of details, is what I'm after in
the big picture grand scheme of things.
It's a long-term goal.
--
Rick C. Hodgin
[toc] | [prev] | [next] | [standalone]
| From | "Rick C. Hodgin" <rick.c.hodgin@gmail.com> |
|---|---|
| Date | 2018-10-03 10:09 -0400 |
| Message-ID | <pp2ij7$i07$1@dont-email.me> |
| In reply to | #136111 |
On 10/3/2018 10:05 AM, Rick C. Hodgin wrote:
> The CFSCA model I've had since the late 90s is always there in
> the back of my mind, driving this thinking more than the type
> of guidance you give me here.
>
> CFSCA = Comments, Flow chart, Source Code, Assembly
CFSCA is pronounced as cough-ska.
> Envision a window with parallel panes:
>
> +-+-+----------------+-+
> |C|F|Source Code |A|
> +-+-+----------------+-+
> | | |#include <io.h> | |
> | | | | |
> | | |int main() | |
> | | |{ | |
> | | | return 0; | |
> | | |} | |
> +-+-+----------------+-+
To be clear about this, the CFSCA design associates flow
chart elements with literal code, and the comments that
exist are not line or block comments in source code, but
are comments that convey the sentiment of what's happening
in broad strokes, like when you're mapping out the flow of
a large system.
> In the combination editor/debugger, you're able to hit Ctrl+
> Alt+Left/Right to navigate between panes. You can look at
> the source code primarily, but also single-step through your
> code at the Flow chart or Comments level, or if there's a
> real issue, go down into assembly and single-step there.
>
> The ability to move in thoughts, in concepts, in ideas,
> rather than the minutia of details, is what I'm after in
> the big picture grand scheme of things.
>
> It's a long-term goal.
You can see my early workings with it here, where you see
the assembly language pane front-and-center, and the panes
to the left of that window are the CFSC panes, with the
assembly one open and visible:
If you can't see the video, use VLC (videolan.org):
http://www.visual-freepro.org/videos/2014_02_13__exodus_debi_debugger.ogv
--
Rick C. Hodgin
[toc] | [prev] | [next] | [standalone]
| From | David Brown <david.brown@hesbynett.no> |
|---|---|
| Date | 2018-10-03 16:22 +0200 |
| Message-ID | <pp2jbb$n26$1@dont-email.me> |
| In reply to | #136111 |
On 03/10/18 16:05, Rick C. Hodgin wrote:
> On 10/3/2018 9:39 AM, David Brown wrote:
>> On 03/10/18 15:03, Rick C. Hodgin wrote:
>>> // Swap a and f()'s result, store f() into t
>>> t = a >< f();
>>
>> I still don't understand what it would mean to "swap a and f()'s
>> result", unless you language supports references and f() returns a
>> reference.
>
> This particular use of the >< function returns the value of a,
> so it would be the same as this operation:
>
> t = a;
> a = f();
>
So why not write that? Everyone can see what that does. There is no
need for a comment - just write code that says what you mean.
>> As a general point, if you ever feel you need to write a comment to say
>> what a line of code /does/ (as distinct from /why/ it does it), then
>> your code is not clear enough.
>
> I have a goal in developing code, David, which is to be able
> to single-step through comments, not code, because, to be
> honest, I don't really care what the code is doing so long
> as it's working. It should be doing what the comments say.
I really am not sure how to respond to that. Are you trying to tell me
you want your tools to interpret the comments and "run" them, regardless
of what the code says? Presumably that would require comments being in
some kind of fixed syntax with defined meanings. In that case, why
bother with the code - the comments /are/ code!
The reality of programming is that it is an extraordinarily bad idea to
try to have the functionality of something defined in two ways here.
And any coding that tries to have comments that say what code does is
doomed to confusing misinformation after code is editing and comments
invariably get out of sync with the code.
>
> Having this feature allows lesser programmers the ability to
> go in and debug complex code. They don't have to know what
> it's doing mechanically, but the operation.
>
> // Load the largest value into x
> x = { .. multi-line complex code here .. };
>
> When they they see that in the comment single-step debugger,
> they can get to the "Load the largest value into x" line, and
> see the operation and know that it should be doing what is
> says.
>
> They can test x and see if it's the largest of what they know
> was the input. If not, they may not know how to fix it, but
> they can add an issue ticket to the project saying, "Hey, on
> lines such-and-such in program xyz, I noticed it says that x
> should be the largest value, but it isn't."
You can do that with a total disregard for the comments. Put the
complex code in a function called "load_the_largest_value", and do a
step-over-function debug operation.
>
> The developers can then go in and look at that code and figure
> out what it's not working.
>
> The CFSCA model I've had since the late 90s is always there in
> the back of my mind, driving this thinking more than the type
> of guidance you give me here.
>
> CFSCA = Comments, Flow chart, Source Code, Assembly
>
> Envision a window with parallel panes:
>
> +-+-+----------------+-+
> |C|F|Source Code |A|
> +-+-+----------------+-+
> | | |#include <io.h> | |
> | | | | |
> | | |int main() | |
> | | |{ | |
> | | | return 0; | |
> | | |} | |
> +-+-+----------------+-+
>
> In the combination editor/debugger, you're able to hit Ctrl+
> Alt+Left/Right to navigate between panes. You can look at
> the source code primarily, but also single-step through your
> code at the Flow chart or Comments level, or if there's a
> real issue, go down into assembly and single-step there.
>
> The ability to move in thoughts, in concepts, in ideas,
> rather than the minutia of details, is what I'm after in
> the big picture grand scheme of things.
>
> It's a long-term goal.
>
I don't really want to put into words what I think of this idea - it
would only upset you, and you would not listen to my advice or opinion
anyway.
[toc] | [prev] | [next] | [standalone]
| From | "Rick C. Hodgin" <rick.c.hodgin@gmail.com> |
|---|---|
| Date | 2018-10-03 10:29 -0400 |
| Message-ID | <pp2jok$pmi$1@dont-email.me> |
| In reply to | #136114 |
On 10/3/2018 10:22 AM, David Brown wrote:
> On 03/10/18 16:05, Rick C. Hodgin wrote:
>> On 10/3/2018 9:39 AM, David Brown wrote:
>>> On 03/10/18 15:03, Rick C. Hodgin wrote:
>>>> // Swap a and f()'s result, store f() into t
>>>> t = a >< f();
>>>
>>> I still don't understand what it would mean to "swap a and f()'s
>>> result", unless you language supports references and f() returns a
>>> reference.
>>
>> This particular use of the >< function returns the value of a,
>> so it would be the same as this operation:
>>
>> t = a;
>> a = f();
>
> So why not write that? Everyone can see what that does. There is no
> need for a comment - just write code that says what you mean.
You can. Nothing stopping you.
>>> As a general point, if you ever feel you need to write a comment to say
>>> what a line of code /does/ (as distinct from /why/ it does it), then
>>> your code is not clear enough.
>>
>> I have a goal in developing code, David, which is to be able
>> to single-step through comments, not code, because, to be
>> honest, I don't really care what the code is doing so long
>> as it's working. It should be doing what the comments say.
>
> I really am not sure how to respond to that. Are you trying to tell me
> you want your tools to interpret the comments and "run" them, regardless
> of what the code says? Presumably that would require comments being in
> some kind of fixed syntax with defined meanings. In that case, why
> bother with the code - the comments /are/ code!
Two models, one to operate at the main outer comment level,
one to operate at the comments-in-code level.
When you step over a comment, you run the code between it
and the next comment.
> The reality of programming is that it is an extraordinarily bad idea to
> try to have the functionality of something defined in two ways here.
> And any coding that tries to have comments that say what code does is
> doomed to confusing misinformation after code is editing and comments
> invariably get out of sync with the code.
They are explicitly different. One is a high-level overview
level, the other is coding-level comments.
You can choose which one to step over, which will be obvious,
because on one you're on the C pane for Comments, on the other
you're in the SC pane or Source Code, and you're in the mode
of stepping via comments.
>> Having this feature allows lesser programmers the ability to
>> go in and debug complex code. They don't have to know what
>> it's doing mechanically, but the operation.
>>
>> // Load the largest value into x
>> x = { .. multi-line complex code here .. };
>>
>> When they they see that in the comment single-step debugger,
>> they can get to the "Load the largest value into x" line, and
>> see the operation and know that it should be doing what is
>> says.
>>
>> They can test x and see if it's the largest of what they know
>> was the input. If not, they may not know how to fix it, but
>> they can add an issue ticket to the project saying, "Hey, on
>> lines such-and-such in program xyz, I noticed it says that x
>> should be the largest value, but it isn't."
>
> You can do that with a total disregard for the comments. Put the
> complex code in a function called "load_the_largest_value", and do a
> step-over-function debug operation.
Yes, and now you're relying on the developer to have done that.
With this /NEW/ ability, you'll be able to leave the details
there, and still accomplish the same thing.
It goes back to having:
#define swap ><
By having ><, and the ability to have #define, you have both.
But by only having swap(a,b) or the swap keyword, you're stuck.
With this /NEW/ ability to step-over comments, you'll be able
to step over comments at the various levels, so that code with
blocks could be stepped into/over multiple ways.
> I don't really want to put into words what I think of this idea - it
> would only upset you, and you would not listen to my advice or opinion
> anyway.
You're always against the things I'm moving toward. It is
literally the enemy within you working against me to do me
harm, even though you'll swear up and down it isn't.
It is like this continually for all people who are not born
again by having their sin forgiven by Jesus Christ. Those
with more sin in their lives will see it more pronounced.
You don't have any of these new ideas I've come up with be-
for you. You're judging them based on what you think they'll
be like, rather than on their merits. That is a bad idea.
--
Rick C. Hodgin
[toc] | [prev] | [next] | [standalone]
| From | David Brown <david.brown@hesbynett.no> |
|---|---|
| Date | 2018-10-03 20:52 +0200 |
| Message-ID | <pp334m$4sn$1@dont-email.me> |
| In reply to | #136115 |
On 03/10/18 16:29, Rick C. Hodgin wrote: > On 10/3/2018 10:22 AM, David Brown wrote: >> On 03/10/18 16:05, Rick C. Hodgin wrote: >>> On 10/3/2018 9:39 AM, David Brown wrote: >>>> On 03/10/18 15:03, Rick C. Hodgin wrote: >>>>> // Swap a and f()'s result, store f() into t >>>>> t = a >< f(); >>>> >>>> I still don't understand what it would mean to "swap a and f()'s >>>> result", unless you language supports references and f() returns a >>>> reference. >>> >>> This particular use of the >< function returns the value of a, >>> so it would be the same as this operation: >>> >>> t = a; >>> a = f(); >> >> So why not write that? Everyone can see what that does. There is no >> need for a comment - just write code that says what you mean. > > You can. Nothing stopping you. I want something stopping /you/ from writing anything else. If a language is going to be useful, then it should fulfil two criteria: 1. It should be as easy as possible to write good code. 2. It should be as hard as possible to write bad code. You make a good effort at number 1 here. You completely miss out on number 2. > >>>> As a general point, if you ever feel you need to write a comment to say >>>> what a line of code /does/ (as distinct from /why/ it does it), then >>>> your code is not clear enough. >>> >>> I have a goal in developing code, David, which is to be able >>> to single-step through comments, not code, because, to be >>> honest, I don't really care what the code is doing so long >>> as it's working. It should be doing what the comments say. >> >> I really am not sure how to respond to that. Are you trying to tell me >> you want your tools to interpret the comments and "run" them, regardless >> of what the code says? Presumably that would require comments being in >> some kind of fixed syntax with defined meanings. In that case, why >> bother with the code - the comments /are/ code! > > Two models, one to operate at the main outer comment level, > one to operate at the comments-in-code level. > > When you step over a comment, you run the code between it > and the next comment. As I said, I have no sensible response here that you would not deem insulting. All I can say is that of all the misfeatures of your language, this one takes special place. But I am not your target audience, so if you think this makes sense, it's up to you. > > You're always against the things I'm moving toward. It is > literally the enemy within you working against me to do me > harm, even though you'll swear up and down it isn't. No, you just pick those cases and forget all the times I have encouraged you or said that I think something was a good idea. To be fair, of the ideas you have posted in this group I think a large proportion have been bad, but I have been quick to say when I think something is good or when I agree with you. I make technical comments and opinions on the technical solutions you present - this is not judgement on the language itself or your goals. (I've talked about them too, but that is a different matter.) When I make such technical comments, I really don't care why you are making the software, where your inspiration or motivation comes from, or anything else involved - I judge entirely on the information you post about the feature in question. I do exactly the same for your language suggestions as for Bart's, Jacob's or anyone else's. It is natural that I think most ideas are bad, because it is very difficult to come up with good new ideas. But it would be nice if you (and Bart, and Jacob) stopped thinking that I and others are working against you or always negative. Show me an idea I like, and I will be positive.
[toc] | [prev] | [next] | [standalone]
| From | "Rick C. Hodgin" <rick.c.hodgin@gmail.com> |
|---|---|
| Date | 2018-10-03 14:57 -0400 |
| Message-ID | <pp33f7$5r5$2@dont-email.me> |
| In reply to | #136123 |
On 10/3/2018 2:52 PM, David Brown wrote: > On 03/10/18 16:29, Rick C. Hodgin wrote: >> On 10/3/2018 10:22 AM, David Brown wrote: >>> On 03/10/18 16:05, Rick C. Hodgin wrote: >>>> On 10/3/2018 9:39 AM, David Brown wrote: >>>>> On 03/10/18 15:03, Rick C. Hodgin wrote: >>>>>> // Swap a and f()'s result, store f() into t >>>>>> t = a >< f(); >>>>> >>>>> I still don't understand what it would mean to "swap a and f()'s >>>>> result", unless you language supports references and f() returns a >>>>> reference. >>>> >>>> This particular use of the >< function returns the value of a, >>>> so it would be the same as this operation: >>>> >>>> t = a; >>>> a = f(); >>> >>> So why not write that? Everyone can see what that does. There is no >>> need for a comment - just write code that says what you mean. >> >> You can. Nothing stopping you. > > I want something stopping /you/ from writing anything else. I know. We won't agree on anything here, David ... so, thank you for contributing again to my life. -- Rick C. Hodgin
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <kst-u@mib.org> |
|---|---|
| Date | 2018-10-02 16:06 -0700 |
| Message-ID | <lnva6k54oi.fsf@kst-u.example.com> |
| In reply to | #136044 |
Bart <bc@freeuk.com> writes:
[...]
> For the length of a string, use strlen. For the length of a string
> constant, use:
>
> strlen("bart")-1;
I think you meant sizeof("bart")-1 .
[...]
--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
Working, but not speaking, for JetHead Development, Inc.
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
[toc] | [prev] | [next] | [standalone]
| From | Bart <bc@freeuk.com> |
|---|---|
| Date | 2018-10-03 00:09 +0100 |
| Message-ID | <RUSsD.633030$zc1.616058@fx10.am4> |
| In reply to | #136063 |
On 03/10/2018 00:06, Keith Thompson wrote:
> Bart <bc@freeuk.com> writes:
> [...]
>> For the length of a string, use strlen. For the length of a string
>> constant, use:
>>
>> strlen("bart")-1;
>
> I think you meant sizeof("bart")-1 .
Yes, thanks.
[toc] | [prev] | [next] | [standalone]
| From | Lew Pitcher <lew.pitcher@digitalfreehold.ca> |
|---|---|
| Date | 2018-10-02 19:21 -0400 |
| Message-ID | <pp0uic$219$1@dont-email.me> |
| In reply to | #136063 |
Keith Thompson wrote:
> Bart <bc@freeuk.com> writes:
> [...]
>> For the length of a string, use strlen. For the length of a string
>> constant, use:
>>
>> strlen("bart")-1;
>
> I think you meant sizeof("bart")-1 .
I'm not sure he did.
We can be certain that
strlen("abc\0def")-1
results in a value that is definitely /not/ "the length of a string
constant" (that constant being "abc\0def", 8 characters, including the
requisite string terminator byte).
OTOH,
sizeof("abc\0def")-1
results in a value that /almost/ reflects the length of the string constant,
only discounting the length of the string terminator byte.
I do believe that
sizeof("abc\0def")
results in the correct "length of the string constant".
--
Lew Pitcher
"In Skills, We Trust"
[toc] | [prev] | [next] | [standalone]
| From | David Brown <david.brown@hesbynett.no> |
|---|---|
| Date | 2018-10-03 11:21 +0200 |
| Message-ID | <pp21nm$5qm$1@dont-email.me> |
| In reply to | #136044 |
On 02/10/18 23:02, Bart wrote: > On 02/10/2018 21:37, Rick C. Hodgin wrote: <snip> >> And why introduce "_Alignof(x)" after sizeof(x) had already >> been established? Why not alignof(x)? >> People might have used "alignof" in their own code, or defined their own "alignof" macro or function. When new features are added to C, the committee is very reluctant to do anything that would break existing code, no matter how unlikely you might think it is for some to use "alignof" as an identifier. So they make the keyword _Alignof, which no one would use (and if they did, it's their own fault). A quick #define or #include <stdalign.h> and you get the friendlier version. >> It's like what posix did. "So many functions, do I prefix >> this one with an underscore in this compiler? Is the posix >> version supported? I don't know, let's try it and see if it >> generates an error. Ope. An error. Try this alternate way >> of spelling it. Another error. Let me try a third. Ah! >> Got it." > > You missed out the ones starting with two underscores. Or ending with > them. Or both. Those are usually implementation-specific. For example, gcc has a "typeof" keyword as an extension. But because that could conflict with valid use as an identifier, it is only available in "gnu" standards modes. In stricter C modes, you can still use "__typeof__" to get the same feature. So if you are using the extension in your own code, "typeof" makes sense. But if you are writing a flexible header for use by others, "__typeof__" is the better choice. > C is really paranoid about encroaching on the namespaces > of programs written decades before. Yes. > > I'm sure there are ways to deal with that without inconveniencing future > programmers for eternity. > Yes - the way C standards and C compilers handle it seems fine.
[toc] | [prev] | [next] | [standalone]
| From | Thiago Adams <thiago.adams@gmail.com> |
|---|---|
| Date | 2018-10-02 13:43 -0700 |
| Message-ID | <e5c5ddf3-fcbc-4376-8a4a-793d91904c08@googlegroups.com> |
| In reply to | #136029 |
On Tuesday, October 2, 2018 at 5:26:42 PM UTC-3, Keith Thompson wrote: > Thiago Adams writes: > > On Tuesday, October 2, 2018 at 4:48:25 PM UTC-3, Bart wrote: > >> On 02/10/2018 19:52, Rick C. Hodgin wrote: > [...] > >> > I do not believe in adding special cases (like swap(a,b)) to > >> > be a built-in compiler feature that behaves differently than > >> > other functions. > >> > >> What not? You take arguments a and b, apply swap to them, and something > >> happens. Just the same as applying any function. > > > > The importance of operators in C, is that > > they are built-in polymorphic operations. > > People that want swap operator (I had suggested this also > > some time ago) is because having this operator we > > don't need to implement it for all types. > > The min a max function doesn't have this problem because > > they can be implemented with simple macros. > > We can find other operations that have the same characteristic. > > > > I find symbols hard to remember compared with names. > > We have in math the symbol for set union, set intersection etc > > and it is hard to remember. These operations also would be very > > useful in computing. > > There's no reason the name of an operator has to be made up of > punctuation characters. Most of them are, but `sizeof` and `_Alignof` > are both operators, and their names are keywords. > > *If* we wanted to add a swap operator to C, it could easily be defined > as an operator with two operands: > a swap b > with whatever semantics seem appropriate. (Of course "swap" is > already used as an identifier in existing code. We could have a > _Swap keyword and a new header defining "swap" as a macro.) > > I would opppose making "swap" a new built-in operation whose syntax > makes it look like a function call: > swap(a, b) > > (There's also std::swap in C++, which depends on features that C doesn't > have.) > And the language design is puzzle where we need to take in account the problems we want to solve and we can find different solutions. For instance, adding gcc's typeof plus gcc's statements and declarations in expression is also a different path do solve the swap problem. C++ templates plus references also is a different path. Just to make clear again the problems that swap operator wants to solve - Hard to create a macro - Creates duplicated code if repeated each time - Boring to create swap function version for each type - Functions needs to take the address of structs. The problem that swap operator would not resolve is that some code need custom swap. (The same problem already exists with copy)
[toc] | [prev] | [next] | [standalone]
| From | scott@slp53.sl.home (Scott Lurndal) |
|---|---|
| Date | 2018-10-02 21:01 +0000 |
| Message-ID | <P0RsD.86047$MJ2.77596@fx12.iad> |
| In reply to | #136029 |
Keith Thompson <kst-u@mib.org> writes: > >There's no reason the name of an operator has to be made up of >punctuation characters. Most of them are, but `sizeof` and `_Alignof` >are both operators, and their names are keywords. > >*If* we wanted to add a swap operator to C, it could easily be defined >as an operator with two operands: > a swap b >with whatever semantics seem appropriate. (Of course "swap" is >already used as an identifier in existing code. We could have a >_Swap keyword and a new header defining "swap" as a macro.) > >I would opppose making "swap" a new built-in operation whose syntax >makes it look like a function call: > swap(a, b) > >(There's also std::swap in C++, which depends on features that C doesn't >have.) Is there really enough usage of a 'swap' type operation such that an operator would be genuinely useful? I don't recall ever needing that functionality. Now byte swapping for endianess reasons, that I use daily.
[toc] | [prev] | [next] | [standalone]
| From | Keith Thompson <kst-u@mib.org> |
|---|---|
| Date | 2018-10-02 14:29 -0700 |
| Message-ID | <ln4le46nrl.fsf@kst-u.example.com> |
| In reply to | #136043 |
scott@slp53.sl.home (Scott Lurndal) writes:
> Keith Thompson <kst-u@mib.org> writes:
>>There's no reason the name of an operator has to be made up of
>>punctuation characters. Most of them are, but `sizeof` and `_Alignof`
>>are both operators, and their names are keywords.
>>
>>*If* we wanted to add a swap operator to C, it could easily be defined
>>as an operator with two operands:
>> a swap b
>>with whatever semantics seem appropriate. (Of course "swap" is
>>already used as an identifier in existing code. We could have a
>>_Swap keyword and a new header defining "swap" as a macro.)
>>
>>I would opppose making "swap" a new built-in operation whose syntax
>>makes it look like a function call:
>> swap(a, b)
>>
>>(There's also std::swap in C++, which depends on features that C doesn't
>>have.)
>
> Is there really enough usage of a 'swap' type operation such that
> an operator would be genuinely useful?
Probably not (thus my emphasis on the "*If*" above).
It's a simple enough operation that a predefined operator or
(overloaded) function doesn't provide all that much benefit over
writing the code inline:
int x, y;
...
const int old_x = x;
x = y;
y = old_x;
("temp" is a common name, but I find "old_x" to be more explicit and
harder to mess up.)
If I'm using a language that provides it as a feature (std::swap in C++,
(x, y) = (y, x) in Python, etc), that's great. If not, it's not that
big a deal.
> I don't recall ever needing that functionality. Now byte swapping
> for endianess reasons, that I use daily.
--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
Working, but not speaking, for JetHead Development, Inc.
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
[toc] | [prev] | [next] | [standalone]
| From | Bart <bc@freeuk.com> |
|---|---|
| Date | 2018-10-02 22:37 +0100 |
| Message-ID | <_yRsD.350664$2v.279948@fx19.am4> |
| In reply to | #136043 |
On 02/10/2018 22:01, Scott Lurndal wrote: > Keith Thompson <kst-u@mib.org> writes: > >> >> There's no reason the name of an operator has to be made up of >> punctuation characters. Most of them are, but `sizeof` and `_Alignof` >> are both operators, and their names are keywords. >> >> *If* we wanted to add a swap operator to C, it could easily be defined >> as an operator with two operands: >> a swap b >> with whatever semantics seem appropriate. (Of course "swap" is >> already used as an identifier in existing code. We could have a >> _Swap keyword and a new header defining "swap" as a macro.) >> >> I would opppose making "swap" a new built-in operation whose syntax >> makes it look like a function call: >> swap(a, b) >> >> (There's also std::swap in C++, which depends on features that C doesn't >> have.) > > Is there really enough usage of a 'swap' type operation such that > an operator would be genuinely useful? In my code, it's used very infrequently (once per 1000 lines at most, usually), but when I need it it's very handy. It's also an easy to understand and implement feature. Usage is somewhat lower than min and max, which you frequently see macros for in C. And those might be a little behind goto, which already exists. -- bart
[toc] | [prev] | [next] | [standalone]
Page 16 of 18 — ← Prev page 1 … 14 15 [16] 17 18 Next page →
Back to top | Article view | comp.lang.c
csiph-web