list

func (*Pair) ACons ¶

func (alist *Pair) ACons(key, value interface{}) *Pair

ACons conses a new alist entry mapping key -> value onto alist.

func (*Pair) ACopy ¶

func (alist *Pair) ACopy() *Pair

ACopy makes a fresh copy of alist. This means copying each pair that forms an assocation as well as the spine of the list.

func (*Pair) ADelete ¶

func (alist *Pair) ADelete(key interface{}) *Pair

ADelete deletes all assocations from alist with the given key, using ==.

The return value may share common tails with the alist argument. The alist is not disordered -- elements that appear in the result alist occur in the same order as they occur in the argument list.

func (*Pair) Adjoin ¶

func (list *Pair) Adjoin(elements ...interface{}) *Pair

Adjoin adds the elements not already in the list parameter to the result list. The result shares a common tail with the list parameter. The new elements are added to the front of the list, but no guarantees are made about their order. Elements are compared using ==.

The list parameter is always a suffix of the result -- even if the list parameter contains repeated elements, these are not reduced.

Adjoin(List("a", "b", "c", "d", "c", "e"), "a", "e", "i", "o", "u")
 => ("u" "o" "i" "a" "b" "c" "d" "c" "e")

func (*Pair) Any ¶

func (list *Pair) Any(predicate func(interface{}) bool) bool

Any applies the predicate across the list, returning true if the predicate returns true on any application.

func isInteger(x interface{}) bool {
  _, ok := x.(int)
  return ok
}

List("a", 3, "b", 2.7).Any(isInteger)   => true
List("a", 3.1, "b", 2.7).Any(isInteger) => false

func (*Pair) Append ¶

func (list *Pair) Append(lists ...*Pair) (result *Pair)

Append returns a list consisting of the elements of the first list followed by the elements of the other lists.

List(1).Append(List(2))          => (1 2)
List(1).Append(List(2, 3, 4))    => (1 2 3 4)
List(1, List(2)).Append(List(3)) => (1 (2) 3)

The resulting list is always newly allocated, except that it shares structure with the final list.

func (*Pair) AppendMap ¶

func (list *Pair) AppendMap(f func(element interface{}) *Pair) (result *Pair)

AppendMap maps f over the elements of the list, just as in Map. However, the results of the applications are appended together to make the final result. AppendMap uses Append to append the results together. The list argument must be finite.

func (*Pair) AppendReverse ¶

func (list *Pair) AppendReverse(tail *Pair) (result *Pair)

AppendReverse returns Append(list.Reverse(), tail).

It is provided because it is a common operation -- a common list-processing style calls for this exact operation to transfer values accumulated in reverse order onto the front of another list, and because the implementation is significantly more efficient than the simple composition it replaces. (But note that this pattern of iterative computation followed by a reverse can frequently be rewritten as a recursion, disposing with the Reverse and AppendReverse steps, and shifting temporary, intermediate storage from the heap to the stack.)

func (*Pair) AppendToSlice ¶

func (list *Pair) AppendToSlice(slice interface{}) (result interface{})

AppendToSlice uses Go's reflect package to append each element of the list to the given slice.

List(1, 2, 3).AppendToSlice([]int(nil)) => [1, 2, 3]

func (*Pair) Assoc ¶

func (alist *Pair) Assoc(key interface{}) (result interface{}, ok bool)

Assoc finds the first pair in alist whose Car field is key, and returns that pair and true. If no pair in alist has key as its Car, then nil and false are returned. Assoc uses == for comparing key against the cars in alist.

func (*Pair) Break ¶

func (list *Pair) Break(predicate func(interface{}) bool) (prefix *Pair, suffix interface{})

Break splits the list into the longest initial prefix whose elements all do not satisfy predicate, and the remaining tail.

func even(x interface{}) bool {
  return x.(int)%2 == 0
}

List(3, 1, 4, 1, 5, 9).Break(even) =>
  (3 1)
  (4 1 5 9)

func (*Pair) Copy ¶

func (list *Pair) Copy() (result *Pair)

Copy copies the spine of the argument.

func (*Pair) Count ¶

func (list *Pair) Count(predicate func(interface{}) bool) (result int)

Count applies predicate element-wise to the elements of list, and a count is tallied of the number of elements that produce a true value. This count is returned. Count is guaranteed to apply predicate to the list elements in a left-to-right order. The list must be finite.

