Sequence

console.log("start");

for (let i of Sequence.empty()) {
    console.log(i);
}

console.log("end");

// Output:
//     start
//     end

for (let i of Sequence.range(2, 4)) {
    console.log(i);
}

// Output:
//     2
//     3
//     4
//     5

for (let i of Sequence.repeat("a", 3)) {
    console.log(i);
}

// Output:
//     a
//     a
//     a

// Add all numbers in the array. The first one is used as the seed.
const numbers = [1, 2, 3],
      sum = from(numbers).aggregate((a, b) => a + b);

console.log(sum); // 6

// Concatenate all strings in the array. Use a seed value.
const animals = ["cat", "dog", "fish", "frog"],
      list = from(animals).aggregate((a, b) => a + ", " + b, "Animals: ");

console.log(list); // Animals: cat, dog, fish, frog

// Use a transformation on the result
const animals = ["cat", "dog", "fish", "frog"],
      concatNext = (a, b) => a + ", " + b,
      prefix = "Animals: ",
      makeParagraph = x => "<p>" + x + "</p>",
      paragraph = from(animals).aggregate(concatNext, prefix, makeParagraph);

console.log(paragraph);

// Output:
//     <p>Animals: cat, dog, fish, frog</p>

const numbers = [1, 2, 3],
      even = [2, 4, 6],
      isEven = n => n % 2 === 0;

from(numbers).all(isEven); // false
from(even).all(isEven); // true

// Without a condition, `any` can be used to quickly test whether
// a sequence is empty.
const empty = [],
      nonEmpty = [1];

console.log(from(empty).any()); // false
console.log(from(nonEmpty).any()); // true

// With a condition
const numbers = [1, 2, 3],
      even = [2, 4, 6],
      isOdd = n => n % 2 !== 0;
from(numbers).any(isOdd); // true
from(even).any(isOdd); // false

// Fist example: simple average
console.log(
    from([1, 2, 3]).average()
);

// Output: 2

// Second example: using the `getValue` function
const employees = [
    { id: 1, salary: 20000 },
    { id: 2, salary: 30000 },
    { id: 3, salary: 40000 }
];

console.log(
    from(employees).average(emp => emp.salary);
);

// Output: 30000

const numbers = [1, 2],
      letters = ["a", "b"],
      result  = from(numbers).concat(letters);

for (let i of result) {
    console.log(i); // 1 2 a b
}

const numbers = [1, 2, 3];
from(numbers).contains(n => n % 2 === 0); // true, 2 is even
from(numbers).contains(n => n > 3); // false, all elements less than 3

// No condition specified
const numbers = [1, 2, 3, 4],
      isEven = n => n % 2 === 0,
      count = from(numbers).count();

console.log(count); // 4

// Count matching elements
const numbers = [1, 2, 3, 4],
      isEven = n => n % 2 === 0,
      numberOfEvens = from(numbers).count(isEven);

console.log(numberOfEvens); // 2

// If the input sequence is not empty, the result is the original
// sequence
const ex1 = from([1, 2]).defaultIfEmpty();

for (let i of ex1) {
    console.log(i);
}

// Output:
//     1
//     2

// If the input sequence is empty, the result is a sequence containing
// one `undefined` value
const ex2 = from([]).defaultIfEmpty();

for (let i of ex2) {
    console.log(i);
}

// Output:
//     undefined

// If the input sequence is empty and a default value is specified,
// the result is a sequence the only item of which is the default value
const ex3 = from([]).defaultIfEmpty(0);

for (let i of ex2) {
    console.log(i);
}

// Output:
//     0

const numbers = [1, 1, 1, 2, 3, 4, 3],
      noDupl = from(numbers).distinct();

for (let n of noDupl) console.log(n); // 1 2 3 4

const numbers = [1, 2, 3];

console.log(from(numbers).elementAt(2)); // Output: 3

const numbers = [1, 2, 3];

console.log(from(numbers).elementAtOrDefault(2)); // Output: 3
console.log(from(numbers).elementAtOrDefault(3)); // Output: undefined
console.log(from(numbers).elementAtOrDefault(false)); // Output: false

const numbers = [1, 2, 3, 4, 5],
      exceptions = [3, 4],
      difference = from(numbers).except(exceptions);

for (let n of difference) console.log(n); // 1 2 5

// No condition specified, simply retrieve the first element of
// the sequence:
const numbers = [1, 2, 3, 4, 5],
      first = from(numbers).first();

console.log(first); // 1

// Getting the first element that matches a condition:
const numbers = [1, 2, 3, 4, 5],
      firstEven = from(numbers).first(n => n % 2 === 0);

console.log(firstEven); // 2

// Get first element of a non-empty sequence
const numbers = [1, 2, 3];
console.log(from(numbers).firstOrDefault()); // Output: 1

// Try to get first element of an empty sequence. No default value specified.
console.log(from([]).firstOrDefault()); // Output: undefined

// Try to get first element of an empty sequence. 0 is specified as a default.
console.log(from([]).firstOrDefault(0)); // Output: 0

