Defining global data
There are two aspects here: First, really global data as in Java's static fields or singleton instances, and data that belongs to a given type, but that cannot be defined within the feature that defines that type because it has to be accessible from the outside as well.
Java, C, etc. provide a modifier
static to declare a field that
exists only once and becomes accessible globally, causing all sorts of problems
since it can be changed from any place, causing all sorts of bugs, in the worst
case races conditions.
Eiffel provides a modifier
once for features that are executed
only once and return the original result on later calls. They essentially behave
like a single static field in its own class in Java that gets initialized when
it is first read. Race conditions are controlled a little better since access
is read only, but if the result is a reference, we may produce races when
modifying the resulting singleton instance.
Global elements via defines section
We need some mechanism to declare inner features that do not depend on instances
of the feature they are declared in, but that could very well depend on outer
feature. Example are the constants
numeric or the identity element in
# identity element # e T is abstract
It should be possible to use such a global element also via a formal generic
argument, i.e., a constrained generic argument
T: monoid should
allow a call to
T.e to get the identity element. If the actual
generic argument for T is
x.y.z.e within the outer instance
x.y. An open
question is if any fields of
y should be
x.y.z.e since this would require identifying and
storing the desired instance of
Defining outer elements via defines section
One way would be using a specific clause
defines (or maybe
outer) that declares features that end up in
the outer feature but are accessible through
monoid<T: monoid<T>> defines # identity element # e T is abstract is # associative operation # infix + (other T) T is abstract
- should state of outer features be accessible from features declared in defines clause?
- should fields be allowed to be declared in the defines clause?
- should statements be allowed in defines clause?
- if fields or statements are allowed, when should they be executed?
Outer elements are not global, they are local to the outer instance. As long as this instance is not a singleton, these are elements that are local to the outer feature.
Do we need more? What for?