func even(x interface{}) bool {
  return x.(int)%2 == 0
}

List(3, 1, 4, 1, 5, 9, 2, 5, 6).Count(even) => 3

func (*Pair) Delete ¶

func (list *Pair) Delete(x interface{}) (result *Pair)

Delete finds all elements of list that are equal (==) to x, and deletes them from the list.

The list is not disordered -- elements that appear in the result list occur in the same order as they occur in the argument list. The result may share a common tail with the argument list.

Note that fully general element deletion can be performed with the Remove and NRemove methods, for example:

func even(x interface{}) bool {
  return x.(int)%2 == 0
}

// Delete all the even elements from list:
list.Remove(even)

func (*Pair) DeleteDuplicates ¶

func (list *Pair) DeleteDuplicates() (result *Pair)

DeleteDuplicates removes duplicate elements from the list argument. If there are multiple equal (==) elements in the argument list, the result list contains the first or leftmost of these elements in the result. The order of these surviving elements is the same as in the original list -- DeleteDuplicates does not disorder the list (hence it is useful for "cleaning up" assocation lists).

The result of DeleteDuplicates may share common tails between argument and result lists -- for example, if the list argument contains only unique elements, it may simply return exactly this list.

Be aware that, in general, DeleteDuplicates runs in time O(n^2) for n-element lists. Uniquifying long lists can be accomplished in O(n lg n) time by sorting the list to bring equal elements together, then using a linear-time algorithm to remove equal elements. Alternatively, one can use algorithms based on element-marking, with linear-time results.

func (*Pair) Drop ¶

func (list *Pair) Drop(k int) (result interface{})

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.

func (*Pair) DropRight ¶

func (list *Pair) DropRight(k int) (result *Pair)

DropRight returns all but the last k elements of list.

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

list may be any finite list, either proper or dotted.

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

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

Append(x.DropRight(k), x.TakeRight(k)) => x

If the argument list is a list of non-zero length, DropRight is guaranteed to return a freshly-allocated list, even in the case where nothing is dropped.

func (*Pair) DropWhile ¶

func (list *Pair) DropWhile(predicate func(interface{}) bool) (result *Pair)

DropWhile drops the longest initial prefix of list whose elements all satisfy predicate, and returns the rest of the list.

func even(x interface{}) bool {
  return x.(int)%2 == 0
}

List(2, 18, 3, 10, 10, 22, 9).DropWhile(even) => (3 10 22 9)

The circular-list case may be viewed as "rotating" the list.

func (*Pair) Every ¶

func (list *Pair) Every(predicate func(interface{}) bool) bool

Every applies the predicate across the list, returning true if the predicate returns true on every application.

func (*Pair) Filter ¶

func (list *Pair) Filter(predicate func(x interface{}) bool) (result *Pair)

Filter returns all the elements of list that satisfy the predicate. The list is not disordered -- elements that appear in the result list occur in the same order as they occur in the argument list. The returned list may share a common tail with the argument list. The dynamic order in which the various applications of predicate are made is not specified.

func even(x interface{}) bool {
  return x.(int)%2 == 0
}

list.List(0, 7, 8, 8, 43, -4).Filter(even) => (0 8 8 -4)

func (*Pair) FilterMap ¶

func (list *Pair) FilterMap(f func(element interface{}) (interface{}, bool)) (result *Pair)

FilterMap is like Map, but only when f returns true as a second value, the first value is saved.

List("a", 1, "b", 3, "c", 7).FilterMap(func(x interface{}) (interface{}, bool) {
  if n, ok := x.(int); ok {
    return n*n, true
  }
  return nil, false
})                    => (1 9 49)

The list argument must be finite.

func (*Pair) Find ¶

func (list *Pair) Find(predicate func(interface{}) bool) (result interface{}, ok bool)

Find returns the first element of list that satisfies predicate. It returns a second value of true if such an element is found, and false otherwise.

func even(x interface{}) bool {
  return x.(int)%2 == 0
}

List(3, 1, 4, 1, 5, 9).Find(even) => 4, true

func (*Pair) FindTail ¶

func (list *Pair) FindTail(predicate func(interface{}) bool) (result *Pair)

FindTail returns the first pair whose Car satisfies predicate. If no pair does, return Nil().

FindTail can be viewed as a general-predicate variant of the Member function.

Examples:

func even(x interface{}) bool {
  return x.(int)%2 == 0
}

