Object.extend = function(o1, o2) {
  for (var x in o2)
    if (o2.hasOwnProperty(x))
      o1[x] = o2[x];

  return o1;
};

Object.extend(Object, {
  copy: function(o) {
    return Object.extend({}, o);
  },

  fromArray: function(o) {
    var r = {};

    Array.map(function(pair) { r[pair[0]] = pair[1]; }, a);

    return r;
  }
});

Object.extend(Function, {
  id: function(a) { return a; }
});

Object.extend(Array, {
  map: function(f, a) {
    for (var i = a.length - 1, r = []; i >= 0; --i)
      r[i] = f(a[i], i);

    return r;
  }
});

Object.extend(String,
  upperFirst: function(s) {
    return s.charAt(0).toUpperCase() + s.substr(1);
  },

  trim: function(s) {
    return s.replace(/^\s+/, "").replace(/\s+$/, "");
  }
});

var Css = (function() {
  var jsEquivs = {
    'float' : "css-float"
    // &c.
  };

  function cssToObject(s) {
    return Object.fromArray(Array.map(textToPair, s.split(";")));
  }

  function textToPair(s) {
    var r = Array.map(String.trim, s.split(":"));

    r[0] = propertyToCss(r[0]);

    return r;
  }

  function propertyToJs(s) {
    return Array.map(String.upperFirst, (jsEquivs[s] || s).split("-")).join("");
  }

  function apply(el, style) {
    if (typeof x === "string")
      el.setAttribute("style", el.style.cssText = style);
    else
      Object.extend(el.style, style);

    return el;
  }

  return {
    propertyToJs: propertyToJs,
    cssToObject: cssToObject,
    apply: apply
  };
})();

var Dom = (function() {
  function get(a) {
    return document.getElementById(a);
  }

  var attrmap = {
    'class': "className"
    // &c.
  };

  function applyAttributes(el, attrs) {
    for (var x in attrs)
      if (attrs.hasOwnProperty(x))
        if (x === "style")
          Css.apply(el, attrs[x]);
        else
          el[attrmap[x] || x] = attrs[x];

    return el;
  }

  function addChildren(el, children, filter) {
    Array.map(function(child) {
      if (!child) return;

      if (child = create(child))
        el.appendChild(child);
    }, children);
  }

  function create(el, filter) {
    if (typeof el === "string")
      return document.createTextNode(el);

    if (!(el instanceof Array))
      return el;

    filter = filter || Function.id;

    var r        = document.createElement(el[0]),
        attrs    = el[1] || {},
        children = el[2] || [];

    applyAttributes(r, attrs);

    addChildren(r, children, filter);

    return filter(r);
  }

  function clear(el) {
    while (el.hasChildNodes())
      el.removeChild(el.firstChild);

    return el;
  }

  return {
    create: create,
    get: get,
    clear: clear
  };
})();

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);