// Get first matching element of a sequence with matching elements
const numbers = [1, 2, 3, 4];
console.log(from(numbers).firstOrDefault(0, n => n % 2 === 0)); // Output: 2

// Get first matching element of a sequence without a matching element
const numbers = [1, 3, 5];
console.log(from(numbers).firstOrDefault(0, n => n % 2 === 0)); // Output: 0

const a = [1, 2, 3],
      b = [2, 3, 4, 3],
      i = from(a).intersect(b);

for (let n of i) console.log(i); // 2 3

const users = [
    { id: 1, name: "Jane Smith" },
    { id: 2, name: "John Smith" },
    { id: 3, name: "Mary Brown" }
];

const emails = [
    { user_id: 1, address: "[email protected]" },
    { user_id: 1, address: "[email protected]" },
    { user_id: 3, address: "[email protected]" }
];

//
// First example: no `transform` function
//

const usersWithEmails =
    from(users)
        .join(emails, user => user.id, email => email.user_id);

for (let uwe of usersWithEmails) {
    console.log(uwe[0].name + ": " + uwe[1]);
}

// Output:
//     Jane Smith: [email protected]
//     Jane Smith: [email protected]
//     Mary Brown: [email protected]

//
// Second example: using a `transform` function
//

const userNamesWithEmails =
    from(users)
        .join(emails,
            user => user.id,
            email => email.user_id,
            (user, email) => user.name + ": " + email.address);

for (let uwe of userNamesWithEmails) {
    console.log(uwe);
}

// Output:
//     Jane Smith: [email protected]
//     Jane Smith: [email protected]
//     Mary Brown: [email protected]

// No condition specified, simply retrieve the last element of
// the sequence:
const numbers = [1, 2, 3, 4, 5],
      last = from(numbers).last();

console.log(last); // 5

// Getting the last element that matches a condition:
const numbers = [1, 2, 3, 4, 5],
      lastEven = from(numbers).last(n => n % 2 === 0);

console.log(lastEven); // 4

// Get last element of a non-empty sequence
const numbers = [1, 2, 3];
console.log(from(numbers).lastOrDefault()); // Output: 3

// Try to get last element of an empty sequence. No default value specified.
console.log(from([]).lastOrDefault()); // Output: undefined

// Try to get last element of an empty sequence. 0 is specified as a default.
console.log(from([]).lastOrDefault(0)); // Output: 0

// Get last matching element of a sequence with matching elements
const numbers = [1, 2, 3, 4];
console.log(from(numbers).lastOrDefault(0, n => n % 2 === 0)); // Output: 4

// Get last matching element of a sequence without a matching element
const numbers = [1, 3, 5, 7];
console.log(from(numbers).lastOrDefault(0, n => n % 2 === 0)); // Output: 0

// Called with no arguments
const numbers = [20, 35, -12, 0, 4, -7];
console.log(from(numbers).max()); // Output: 35

// Using a transformation
const people = [
    { name: "Jennifer", age: 23 },
    { name: "John", age: 33 },
    { name: "Jack", age: 42 },
    { name: "Jill", age: 18 },
    { name: "Bob", age: 20 }
];

console.log(from(people).max(p => p.age));

// Output:
//     42

// Using a transformation and a custom comparer
const people = [
    { name: "Jennifer", age: 23 },
    { name: "John", age: 33 },
    { name: "Jack", age: 42 },
    { name: "Jill", age: 18 },
    { name: "Bob", age: 20 }
];

const compareLength = (a, b) => a.length - b.length;

console.log(
    from(people).max(p => p.name, compareLength);
);

// Output:
//     "Jennifer"

// Called with no arguments
const numbers = [20, 35, -12, 0, 4, -7];
console.log(from(numbers).min()); // Output: -12

// Using a transformation
const people = [
    { name: "Jennifer", age: 23 },
    { name: "John", age: 33 },
    { name: "Jack", age: 42 },
    { name: "Jill", age: 18 },
    { name: "Bob", age: 20 }
];

console.log(from(people).min(p => p.age));

// Output:
//     18

// Using a transformation and a custom comparer
const people = [
    { name: "Jennifer", age: 23 },
    { name: "John", age: 33 },
    { name: "Jack", age: 42 },
    { name: "Jill", age: 18 },
    { name: "Bob", age: 20 }
];

const compareLength = (a, b) => a.length - b.length;

console.log(
    from(people).min(p => p.name, compareLength);
);

// Output:
//     "Bob"

// Simple case, only the `item` parameter of `matches` is used
const numbers = [1, 2, 3, 4, 5],
      even = from(numbers).select(n => n % 2 === 0);

for (let n of even) {
    console.log(n); // 2 4
}

// Here we also use the `index` parameter
const numbers = [1, 2, 3, 4, 5],
      numbersPlusIndices = from(numbers).select((n, i) => n + i);

for (let n of numbersPlusIndices) {
    console.log(n); // 1 3 5 7 9
}

// Simple example, only the `getIterable` function is used
const taskLists = [
    {tasks: [1]}, {tasks: [2, 3]}, {tasks: [4]},
    {tasks: []}, {tasks: [5]}
];