List(3, 1, 37, -8, -5, 0, 0).FindTail(even) => (-8 -5 0 0)
List(3, 1, 37, -5).FindTail(even) => ()

In the circular-list case, this function "rotates" the list.

FindTail is essentially DropWhile, where the sense of the predicate is inverted: FindTail searches until it finds an element satisfying the predicate; DropWhile searches until it finds an element that doesn't satisfy the predicate.

func (*Pair) Fold ¶

func (list *Pair) Fold(f func(intermediate, element interface{}) interface{}, init interface{}) (result interface{})

Fold is the fundamental list iterator.

If list == (e_1 e_2 ... e_n), then this method returns

f(f(f(f(init, e1), e2), ...), e_n)

That is, it obeys the recursion

list.Fold(f, init)  == list.Cdr.Fold(f, f(init, list.Car))
Nil().Fold(f, init) == init

The list argument must be finite.

Examples:

func add(x, y interface{}) interface{} {
  return x.(int) + y.(int)
}

list.Fold(add, 0)          // Add up the elements of list.

func cons(tail, head interface{}) interface{} {
  return NewPair(head, tail)
}

list.Fold(cons, Nil())     // Reverse list.

// How many strings in list?
list.Fold(func(count, x interface{}) interface{} {
  if _, ok := x.(string); ok {
    return count.(int) + 1
  }
  return count.(int)
})

// Length of the longest string in list:
list.Fold(func(maxLen, x interface{}) interface{} {
  if s, ok := x.(string); ok && len(s) > maxLen.(int) {
    return len(s)
  }
  return maxLen
})

func (*Pair) FoldRight ¶

func (list *Pair) FoldRight(f func(intermediate, element interface{}) interface{}, init interface{}) (result interface{})

FoldRight is the fundamental list recursion operator.

If list == (e_1 e_2 ... e_n), then this method returns

f(f(f(f(init, e_n), ...), e_2), e_1)

That is, it obeys the recursion

list.FoldRight(f, init)  == f(list.Cdr.FoldRight(f, init), list.Car)
Nil().FoldRight(f, init) == init

The list argument must be finite.

Examples:

func cons(tail, head interface{}) interface{} {
  return NewPair(head, tail)
}

list.FoldRight(cons, Nil())     // Copy list.

// Filter the even numbers out of list.
list.FoldRight(func(l, x interface{}) interface{} {
  if x.(int)%2 == 0 {
    return NewPair(x, l)
  }
  return l
}, Nil())

func (*Pair) ForEach ¶

func (list *Pair) ForEach(f func(element interface{}))

ForEach is like Map, but ForEach calls f for its side effects rather than for its values. ForEach is guaranteed to call f on the elements of the list in order from left to right. The list argument must be finite.

v := make([]int, 5)
List(0, 1, 2, 3, 4).ForEach(func (e interface{}) {
  i := e.(int)
  v[i] = i
})
v => [0, 1, 2, 3, 4]

func (*Pair) Index ¶

func (list *Pair) Index(predicate func(interface{}) bool) (result int)

Index returns the index of the leftmost element that satisfies predicate.

func even(x interface{}) bool {
  return x.(int)%2 == 0
}

List(3, 1, 4, 1, 5, 9).Index(even) => 2

func (*Pair) Last ¶

func (list *Pair) Last() (result interface{})

Last returns the last element of the finite list. If list is nil or dotted, Last returns Nil().

func (*Pair) LastPair ¶

func (list *Pair) LastPair() (result *Pair)

LastPair returns the last pair in the finite list. If list is nil or dotted, LastPair returns Nil().

func (*Pair) Length ¶

func (list *Pair) Length() (result int)

Length returns the length of the argument. It is an error to pass a value which is not a proper list (finite and Nil()-terminated). In particular, this means Length may diverge or panic when Length is applied to a circular list.

The length of a proper list is a non-negative integer n such that Cdr applied n times to the list produces the empty list.

func (*Pair) Map ¶

func (list *Pair) Map(f func(element interface{}) interface{}) (result *Pair)

Map applies f element-wise to the elements of list and returns a list of the results, in order. Map is guaranteed to call f on the elements of the list in order from left to right. The list argument must be finite.

List(List(1, 2), List(3, 4), List(5, 6)).Map(Cadr) => (2 4 6)

