Lazy Lazy

Wraps an object and returns a Sequence. For null or undefined, simply returns an empty sequence (see Lazy.strict for a stricter implementation).

• For arrays, Lazy will create a sequence comprising the elements in the array (an ArrayLikeSequence).
• For objects, Lazy will create a sequence of key/value pairs (an ObjectLikeSequence).
• For strings, Lazy will create a sequence of characters (a StringLikeSequence).

function Lazy(source) { /*...*/ }

function Lazy(source) {
  if (isArray(source)) {
    return new ArrayWrapper(source);

  } else if (typeof source === "string") {
    return new StringWrapper(source);

  } else if (source instanceof Sequence) {
    return source;
  }

  if (Lazy.extensions) {
    var extensions = Lazy.extensions, length = extensions.length, result;
    while (!result && length--) {
      result = extensions[length](source);
    }
    if (result) {
      return result;
    }
  }

  return new ObjectWrapper(source);
}

Lazy([1, 2, 4])       // instanceof Lazy.ArrayLikeSequence
Lazy({ foo: "bar" })  // instanceof Lazy.ObjectLikeSequence
Lazy("hello, world!") // instanceof Lazy.StringLikeSequence
Lazy()                // sequence: []
Lazy(null)            // sequence: []

createWrapper Lazy.createWrapper

