Class based contracts

[mlhaufe]

Currently contracts are defined as such:

const baseContract = new Contract<Base>({
    [invariant]: self => ...,
    featureName: {
        demands(self, args) { ... },
        ensures(self, old, args) { ... }
    }
}),
subContract = new Contract<Sub>({
    [extend]: baseContract,
    [invariant]: self => ...,
    featureName: {
        rescue(self, error, args, retry) { ...; retry(); }
    }
});

@Contracted(baseContract)
class Base { ... }

@Contracted(subContract)
class Sub extends Base { ... }

The extend property is a reinvention of the native class functionality, except currently the contract property is not doing the equivalent checks. Contracts should be changed to utilize the native class functionality:

class BaseContract extends Contract<Base> {
    [invariant](ctx) { ... }
    featureName() {
        return {
            demands(ctx, args) { ... },
            ensures(ctx, old, returnValue, args) {  ... }
        }
    }
}

class SubContract extends BaseContract<Sub> {
    [invariant](){ return this.ctx.value <= 100 }
    featureName() {
        return {
            rescue(ctx, error, args, retry){ ...; retry(...args); }
        }
    }
}

@Contracted(BaseContract)
class Base {...}

@Contracted(SubContract)
class Sub extends Base { ... }

• Update implementation
• Update README
• Update Unit tests
• Update Changelog

[mlhaufe]

Does [checkedMode] become an argument of the constructor?

Presently all contract usages are (en|dis)abled, as a constructor argument it would enable the instance of the contract to be (en|dis)abled

[mlhaufe]

1. How could @override be used here in the class form?
2. Could Feature Oriented Programming be leveraged to simplify the implementation?