List(1, 2, 3, 4, 5).Map(func (n interface{}) interface{} {return x.(int)+1}) => (2 3 4 5 6)

count := 0
List("a", "b").Map(func(_ interface{}) interface{} {
   count++
   return count
})                  => (1 2)

func (*Pair) Member ¶

func (list *Pair) Member(x interface{}) (result *Pair)

Member returns the first sublist of list whose Car is x, where the sublists of list ar the non-empty lists returned by list.Drop(i) for i less than the length of list. If x does not occur in list, then nil is returned. Member uses == to compare x with the elements of the list.

List(1, 2, 3).Member(1) => (1 2 3)
List(1, 2, 3).Member(2) => (2 3)
List(2, 3, 4).Member(1) => ()

Note that fully general list searching may be performed with the Find and FindTail functions.

func (*Pair) NADelete ¶

func (alist *Pair) NADelete(key interface{}) *Pair

NADelete is the linear-update variant of ADelete.

func (*Pair) NAppend ¶

func (list *Pair) NAppend(lists ...*Pair) (result *Pair)

NAppend is the linear-update variant of Append -- it is allowed, but not required, to alter cons cells in the argument lists to construct the result list. The last list is never altered; the result list shares structure with this parameter.

func (*Pair) NAppendMap ¶

func (list *Pair) NAppendMap(f func(element interface{}) *Pair) (result *Pair)

NAppendMap maps f over the elements of the list, just as in Map. However, the results of the applications are appended together to make the final result. NAppendMap uses NAppend to append the results together. The list argument must be finite.

Example:

List(1, 3, 8).NAppendMap(func(x interface{}) *Pair {
  return List(x, -(x.(int)))
})                              => (1 -1 3 -3 8 -8)

func (*Pair) NAppendReverse ¶

func (list *Pair) NAppendReverse(tail *Pair) (result *Pair)

NAppendReverse is the linear-update variant of AppendReverse.

func (*Pair) NBreak ¶

func (list *Pair) NBreak(predicate func(interface{}) bool) (prefix *Pair, suffix interface{})

NBreak is the linear-update variant of Break.

func (*Pair) NDelete ¶

func (list *Pair) NDelete(x interface{}) (result *Pair)

NDelete is the linear-update variant of Delete.

func (*Pair) NDeleteDuplicates ¶

func (list *Pair) NDeleteDuplicates() (result *Pair)

NDeleteDuplicates is the linear-update variant of DeleteDuplicates.

func (*Pair) NDropRight ¶

func (list *Pair) NDropRight(k int) (result *Pair)

NDropRight is the linear-update variant of DropRight.

func (*Pair) NFilter ¶

func (list *Pair) NFilter(predicate func(x interface{}) bool) (result *Pair)

NFilter is the linear-update variant of Filter.

func (*Pair) NFilterMap ¶

func (list *Pair) NFilterMap(f func(element interface{}) (interface{}, bool)) (result *Pair)

NFilterMap is the linear-update variant of FilterMap.

func (*Pair) NMap ¶

func (list *Pair) NMap(f func(element interface{}) interface{}) (result *Pair)

NMap is the linear-update variant of Map.

func (*Pair) NPartition ¶

func (list *Pair) NPartition(predicate func(x interface{}) bool) (in, out *Pair)

NPartition is the linear-update variant of Partition.

func (*Pair) NRemove ¶

func (list *Pair) NRemove(predicate func(x interface{}) bool) (result *Pair)

NRemove is the linear-update variant of Remove.

func (*Pair) NReverse ¶

func (list *Pair) NReverse() (result *Pair)

NReverse is the linear-update variant of Reverse. The list must be a proper list.

func (*Pair) NReverseLast ¶

func (list *Pair) NReverseLast() (result, last *Pair)

NReverseLast is the linear-update variant of ReverseLast.

func (*Pair) NSpan ¶

func (list *Pair) NSpan(predicate func(interface{}) bool) (prefix *Pair, suffix interface{})

NSpan is the linear-update variant of Span.

func (*Pair) NSplitAt ¶

func (list *Pair) NSplitAt(k int) (prefix *Pair, suffix interface{})

NSplitAt is the linear-update variant of SplitAt.

func (*Pair) NTake ¶

func (list *Pair) NTake(k int) (result *Pair)

NTake is the linear-update variant of Take.

If x is circular, NTake may return a shorter-than-expected list.

func (*Pair) NTakeWhile ¶