Defines a wrapper for custom StreamLikeSequences. This is useful if you want a way to handle a stream of events as a sequence, but you can't use Lazy's existing interface (i.e., you're wrapping an object from a library with its own custom events).

This method defines a factory: that is, it produces a function that can be used to wrap objects and return a Sequence. Hopefully the example will make this clear.

Lazy.createWrapper = function(initializer) { /*...*/ }

Lazy.createWrapper = function createWrapper(initializer) {
  var ctor = function() {
    this.listeners = [];
  };

  ctor.prototype = Object.create(StreamLikeSequence.prototype);

  ctor.prototype.each = function(listener) {
    this.listeners.push(listener);
  };

  ctor.prototype.emit = function(data) {
    var listeners = this.listeners;

    for (var len = listeners.length, i = len - 1; i >= 0; --i) {
      if (listeners[i](data) === false) {
        listeners.splice(i, 1);
      }
    }
  };

  return function() {
    var sequence = new ctor();
    initializer.apply(sequence, arguments);
    return sequence;
  };
}

var factory = Lazy.createWrapper(function(eventSource) {
  var sequence = this;

  eventSource.handleEvent(function(data) {
    sequence.emit(data);
  });
});

var eventEmitter = {
  triggerEvent: function(data) {
    eventEmitter.eventHandler(data);
  },
  handleEvent: function(handler) {
    eventEmitter.eventHandler = handler;
  },
  eventHandler: function() {}
};

var events = [];

factory(eventEmitter).each(function(e) {
  events.push(e);
});

eventEmitter.triggerEvent('foo');
eventEmitter.triggerEvent('bar');

events // => ['foo', 'bar']

generate Lazy.generate

Creates a GeneratedSequence using the specified generator function and (optionally) length.

Lazy.generate = function(generatorFn, length) { /*...*/ }

Lazy.generate = function generate(generatorFn, length) {
  return new GeneratedSequence(generatorFn, length);
}

var randomNumbers = Lazy.generate(Math.random);
var countingNumbers = Lazy.generate(function(i) { return i + 1; }, 5);

randomNumbers          // instanceof Lazy.GeneratedSequence
randomNumbers.length() // => undefined
countingNumbers          // sequence: [1, 2, 3, 4, 5]
countingNumbers.length() // => 5

range Lazy.range

Creates a sequence from a given starting value, up to a specified stopping value, incrementing by a given step. Invalid values for any of these arguments (e.g., a step of 0) result in an empty sequence.

Lazy.range = function() { /*...*/ }

Lazy.range = function range() {
  var start = arguments.length > 1 ? arguments[0] : 0,
      stop  = arguments.length > 1 ? arguments[1] : arguments[0],
      step  = arguments.length > 2 && arguments[2];

  if (step === false) {
    step = stop > start ? 1 : -1;
  }

  if (step === 0) {
    return Lazy([]);
  }

  return Lazy.generate(function(i) { return start + (step * i); })
    .take(Math.ceil((stop - start) / step));
}

Lazy.range(3)         // sequence: [0, 1, 2]
Lazy.range(1, 4)      // sequence: [1, 2, 3]
Lazy.range(2, 10, 2)  // sequence: [2, 4, 6, 8]
Lazy.range(5, 1, 2)   // sequence: []
Lazy.range(5, 15, -2) // sequence: []
Lazy.range(3, 10, 3)  // sequence: [3, 6, 9]
Lazy.range(5, 2)      // sequence: [5, 4, 3]
Lazy.range(7, 2, -2)  // sequence: [7, 5, 3]
Lazy.range(3, 5, 0)   // sequence: []

repeat Lazy.repeat

Creates a sequence consisting of the given value repeated a specified number of times.

Lazy.repeat = function(value, count) { /*...*/ }

Lazy.repeat = function repeat(value, count) {
  return Lazy.generate(function() { return value; }, count);
}

Lazy.repeat("hi", 3)          // sequence: ["hi", "hi", "hi"]
Lazy.repeat("young")          // instanceof Lazy.GeneratedSequence
Lazy.repeat("young").length() // => undefined
Lazy.repeat("young").take(3)  // sequence: ["young", "young", "young"]

strict Lazy.strict

Provides a stricter version of Lazy which throws an error when attempting to wrap null, undefined, or numeric or boolean values as a sequence.

Lazy.strict = function() { /*...*/ }

Lazy.strict = function strict() {
  function StrictLazy(source) {
    if (source == null) {
      throw new Error("You cannot wrap null or undefined using Lazy.");
    }

    if (typeof source === "number" || typeof source === "boolean") {
      throw new Error("You cannot wrap primitive values using Lazy.");
    }

    return Lazy(source);
  };

  Lazy(Lazy).each(function(property, name) {
    StrictLazy[name] = property;
  });

  return StrictLazy;
}

var Strict = Lazy.strict();

Strict()                  // throws
Strict(null)              // throws
Strict(true)              // throws
Strict(5)                 // throws
Strict([1, 2, 3])         // instanceof Lazy.ArrayLikeSequence
Strict({ foo: "bar" })    // instanceof Lazy.ObjectLikeSequence
Strict("hello, world!")   // instanceof Lazy.StringLikeSequence

// Let's also ensure the static functions are still there.
Strict.range(3)           // sequence: [0, 1, 2]
Strict.generate(Date.now) // instanceof Lazy.GeneratedSequence

define Sequence.define

Create a new constructor function for a type inheriting from Sequence.

Sequence.define = function(methodName, overrides) { /*...*/ }

Sequence.define = function define(methodName, overrides) {
  if (!overrides || (!overrides.getIterator && !overrides.each)) {
    throw new Error("A custom sequence must implement *at least* getIterator or each!");
  }

  return defineSequenceType(Sequence, methodName, overrides);
}

// This sequence type logs every element to the specified logger as it
// iterates over it.
Lazy.Sequence.define("verbose", {
  init: function(logger) {
    this.logger = logger;
  },

  each: function(fn) {
    var logger = this.logger;
    return this.parent.each(function(e, i) {
      logger(e);
      return fn(e, i);
    });
  }
});

Lazy([1, 2, 3]).verbose(logger).each(Lazy.noop) // calls logger 3 times

async Sequence#async

Creates a sequence, with the same elements as this one, that will be iterated over asynchronously when calling each.

Sequence.async = function(interval) { /*...*/ }

Sequence.async = function async(interval) {
  return new AsyncSequence(this, interval);
}

Lazy([1, 2, 3]).async(100).each(fn) // calls fn 3 times asynchronously

chunk Sequence#chunk

Breaks this sequence into chunks (arrays) of a specified length.

Sequence.chunk = function(size) { /*...*/ }

Sequence.chunk = function chunk(size) {
  if (size < 1) {
    throw new Error("You must specify a positive chunk size.");
  }

  return new ChunkedSequence(this, size);
}

Lazy([]).chunk(2)        // sequence: []
Lazy([1, 2, 3]).chunk(2) // sequence: [[1, 2], [3]]
Lazy([1, 2, 3]).chunk(1) // sequence: [[1], [2], [3]]
Lazy([1, 2, 3]).chunk(4) // sequence: [[1, 2, 3]]
Lazy([1, 2, 3]).chunk(0) // throws

compact Sequence#compact

Creates a new sequence with the same elements as this one, except for all falsy values (false, 0, "", null, and undefined).

Sequence.compact = function() { /*...*/ }

Sequence.compact = function compact() {
  return this.filter(function(e) { return !!e; });
}

Lazy(["foo", null, "bar", undefined]).compact() // sequence: ["foo", "bar"]

concat Sequence#concat

Creates a new sequence with all of the elements of this one, plus those of the given array(s).

Sequence.concat = function(var_args) { /*...*/ }

Sequence.concat = function concat(var_args) {
  return new ConcatenatedSequence(this, arraySlice.call(arguments, 0));
}

var left  = [1, 2, 3];
var right = [4, 5, 6];

Lazy(left).concat(right)             // sequence: [1, 2, 3, 4, 5, 6]
Lazy(left).concat(Lazy(right))       // sequence: [1, 2, 3, 4, 5, 6]
Lazy(left).concat(right, [7, 8])     // sequence: [1, 2, 3, 4, 5, 6, 7, 8]
Lazy(left).concat([4, [5, 6]])       // sequence: [1, 2, 3, 4, [5, 6]]
Lazy(left).concat(Lazy([4, [5, 6]])) // sequence: [1, 2, 3, 4, [5, 6]]

consecutive Sequence#consecutive

Groups this sequence into consecutive (overlapping) segments of a specified length. If the underlying sequence has fewer elements than the specified length, then this sequence will be empty.

Sequence.consecutive = function(length) { /*...*/ }

Sequence.consecutive = function consecutive(count) {
  return new ConsecutiveSequence(this, count);
}

function sum(vals) { return Lazy(vals).sum(); }
var pairs = Lazy([1, 2, 3, 4]).consecutive(2);

// Make sure consecutive sequences are reusable.
pairs.map(sum) // => sequence: [3, 5, 7]
pairs.map(sum) // => sequence: [3, 5, 7]

Lazy([]).consecutive(2)        // => sequence: []
Lazy([1]).consecutive(2)       // => sequence: []
Lazy([1, 2]).consecutive(2)    // => sequence: [[1, 2]]
Lazy([1, 2, 3]).consecutive(2) // => sequence: [[1, 2], [2, 3]]
Lazy([1, 2, 3]).consecutive(0) // => sequence: [[]]
Lazy([1, 2, 3]).consecutive(1) // => sequence: [[1], [2], [3]]

contains Sequence#contains

Checks whether the given value is in this sequence.

Sequence.contains = function(value, equalityFn) { /*...*/ }

Sequence.contains = function contains(value, equalityFn) {
  return this.indexOf(value, equalityFn) !== -1;
}

var numbers = [5, 10, 15, 20];

Lazy(numbers).contains(15) // => true
Lazy(numbers).contains(13) // => false

countBy Sequence#countBy

Creates a new ObjectLikeSequence containing the unique keys of all the elements in this sequence, each paired with the number of elements in this sequence having that key.

Sequence.countBy = function(keyFn) { /*...*/ }

Sequence.countBy = function countBy(keyFn) {
  return new CountedSequence(this, keyFn);
}

function oddOrEven(x) {
  return x % 2 === 0 ? 'even' : 'odd';
}

var numbers = [1, 2, 3, 4, 5];

Lazy(numbers).countBy(oddOrEven)            // sequence: { odd: 3, even: 2 }
Lazy(numbers).countBy(oddOrEven).get("odd") // => 3
Lazy(numbers).countBy(oddOrEven).get("foo") // => undefined

dropWhile Sequence#dropWhile

aliases: skipWhile

Creates a new sequence comprising the elements from this sequence after those that satisfy some predicate. The sequence starts with the first element that does not match the predicate.

Sequence.dropWhile = function(predicate) { /*...*/ }

Sequence.dropWhile = function dropWhile(predicate) {
  return new DropWhileSequence(this, predicate);
}

each Sequence#each

aliases: forEach

Iterates over this sequence and executes a function for every element.

Sequence.each = function(fn) { /*...*/ }

Sequence.each = function each(fn) {
  var iterator = this.getIterator(),
      i = -1;

  while (iterator.moveNext()) {
    if (fn(iterator.current(), ++i) === false) {
      return false;
    }
  }

  return true;
}

Lazy([1, 2, 3, 4]).each(fn) // calls fn 4 times

equals Sequence#equals

Compare this to another sequence for equality.

Sequence.equals = function(other, equalityFn) { /*...*/ }

Sequence.equals = function equals(other, equalityFn) {
  if (!(other instanceof Sequence)) {
    return false;
  }

  var it  = this.getIterator(),
      oit = other.getIterator(),
      eq  = equalityFn || Lazy.equality;
  while (it.moveNext()) {
    if (!oit.moveNext()) {
      return false;
    }
    if (!eq(it.current(), oit.current())) {
      return false;
    }
  }
  return !oit.moveNext();
}

Lazy([1, 2]).equals(Lazy([1, 2]))   // => true
Lazy([1, 2]).equals(Lazy([2, 1]))   // => false
Lazy([1]).equals(Lazy([1, 2]))      // => false
Lazy([1, 2]).equals(Lazy([1]))      // => false
Lazy([]).equals(Lazy([]))           // => true
Lazy(['foo']).equals(Lazy(['foo'])) // => true
Lazy(['1']).equals(Lazy([1]))       // => false
Lazy([false]).equals(Lazy([0]))     // => false
Lazy([1, 2]).equals([1, 2])         // => false
Lazy([1, 2]).equals('[1, 2]')       // => false

every Sequence#every

aliases: all

Checks whether every element in this sequence satisfies a given predicate.

Sequence.every = function(predicate) { /*...*/ }

Sequence.every = function every(predicate) {
  predicate = createCallback(predicate);

  return this.each(function(e, i) {
    return !!predicate(e, i);
  });
}

var numbers = [1, 2, 3, 4, 5];

var objects = [{ foo: true }, { foo: false, bar: true }];

Lazy(numbers).every(isEven)     // => false
Lazy(numbers).every(isPositive) // => true
Lazy(objects).all('foo')        // => false
Lazy(objects).all('bar')        // => false

filter Sequence#filter

aliases: select

Creates a new sequence whose values are the elements of this sequence which satisfy the specified predicate.

Sequence.filter = function(filterFn) { /*...*/ }

Sequence.filter = function filter(filterFn) {
  return new FilteredSequence(this, createCallback(filterFn));
}

var numbers = [1, 2, 3, 4, 5, 6];

Lazy(numbers).filter(isEven) // sequence: [2, 4, 6]

function isEven(x) { return x % 2 === 0; }

var smArr = Lazy.range(10).toArray(),
    lgArr = Lazy.range(100).toArray();

Lazy(smArr).filter(isEven).each(Lazy.noop) // lazy - 10 elements
Lazy(lgArr).filter(isEven).each(Lazy.noop) // lazy - 100 elements
_.each(_.filter(smArr, isEven), _.noop)    // lodash - 10 elements
_.each(_.filter(lgArr, isEven), _.noop)    // lodash - 100 elements

find Sequence#find

aliases: detect

Seaches for the first element in the sequence satisfying a given predicate.

Sequence.find = function(predicate) { /*...*/ }

Sequence.find = function find(predicate) {
  return this.filter(predicate).first();
}

function divisibleBy3(x) {
  return x % 3 === 0;
}

var numbers = [5, 6, 7, 8, 9, 10];

Lazy(numbers).find(divisibleBy3) // => 6
Lazy(numbers).find(isNegative)   // => undefined

findWhere Sequence#findWhere

Returns the first element in this sequence with property names and values matching those of the specified object.

Sequence.findWhere = function(properties) { /*...*/ }

Sequence.findWhere = function findWhere(properties) {
  return this.where(properties).first();
}

var words = ["foo", "bar"];

Lazy(words).findWhere({ 0: "f" }); // => "foo"
Lazy(words).findWhere({ 0: "z" }); // => undefined

first Sequence#first

aliases: head take

Creates a new sequence comprising the first N elements from this sequence, OR (if N is undefined) simply returns the first element of this sequence.

Sequence.first = function(count) { /*...*/ }

Sequence.first = function first(count) {
  if (typeof count === "undefined") {
    return getFirst(this);
  }
  return new TakeSequence(this, count);
}

function powerOfTwo(exp) {
  return Math.pow(2, exp);
}

Lazy.generate(powerOfTwo).first()          // => 1
Lazy.generate(powerOfTwo).first(5)         // sequence: [1, 2, 4, 8, 16]
Lazy.generate(powerOfTwo).skip(2).first()  // => 4
Lazy.generate(powerOfTwo).skip(2).first(2) // sequence: [4, 8]

flatten Sequence#flatten

Creates a new sequence with every element from this sequence, and with arrays exploded so that a sequence of arrays (of arrays) becomes a flat sequence of values.

Sequence.flatten = function(shallow) { /*...*/ }

Sequence.flatten = function flatten(shallow) {
  return new FlattenedSequence(this, shallow);
}

Lazy([1, [2, 3], [4, [5]]]).flatten()     // sequence: [1, 2, 3, 4, 5]
Lazy([1, [2, 3], [4, [5]]]).flatten(true) // sequence: [1, 2, 3, 4, [5]]
Lazy([1, Lazy([2, 3])]).flatten()         // sequence: [1, 2, 3]

get Sequence#get

Returns the element at the specified index. Note that, for sequences that are not ArrayLikeSequences, this may require partially evaluating the sequence, iterating to reach the result. (In other words for such sequences this method is not O(1).)

Sequence.get = function(i) { /*...*/ }

Sequence.get = function get(i) {
  var element;
  this.each(function(e, index) {
    if (index === i) {
      element = e;
      return false;
    }
  });
  return element;
}

getIterator Sequence#getIterator

Creates an Iterator object with two methods, moveNext -- returning true or false -- and current -- returning the current value.

This method is used when asynchronously iterating over sequences. Any type inheriting from Sequence must implement this method or it can't support asynchronous iteration.

Note that this method is not intended to be used directly by application code. Rather, it is intended as a means for implementors to potentially define custom sequence types that support either synchronous or asynchronous iteration.

Sequence.getIterator = function() { /*...*/ }

Sequence.getIterator = function getIterator() {
  return new Iterator(this);
}

var iterator = Lazy([1, 2]).getIterator();

iterator.moveNext(); // => true
iterator.current();  // => 1
iterator.moveNext(); // => true
iterator.current();  // => 2
iterator.moveNext(); // => false

groupBy Sequence#groupBy

Creates a new ObjectLikeSequence comprising the elements in this one, grouped together according to some key. The value associated with each key in the resulting object-like sequence is an array containing all of the elements in this sequence with that key.

Sequence.groupBy = function(keyFn, valFn) { /*...*/ }

Sequence.groupBy = function groupBy(keyFn, valFn) {
  return new GroupedSequence(this, keyFn, valFn);
}

function oddOrEven(x) {
  return x % 2 === 0 ? 'even' : 'odd';
}
function square(x) {
  return x*x;
}

var numbers = [1, 2, 3, 4, 5];

Lazy(numbers).groupBy(oddOrEven)                     // sequence: { odd: [1, 3, 5], even: [2, 4] }
Lazy(numbers).groupBy(oddOrEven).get("odd")          // => [1, 3, 5]
Lazy(numbers).groupBy(oddOrEven).get("foo")          // => undefined
Lazy(numbers).groupBy(oddOrEven, square).get("even") // => [4, 16]

Lazy([
  { name: 'toString' },
  { name: 'toString' }
]).groupBy('name');
// => sequence: {
  'toString': [
    { name: 'toString' },
    { name: 'toString' }
  ]
}

