// [[file:../README.org::*Other sorts of specializers][Other sorts of specializers:3]]
 // [[[[file:~/git_repos/git.fiddlerwoaroof.com/js-generic-functions/README.org::imports][imports]]][imports]]
 import { defgeneric } from "./genfuns.js";
 // imports ends here
 // [[[[file:~/git_repos/git.fiddlerwoaroof.com/js-generic-functions/README.org::specializer-import][specializer-import]]][specializer-import]]
 import { Shape, Eql } from "./genfuns.js";
 // specializer-import ends here
 
 describe("defgeneric", () => {
   test("methods get called appropriately", () => {
     // [[[[file:~/git_repos/git.fiddlerwoaroof.com/js-generic-functions/README.org::basic-definition][basic-definition]]][basic-definition]]
     const example1generic = defgeneric("example1", "a", "b")
       .primary([Number, Object], (n, __) => [1, n])
       .primary([Object, Number], (_, n) => [2, n])
       .primary([Object, Object], (_, __) => [5, null]);
     // basic-definition ends here
 
     // [[[[file:~/git_repos/git.fiddlerwoaroof.com/js-generic-functions/README.org::call-the-function][call-the-function]]][call-the-function]]
     const example1 = example1generic.fn;
     
     expect(example1(5, {})).toEqual([1, 5]);
     expect(example1({}, 6)).toEqual([2, 6]);
     expect(example1("hello", {})).toEqual([5, null]);
     expect(example1({}, "world")).toEqual([5, null]);
     expect(example1({}, {})).toEqual([5, null]);
     // call-the-function ends here
 
     // [[[[file:~/git_repos/git.fiddlerwoaroof.com/js-generic-functions/README.org::add-methods][add-methods]]][add-methods]]
     example1generic
       .primary([String, Object], (s, __) => [3, s])
       .primary([Object, String], (_, s) => [4, s]);
     
     expect(example1("hello", {})).toEqual([3, "hello"]);
     expect(example1({}, "world")).toEqual([4, "world"]);
     // add-methods ends here
 
     
   });
   test ('specializers work as expected', () => {
     // [[[[file:~/git_repos/git.fiddlerwoaroof.com/js-generic-functions/README.org::specializer-examples][specializer-examples]]][specializer-examples]]
     const example2 = defgeneric("example2", "inp")
       .primary([Shape("a", "b")], inp => `a: ${inp.a} b: ${inp.b}`)
       .primary([Shape("a")], inp => `a: ${inp.a} b: <missing>`)
       .primary([Shape(["c", 1])], inp => `c: one`)
       .primary([Shape(["c", 2])], inp => `c: two`)
       .primary([Eql(1)], inp => "one").fn;
     
     expect(example2({ a: 3, q: "whatever" })).toEqual("a: 3 b: <missing>");
     expect(example2({ a: 3, b: 4, q: "whatever" })).toEqual("a: 3 b: 4");
     expect(example2({ c: 1, q: "whatever" })).toEqual("c: one");
     expect(example2({ c: 2, q: "whatever" })).toEqual("c: two");
     expect(example2(1)).toEqual("one");
     // specializer-examples ends here
   })
 });
 // Other sorts of specializers:3 ends here