"Open" enums?

[gwhitney]

Often I would like the individual identifiers in an enum to "pollute" the outer namespace, e.g.

enum WeekDay
   Monday
   Tuesday // etc., I won't bore you
 
function schedule(a: Appointment, d: WeekDay)
   //implementation detail

doNotForget := schedule wedding, WeekDay.Saturday
// ack, we all know Saturday is a WeekDay. Why not just:
// doNotForget := schedule wedding, Saturday

I would love some declaration like open enum WeekDay that would allow dropping the often-redundant WeekDay. part. (There's lots of ways to do this; use regular enum and just add a bunch of constant definitions immediately after is the most straightforward; I've also seen defining a bunch of disparate Symbol('Monday') constants and then defining WeekDay to be the union of all their types.)

[bbrk24]

Some of this could be helped by type-informed compilation. Swift lets you do this:

enum Weekday {
  case monday, tuesday, /* ... */ saturday, sunday
}

func schedule(appointment: Appointment, for day: Weekday) {
  // ...
}

schedule(appointment: wedding, for: .saturday)

Note the leading dot -- saturday by itself is still available.

[edemaine]

I like the idea of a simple transpilation like this:

open enum WeekDay
  Monday
  Tuesday
↓↓↓
enum WeekDay {
  Monday,
  Tuesday
}
const { Monday, Tuesday } = WeekDay

TypeScript seems to understand that the global Monday is then of type WeekDay.Monday.

On the other hand, I'm not a fan of the word "open". One possibility is global enum or enum global, as global is a TypeScript word that feels natural here (declare the items globally too). Except this would also work inside a function or other scope, so that also seems inaccurate.

[edemaine]

Indeed! Too bad it's so different from JS/TS's using, or we could use using enum...

[bbrk24]

Wait, since when does JS have using?

But the JS keyword that does behave somewhat like this is with, and I'll admit that with enum sounds a bit awkward.

[edemaine]

JS using is Stage 3 but TS jumped the gun and added it (transpiled) already.

with would normally take an indented block, so it's not quite that. And we probably don't want to encourage thinking about with more. 😄

[gwhitney]

If arbitrary keywords might be acceptable, some options are 'transparent', 'destructured' (based on your proposed transpilation!), 'lift' or 'lifted', 'unscoped', 'outer', 'raise or raised', etc. If one is looking for a notation that doesn't involve anything that's not an existing keyword or symbol, some goofy options are enum^ (up arrow to indicate the inner symbols go up to the current scope) or enum and Weekday {Monday, Tuesday} indicating that you get the enum itself and all the symbols or, as a nod to C++, enum++ ;-). Sorry I don't have a killer notation; I wish it just worked like this all the time, but I totally understand why that's an inappropriate design decision for Civet.

Oh, one other option that just popped into my head: use enumerators or enumeration in place of enum -- it's a new keyword, but enum is already a slightly silly abbreviation for one of those two words, so using one of them doesn't take up any "semantic namespace" and would be in line with Civet's feel of being more literate, and again aligns conceptually with the idea that you get the regular 'enum' and more...

[gwhitney]

P.S. another option: horriblyPolluting enum Weekday { ... ;-)