indexBy Sequence#indexBy

Creates a new ObjectLikeSequence comprising the elements in this one, indexed according to some key.

Sequence.indexBy = function(keyFn, valFn) { /*...*/ }

Sequence.indexBy = function(keyFn, valFn) {
  return new IndexedSequence(this, keyFn, valFn);
}

var people = [
  { name: 'Bob', age: 25 },
  { name: 'Fred', age: 34 }
];

var bob  = people[0],
    fred = people[1];

Lazy(people).indexBy('name')        // sequence: { 'Bob': bob, 'Fred': fred }
Lazy(people).indexBy('name', 'age') // sequence: { 'Bob': 25, 'Fred': 34 }

indexOf Sequence#indexOf

Performs (at worst) a linear search from the head of this sequence, returning the first index at which the specified value is found.

Sequence.indexOf = function(value, equalityFn) { /*...*/ }

Sequence.indexOf = function indexOf(value, equalityFn) {
  var eq = equalityFn || Lazy.equality,
      foundIndex = -1;

  this.each(function(e, i) {
    if (eq(e, value)) {
      foundIndex = i;
      return false;
    }
  });
  return foundIndex;
}

function reciprocal(x) { return 1 / x; }

Lazy(["foo", "bar", "baz"]).indexOf("bar")   // => 1
Lazy([1, 2, 3]).indexOf(4)                   // => -1
Lazy([1, 2, 3]).map(reciprocal).indexOf(0.5) // => 1

