[R6RS] Enumerations proposal pre-draft
sperber at informatik.uni-tuebingen.de
Sun May 7 10:58:57 EDT 2006
I've attached a new draft of the proposal, mainly for Will at this
point. The Subversion repo also contains a reference implementation.
This is sort of halfway between my original draft and Will's
- Enumeration values are symbols.
- There's still a macro to set up enumeration types, and it's used to
define a convenience macro for expressing and statically checking
- A bit more scaffolding is used to tie enumeration types and
enumeration-set types together; this enables using things other than
symbols as the basis for enumeration sets. (Such as the finite
types in Scheme 48.)
- Subtyping in enumeration-set types is enabled, as per Will's
I tried to preserve the spirit of both. Let me know where I didn't
Cheers =8-} Mike
Friede, Völkerverständigung und überhaupt blabla
Enumeration types are subtypes of Scheme's standard symbol
types. Each enumeration type represents a fixed set of
symbols, which are specified when the enumeration type is
The syntax for defining an enumerated type is:
This defines a macro <type-name> and three procedures:
<elements-name>, <predicate-name>, and <index-accessor>. <elements-name>
will be a procedure of no arguments that returns symbols that comprise
the enumeration type, in the same order as they were specified.
<predicate-name> will take an arbitrary object, returning true if and
only if the object is one of the symbols returned by <type-name>.
<index-accessor> takes an arbitrary object, returning false if the
object is not one of the symbols returned by <type-name>; if the
object is one of the symbols returned by <type-name>, then
<index-accessor> returns its 0-origin index within the vector returned
<type-name> will be a macro of one operand, which must be one of the
enumeration symbols. It will return the corresponding symbol. If the
operand is not a symbol or if the symbol is not a member of the
enumeration type, an expansion-time exception will be raised.
The <type-name> procedure also serves as the canonical
representation of the enumerated type.
(black white purple maroon))
(colors) => #(black white purple maroon)
(color? 'black) => #t
(color? 'gold) => #f
(color black) => 'black
(color purpel) => <expansion-time error>
(color-index (color purple)) => 2
Enumeration-set types work naturally with the enumeration types.
The syntax for defining such a type is:
(define-enum-set-type <constructor-syntax> <constructor> <predicate>
<enum-type> <elements> <element-index>)
where <constructor-syntax> is an identifier that will be bound to a
constructor macro, <constructor> is an identifier that will be bound
to a constructor procedure, and <predicate> is an identifier that will
be bound to a predicate for the enumeration-set type being defined.
<enum-type>, <elements>, and <element-index> define the enumeration
type upon which the enumeration-set-type is based. <enum-type> must
be a macro corresponding to the <type-name> macro defined by
`define-enum-type', i.e. take a symbol operand and return the
corresponding enumeration member. <elements> must be a thunk
returning a vector of the elements of the enumeration, and
<element-index> must be a procedure accepting an enumeration element
and returning a corresponding index.
The <constructor-syntax> macro takes any number of symbol operands,
each of which must identify a member of the enumeration via the
<enum-type> macro. The <constructor> procedure will accept a list of
enumeration elements and return the corresponding enumeration set.
The <predicate> procedure will accept any object and return #t if the
object is an enumeration set of the type being defined, #f otherwise.
The representation of an enumeration set is not specified
by this proposal.
Given the enumerated type `color', for example, we can define
sets of color:
(define-enum-set-type color-set make-color-set color-set?
color colors color-index)
(color-set? (color-set black white)) => #t
(color-set? (make-color-set (list (color black) (color white)))) => #t
(color-set? '(black white)) => #f
(enum-set-member? symbol enum-set)
(enum-set-subset? enum-set enum-set)
(enum-set=? enum-set enum-set) => boolean
(enum-set-union enum-set enum-set) => enum-set
(enum-set-intersection enum-set enum-set => enum-set
(enum-set-difference enum-set enum-set)
(enum-set-complement enum-set) => enum-set
`enum-set-universe' returns the thunk used in the position of
<elements> in the `define-enum-set-type' form; that thunk returns a
vector of the members of the enumeration type, in order.
`enum-set->list' returns a list of the symbols that belong to an
`enum-set-member?' returns true if and only if its first argument is
an element of its second argument.
`enum-set-subset?' returns true if and only if the universe of its
first argument is a subset of the universe of its second argument
(considered as sets of symbols) and every element of its first
argument is a member of its second.
`enum-set=?' returns true if and only if its first argument is a
subset of its second and vice versa, as determined by the
`enum-set-union' takes two enumeration sets that share the same
enumeration type as universe, and returns their union.
`enum-set-intersection' takes two enumeration sets that share the same
enumeration type as universe, and returns their intersection.
`enum-set-difference' takes two enumeration sets that share the same
enumeration type as universe, and returns their difference.
`enum-set-complement' takes an enumeration set and returns
its complement with respect to its universe.
((enum-set-universe (color-set))) => #(black white purple maroon)
(enum-set->list (color-set)) => ()
(color-set purpel) => <expansion-time error>
(enum-set-member? 'white (make-color-set '(white))) => #t
(enum-set-subset? (color-set white)
(enum-set-complement (color-set black))) => #t
(enum-set=? (color-set black maroon)
(color-set white purple))) => #t
(black white green red blue purple maroon))
(define-enum-set-type other-color-set make-other-color-set other-color-set?
other-color other-colors other-color-index)
(enum-set-subset? (color-set white) (other-color-set black white red green))
(enum-set=? (color-set black white) (other-color-set black white))
More information about the R6RS