uuid!() and iota!() (and maybe random!()) syntax extensions

[graydon]

uuid!() should generate a UUID (http://en.wikipedia.org/wiki/Universally_unique_identifier). It should take arguments (or there should be multiple variants of the call) to indicate the UUID-variant. The default should just be random. Could possibly defer to a random!() syntax extension that generates a random value at compile time.

iota!() should do something like what the iota expression in Go does: http://golang.org/ref/spec#Iota -- evaluate to a constant integer starting from zero and increment the counter, resetting on some reaosnable boundary such as "per module" or "per scope".

(Nominating for feature complete.)

[emberian]

I really, really dislike the name iota. Not only does the usage of the name in various languages map to different concepts (APL/C++/D vs Go), the name has no semantic content. It'd be like using i().

[brson]

After consideration I don't think that uuid! is suitable for TLS keys, at least not on its own. A UUID alone doesn't encode any type information so a UUID TLS key is not type safe.

[graydon]

Ah, fair point. Would need a typed declaration. const v : TlsVar<T> = TlsVar(uuid!()); Could be macroized pretty easily. Not sure at that point it's much better than the address-of-a-function thing we do now (which can also be macroized) but maybe it'll work better cross-crate and on windows?

[graydon]

@cmr concerning the name iota, it has a use in english meaning "a small amount", and at least a reasonable number of uses in programming languages: std::iota(begin, end, v) in C++, the (iota n) function in scheme, the ⍳ (iota) built-in function in APL, and as a magic constant expression in at least two Pike languages (Limbo and Go).

[graydon]

Oh I see, you pointed out the languages that have it (including D, I didn't see!) but just think it's inconsistently used. Hmm. I dunno. This is a syntax extension. It's not like you're going to call it without awareness of what it's for. I guess I'm curious what else you'd want here instead? The use case is:

const CODE_FOO : u8 = iota!();
const CODE_BAR : u8 = iota!();
// ...
const CODE_QUUX : u8 = iota!();

In order to define an arbitrary sequence of values that you don't care about the numbering of, just "one more than previous". Similar to use in an enum. I suppose most of the time this can be done as:

const CODE_FOO : u8 = 0;
const CODE_BAR : u8 = CODE_FOO + 1;
const CODE_BAR : u8= CODE_BAZ + 1;
...

It's just a lot wordier (have to repeat each variant) and more prone to copy-paste errors.

[emberian]

I agree that it's nice to have, but I'd call it incr_id!() or something.
It's just the name I dislike.

[bstrie]

I actually feel like iota does basically the same thing in D and C++ and Go. iota!() is fine for this purpose.

[catamorphism]

Just a bug, de-nominating

[pongad]

I am not quite sure why we need iota. It seems to me the reason Go uses iota is because it lacks enums. If there's still need for it, however, I would suggest something like

iota!(u8, FOO, BAR, BAZ)

as it would make the resets clear. One can also align the argument like

iota!(u8, FOO,
          BAR,
          ...)

[pongad]

Does something like this look right? https://gist.github.com/pongad/8968393

[brson]

Old bug, demand has subsided. I don't think there's any value keeping it around.