initial Sequence#initial

Creates a new sequence comprising all but the last N elements of this sequence.

Sequence.initial = function(count) { /*...*/ }

Sequence.initial = function initial(count) {
  return new InitialSequence(this, count);
}

Lazy([1, 2, 3, 4]).initial()                    // sequence: [1, 2, 3]
Lazy([1, 2, 3, 4]).initial(2)                   // sequence: [1, 2]
Lazy([1, 2, 3]).filter(Lazy.identity).initial() // sequence: [1, 2]

intersection Sequence#intersection

Creates a new sequence with all the elements of this sequence that also appear among the specified arguments.

Sequence.intersection = function(var_args) { /*...*/ }

Sequence.intersection = function intersection(var_args) {
  if (arguments.length === 1 && isArray(arguments[0])) {
    return new SimpleIntersectionSequence(this, (/** @type {Array} */ var_args));
  } else {
    return new IntersectionSequence(this, arraySlice.call(arguments, 0));
  }
}

Lazy(["foo", "bar"]).intersection([])             // sequence: []
Lazy(["foo", "bar"]).intersection(["bar", "baz"]) // sequence: ["bar"]
Lazy(["a", "a"]).intersection(["a"])              // sequence: ["a"]
Lazy(["a"]).intersection(["a", "a"])              // sequence: ["a"]
Lazy(["a", "a"]).intersection(["a", "a"])         // sequence: ["a"]
Lazy(["a", "a"]).intersection(["a"], ["a"])       // sequence: ["a"]

invoke Sequence#invoke

Creates a new sequence whose values are calculated by invoking the specified function on each element in this sequence.

Sequence.invoke = function(methodName) { /*...*/ }

Sequence.invoke = function invoke(methodName) {
  return this.map(function(e) {
    return e[methodName]();
  });
}

function Person(first, last) {
  this.fullName = function fullName() {
    return first + " " + last;
  };
}

var people = [
  new Person("Dan", "Tao"),
  new Person("Bob", "Smith")
];

Lazy(people).invoke("fullName") // sequence: ["Dan Tao", "Bob Smith"]

isEmpty Sequence#isEmpty

Checks whether the sequence has no elements.

Sequence.isEmpty = function() { /*...*/ }

Sequence.isEmpty = function isEmpty() {
  return !this.any();
}

Lazy([]).isEmpty()        // => true
Lazy([1, 2, 3]).isEmpty() // => false

join Sequence#join

aliases: toString

Creates a string from joining together all of the elements in this sequence, separated by the given delimiter.

Sequence.join = function(delimiter) { /*...*/ }

Sequence.join = function join(delimiter) {
  delimiter = typeof delimiter === "undefined" ? "," : String(delimiter);

  var i = -1;
  return this.reduce(function(str, e) {
    if (++i > 0) {
      str += delimiter;
    }
    return str + e;
  }, "");
}

function toParam(v, k) {
  return k + '=' + v;
}

Lazy([6, 29, 1984]).join("/")  // => "6/29/1984"
Lazy(["a", "b", "c"]).join()   // => "a,b,c"
Lazy(["a", "b", "c"]).join("") // => "abc"
Lazy([1, 2, 3]).join()         // => "1,2,3"
Lazy([1, 2, 3]).join("")       // => "123"
Lazy(["", "", ""]).join(",")   // => ",,"
Lazy([1, 2]).join(0)           // => "102"
Lazy(["cons", "d"]).join(true) // => "construed"
Lazy({foo: 1, bar: 2}).values().join()        // "1,2"
Lazy({foo: 1, bar: 2}).keys().join()          // "foo,bar"
Lazy({foo: 1, bar: 2}).map(toParam).join('&') // 'foo=1&bar=2'

last Sequence#last

Creates a new sequence comprising the last N elements of this sequence, OR (if N is undefined) simply returns the last element of this sequence.

Sequence.last = function(count) { /*...*/ }

Sequence.last = function last(count) {
  if (typeof count === "undefined") {
    return this.reverse().first();
  }
  return this.reverse().take(count).reverse();
}

Lazy([1, 2, 3]).last()                 // => 3
Lazy([1, 2, 3]).last(2)                // sequence: [2, 3]
Lazy([1, 2, 3]).filter(isEven).last(2) // sequence: [2]

lastIndexOf Sequence#lastIndexOf

Performs (at worst) a linear search from the tail of this sequence, returning the last index at which the specified value is found.

Sequence.lastIndexOf = function(value) { /*...*/ }

Sequence.lastIndexOf = function lastIndexOf(value, equalityFn) {
  var reversed = this.getIndex().reverse(),
      index    = reversed.indexOf(value, equalityFn);
  if (index !== -1) {
    index = reversed.length() - index - 1;
  }
  return index;
}

Lazy(["a", "b", "c", "b", "a"]).lastIndexOf("b")    // => 3
Lazy([1, 2, 3]).lastIndexOf(0)                      // => -1
Lazy([2, 2, 1, 2, 4]).filter(isEven).lastIndexOf(2) // 2

map Sequence#map

aliases: collect

Creates a new sequence whose values are calculated by passing this sequence's elements through some mapping function.

Sequence.map = function(mapFn) { /*...*/ }

Sequence.map = function map(mapFn) {
  return new MappedSequence(this, createCallback(mapFn));
}

function addIndexToValue(e, i) { return e + i; }

Lazy([]).map(increment)              // sequence: []
Lazy([1, 2, 3]).map(increment)       // sequence: [2, 3, 4]
Lazy([1, 2, 3]).map(addIndexToValue) // sequence: [1, 3, 5]

function increment(x) { return x + 1; }

var smArr = Lazy.range(10).toArray(),
    lgArr = Lazy.range(100).toArray();