func (list *Pair) NTakeWhile(predicate func(interface{}) bool) (result *Pair)

NTakeWhile is the linear-update variant of TakeWhile.

func (*Pair) NonCircularLength ¶

func (list *Pair) NonCircularLength() (result int, nonCircular bool)

NonCircularLength returns the length of the argument and true if list is a proper list. If list is circular, though, NonCircularLength returns -1 and false.

The length of a proper list is a non-negative integer n such that Cdr applied n times to the list produces the empty list.

func (*Pair) PairFold ¶

func (list *Pair) PairFold(f func(intermediate interface{}, sublist *Pair) interface{}, init interface{}) (result interface{})

PairFold is analogous to Fold, but f is applied to successive sublists of the list, rather than successive elements -- that is, f is applied to the pairs making up the list, giving this recursion:

list.PairFold(f, init)  == { tail := list; list.Cdr.PairFold(f, f(init, tail)) }
Nil().PairFold(f, init) == init

The list argument must be finite. The f function may reliably assign to the Cdr of each pair it is given without altering the sequence of execution.

Example:

// Destructively reverse a list.
list.PairFold(func(tail interface{}, pair *Pair) interface{} {
  pair.Cdr = tail
  return pair
}, Nil())

func (*Pair) PairFoldRight ¶

func (list *Pair) PairFoldRight(f func(intermediate interface{}, sublist *Pair) interface{}, init interface{}) (result interface{})

PairFoldRight holds the same relationship with FoldRight that PairFold holds with Fold.

PairFoldRight obeys the recursion:

list.PairFoldRight(f, init)  == f(list.Cdr.PairFoldRight(f, init), list)
Nil().PairFoldRight(f, init) == init

Example:

func cons(tail interface{}, pair *Pair) interface{} {
  return NewPair(pair, tail)
}

List(1, 2, 3).PairFoldRight(cons, Nil()) => ((1 2 3) (2 3) (3))

The list argument must be finite.

func (*Pair) PairForEach ¶

func (list *Pair) PairForEach(f func(sublist *Pair))

PairForEach is like ForEach, but f is applied to successive sublists of the argument list. That is, f is applied to the cons cells of the list, rather than the list's elements. These applications occur in left-to-right order.

The f function may reliably assign to the Cdr of the pairs it is given without altering the sequence of execution.

List(1, 2, 3).PairForEach(func (x interface{}) { fmt.Println(x) }) =>
   (1 2 3)
   (2 3)
   (3)

The list argument must be finite.

func (*Pair) Partition ¶

func (list *Pair) Partition(predicate func(x interface{}) bool) (in, out *Pair)

Partition partitions the elements of list with predicate pred, and returns two values: the list of in-elements and the list of out-elements. The lists are not disordered -- elements occur in the result lists in the same order as they occur in the argument list. The dynamic order in which the various applications of predicate are made is not specified. One of the returned lists may share a common tail with the argument list.

func isString(x interface{}) bool {
  _, ok := x.(string)
  return ok
}

list.List("one", 2, 3, "four", "five", 6).Partition(isString) =>
   ("one" "four" "five")
   (2 3 6)

func (*Pair) Reduce ¶

func (list *Pair) Reduce(f func(intermediate, element interface{}) interface{}, init interface{}) (result interface{})

Reduce is a variant of Fold.

init should be a "right identity" of the function f -- that is, for any value x acceptable to f, f(init, x) == x.

Reduce has the following definition:

If list == Nil(), return init;
Otherwise, return list.Cdr.Fold(f, list.Car)

...in other words, we compute list.Fold(f, init)

Note that init is used only in the empy-list case. You typically use Reduce when applying f is expensive and you'd like to avoid the extra application incurred when Fold applies f to the head of list and the identity value, redundantly producing the same value passed in to f. For example, if f involves searching a file directory or performing a database query, this can be significant. In general, however, Fold is useful in many contexts where Reduce is not (consider the examples given in the Fold documentation -- only one of them uses a function with a right identity. The others may not be performed with Reduce).

func max(x, y interface{}) interface{} {
  if x.(int) > y.(int) {
    return x
  }
  return y
}

// Take the max of a list of non-negative integers.
nums.Reduce(max, 0)

func (*Pair) ReduceRight ¶

func (list *Pair) ReduceRight(f func(intermediate, element interface{}) interface{}, init interface{}) (result interface{})

