To recap: this is about attempting to reproduce the essential capabiities of Andl (based on TTM/D) as a set of extensions to a standard OO language. I am using C#, but my comments should apply equally to Java, C++, Rust, Dlang, Go, etc.
In my opinion the TTM/D type system can be substantially reproduced as follows.
- Scalar types: the requirements are satisfied by any type that is immutable and provides value semantics. In practice this means a class in which:
- All members are (recursively) scalar, tuple or relation types
- Members can only be set to a value at construction time
- Operator ‘=’ implements equality of value
- The hash value depends only on the value (therefore is constant)
- Tuple types: the requirements are satisfied by a type that is immutable and has value semantics, and also:
- All members are scalar types or (recursively) tuple types
- Operator ‘=’ implements equality of value by member name (only if same heading)
- The hash value depends only on the value (therefore is constant)
- A value can be created by member-wise copy of another tuple type (only if same heading)
- Relation types: the requirements are satisfied by a type that:
- Can provide an enumerator over tuple types for others to use
- All operations on relations are then implemented by enumerating streams of tuples (pipelining).
- Relvar: an object of relational type with the additional feature that:
- It can accept an enumeration over tuple types and apply it to a persistence store.
Tuple types are the core of the system. In the absence of compiler support, every tuple type consumed or emitted by any relational operator has to be individually declared, but the common functionality comes from inheriting a base class and related interfaces.
Relation types are interesting. A lengthy sequence of operations of the Relational Algebra is just a set of chained functions calls and enumerators. It does not in fact cause any processing of data until a caller either (a) retrieves data to be sent elsewhere or (b) commits a transaction. A relvar is a relation type from which an enumerator can be obtained and which accepts updates. It is not a collection, just an adapter to someone else’s collection.
I have a crude but working implementation (and I have learned a lot about C# generics). Still hard to tell whether it leads anywhere, but I should be able to hook it up to the Andl database backend and then we’ll see. An Sql implementation can then generate Sql and enumerate the result set instead of the raw data (Andl does that).