Lazy(smArr).map(increment).each(Lazy.noop) // lazy - 10 elements
Lazy(lgArr).map(increment).each(Lazy.noop) // lazy - 100 elements
_.each(_.map(smArr, increment), _.noop)    // lodash - 10 elements
_.each(_.map(lgArr, increment), _.noop)    // lodash - 100 elements

max Sequence#max

Gets the maximum value in the sequence.

Sequence.max = function(valueFn) { /*...*/ }

Sequence.max = function max(valueFn) {
  if (typeof valueFn !== "undefined") {
    return this.maxBy(valueFn);
  }

  return this.reduce(function(prev, current, i) {
    if (typeof prev === "undefined") {
      return current;
    }
    return current > prev ? current : prev;
  });
}

function reverseDigits(x) {
  return Number(String(x).split('').reverse().join(''));
}

Lazy([]).max()                              // => undefined
Lazy([1]).max()                             // => 1
Lazy([1, 2]).max()                          // => 2
Lazy([2, 1]).max()                          // => 2
Lazy([6, 18, 2, 48, 29]).max()              // => 48
Lazy([6, 18, 2, 48, 29]).max(reverseDigits) // => 29
Lazy(['b', 'c', 'a']).max()                 // => 'c'

memoize Sequence#memoize

Provides an indexed, memoized view into the sequence. This will cache the result whenever the sequence is first iterated, so that subsequent iterations will access the same element objects.

Sequence.memoize = function() { /*...*/ }

Sequence.memoize = function memoize() {
  return new MemoizedSequence(this);
}

function createObject() { return new Object(); }

var plain    = Lazy.generate(createObject, 10),
    memoized = Lazy.generate(createObject, 10).memoize();

plain.toArray()[0] === plain.toArray()[0];       // => false
memoized.toArray()[0] === memoized.toArray()[0]; // => true

min Sequence#min

Gets the minimum value in the sequence.

Sequence.min = function(valueFn) { /*...*/ }

Sequence.min = function min(valueFn) {
  if (typeof valueFn !== "undefined") {
    return this.minBy(valueFn);
  }

  return this.reduce(function(prev, current, i) {
    if (typeof prev === "undefined") {
      return current;
    }
    return current < prev ? current : prev;
  });
}

function negate(x) { return x * -1; }

Lazy([]).min()                       // => undefined
Lazy([1]).min()                      // => 1
Lazy([1, 2]).min()                   // => 1
Lazy([2, 1]).min()                   // => 1
Lazy([6, 18, 2, 49, 34]).min()       // => 2
Lazy([6, 18, 2, 49, 34]).min(negate) // => 49
Lazy(['b', 'a', 'c']).min()          // => 'a'

none Sequence#none