const allTasks = from(taskLists).selectMany(t => t.tasks);

for (let t of allTasks) {
    console.log(t); // 1 2 3 4 5
}

// Here we use both transformation functions
const tasksByDate = [
    {
        date: "2015-09-20",
        tasks: [
            { id: 1, text: "buy groceries" },
            { id: 2, text: "do laundry" },
            { id: 3, text: "meet Janet" }
        ]
    },
    // ... more objects like above ...
];

const allTasks =
    from(tasksByDate)
        .selectMany(date => date.tasks, (date, task) => task.text);

for (let task of allTasks) {
    console.log(task);
}

// Output:
//     buy groceries
//     do laundry
//     meet Janet
//     ...

// No condition specified, simply retrieve the only element of
// the sequence:
const numbers = [1],
      single = from(numbers).single();

console.log(single); // 1

// Getting the only element that matches a condition:
const numbers = [1, 2, 3],
      singleEven = from(numbers).single(n => n % 2 === 0);

console.log(singleEven); // 2

// `single` can be used to express that we expect only one matching
// element when the presence of more than one matching elements is
// a programming error:

// this is expected to contain only one even number
const numbers = [1, 2, 3, 4, 5];

// BOOM! this throws a RangeError because the sequence contains more
// than one matching element
const even = from(numbers).single(even);

// Get the only element of a non-empty sequence
const numbers = [1];
console.log(from(numbers).singleOrDefault()); // Output: 1

// Try to get the single element of an empty sequence. No default value specified.
console.log(from([]).singleOrDefault()); // Output: undefined

// Try to get single element of an empty sequence. 0 is specified as a default.
console.log(from([]).singleOrDefault(0)); // Output: 0

// Get single matching element of a sequence with matching elements
const numbers = [1, 2, 3];
console.log(from(numbers).singleOrDefault(0, n => n % 2 === 0)); // Output: 2

// Get last matching element of a sequence without a matching element
const numbers = [1, 3, 5, 7];
console.log(from(numbers).singleOrDefault(0, n => n % 2 === 0)); // Output: 0

// Get single matching element of a sequence with multiple matching elements
const numbers = [1, 2, 3, 4];

// BOOM! This throws a `RangeError`:
console.log(from(numbers).singleOrDefault(0, n => n % 2 === 0));

// Without `getValue`
console.log(
    from([1, 2, 3]).sum()
);

// Output: 6

// With `getValue`
const employees = [
    { name: "John Smith", salary: 15000 },
    { name: "Jane Smith", salary: 26000 },
    { name: "Jane Doe", salary: 15000 },
];

const totalSalary = from(employees).sum(emp => emp.salary);

console.log(totalSalary); // 56000

const books = [
    { title: "The Lord of the Rings", author: "J. R. R. Tolkien", category: "fantasy" },
    { title: "Solaris", author: "Stanislaw Lem", category: "sci-fi" },
    { title: "The Hobbit", author: "J. R. R. Tolkien", category: "fantasy" },
    { title: "Rendezvous with Rama", author: "A. C. Clarke", category: "sci-fi" },
    { title: "JavaScript Allongé", author: "Reginald Braithwaithe", category: "non-fiction" }
];

// Only `getKey` used:
let booksByCategory =
    from(books)
        .toLookup(b => b.category);

for (let {category, books} of booksByCategory) {
    console.log(category);
    for (let book of books) {
        console.log("    " + book.author + " - " + book.title);
    }
}

// Output:
//     fantasy
//         J. R. R. Tolkien - The Lord of the Rings
//         J. R. R. Tolkien - The Hobbit
//     sci-fi
//         Stanislaw Lem - Solaris
//         A. C. Clarke - Rendezvous with Rama
//     non-fiction
//         Reginald Braithwaithe - JavaScript Allongé

// `getKey` and `transform` used:
let booksByCategory =
    from(books)
        .toLookup(b => b.category, b => b.title);

for (let {category, titles} of booksByCategory) {
    console.log(category);
    for (let title of titles) {
        console.log("    " + title);
    }
}

// Output:
//     fantasy
//         The Lord of the Rings
//         The Hobbit
//     sci-fi
//         Solaris
//         Rendezvous with Rama
//     non-fiction
//         JavaScript Allongé

const a = [1, 2, 1, 3, 2],
      b = [3, 3, 4, 5, 4],
      u = from(a).union(b);
for (let i of u) console.log(i); // 1 2 3 4 5

// Simple case, only the `item` parameter of `matches` is used
const numbers = [1, 2, 3, 4, 5],
      even = from(numbers).where(n => n % 2 === 0);

for (let n of even) console.log(n); // 2 4

// Here we also use the `index` parameter
const numbers = [2, 1, 3, 0, 4],
      itemEqualsIndex = (item, index) => item === index,
      numbersEqualToTheirIndices = from(numbers).where(itemEqualsIndex);

for (let n of numbersEqualToTheirIndices) {
    console.log(n); // 1 4
}