Enum Types

[dhall-lang]

Enum Types

[nbouscal]

Just a note for anyone else finding this from Google, constructors was deprecated because it's no longer necessary. Enums like in the original request are now basically supported, you can do this:

let Enum = < A | B >
in [ Enum.A, Enum.B ]

[Gabriella439]

@srid @Koshroy : Note that newer versions of Dhall have a constructors keyword, which provides a nicer solution to this problem. You can now do:

    let type = constructors < A : {} | B : {} >

in [ type.A {=}, type.B {=} ]

[Gabriella439]

Unions are the recommended way to do this:

-- The type
< Type/A : {} | Type/B : {} >  

-- The values
< Type/A = {=} | Type/B : { } >
< Type/A : { } | Type/B = {=} >

Even if Dhall added support for enums as a special case of unions it wouldn't significantly reduce the boilerplate because an enum literal would still need to specify all other alternatives

What I do in cases like these is define synonyms for each alternative, like this:

    let Type/A = < Type/A = {=} | Type/B : { } >
in  let Type/B = < Type/A : { } | Type/B = {=} >
in  [ Type/A, Type/B, Type/B, TypeA ]

... or save the synonyms in named files:

$ cat Type/A
< Type/A = {=} | Type/B : { } >
$ cat Type/B
< Type/A : { } | Type/B = {=} >
$ cat example
[ ./Type/A , ./Type/B , ./Type/B , ./TypeA ]

This helps reduce the boilerplate so you only need to write out the full union literal once per alternative

[Koshroy]

This answered my question! Thanks a lot!

[Gabriella439]

You're welcome! :)

[srid]

... or save the synonyms in named files:

This is not really practical for enums with say 10 constructors, right?

You would have ./Type/A with 9 other alternatives; likewise for Type/B, Type/C, etc.