Comparing JavaScript, CoffeeScript & ClojureScript(dosync.posterous.com)

    (defprotocol ISlice
      (-shift [this]))

    (deftype Slice [start end]
      ISlice
      (-shift [_] (Slice. (inc start) (inc end)))
      IFn
      (-invoke [_ x]
        (cond
          (string? x) (.substring x start end)
          (vector? x) (subvec x start end))))

    (def s (Slice. 0 5))
    (def v ["List Processing" [0 1 2 3 4 5 6]])

    (map s v)
    ;; >> ("List " [0 1 2 3 4])
    (map (-shift s) v)
    ;; >> ("ist P" [1 2 3 4 5])

    slice = (start, end) ->
      (list) ->
        if typeof list is 'string'
          list.substring start, end
        else
          list.slice start, end

    vector = ["List Processing", [0, 1, 2, 3, 4, 5, 6]]

    vector.map slice 0, 5
    # ["List ",[0,1,2,3,4]]

    vector.map slice 1, 6
    # ["ist P",[1,2,3,4,5]]

    Object.defineProperty Object.prototype, 'bar',
        value: -> 'whatever'
        
    'foo'.bar()
    (1).bar()
    [1,2,3].bar()

    MagicHash = (props) ->
      f = (key) -> f[key]
      f[k] = v for k,v of props
      return f
  
    address = new MagicHash
      street: '1010 Foo Ave.'
      apt: '1111'
      city: 'Bit City'
      zip: '000000000'

    address.apt
    #> '1111'
    ['street', 'zip'].map address
    #> [ '1010 Foo Ave.', '000000000' ]

    map = (fn, arr) -> arr.map fn

    map address, ['street', 'zip']
    #> [ '1010 Foo Ave.', '000000000' ]
    

  package main

  type Foo struct {
	a, b, c int
  }

  func (f *Foo) bar(x int) int {
	return f.a + f.b + f.c + x
  }

  func main() {
	afoo := Foo{1, 2, 3}
	afoo.bar(3)
  }