Code I wrote whilst angry

[Twey]

I just used this code to vent some frustration earlier, hope you all like it. It's pretty self-explanatory. It's probably too theoretical to go into the DD scripts archives, so I'll just leave it lying about here.

var Generic = (function() {
  var MATCH_FAIL = {},
      MATCH_ANY  = function() { return MATCH_ANY; };

  function create(fallback) {
    var s = function() {
      for (var i = 0, args = Array.prototype.slice.call(arguments), r; i < specs.length; ++i)
        if ((r = specs[i].match(args)) !== MATCH_FAIL)
          return r;

      if (s._fallback)
        return s._fallback.apply(this, args);

      throw new Error("Generic: No methods matched and no fallback provided.");
    }, specs = s._specs = [];

    s.specialise = specialise;
    s.addFallback = addFallback;
    if (fallback)
      s.addFallback(fallback);

    return s;
  }

  function specialise(patterns, func) {
    var s = this._specs;

    s[s.length] = new Specialisation(patterns, func, this);

    return this;
  }

  function addFallback(func) {
    this._fallback = func;

    return this;
  }

  /**** Begin Specialisation ****/

  function Specialisation(patterns, func, context) {
    this.patterns = patterns;
    this.func = func;
    this.context = context;
  }

  Specialisation.compatible = function(value, pattern) {
    if (pattern === MATCH_ANY && value !== undefined)
      return true;
    else if ((typeof pattern === "string" || pattern instanceof String) && typeof value === pattern)
      return true;
    else if (typeof pattern === "function" && value instanceof pattern)
      return true;
    else if (pattern instanceof Pattern)
      return pattern.guard(value);
    else if (pattern instanceof Interface)
      return pattern.match(value);

    return false;
  };

  Specialisation.prototype = {
    match: function(args) {
      for (var i = 0, a = this.patterns, n = a.length; i < n; ++i)
        if (!Specialisation.compatible(args[i], a[i]))
          return MATCH_FAIL;

      return this.func.apply(this.context, args);
    }
  };

  /**** Begin Pattern ****/

  function Pattern(guard) {
    this.guard = guard;
  }

  function GUARD(func) {
    return new Pattern(func);
  }

  function GUARD_IS(right) {
    return new Pattern(function(val) {
      return val === right;
    });
  }

  /**** Begin Interface ****/

  function Interface(obj) {
    if (!(this instanceof Interface))
      return new Interface(obj);

    for (var x in obj)
      if (obj.hasOwnProperty(x))
        this[x] = obj[x];
  }

  Interface.getSkeleton = function(obj) {
    var r = {};

    for (var x in obj)
      if (obj.hasOwnProperty(x))
        r[x] = typeof obj[x];

    return new Interface(r);
  };

  Interface.prototype = {
    match: function(value) {
      for (var x in this)
        if (this.hasOwnProperty(x) && !Specialisation.compatible(value[x], this[x]))
          return false;

      return true;
    }
  };

  return {
    create: create,
    Interface: Interface,
    GUARD: GUARD,
    GUARD_IS: GUARD_IS,
    MATCH_ANY: MATCH_ANY
  };
})();

function Animal(species) {
  this.species = species;
}

var iAnimal = Generic.Interface.getSkeleton(new Animal("foo"));

var iDog = Generic.Interface({'species' : Generic.GUARD_IS("dog")});

var sound = Generic.create()
  .specialise([iDog, 'undefined'], function() {
    print("I got a dog!  I got one!");
  })
  .specialise(['string', iAnimal], function(snd, an) {
    print("A " + an.species + " says '" + snd + "',");
  })
  .specialise([iAnimal, 'string'], function(an, snd) {
    print("but a " + an.species + " says '" + snd + "',");
  })
  .specialise([Animal], function(an) {
    print("and a " + an.species + " is apparently silent.");
  })
  .specialise([Generic.MATCH_ANY, 'undefined'], function(val) {
    print("... and whatever noise a " + val + " makes...");
  })
  .addFallback(function() {
    print("Er... random animal noise?");
  });

sound(new Animal("dog"));
sound("woof", new Animal("dog"));
sound(new Animal("cat"), "miaow");
sound(new Animal("frog"));
sound(42);
sound(4, 5);

[TheJoshMan]

and a cow says: MOO...

[Twey]

Only if you specialise to it.

[mburt]

Uh I tested it, and all that happened was it printed a blank page.

[TheJoshMan]

sound("MOO", new Animal("cow"));

[Twey]

The print() statements I used are meant for running in a console, change them to alert() or something if you intend to run it in a browser.

What it does isn't remarkable, that's just standardly-idiotic sample code. What's hopefully interesting is how it does it.

[mburt]

Yeah I'm not entirely sure what it does. It just looks like the Generic method creates functions?

[Twey]

No, it's a crude implementation of dispatching to functions based on argument types — one way of doing classical OO in a purely-functional language. It can be thought of in terms of Haskell's typeclasses, or Common Lisp's... well, generics; that latter was the inspiration for this.

Simply, a single generic is created, and then onto that generic can be attached various specialisations to various argument types. When the generic is called, unlike a traditional function, it inspects its arguments and dispatches the call and the arguments to the appropriate specialisation. My implementation here caters to Javascript's split personality with regards to OO by allowing dispatching using both duck-typing via interfaces, and by type or instance as reported by typeof and instanceof.

[mburt]

Ah I see... I think I understand it. A little bit, at least.

[Trinithis]

typeof pattern === "function" || pattern instanceof Function

I tested on IE and FF and you don't need the latter half for functions.

"Structure and Interpretation of Computer Programs" (large PDF link) talks about this type of dispatch if anyone is curious. (Begins talking about it on 2.4)