@@ -1,8 +1,16 @@

+export function NoNextMethodError() {}

+NoNextMethodError.prototype = Object.create(Error);

+

+export function NoApplicableMethodError() {}

+NoNextMethodError.prototype = Object.create(Error);

+

+export function NoPrimaryMethodError() {}

+NoPrimaryMethodError.prototype = Object.create(NoApplicableMethodError);

+

 const before_qualifier = Symbol.for('before');

 const after_qualifier = Symbol.for('after');

 const around_qualifier = Symbol.for('around');

-

 let genfun_prototype = {

     name: "(placeholder)",

     lambda_list: [],

@@ -61,7 +69,7 @@ let method_prototype = {

     generic_function: {},

 };

-function StandardMethod(

+export function StandardMethod(

     lambda_list, qualifiers, specializers, body

 ) {

     if (! (this instanceof StandardMethod) ) {

@@ -97,7 +105,7 @@ function apply_generic_function(gf, args) {

     let applicable_methods =

         compute_applicable_methods_using_classes(gf, required_portion(args));

     if (applicable_methods.length === 0) {

-        throw new Error(`no applicable methods for gf ${gf.name} with args ${JSON.stringify(args)}`);

+        throw new NoApplicableMethodError(`no applicable methods for gf ${gf.name} with args ${JSON.stringify(args)}`);

     } else {

         return apply_methods(gf, args, applicable_methods);

     }

@@ -107,30 +115,83 @@ function method_more_specific_p(m1, m2, required_classes) {

     const m1specializers = m1.specializers;

     const m2specializers = m2.specializers;

+    let result = null;

     for (let [spec1, spec2] of m1specializers.map((el, idx) => [el, m2specializers[idx]])) {

         if (spec1 !== spec2) {

-            return sub_specializer_p(spec1, spec2);

+            result = sub_specializer_p(spec1, spec2);

+            break;

         }

     }

+

+    return result;

 }

-function sub_specializer_p(c1, c2) {

-    return c1.isPrototypeOf(c2);

+export function sub_specializer_p(c1, c2) {

+    let result = false;

+    if (c1 instanceof Specializer) {

+        result = c1.super_of(c2);

+    } else if (c1.prototype !== undefined && c2.prototype !== undefined) {

+        result = Object.isPrototypeOf.call(c1.prototype, c2.prototype);

+    }

+    return result;

 }

 const idS = Symbol.for('id');

 Object.prototype[idS] = function () { return this };

-export function matchesSpecializer(obj, specializer) {

-    let result = obj === specializer.prototype;

-    let objType = typeof obj;

+export function Specializer() {}

+Specializer.prototype = {

+    matches(obj) { return false; },

+    super_of(obj) { return false; },

+}

+

+function isSuperset(superset, subset) {

+    return Array.from(subset).every(superset.has.bind(superset));

+}

+

+export function Shape(...keys) {

+    if (! (this instanceof Shape) ) {

+        return new Shape(...keys);

+    }

+    this.keys = new Set(keys);

+}

+Shape.prototype = Object.assign(new Specializer(), {

+    matches(obj) {

+        return Array.from(this.keys).every(key => obj[key] !== undefined);

+    },

+    super_of(spec) {

+        // this is the super of spec

+        //     if this.keys is a subset of spec.keys

+        // and if this.keys != spec.keys

-    if (!result && objType === 'object') {

-        result = Object.isPrototypeOf.call(specializer.prototype, obj);

-    } else if (objType === 'number') {

-        result = matchesSpecializer(Number.prototype, specializer) || matchesSpecializer(specializer.prototype, Number);

-    } else if (objType === 'string') {

-        result = matchesSpecializer(String.prototype, specializer) || matchesSpecializer(specializer.prototype, String);

+        if (!(spec instanceof Shape)) {

+            return false;

+        }

+

+        let this_keys_subset_of_spec_keys = isSuperset(spec.keys, this.keys);

+        let not_eq = this.keys.size !== spec.keys.size;

+

+        return this_keys_subset_of_spec_keys && not_eq;

+    }

+});

+

+export function matches_specializer(obj, specializer) {

+    let objType = typeof obj;

+    let specializer_proto = specializer && specializer.prototype

+    let result = obj === specializer_proto;

+

+    if (obj === null && obj === specializer) {

+        result = true;

+    } else if (specializer && specializer.prototype !== undefined) {

+        if (!result && objType === 'object') {

+            result = Object.isPrototypeOf.call(specializer_proto, obj);

+        } else if (objType === 'number') {

+            result = matches_specializer(Number.prototype, specializer) || matches_specializer(specializer_proto, Number);

+        } else if (objType === 'string') {

+            result = matches_specializer(String.prototype, specializer) || matches_specializer(specializer_proto, String);

+        }

+    } else if (specializer instanceof Specializer) {

+        result = specializer.matches(obj);

     }

     return result;

@@ -139,17 +200,20 @@ export function matchesSpecializer(obj, specializer) {

 function compute_applicable_methods_using_classes(gf, required_classes) {

     const applicable_methods = gf.methods.filter(

-        method => method.specializers.every((specializer, idx) => matchesSpecializer(required_classes[idx], specializer))

+        method => method.specializers.every((specializer, idx) => matches_specializer(required_classes[idx], specializer))

+        

     );

     applicable_methods.sort((a,b) => {

+        let result = 0;

         if (method_more_specific_p(a,b)) {

-            return 1;

+            result = 1;

         }

         if (method_more_specific_p(b,a)) {

-            return -1;

+            result = -1;

         }

-        return 0;

+

+        return result;

     })

     return applicable_methods;

@@ -173,6 +237,19 @@ function arr_eq(a1, a2) {

     }

 }

+function set_eq(a1, a2) {

+    if (a1.length !== a2.length) {

+        return false;

+    } else {

+        let result = true;

+        for (let elem of a1) {

+            result = result && a2.has(elem);

+            if (!result) break;

+        }

+        return result;

+    }

+}

+

 const primary_method_p =

       method => method instanceof WrappedMethod || method.qualifiers.length === 0;

 const before_method_p =

@@ -196,7 +273,7 @@ function apply_methods(gf, args, applicable_methods) {

     const main_call = Object.defineProperty(

         function() {

             if (primaries.length === 0) {

-                throw new Error(`No primary method for ${gf.name}`);

+                throw new NoPrimaryMethodError(`No primary method for ${gf.name}`);

             }

             for (let before of befores) {

@@ -227,15 +304,16 @@ function apply_method(method, args, next_methods) {

     const method_context = {

         call_next_method(...cnm_args) {

             if (next_methods.length === 0) {

-                throw new Error(`no next method for genfun ${method.generic_function.name}`);

+                throw new NoNextMethodError(`no next method for genfun ${method.generic_function.name}`);

             }

             return method instanceof WrappedMethod

                 ? method.continuation()

                 : apply_methods(method.generic_function, cnm_args.length > 0 ? cnm_args : args, next_methods);

         },

+

         get next_method_p() {

-            return next_methods.length === 0

+            return next_methods.length !== 0

         }

     };

@@ -1,49 +1,68 @@

-import * as uut from './genfuns.js';

+import * as uut from './genfuns';

+import * as e from './genfuns';

-describe('matchesSpecializer', () => {

-    function AThing() {};

-    const an_instance = new AThing();

-    

+describe('matches_specializer', () => {

     test('works in expected cases', () => {

-        expect(uut.matchesSpecializer(an_instance, AThing)).toBeTruthy();

-        expect(uut.matchesSpecializer(an_instance, String)).toBeFalsy();

-        expect(uut.matchesSpecializer(an_instance, Object)).toBeTruthy();

+        function AThing() { }

+        const an_instance = new AThing();

-        expect(uut.matchesSpecializer(new String("foobar"), String)).toBeTruthy();

-        expect(uut.matchesSpecializer(new String("foobar"), Object)).toBeTruthy();

+        expect(uut.matches_specializer(an_instance, AThing)).toBeTruthy();

+        expect(uut.matches_specializer(an_instance, String)).toBeFalsy();

+        expect(uut.matches_specializer(an_instance, Object)).toBeTruthy();

-        expect(uut.matchesSpecializer(new Number(1), Number)).toBeTruthy();

-        expect(uut.matchesSpecializer(new Number(1), Object)).toBeTruthy();

-        expect(uut.matchesSpecializer(new Number(1), String)).toBeFalsy();

-

-        expect(uut.matchesSpecializer([], Array)).toBeTruthy();

-        expect(uut.matchesSpecializer([], Object)).toBeTruthy();

-        expect(uut.matchesSpecializer([], Number)).toBeFalsy();

+        expect(uut.matches_specializer([], Array)).toBeTruthy();

+        expect(uut.matches_specializer([], Object)).toBeTruthy();

+        expect(uut.matches_specializer([], Number)).toBeFalsy();

         function Foo() {}

         Foo.prototype = Object.create(null);

         const inst = new Foo();

-        expect(uut.matchesSpecializer(inst, Foo)).toBeTruthy();

-        expect(uut.matchesSpecializer(inst, Object)).toBeFalsy();

+        expect(uut.matches_specializer(inst, Foo)).toBeTruthy();

+        expect(uut.matches_specializer(inst, Object)).toBeFalsy();

+

+        expect(uut.matches_specializer({a:1}, uut.Shape('a'))).toBeTruthy();

+        expect(uut.matches_specializer({a:1, b:2}, uut.Shape('a'))).toBeTruthy();

+        expect(uut.matches_specializer({b:2}, uut.Shape('a'))).toBeFalsy();

+

+        expect(uut.matches_specializer({a:1, b:2, c:3}, uut.Shape('a', 'b', 'c'))).toBeTruthy();

+        expect(uut.matches_specializer({a:1, b:2, c:3, d:4}, uut.Shape('a', 'b', 'c'))).toBeTruthy();

+        expect(uut.matches_specializer({a:1, c:3}, uut.Shape('a', 'b', 'c'))).toBeFalsy();

+        expect(uut.matches_specializer({c:3}, uut.Shape('a', 'b', 'c'))).toBeFalsy();

+        expect(uut.matches_specializer({d:3}, uut.Shape('a', 'b', 'c'))).toBeFalsy();

     });

-    test('works in for primitives', () => {

-        expect(uut.matchesSpecializer(1, Number)).toBeTruthy();

-        expect(uut.matchesSpecializer(1, Object)).toBeTruthy();

-        expect(uut.matchesSpecializer(1, String)).toBeFalsy();

+    test('null behavior', () => {

+        expect(uut.matches_specializer(null, null)).toBeTruthy();

+        expect(uut.matches_specializer(null, Number)).toBeFalsy();

+        expect(uut.matches_specializer(null, String)).toBeFalsy();

+        expect(uut.matches_specializer(null, Object)).toBeFalsy();

+    });

-        expect(uut.matchesSpecializer("1", String)).toBeTruthy();

-        expect(uut.matchesSpecializer("1", Object)).toBeTruthy();

-        expect(uut.matchesSpecializer("1", Number)).toBeFalsy();

+    test('undefined (the value) behavior', () => {

+        expect(uut.matches_specializer(undefined, undefined)).toBeTruthy();

+        expect(uut.matches_specializer(undefined, Number)).toBeFalsy();

+        expect(uut.matches_specializer(undefined, String)).toBeFalsy();

+        expect(uut.matches_specializer(undefined, Object)).toBeFalsy();

+    });

-        expect(uut.matchesSpecializer(null, Number)).toBeFalsy();

-        expect(uut.matchesSpecializer(null, String)).toBeFalsy();

-        expect(uut.matchesSpecializer(null, Object)).toBeFalsy();

+    test('works for numbers', () => {

+        expect(uut.matches_specializer(new Number(1), Number)).toBeTruthy();

+        expect(uut.matches_specializer(new Number(1), Object)).toBeTruthy();

+        expect(uut.matches_specializer(new Number(1), String)).toBeFalsy();

-        expect(uut.matchesSpecializer(undefined, Number)).toBeFalsy();

-        expect(uut.matchesSpecializer(undefined, String)).toBeFalsy();

-        expect(uut.matchesSpecializer(undefined, Object)).toBeFalsy();

+        expect(uut.matches_specializer(1, Number)).toBeTruthy();

+        expect(uut.matches_specializer(1, Object)).toBeTruthy();

+        expect(uut.matches_specializer(1, String)).toBeFalsy();

     });

+

+    test('handles strings', () => {

+        expect(uut.matches_specializer(new String("foobar"), String)).toBeTruthy();

+        expect(uut.matches_specializer(new String("foobar"), Object)).toBeTruthy();

+

+        expect(uut.matches_specializer("1", String)).toBeTruthy();

+        expect(uut.matches_specializer("1", Object)).toBeTruthy();

+        expect(uut.matches_specializer("1", Number)).toBeFalsy();

+    })

 });

 describe('defgeneric', () => {

@@ -54,6 +73,12 @@ describe('defgeneric', () => {

                 .fn(1,2)

         ).toEqual(1);

+        expect(() => {

+            uut.defgeneric("foobar", "a")

+                .primary([String], function (a) {})

+                .fn({})

+        }).toThrow(e.NoApplicableMethodError);

+

         expect(

             uut.defgeneric("testing1", "a", "b")

                 .primary([Number, Number], (_, __) => 1)

@@ -95,6 +120,149 @@ describe('defgeneric', () => {

         ).toEqual('hi');

         expect(thirdCounts).toEqual(2);

+        expect(

+            uut.defgeneric("foobar", "a")

+                .primary([Object], function (a) {

+                    return 1

+                })

+                .primary([String], function (a) {

+                    return 2

+                })

+                .fn("foobar"))

+            .toEqual(2);

+    });

+

+    test('next-method-p works', () => {

+        expect.assertions(3);

+

+        uut.defgeneric("foobar", "a")

+            .primary([Object], function (a) {

+                expect(this.next_method_p).toBe(false);

+            })

+            .fn({});

+

+        uut.defgeneric("foobar", "a")

+            .primary([Object], function (a) {

+                expect(this.next_method_p).toBe(false);

+            })

+            .primary([String], function (a) {

+                expect(this.next_method_p).toBe(true);

+            })

+            .fn("foobar");

+

+        uut.defgeneric("foobar", "a")

+            .primary([Object], function (a) {

+                expect(this.next_method_p).toBe(false);

+            })

+            .primary([String], function (a) {

+                expect(this.next_method_p).toBe(true);

+            })

+            .fn(1);

+

+    });

+

+    test('call-next-method works', () => {

+        expect(() => {

+            uut.defgeneric("foobar", "a")

+                .primary([Object], function (a) {

+                    this.call_next_method();

+                })

+                .fn({});

+        }).toThrow(e.NoNextMethodError);

+

+        expect(() => {

+            uut.defgeneric("foobar", "a")

+                .primary([Object], function (a) {

+                    this.call_next_method();

+                })

+                .primary([String], function (a) {

+                    return 1;

+                })

+                .fn({});

+        });

+

+        expect(

+            uut.defgeneric("foobar", "a")

+                .primary([Object], function (a) {

+                    return 1;

+                })

+                .primary([String], function (a) {

+                    return this.call_next_method();

+                })

+                .fn("foobar")

+        ).toEqual(1);

+        

+        expect(

+            uut.defgeneric("foobar", "a", "b")

+                .primary ([String, String], function (a,b) {

+                    return `1${this.call_next_method()}`;

+                })

+                .primary ([Object, String], function (a,b) {

+                    return `3${this.call_next_method()}`;

+                })

+                .primary ([String, Object], function (a,b) {

+                    return `2${this.call_next_method()}`;

+                })

+                .primary ([Object, Object], function (a,b) {

+                    return `4`;

+                }).fn("a", "b")

+        ).toEqual("1234");

+    });

+});

+

+describe('custom specializers', () => {

+    test('Shape works', () => {

+        expect(uut.defgeneric("foobar", "a")

+               .primary([uut.Shape('a', 'b')], ({a,b}) => a+b)

+               .primary([Object], _ => null)

+               .fn({a:1,b:2}))

+            .toEqual(3);

+

+        expect(uut.defgeneric("foobar", "a")

+               .primary([uut.Shape('a', 'b')], ({a,b}) => a+b)

+               .primary([Object], _ => null)

+               .fn({a:1,b:2,c:3}))

+            .toEqual(3);

+

+        expect(uut.defgeneric("foobar", "a")

+               .primary([uut.Shape('a', 'b')], ({a,b}) => a+b)

+               .primary([Object], _ => null)

+               .fn({a:1}))

+            .toEqual(null);

+    });

+

+    test('Shape, prototype precedence', () => {

+        expect(uut.defgeneric("foobar4", "a")

+               .primary([uut.Shape('a')], ({a}) => a)

+               .primary([uut.Shape('a', 'b')], ({a,b}) => {return a+b})

+               .primary([Object], _ => null).fn({a:1,b:3}))

+            .toEqual(4);

+

+        expect(uut.defgeneric("foobar", "a")

+               .primary([uut.Shape('a', 'b')], ({a,b}) => a+b)

+               .primary([uut.Shape('b')], ({b}) => b)

+               .primary([Object], _ => null)

+               .fn({a:1,b:2}))

+            .toEqual(3);

+

+        const Foo = function () {}

+        Foo.prototype = {a: true, b: null};

+        expect(uut.defgeneric("foobar", "a")

+               .primary([uut.Shape('a')], function ({a}) { return 'a'; })

+               .primary([uut.Shape('a', 'b', 'c')], function ({a,b,c}) { return `c${this.call_next_method()}`; })

+               .primary([uut.Shape('a', 'b')], function ({a,b}) { return `b${this.call_next_method()}`; })

+               .primary([Object], _ => null)

+               .fn(Object.assign(new Foo(), {c: 3})))

+            .toEqual('cba');

+    });

+});

+describe("Shape", () => {

+    test('super_of', () => {

+        expect(uut.Shape().super_of(uut.Shape("a", "b", "c"))).toBeTruthy();

+        expect(uut.Shape('a').super_of(uut.Shape('a', 'b'))).toBeTruthy();

+        expect(uut.Shape("a", "b").super_of(uut.Shape("a", "b", "c"))).toBeTruthy();

+        expect(uut.Shape("a", "b").super_of(uut.Shape("a", "b"))).toBeFalsy();

+        expect(uut.Shape("a", "b").super_of(uut.Shape("a"))).toBeFalsy();

     });

 });

@@ -1,3 +1,5 @@

+import * as gf from '../src/genfuns';

+

 function zipWith(fn, ...args) {

     const minLen = Math.min(...args.map(x => x.length));

     const res = [];