func (list *Pair) Drop(k int) (result interface{}) {
	if k < 0 {
		panic(outOfBounds(k, list))
	}
	result = list
	for i := k; i > 0; i-- {
		pair, _ := result.(*Pair)
		if pair == nil {
			panic(outOfBounds(k, list))
		}
		result = pair.Cdr
	}
	return
}
Drop returns all but the first k elements of the list.

List(1, 2, 3, 4, 5).Drop(2) => (3 4 5)

x may be any value -- a proper, circular, or dotted list.

Cons(1, 2, 3, "d").Drop(2) => (3 . "d")
Cons(1, 2, 3, "d").Drop(3) => "d"

For a legal k, Take and Drop partition the list in a manner which can be inverted with Append:

Append(x.Take(k), x.Drop(k)) => x

Drop is exactly equivalent to performing k Cdr operations on x; the returned value shares a
common tail with x.
package list
func Car(x interface{}) interface{} {
	pair, _ := x.(*Pair)
	if pair == nil {
		return nil
	}
	return pair.Car
}
func Cdr(x interface{}) interface{} {
	pair, _ := x.(*Pair)
	if pair == nil {
		return nil
	}
	return pair.Cdr
}
func Caar(x interface{}) interface{} {
	return Car(Car(x))
}
func Cadr(x interface{}) interface{} {
	return Car(Cdr(x))
}
func Cdar(x interface{}) interface{} {
	return Cdr(Car(x))
}
func Cddr(x interface{}) interface{} {
	return Cdr(Cdr(x))
}
func Caaar(x interface{}) interface{} {
	return Caar(Car(x))
}
func Caadr(x interface{}) interface{} {
	return Caar(Cdr(x))
}
func Cadar(x interface{}) interface{} {
	return Cadr(Car(x))
}
func Caddr(x interface{}) interface{} {
	return Cadr(Cdr(x))
}
func Cdaar(x interface{}) interface{} {
	return Cdar(Car(x))
}
func Cdadr(x interface{}) interface{} {
	return Cdar(Cdr(x))
}
func Cddar(x interface{}) interface{} {
	return Cddr(Car(x))
}
func Cdddr(x interface{}) interface{} {
	return Cddr(Cdr(x))
}
func Caaaar(x interface{}) interface{} {
	return Caaar(Car(x))
}
func Caaadr(x interface{}) interface{} {
	return Caaar(Cdr(x))
}
func Caadar(x interface{}) interface{} {
	return Caadr(Car(x))
}
func Caaddr(x interface{}) interface{} {
	return Caadr(Cdr(x))
}
func Cadaar(x interface{}) interface{} {
	return Cadar(Car(x))
}
func Cadadr(x interface{}) interface{} {
	return Cadar(Cdr(x))
}
func Caddar(x interface{}) interface{} {
	return Caddr(Car(x))
}
func Cadddr(x interface{}) interface{} {
	return Caddr(Cdr(x))
}
func Cdaaar(x interface{}) interface{} {
	return Cdaar(Car(x))
}
func Cdaadr(x interface{}) interface{} {
	return Cdaar(Cdr(x))
}
func Cdadar(x interface{}) interface{} {
	return Cdadr(Car(x))
}
func Cdaddr(x interface{}) interface{} {
	return Cdadr(Cdr(x))
}
func Cddaar(x interface{}) interface{} {
	return Cddar(Car(x))
}
func Cddadr(x interface{}) interface{} {
	return Cddar(Cdr(x))
}
func Cdddar(x interface{}) interface{} {
	return Cdddr(Car(x))
}
func Cddddr(x interface{}) interface{} {
	return Cdddr(Cdr(x))
}
func (list *Pair) Ref(n int) (result interface{}) {
	if n >= 0 {
		for l, i := list, 0; l != nil; i++ {
			if i == n {
				return l.Car
			}
			l, _ = l.Cdr.(*Pair)
		}
	}
	panic(outOfBounds(n, list))
}
func (list *Pair) Take(k int) (result *Pair) {
	if k == 0 {
		return
	}
	if k < 0 || list == nil {
		panic(outOfBounds(k, list))
	}
	result = &Pair{Car: list.Car}
	pair := list
	last := result
	for i := k - 1; i > 0; i-- {
		if pair, _ = pair.Cdr.(*Pair); pair == nil {
			panic(outOfBounds(k, list))
		}
		last = last.ncdr(pair.Car)
	}
	last.Cdr = (*Pair)(nil)
	return
}