gistfile1.coffee

do ->
    Function::implements = (argv...) ->
        for proto in argv
            for key, value of proto::
                @::[key] = value
        @

    has = (key) ->
        return Object::hasOwnProperty(key)

    each = (object, method, context = @) ->
        for key, value in object
            if method.call(context, [key, value]) == false
                break
        object

    create = Object.create or (self) ->
        F = ->
        F.prototype = self
        new F

    merge = Object.merge or (argv...) ->
        object = {}
        each(argv, (noop, next = {}) ->
            each(next, (key, value) ->
                if has(next, key)
                    object[key] = value
                )
            )
        object

    this.fw = {
        has: has
        each: each
        create: create
        merge: merge
    } 

class Animal
    hello: (what) ->
        alert(what or @options.hello)

class Organic
    foo: (what) ->
        alert(what or @options.foo)

class Options
    setOptions: (options) ->
        fw.merge(@options, options)
        @

class Snake extends Animal
    @implements Options, Organic

    options: {
        "foo": "bar"
        "hello": "world"
    }

    constructor: (hello, foo, options) ->
        @setOptions(options)
        @hello(hello)
        @foo(foo)

new Snake();