Checks whether NO elements in this sequence satisfy the given predicate (the opposite of Sequence#all, basically).

Sequence.none = function(predicate) { /*...*/ }

Sequence.none = function none(predicate) {
  return !this.any(predicate);
}

var numbers = [1, 2, 3, 4, 5];

Lazy(numbers).none()           // => false
Lazy(numbers).none(isEven)     // => false
Lazy(numbers).none(isNegative) // => true
Lazy([]).none(isEven)          // => true
Lazy([]).none(isNegative)      // => true
Lazy([]).none()                // => true

ofType Sequence#ofType

Creates a new sequence whose values have the specified type, as determined by the typeof operator.

Sequence.ofType = function(type) { /*...*/ }

Sequence.ofType = function ofType(type) {
  return this.filter(function(e) { return typeof e === type; });
}

Lazy([1, 2, 'foo', 'bar']).ofType('number')  // sequence: [1, 2]
Lazy([1, 2, 'foo', 'bar']).ofType('string')  // sequence: ['foo', 'bar']
Lazy([1, 2, 'foo', 'bar']).ofType('boolean') // sequence: []

pluck Sequence#pluck

Creates a new sequence whose values are calculated by accessing the specified property from each element in this sequence.

Sequence.pluck = function(propertyName) { /*...*/ }

Sequence.pluck = function pluck(property) {
  return this.map(property);
}

var people = [
  { first: "Dan", last: "Tao" },
  { first: "Bob", last: "Smith" }
];

Lazy(people).pluck("last") // sequence: ["Tao", "Smith"]

reduce Sequence#reduce

aliases: inject foldl

Aggregates a sequence into a single value according to some accumulator function.

For an asynchronous sequence, instead of immediately returning a result (which it can't, obviously), this method returns an AsyncHandle whose onComplete method can be called to supply a callback to handle the final result once iteration has completed.

Sequence.reduce = function(aggregator, memo) { /*...*/ }

Sequence.reduce = function reduce(aggregator, memo) {
  if (arguments.length < 2) {
    return this.tail().reduce(aggregator, this.head());
  }

  var eachResult = this.each(function(e, i) {
    memo = aggregator(memo, e, i);
  });

  // TODO: Think of a way more efficient solution to this problem.
  if (eachResult instanceof AsyncHandle) {
    return eachResult.then(function() { return memo; });
  }

  return memo;
}

function multiply(x, y) { return x * y; }

var numbers = [1, 2, 3, 4];

Lazy(numbers).reduce(multiply)    // => 24
Lazy(numbers).reduce(multiply, 5) // => 120

reduceRight Sequence#reduceRight

aliases: foldr

Aggregates a sequence, from the tail, into a single value according to some accumulator function.

Sequence.reduceRight = function(aggregator, memo) { /*...*/ }

Sequence.reduceRight = function reduceRight(aggregator, memo) {
  if (arguments.length < 2) {
    return this.initial(1).reduceRight(aggregator, this.last());
  }

  // This bothers me... but frankly, calling reverse().reduce() is potentially
  // going to eagerly evaluate the sequence anyway; so it's really not an issue.
  var indexed = this.getIndex(),
      i = indexed.length() - 1;
  return indexed.reverse().reduce(function(m, e) {
    return aggregator(m, e, i--);
  }, memo);
}

function append(s1, s2) {
  return s1 + s2;
}

function isVowel(str) {
  return "aeiou".indexOf(str) !== -1;
}

Lazy("abcde").reduceRight(append)                 // => "edcba"
Lazy("abcde").filter(isVowel).reduceRight(append) // => "ea"

reject Sequence#reject

Creates a new sequence whose values exclude the elements of this sequence identified by the specified predicate.

Sequence.reject = function(rejectFn) { /*...*/ }

Sequence.reject = function reject(rejectFn) {
  rejectFn = createCallback(rejectFn);
  return this.filter(function(e) { return !rejectFn(e); });
}

Lazy([1, 2, 3, 4, 5]).reject(isEven)              // sequence: [1, 3, 5]
Lazy([{ foo: 1 }, { bar: 2 }]).reject('foo')      // sequence: [{ bar: 2 }]
Lazy([{ foo: 1 }, { foo: 2 }]).reject({ foo: 2 }) // sequence: [{ foo: 1 }]

rest Sequence#rest

aliases: skip tail rest

Creates a new sequence comprising all but the first N elements of this sequence.

Sequence.rest = function(count) { /*...*/ }

Sequence.rest = function rest(count) {
  return new DropSequence(this, count);
}

Lazy([1, 2, 3, 4]).rest()  // sequence: [2, 3, 4]
Lazy([1, 2, 3, 4]).rest(0) // sequence: [1, 2, 3, 4]
Lazy([1, 2, 3, 4]).rest(2) // sequence: [3, 4]
Lazy([1, 2, 3, 4]).rest(5) // sequence: []

reverse Sequence#reverse

Creates a new sequence with the same elements as this one, but to be iterated in the opposite order.

Note that in some (but not all) cases, the only way to create such a sequence may require iterating the entire underlying source when each is called.

Sequence.reverse = function() { /*...*/ }

Sequence.reverse = function reverse() {
  return new ReversedSequence(this);
}

Lazy([1, 2, 3]).reverse() // sequence: [3, 2, 1]
Lazy([]).reverse()        // sequence: []

shuffle Sequence#shuffle

Creates a new sequence with the same elements as this one, in a randomized order.

Sequence.shuffle = function() { /*...*/ }

Sequence.shuffle = function shuffle() {
  return new ShuffledSequence(this);
}

Lazy([1, 2, 3, 4, 5]).shuffle().value() // =~ [1, 2, 3, 4, 5]
Lazy([]).shuffle().value()              // => []
Lazy([1]).shuffle().each(Lazy.noop)     // => true
Lazy([]).shuffle().each(Lazy.noop)      // => true

size Sequence#size

Gets the number of elements in the sequence. In some cases, this may require eagerly evaluating the sequence.

Sequence.size = function() { /*...*/ }

Sequence.size = function size() {
  return this.getIndex().length();
}

Lazy([1, 2, 3]).size();                 // => 3
Lazy([1, 2]).map(Lazy.identity).size(); // => 2
Lazy([1, 2, 3]).reject(isEven).size();  // => 2
Lazy([1, 2, 3]).take(1).size();         // => 1
Lazy({ foo: 1, bar: 2 }).size();        // => 2
Lazy('hello').size();                   // => 5

some Sequence#some

aliases: any

Checks whether at least one element in this sequence satisfies a given predicate (or, if no predicate is specified, whether the sequence contains at least one element).

Sequence.some = function(predicate) { /*...*/ }

Sequence.some = function some(predicate) {
  predicate = createCallback(predicate, true);

  var success = false;
  this.each(function(e) {
    if (predicate(e)) {
      success = true;
      return false;
    }
  });
  return success;
}

var numbers = [1, 2, 3, 4, 5];

Lazy(numbers).some()           // => true
Lazy(numbers).some(isEven)     // => true
Lazy(numbers).some(isNegative) // => false
Lazy([]).some()                // => false

sort Sequence#sort

Creates a new sequence with the same elements as this one, but ordered using the specified comparison function.

This has essentially the same behavior as calling Array#sort, but obviously instead of modifying the collection it returns a new Sequence object.

Sequence.sort = function(sortFn, descending) { /*...*/ }

Sequence.sort = function sort(sortFn, descending) {
  sortFn || (sortFn = compare);
  if (descending) { sortFn = reverseArguments(sortFn); }
  return new SortedSequence(this, sortFn);
}

- 1 if the first is greater
- -1 if the second is greater
- 0 if the two values are the same

Lazy([5, 10, 1]).sort()                // sequence: [1, 5, 10]
Lazy(['foo', 'bar']).sort()            // sequence: ['bar', 'foo']
Lazy(['b', 'c', 'a']).sort(null, true) // sequence: ['c', 'b', 'a']
Lazy([5, 10, 1]).sort(null, true)      // sequence: [10, 5, 1]

// Sorting w/ custom comparison function
Lazy(['a', 'ab', 'aa', 'ba', 'b', 'abc']).sort(function compare(x, y) {
  if (x.length && (x.length !== y.length)) { return compare(x.length, y.length); }
  if (x === y) { return 0; }
  return x > y ? 1 : -1;
});
// => sequence: ['a', 'b', 'aa', 'ab', 'ba', 'abc']

sortBy Sequence#sortBy

Creates a new sequence with the same elements as this one, but ordered by the results of the given function.

You can pass:

• a string, to sort by the named property
• a function, to sort by the result of calling the function on each element

Sequence.sortBy = function(sortFn, descending) { /*...*/ }

Sequence.sortBy = function sortBy(sortFn, descending) {
  sortFn = createComparator(sortFn);
  if (descending) { sortFn = reverseArguments(sortFn); }
  return new SortedSequence(this, sortFn);
}

function population(country) {
  return country.pop;
}

function area(country) {
  return country.sqkm;
}

var countries = [
  { name: "USA", pop: 320000000, sqkm: 9600000 },
  { name: "Brazil", pop: 194000000, sqkm: 8500000 },
  { name: "Nigeria", pop: 174000000, sqkm: 924000 },
  { name: "China", pop: 1350000000, sqkm: 9700000 },
  { name: "Russia", pop: 143000000, sqkm: 17000000 },
  { name: "Australia", pop: 23000000, sqkm: 7700000 }
];

Lazy(countries).sortBy(population).last(3).pluck('name') // sequence: ["Brazil", "USA", "China"]
Lazy(countries).sortBy(area).last(3).pluck('name')       // sequence: ["USA", "China", "Russia"]
Lazy(countries).sortBy(area, true).first(3).pluck('name') // sequence: ["Russia", "China", "USA"]

var randoms = Lazy.generate(Math.random).take(100).toArray();

Lazy(randoms).sortBy(Lazy.identity).each(Lazy.noop) // lazy
_.each(_.sortBy(randoms, Lazy.identity), _.noop)    // lodash

sortedIndex Sequence#sortedIndex

Performs a binary search of this sequence, returning the lowest index where the given value is either found, or where it belongs (if it is not already in the sequence).

This method assumes the sequence is in sorted order and will fail otherwise.

Sequence.sortedIndex = function(value) { /*...*/ }

Sequence.sortedIndex = function sortedIndex(value) {
  var indexed = this.getIndex(),
      lower   = 0,
      upper   = indexed.length(),
      i;

  while (lower < upper) {
    i = (lower + upper) >>> 1;
    if (compare(indexed.get(i), value) === -1) {
      lower = i + 1;
    } else {
      upper = i;
    }
  }
  return lower;
}

Lazy([1, 3, 6, 9]).sortedIndex(3)                    // => 1
Lazy([1, 3, 6, 9]).sortedIndex(7)                    // => 3
Lazy([5, 10, 15, 20]).filter(isEven).sortedIndex(10) // => 0
Lazy([5, 10, 15, 20]).filter(isEven).sortedIndex(12) // => 1

sum Sequence#sum

Gets the sum of the numeric values in the sequence.

Sequence.sum = function(valueFn) { /*...*/ }

Sequence.sum = function sum(valueFn) {
  if (typeof valueFn !== "undefined") {
    return this.sumBy(valueFn);
  }

  return this.reduce(function(x, y) { return x + y; }, 0);
}

Lazy([]).sum()                     // => 0
Lazy([1, 2, 3, 4]).sum()           // => 10
Lazy([1.2, 3.4]).sum(Math.floor)   // => 4
Lazy(['foo', 'bar']).sum('length') // => 6

takeWhile Sequence#takeWhile

Creates a new sequence comprising the elements from the head of this sequence that satisfy some predicate. Once an element is encountered that doesn't satisfy the predicate, iteration will stop.

Sequence.takeWhile = function(predicate) { /*...*/ }

Sequence.takeWhile = function takeWhile(predicate) {
  return new TakeWhileSequence(this, predicate);
}

function lessThan(x) {
  return function(y) {
    return y < x;
  };
}

Lazy([1, 2, 3, 4]).takeWhile(lessThan(3)) // sequence: [1, 2]
Lazy([1, 2, 3, 4]).takeWhile(lessThan(0)) // sequence: []

tap Sequence#tap

Passes each element in the sequence to the specified callback during iteration. This is like Sequence#each, except that it can be inserted anywhere in the middle of a chain of methods to "intercept" the values in the sequence at that point.

Sequence.tap = function(callback) { /*...*/ }

Sequence.tap = function tap(callback) {
  return new TappedSequence(this, callback);
}

Lazy([1, 2, 3]).tap(fn).each(Lazy.noop); // calls fn 3 times

toArray Sequence#toArray

Creates an array snapshot of a sequence.

Note that for indefinite sequences, this method may raise an exception or (worse) cause the environment to hang.

Sequence.toArray = function() { /*...*/ }

Sequence.toArray = function toArray() {
  return this.reduce(function(arr, element) {
    arr.push(element);
    return arr;
  }, []);
}

Lazy([1, 2, 3]).toArray() // => [1, 2, 3]

toObject Sequence#toObject

Creates an object from a sequence of key/value pairs.

Sequence.toObject = function() { /*...*/ }

Sequence.toObject = function toObject() {
  return this.reduce(function(object, pair) {
    object[pair[0]] = pair[1];
    return object;
  }, {});
}

var details = [
  ["first", "Dan"],
  ["last", "Tao"],
  ["age", 29]
];

Lazy(details).toObject() // => { first: "Dan", last: "Tao", age: 29 }

union Sequence#union

Creates a new sequence with all the unique elements either in this sequence or among the specified arguments.

Sequence.union = function(var_args) { /*...*/ }

Sequence.union = function union(var_args) {
  return this.concat(var_args).uniq();
}

Lazy(["foo", "bar"]).union([])             // sequence: ["foo", "bar"]
Lazy(["foo", "bar"]).union(["bar", "baz"]) // sequence: ["foo", "bar", "baz"]

uniq Sequence#uniq

aliases: unique

Creates a new sequence with every unique element from this one appearing exactly once (i.e., with duplicates removed).

Sequence.uniq = function(keyFn) { /*...*/ }

Sequence.uniq = function uniq(keyFn) {
  return new UniqueSequence(this, keyFn);
}

Lazy([1, 2, 2, 3, 3, 3]).uniq() // sequence: [1, 2, 3]
Lazy([{ name: 'mike' }, 
    { name: 'sarah' }, 
    { name: 'mike' }
]).uniq('name')
// sequence: [{ name: 'mike' }, { name: 'sarah' }]

function randomOf(array) {
  return function() {
    return array[Math.floor(Math.random() * array.length)];
  };
}

var mostUnique = Lazy.generate(randomOf(_.range(100)), 100).toArray(),
    someUnique = Lazy.generate(randomOf(_.range(50)), 100).toArray(),
    mostDupes  = Lazy.generate(randomOf(_.range(5)), 100).toArray();

Lazy(mostUnique).uniq().each(Lazy.noop) // lazy - mostly unique elements
Lazy(someUnique).uniq().each(Lazy.noop) // lazy - some unique elements
Lazy(mostDupes).uniq().each(Lazy.noop)  // lazy - mostly duplicate elements
_.each(_.uniq(mostUnique), _.noop)      // lodash - mostly unique elements
_.each(_.uniq(someUnique), _.noop)      // lodash - some unique elements
_.each(_.uniq(mostDupes), _.noop)       // lodash - mostly duplicate elements

where Sequence#where

Creates a new sequence whose values are the elements of this sequence with property names and values matching those of the specified object.

Sequence.where = function(properties) { /*...*/ }

Sequence.where = function where(properties) {
  return this.filter(properties);
}

var people = [
  { first: "Dan", last: "Tao" },
  { first: "Bob", last: "Smith" }
];

Lazy(people).where({ first: "Dan" }) // sequence: [{ first: "Dan", last: "Tao" }]

var animals = ["dog", "cat", "mouse", "horse", "pig", "snake"];

Lazy(animals).where({ length: 3 }).each(Lazy.noop) // lazy
_.each(_.where(animals, { length: 3 }), _.noop)    // lodash

without Sequence#without

aliases: difference

Creates a new sequence with all the elements of this sequence that are not also among the specified arguments.

Sequence.without = function(var_args) { /*...*/ }

Sequence.without = function without(var_args) {
  return new WithoutSequence(this, arraySlice.call(arguments, 0));
}

Lazy([1, 2, 3, 4, 5]).without(2, 3)   // sequence: [1, 4, 5]
Lazy([1, 2, 3, 4, 5]).without([4, 5]) // sequence: [1, 2, 3]

zip Sequence#zip

Creates a new sequence by combining the elements from this sequence with corresponding elements from the specified array(s).

Sequence.zip = function(var_args) { /*...*/ }

Sequence.zip = function zip(var_args) {
  if (arguments.length === 1) {
    return new SimpleZippedSequence(this, (/** @type {Array} */ var_args));
  } else {
    return new ZippedSequence(this, arraySlice.call(arguments, 0));
  }
}

Lazy([1, 2]).zip([3, 4])     // sequence: [[1, 3], [2, 4]]
Lazy([]).zip([0])            // sequence: [[undefined, 0]]
Lazy([0]).zip([])            // sequence: [[0, undefined]]
Lazy([]).zip([1, 2], [3, 4]) // sequence: [[undefined, 1, 3], [undefined, 2, 4]]
Lazy([]).zip([1], [2, 3])    // sequence: [[undefined, 1, 2], [undefined, undefined, 3]]
Lazy([1, 2]).zip([3], [4])   // sequence: [[1, 3, 4], [2, undefined, undefined]]

var smArrL = Lazy.range(10).toArray(),
    smArrR = Lazy.range(10, 20).toArray(),
    lgArrL = Lazy.range(100).toArray(),
    lgArrR = Lazy.range(100, 200).toArray();

Lazy(smArrL).zip(smArrR).each(Lazy.noop) // lazy - zipping 10-element arrays
Lazy(lgArrL).zip(lgArrR).each(Lazy.noop) // lazy - zipping 100-element arrays
_.each(_.zip(smArrL, smArrR), _.noop)    // lodash - zipping 10-element arrays
_.each(_.zip(lgArrL, lgArrR), _.noop)    // lodash - zipping 100-element arrays

define ArrayLikeSequence.define

Create a new constructor function for a type inheriting from ArrayLikeSequence.

ArrayLikeSequence.define = function(methodName, overrides) { /*...*/ }

ArrayLikeSequence.define = function define(methodName, overrides) {
  if (!overrides || typeof overrides.get !== 'function') {
    throw new Error("A custom array-like sequence must implement *at least* get!");
  }

  return defineSequenceType(ArrayLikeSequence, methodName, overrides);
}

Lazy.ArrayLikeSequence.define("offset", {
  init: function(offset) {
    this.offset = offset;
  },

  get: function(i) {
    return this.parent.get((i + this.offset) % this.parent.length());
  }
});

Lazy([1, 2, 3]).offset(1) // sequence: [2, 3, 1]

concat ArrayLikeSequence#concat

An optimized version of Sequence#concat that returns another ArrayLikeSequence if the argument is an array.

ArrayLikeSequence.concat = function(var_args) { /*...*/ }

ArrayLikeSequence.concat = function concat(var_args) {
  if (arguments.length === 1 && isArray(arguments[0])) {
    return new IndexedConcatenatedSequence(this, (/** @type {Array} */ var_args));
  } else {
    return Sequence.prototype.concat.apply(this, arguments);
  }
}

Lazy([1, 2]).concat([3, 4]) // instanceof Lazy.ArrayLikeSequence
Lazy([1, 2]).concat([3, 4]) // sequence: [1, 2, 3, 4]

first ArrayLikeSequence#first

An optimized version of Sequence#first, which creates an ArrayLikeSequence so that the result still provides random access.

Lazy([1, 2, 3]).first(2) // instanceof Lazy.ArrayLikeSequence

get ArrayLikeSequence#get

Returns the element at the specified index.

ArrayLikeSequence.get = function(i) { /*...*/ }

ArrayLikeSequence.get = function get(i) {
  return this.parent.get(i);
}

function increment(x) { return x + 1; }

Lazy([1, 2, 3]).get(1)                // => 2
Lazy([1, 2, 3]).get(-1)               // => undefined
Lazy([1, 2, 3]).map(increment).get(1) // => 3

length ArrayLikeSequence#length

Returns the length of the sequence.

ArrayLikeSequence.length = function() { /*...*/ }

ArrayLikeSequence.length = function length() {
  return this.parent.length();
}

function increment(x) { return x + 1; }

Lazy([]).length()                       // => 0
Lazy([1, 2, 3]).length()                // => 3
Lazy([1, 2, 3]).map(increment).length() // => 3

map ArrayLikeSequence#map

An optimized version of Sequence#map, which creates an ArrayLikeSequence so that the result still provides random access.

Lazy([1, 2, 3]).map(Lazy.identity) // instanceof Lazy.ArrayLikeSequence

pop ArrayLikeSequence#pop

Returns a new sequence with the same elements as this one, minus the last element.

ArrayLikeSequence.pop = function() { /*...*/ }

ArrayLikeSequence.pop = function pop() {
  return this.initial();
}

Lazy([1, 2, 3]).pop() // sequence: [1, 2]
Lazy([]).pop()        // sequence: []

push ArrayLikeSequence#push

Returns a new sequence with the same elements as this one, plus the specified element at the end.

ArrayLikeSequence.push = function() { /*...*/ }

ArrayLikeSequence.push = function push(value) {
  return this.concat([value]);
}

Lazy([1, 2]).push(3) // sequence: [1, 2, 3]
Lazy([]).push(1)     // sequence: [1]

rest ArrayLikeSequence#rest

An optimized version of Sequence#rest, which creates an ArrayLikeSequence so that the result still provides random access.

Lazy([1, 2, 3]).rest() // instanceof Lazy.ArrayLikeSequence

reverse ArrayLikeSequence#reverse

An optimized version of Sequence#reverse, which creates an ArrayLikeSequence so that the result still provides random access.

Lazy([1, 2, 3]).reverse() // instanceof Lazy.ArrayLikeSequence

shift ArrayLikeSequence#shift

Returns a new sequence with the same elements as this one, minus the first element.

ArrayLikeSequence.shift = function() { /*...*/ }

ArrayLikeSequence.shift = function shift() {
  return this.drop();
}

Lazy([1, 2, 3]).shift() // sequence: [2, 3]
Lazy([]).shift()        // sequence: []

slice ArrayLikeSequence#slice

Returns a new sequence comprising the portion of this sequence starting from the specified starting index and continuing until the specified ending index or to the end of the sequence.

ArrayLikeSequence.slice = function(begin, end) { /*...*/ }

ArrayLikeSequence.slice = function slice(begin, end) {
  var length = this.length();

  if (begin < 0) {
    begin = length + begin;
  }

  var result = this.drop(begin);

  if (typeof end === "number") {
    if (end < 0) {
      end = length + end;
    }
    result = result.take(end - begin);
  }

  return result;
}

Lazy([1, 2, 3, 4, 5]).slice(0)     // sequence: [1, 2, 3, 4, 5]
Lazy([1, 2, 3, 4, 5]).slice(2)     // sequence: [3, 4, 5]
Lazy([1, 2, 3, 4, 5]).slice(2, 4)  // sequence: [3, 4]
Lazy([1, 2, 3, 4, 5]).slice(-1)    // sequence: [5]
Lazy([1, 2, 3, 4, 5]).slice(1, -1) // sequence: [2, 3, 4]
Lazy([1, 2, 3, 4, 5]).slice(0, 10) // sequence: [1, 2, 3, 4, 5]

unshift ArrayLikeSequence#unshift

Returns a new sequence with the same elements as this one, plus the specified element at the beginning.

ArrayLikeSequence.unshift = function() { /*...*/ }

ArrayLikeSequence.unshift = function unshift(value) {
  return Lazy([value]).concat(this);
}

Lazy([1, 2]).unshift(3) // sequence: [3, 1, 2]
Lazy([]).unshift(1)     // sequence: [1]

define ObjectLikeSequence.define

Create a new constructor function for a type inheriting from ObjectLikeSequence.

ObjectLikeSequence.define = function(methodName, overrides) { /*...*/ }

ObjectLikeSequence.define = function define(methodName, overrides) {
  if (!overrides || typeof overrides.each !== 'function') {
    throw new Error("A custom object-like sequence must implement *at least* each!");
  }

  return defineSequenceType(ObjectLikeSequence, methodName, overrides);
}