Self-documentation: refactor enums?

[pygy]

Pipe dream: it would be nice to have

require("CairoConstants")
CairoConstants.format.rgb24 # -> 1
show(CairoConstants.format) # List all names, alphabetically.

It could be implemented as descendants of an abstract CConst/CEnum type (for the show() implementation), built with a macro that takes a name, an offset and an array of symbols (with nothing for holes) as parameters. A variation could take Dict with symbols as keys.

Once immutable types are implemented, this should be as efficient as traditional const values.

[pygy]

What do you think of this?

module Cairo

format = @ CEnum [
    -1, :invalid,
    :argb32,
    :rgb24,
    ...
]

@ assert format.argb32 == 0 # true

end

Note that negative and non-incremental indices must come before their names.
Implementation:

abstract CEnum

module Base

function show{T<:CEnum}(io::IO, enum::T)
    for name in sort(map(string,[names(enum)...]))
        print(io, "$name\n")
    end
end

macro CEnum(symbols)
  symbols = eval(symbols)
  typ = symbol(string("CEnum",gensym()))
  names = Any[] # `Any` is required for the `Expr(...)` below
  values = Int[]
  i = isa(symbols[1], Integer) ? symbols[1] : 0
  first = true
  for e in symbols
    if isa (e, Symbol)
      push!(names, e)
      push!(values, i)
      i = i +1
    elseif isa(e, Integer)
      if e <= i && !first
        error("Bad index in enum: $e")
      end
      i = e
    else
      error("Bad type in enum: $e is a $(typeof(e)). Int or Symbol expected.")
    end
    first = false
  end
  Expr(:block, Any[
    Expr(:type, Any[
      Expr(:<:, Any[typ,:CEnum], Any), 
      Expr(:block, names, Any)
    ], Any),
    Expr(:call, Any[typ, values...], Any)
  ], Any)
end

end #Base

[Keno]

I'm actually not too opposed to keeping the C enums in this case since this is a rather low level library and people using it will be looking at the Cairo docs, which list the C enums. Having to translate seems like an unnecessary obstacle.

[pygy]

The translation is trivial (CAIRO_FORMAT_ARGB32 becomes Cairo.format.argb32), and all caps are IMO ugly.

It enables the possiblity to cache Cairo.format in a local, reducing clutter.

BTW, this is a suggestion for a general convention for representing enums in Julia. We don't have to follow the conventions of other languages when we can do better.

[timholy]

Enums are still under discussion in base Julia, you may want to consider bringing this up there.

[nolta]

I agree w/ @loladiro -- let's keep the C names.