In LISP, there’s a collection of functions used to slice up lists - car and cdr are the basic ones, but you can stack them up like this:

(car '(1 2 3)) => 1
(cdr '(1 2 3)) => (2 3)
(cdar '(1 2 3)) => (car '(2 3)) => 2

These are kind of useful, but according to Wikipedia:

Most Lisps set a limit on the number of composed forms they support; Common Lisp and Scheme both provide forms with up to four repetitions of the a and d.

So, since I work in Ruby more often than LISP, these functions have two weaknesses for me:

  1. They’re in the wrong language
  2. There’s an artificial and arbitrary limit to how many I can stack up

So I thought to myself � I can hook method_missing on an Array in Ruby…


# carpark.rb
# RubyTut
#
# Created by Bryce Kerley on 2006-11-08.
# This code is public domain.
#
# Subversion info:
#
# $Id: carpark.rb 176 2006-11-09 04:12:04Z bkerley $

class Array
  def method_missing(m, *a)
    s = m.to_s
    return super.method_missing(m, a) unless s =~ /c[ad]+r/
    o = s[1..-2]
    if o.length == 1
      return self[0] if o[0..0] == “a”
      return self[1..-1] if o[0..0] == “d”
    end
    return self[0].send(“c#{o[1..-1]}r”.to_sym) if o[0..0]==”a”
    return self[1..-1].send(“c#{o[1..-1]}r”.to_sym) if o[0..0]==”d”

    return "failed #{o}"
  end
end

Sample run:

irb(main):001:0> require 'carpark'
=> true
irb(main):002:0> x = [[[[1, 2, 3], 4, 5], 5, 6, [420], 11], 3]
=> [[[[1, 2, 3], 4, 5], 5, 6, [420], 11], 3]
irb(main):003:0> x.cdr
=> [3]
irb(main):004:0> x.cdar
=> 3
irb(main):005:0> x.caaadr
=> [2, 3]

Use wisely