(Also bumped bower version in the test support code - it was failing to install dependencies)

Input:

data P t = P
class IsUnit unit | -> unit
instance isUnitInst :: IsUnit Unit

class IsUnit2 unit | -> unit
instance isUnitInst2 :: IsUnit unit => IsUnit2 unit

foo :: P _
foo = P :: forall unit . IsUnit unit => P unit

bar :: P _
bar = P :: forall unit . IsUnit2 unit => P unit

Previous output:

var foo = (function (dictIsUnit) { return P.value; })(isUnitInst);
var bar = (function (dictIsUnit2) { return P.value; })(isUnitInst2(isUnitInst));

Current progress:

var foo = (function (dictIsUnit) { return P.value; })({});
var bar = (function (dictIsUnit2) { return P.value; })({});

Goal:

var foo = P.value;
var bar = P.value;

Switched to undefined. For the above example it now produces:

var foo = P.value;
var bar = P.value;

I'm happy with this. Wasn't too keen on having to change externs for tracking type class emptiness, but I'm okay with it. 😄

Pushed a fix for the super class lookup, but haven't properly tested yet.

With the latest code....

Example:

class WithArgEmpty t
instance withArgEmptyCheck :: WithArgEmpty Check
class WithArgEmpty t <= WithArgHasEmptySuper t where
  withArgHasEmptySuper :: t
instance withArgHasEmptySuperCheck :: WithArgHasEmptySuper Check where
  withArgHasEmptySuper = Check
whenAccessingSuperDict :: Check
whenAccessingSuperDict = foo Check where
  bar :: forall t . WithArgEmpty t => t -> t
  bar x = x
  foo :: forall t . WithArgHasEmptySuper t => t -> t
  foo x = bar x

Before:

var withArgEmptyCheck = WithArgEmpty;
var withArgHasEmptySuperCheck = new WithArgHasEmptySuper(function () {
    return withArgEmptyCheck;
}, Check.value);
var whenAccessingSuperDict = (function () {
    var bar = function (dictWithArgEmpty) {
        return function (x) {
            return x;
        };
    };
    var foo = function (dictWithArgHasEmptySuper) {
        return function (x) {
            return bar(dictWithArgHasEmptySuper.WithArgEmpty0())(x);
        };
    };
    return foo(withArgHasEmptySuperCheck)(Check.value);
})();

After:

var withArgEmptyCheck = WithArgEmpty;
var withArgHasEmptySuperCheck = new WithArgHasEmptySuper(function () {
    return undefined;
}, Check.value);
var whenAccessingSuperDict = (function () {
    var bar = function (dictWithArgEmpty) {
        return function (x) {
            return x;
        };
    };
    var foo = function (dictWithArgHasEmptySuper) {
        return function (x) {
            return bar()(x);
        };
    };
    return foo(withArgHasEmptySuperCheck)(Check.value);
})();

That is, the call to bar in foo no-longer bothers to look up the super class dict. But even if it did, it would be undefined anyway.

I think this is ready to look at again. I've also added a test.

This is pretty exciting! My silence on it is not due to lack of enthusiasm, just lack of time 😄

Really looking forward to this being released! 👍
It inspired me to create purescript-tscompat because the idea of zero runtime overhead typeclasses was too enticing.

Apart from the conflicts (which are very minor), is there anything getting in the way of merging this?

Not as far as I'm concerned, I forgot it wasn't merged already actually!

@hdgarrood, I don't think so. I'll try to get this updated tonight.

After rebasing, it seems to get stuck on the PartialTCO.purs test. Haven't yet had time to look into why though. Will push here and tag with 'needs more work'.

Here is a comparison of the output of master vs this branch:
https://gist.github.com/natefaubion/fa442e3c075bebf82f6026776bf16733

Specifically lines 20-22. It appears to be writing to the wrong variable.

All tests on our work projects run just fine.

I've just tested this on our code at work and it seems to work fine for me too. Shall we try to get this merged? @LiamGoodacre has the approach changed much since this was last reviewed, or is there anything in particular you think wants looking at? Since this passed review already I'm tempted to just merge it.

@hdgarrood I'm happy to have this merged now 👍

Nice, thanks! :)