[go-nuts] missing syntax features in Go

You can already express these constructs easily and without ambiguity in the language that exists today. Yet another way to expresses literals would not pay for itself.

Given that Go literals are of very high precision I am not
convinced this is really helpful.

All except binary literals are already supported and some line has
to be drawn; otherwise someone will demand support for vigesimal
literals because it would be convenient during transcription of
Mayaen calendars.

V.

It is not about "modern" languages at all. Non-decimal integer literals are
a convenience that have been around in many forms for 50+ years.

The heritage of pre-C computers had one (PDP-8) where use of octal made
special sense so the developers of C were comfortable with that and added
special "leading zero means octal" code. When PCC/UNIX moved to the
Interdata 8/32 they wanted hexadecimal and thus "0x" (they may have had hex
before, but big octal constants were popular on the PDP-11 even though it
hex would have been more natural). They never met any other big needs so
BTL stopped there.

In other realms, unifying the idea of flexible radix was a popular topic.
There are a few schools of thought, the prefix camp and the postfix camps
and the radix in decimal and radix coded as a symbol approaches. Manlio
listed a prefix-symbol approach. Another way that I'm fond of is the
'radix' coding scheme:

123 => 123
10r123 => "123" in radix 10 == 123 decimal
16r123 => "123" in radix 16 == 291 decimal
16rFACE => "FACE" in radix 16 == 64206 decimal

I like this because it is regular, does not give leading zeroes magic
meaning, and because it is general for bases 2 through 36.

The language Ada had a nice addition for integer literals, the "don't care"
underscore. The rule is that "_" within numbers is ignored. This means you
can write the literal 16_777_216 for the value of 2**24, using the
underscore for [,.]. I like it much better than a long string of digits. It
did not catch on outside Ada though. Pitty!

Michael

Limbo used this scheme, if you're looking for a direct (if dotted) line to Go.

see 2.4.1: http://doc.cat-v.org/inferno/4th_edition/limbo_language/limbo

                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Perl, too.

The D programming language has this feature too.

-david

Il giorno mercoledì 10 dicembre 2014 18:35:15 UTC+1, drj ha scritto:
Right, I forgot about this scheme; thanks.

Hoever Go is using a prefix scheme; the problem is that it is not regular
due to
how octal integer literals are encoded. Using 0o prefix would make it more
regular,
and, more important, more readable.

Binary literals support is not really required, but it, again, helps
readability.

Regards Manlio Perillo

I argued for binary literals way back when.

Aaaand, apparently, Rust's gonna have this too.

Go doesn't have it.

-rob

If Rust jumped off a bridge, would you too? Seriously, what sort of an argument is that? Go clearly isn't a language that wants to compete for the length of its feature list.