ReduceRight is the fold-right variant of Reduce.

It obeys the following definition:

Nil().ReduceRight(f, init) == init
List(e_1).ReduceRight(f, init) == f(init, e_1) == e_1
List(e_1, e_2, ...).ReduceRight(f, init) == f(List(e_2, ...).Reduce(f, init), e_1)

...in other words, we compute list.FoldRight(f, init)

func append(intermediate, element interface{}) interface{} {
  return Append(intermediate.(*Pair), element.(*Pair))
}

listOfLists.ReduceRight(append, Nil())

func (*Pair) Ref ¶

func (list *Pair) Ref(n int) (result interface{})

Ref returns the nth element of list.

(This is the same as the Car of list.Drop(n).) Ref panics if n >= l, where l is the length of list.

func (*Pair) Remove ¶

func (list *Pair) Remove(predicate func(x interface{}) bool) (result *Pair)

Remove returns list without the elements that satisfy predicate:

func (list *Pair) Remove(predicate func(x interface{}) bool) *Pair {
  return list.Filter(func (x interface{}) bool {return !predicate(x)})
}

The list is not disordered -- elements that appear in the result list occur in the same order as they occur in the argument list. The returned list may share a common tail with the argument list. The dynamic order in which the various applications of predicate are made is not specified.

func even(x interface{}) bool {
  return x.(int)%2 == 0
}

list.List(0, 7, 8, 8, 43, -4).Remove(even) => (7 43)

func (*Pair) Reverse ¶

func (list *Pair) Reverse() (result *Pair)

Reverse returns a newly allocated list consisting of the elements of list in reverse order. The list must be a proper list.

func (*Pair) ReverseLast ¶

func (list *Pair) ReverseLast() (result, last *Pair)

ReverseLast is like Reverse, except that both the resulting list as well as the last pair of the resulting list is returned. This enables setting the Cdr of the last pair to a value other than Nil().

func (*Pair) Span ¶

func (list *Pair) Span(predicate func(interface{}) bool) (prefix *Pair, suffix interface{})

Span splits the list into the longest initial prefix whose elements all satisfy predicate, and the remaining tail.

func even(x interface{}) bool {
  return x.(int)%2 == 0
}

List(2, 18, 3, 10, 22, 9).Span(even) =>
  (2 18)
  (3 10 22 9)

func (*Pair) SplitAt ¶

func (list *Pair) SplitAt(k int) (prefix *Pair, suffix interface{})

SplitAt splits the list at index k, returning a list of the first k elements, and the remaining tail.

func (*Pair) String ¶

func (list *Pair) String() string

func (*Pair) Take ¶

func (list *Pair) Take(k int) (result *Pair)

Take returns the first k elements of the list.

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

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

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

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

If the argument list is a list of non-zero length, Take is guaranteed to return a freshly-allocated list, even in the case where the entire list is taken.

func (*Pair) TakeRight ¶

func (list *Pair) TakeRight(k int) (result interface{})

TakeRight returns the last k elements of list.

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

list may be any finite list, either proper or dotted.

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

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

Append(x.DropRight(k), x.TakeRight(k)) => x

TakeRight's return value is guaranteed to share a common tail with list.

func (*Pair) TakeWhile ¶

func (list *Pair) TakeWhile(predicate func(interface{}) bool) (result *Pair)

TakeWhile returns the longest initial prefix of list whose elements all satisfy predicate.

func even(x interface{}) bool {
  return x.(int)%2 == 0
}

List(2, 18, 3, 10, 22, 9).TakeWhile(even) => (2 18)

func (*Pair) ToSlice ¶

func (list *Pair) ToSlice() (result []interface{})

ToSlice uses Go's reflect package to convert the list to a slice.

If you need a slice of a particular type, use AppendToSlice to append to a nil value of that slice type instead.

func (*Pair) Unzip ¶

func (list *Pair) Unzip(n int) (result []*Pair)

Unzip takes a list, which must contain at least n elements, and returns a slice of length n of lists. The first result list contains the first element of the list, the second result list contains the second element the list, and so on.

List(1, "one").Unzip(2) => [(1), ("one")]

func (*Pair) Zip ¶

func (list *Pair) Zip() (result *Pair)

Zip returns a list of the same length, each element of which is a one-element list comprised of the corresponding elements from list. The list must be finite.

List(1, 2, 3).Zip() => ((1) (2) (3))