chrisdone
commented
12 years ago Unless I'm missing something, we would never encounter an expression like minBound r because minBound is not a function.
We already discussed this on IRC. I think you can solve it this way for single-variable classes and methods of a particular form. Otherwise you need to know the instance dictionaries either at compile-time or attach some type meta-data to all expressions. Consider read "abc", how do you handle that? Or def?
For show r and x*y we have some chance, though. Those could be, as a general solution, r.show(r) and x.mult(x,y), or some-such (probably more like var mymethod=function(a,b,c){a.mymethod(a,b,c)} where a contains is whatever is type-class polymorphic in the method declaration). I thought about implementing a subset of type-classes like that, it seemed feasible. We could merely disable class or instance declarations outside of the scope of what we are able to support like this. For this approach I think you're on the right track, but that there are some strict limitations of what's possible.
Otherwise I think we're confined to waiting for haskell-type-exts to get polished off (seems like that will take some time), or to polish it ourselves.
FWIW, constructors are scoped:
> function X(){}; var x1 = new X(); var x2 = (function(){ function X(){}; return new X(); });
> [x1.constructor == x2.constructor,x2 instanceof X]
→ [false, false]
johnpmayer
sviperll
periodic
hanshoglund
luite
cdsmith
mcandre
paulcc
jwiegley
bergmark
Has any thought been put into if type classes should be supported, and if so how this should be done?
I've been thinking about one way of doing it, but I'm not sure how well it would work out.
When we parse
We store this information in the CompileState as
stateClassDecls :: [(Name, [Name])]generates
When we encounter an expression like
minBound rwe check if it's defined instateClassDeclsand in that case we callr.minBoundotherwise we treat it like we always do.This is the simplest solution but has the problem that a instance declaration that's local in Haskell would be made global in JS. If we solve this by subclassing Rec locally to the instance declaration
instanceofchecks for types will still work, but it will probably cause issues when encoding (which subclass do we deserialize to?). We might instead be able to declare instances separatelyinstanceDecls.Rec_Bounded = { minBound : r0, maxBound : r1 };
We would then need to know the concrete type in order to generate the
Rec_Bounded.minboundexpression. This could be accomplished by transformingminBound rtoinstanceDecls[r.constructor.name + "_Bounded"], the "Bounded" part can be retrieved during compilation.Is this a proper solution or did I miss anything?