Model interface

In order to make the query API much more awesome, I would like to introduce the following interface to ceylon.language.meta.model:

shared interface Model<Parent,Result> 
        given Result<T> {

    shared Result<Type> get<Type>(Attribute<Parent,Type> attribute);

}

Then, we would change the typechecker so that any member expression like person.name where person is a Model<Person,Expression> would be desugared to:

person.get(`Person.name`)

(In the query API, I would declare From<T> to satisfy Model<T,Expression>.)

As a second phase, we can also figure out some way to support basic operators like ==, !=, <, >, <=, >=, &&, ||, !, +, -, *, / at the Model level.

There is one big problem with this otherwise-rather-simple proposal: the JVM backend doesn’t yet support type constructors, which is, AFAICT, essential to this proposal.

[gavinking]

An alternative syntax would be:

    value person = criteria.from(`Person`);
    value address = criteria.join(person.`address`);

    List<NameAndCity> results
            = criteria
                .where(
                    like(person.`name`, "Gavin%"),
                    address.`state` == literal("CA"))
                .orderBy(
                    asc(address.`zip`),
                    desc(person.`name`))
                .select(construct(`NameAndCity`,
                         with(address.`city`)
                        .with(person.`name`)))
                .getResults();

[gavinking]

With this proposal, the following query:

    value person = criteria.from(`Person`);
    value address = person.join(`Person.address`);

    List<NameAndCity> results
            = criteria
                .where(
                    like(person.get(`Person.name`), "Gavin%"),
                    address.get(`Address.state`).equalTo("CA"))
                .orderBy(
                    asc(address.get(`Address.zip`)),
                    desc(person.get(`Person.name`)))
                .select(construct(`NameAndCity`,
                         with(address.get(`Address.city`))
                        .with(person.get(`Person.name`))))
                .getResults();

Would simplify to:

    value person = criteria.from(`Person`);
    value address = criteria.join(person.address);

    List<NameAndCity> results
            = criteria
                .where(
                    like(person.name, "Gavin%"),
                    address.state == literal("CA"))
                .orderBy(
                    asc(address.zip),
                    desc(person.name))
                .select(construct(`NameAndCity`,
                         with(address.city)
                        .with(person.name)))
                .getResults();

Which is much better.