Improve my bland List

class List
        attr_reader :car, :cdr, :size
        def initialize(*args)
                if args.size.zero? then
                        @car = nil; @cdr = nil; @size = 0
                elsif args.size == 1
                        @car = args[0]; @cdr = List.new; @size = 1
                else
                        @car = args[0]
                        @cdr = List.new *args[1 .. args.size - 1]
                        @size = args.size
                end
        end
        def [](n)
                raise ArgumentError unless n.class == Fixnum
                unless n > @size - 1 then
                        if n.zero? then @car
                        else @cdr[n - 1] end
                end
        end
        def []=(n,a)
                raise ArgumentError unless n.class == Fixnum
                unless n > @size - 1 then
                        if n.zero? then @car = a
                        else @cdr[n-1] = a end
                else raise ArgumentError
                end
        end
        def length
                @size
        end
        def null?
                @cdr.nil?
        end
        def member?(a)
                if a.nil? then true end
                unless self.null? then
                        if @car == a then true
                        else @cdr.member? a end
                else false
                end
        end
        def include?(a)
                self.member? a
        end
end

>>68
I'm not talking about memory overhead, although it's kind of linked with what I'm saying (don't mind the pun). Linked structures are just inherently cache inefficient, arrays do things much faster on modern architectures.