New unboxing approach

[tomtau]

The goal is to try the new unboxing approach. Simply put, incorporate all types (primitive types and references type into one closure class. See the code below:

package boxing;

abstract class Closure {
    long ix; // long input, or other primitive types + there should be a TAG
    Object ox; // ref input for closure
    long iout; // int output, or other primitive types + there should be a TAG
    Object oout; // ref output

    abstract void apply();
}

// Int -> Int
class Inc extends Closure {
    public void apply() { // Int -> Int
        this.iout = ix+1;
    }
}

// apply : (A -> B) -> A -> B
// apply = \f . \x . f x
class Apply extends Closure {
    Closure ap = this;

    public void apply() {
        oout = new Closure() {
                public void apply() {
                    Closure f = (Closure) ap.ox;
                    f.ix = this.ix; // set arguments, potentially could have a tag to decide which assignement to make.
                    f.ox = this.ox;
                    f.apply();
                    this.iout = f.iout; // set the outputs
                    this.oout = f.oout;
                }
            };
    }
}

}

[bixuanzju]

@tomtau Are you working on that now?

[tomtau]

I've been waiting for major refactoring to be done, so I can start rewriting in a version that will be easier to merge - I guess most changes are done by now?

[bixuanzju]

@tomtau yes

[VladUreche]

@tomtau, your approach looks very good. There is a slight difference when comparing to miniboxing and specialization in Scala: classes have specialized variants, where only one type of the fields appears (not both primitive and object) -- and all access is done through methods, which are overloaded.

Here's (an unrelated) document that happens to explain this: https://docs.google.com/document/d/12pgg8LBkTNaB5BoeKlBrei-Mst8shdGY7ZPfMFuIYzY/edit?usp=sharing -- just search for miniboxing