Lazy Sequences

import { sequenceOf, asSequence, generateSequence, Sequence } from 'kotlinify-ts/sequences';

// From values
sequenceOf(1, 2, 3, 4, 5)
  .filter(x => x % 2 === 0)
  .toArray(); // [2, 4]

// From arrays or iterables
asSequence([1, 2, 3, 4, 5])
  .map(x => x * 2)
  .toArray(); // [2, 4, 6, 8, 10]

// From array prototype extension
[1, 2, 3].asSequence()
  .filter(x => x > 1)
  .toArray(); // [2, 3]

// Using static methods
Sequence.of(1, 2, 3)
  .map(x => x * 2)
  .toArray(); // [2, 4, 6]

Sequence.from(new Set([1, 2, 3]))
  .filter(x => x > 1)
  .toArray(); // [2, 3]

// Fibonacci sequence
const fibonacci = generateSequence([0, 1], ([a, b]) => [b, a + b])
  .map(([a]) => a)
  .take(10)
  .toArray();

console.log('Fibonacci:', fibonacci);

// Powers of 2 up to 100
const powersOf2 = generateSequence(1, x => x < 100 ? x * 2 : null)
  .toArray();

console.log('Powers of 2:', powersOf2);

// Simple counter
const numbers = sequenceOf(1, 2, 3, 4, 5)
  .map(x => x * x)
  .toArray();

console.log('Squares:', numbers);

import { asSequence } from 'kotlinify-ts/sequences';

// Basic transformations
asSequence([1, 2, 3, 4, 5])
  .map(x => x * 2)
  .filter(x => x > 5)
  .toArray(); // [6, 8, 10]

// Indexed transformations
asSequence(['a', 'b', 'c'])
  .mapIndexed((index, value) => `${index}: ${value}`)
  .toArray(); // ['0: a', '1: b', '2: c']

asSequence([10, 20, 30, 40])
  .filterIndexed((index, value) => index % 2 === 0)
  .toArray(); // [10, 30]

// Null-aware mapping
asSequence([1, null, 2, undefined, 3])
  .mapNotNull(x => x ? x * 2 : null)
  .toArray(); // [2, 4, 6]

// Inverted filter
asSequence([1, 2, 3, 4, 5])
  .filterNot(x => x % 2 === 0)
  .toArray(); // [1, 3, 5]

// FlatMap - flattening sequences
asSequence(['hello', 'world'])
  .flatMap(word => word.split(''))
  .distinct()
  .toArray(); // ['h', 'e', 'l', 'o', 'w', 'r', 'd']

// Flatten nested sequences
asSequence([[1, 2], [3, 4], [5]])
  .flatten()
  .toArray(); // [1, 2, 3, 4, 5]

// Take and drop operations
asSequence([1, 2, 3, 4, 5])
  .drop(2)
  .take(2)
  .toArray(); // [3, 4]

// Conditional take/drop
asSequence([1, 2, 3, 4, 5, 6])
  .takeWhile(x => x < 4)
  .toArray(); // [1, 2, 3]

asSequence([1, 2, 3, 4, 5, 6])
  .dropWhile(x => x < 4)
  .toArray(); // [4, 5, 6]

import { sequenceOf } from 'kotlinify-ts/sequences';

// Remove duplicates
sequenceOf(1, 2, 2, 3, 1, 4)
  .distinct()
  .toArray(); // [1, 2, 3, 4]

// Remove duplicates by property
sequenceOf(
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
  { id: 1, name: 'Charlie' }
)
  .distinctBy(user => user.id)
  .toArray(); // [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]

// Sort sequences (note: sorting requires buffering all elements)
sequenceOf(3, 1, 4, 1, 5, 9)
  .sorted()
  .toArray(); // [1, 1, 3, 4, 5, 9]

// Custom sorting
sequenceOf(3, 1, 4, 1, 5)
  .sorted((a, b) => b - a)
  .toArray(); // [5, 4, 3, 1, 1]

// Sort by property
sequenceOf(
  { name: 'Alice', age: 30 },
  { name: 'Bob', age: 25 },
  { name: 'Charlie', age: 35 }
)
  .sortedBy(user => user.age)
  .toArray(); // Sorted by age: Bob, Alice, Charlie

import { asSequence } from 'kotlinify-ts/sequences';

// Split into fixed-size chunks
asSequence([1, 2, 3, 4, 5, 6, 7])
  .chunked(3)
  .toArray(); // [[1, 2, 3], [4, 5, 6], [7]]

// Transform chunks directly
asSequence([1, 2, 3, 4, 5, 6])
  .chunked(2, chunk => chunk.reduce((a, b) => a + b, 0))
  .toArray(); // [3, 7, 11]

// Sliding windows
asSequence([1, 2, 3, 4, 5])
  .windowed(3)
  .toArray(); // [[1, 2, 3], [2, 3, 4], [3, 4, 5]]

// Windows with custom step
asSequence([1, 2, 3, 4, 5, 6])
  .windowed(2, 2)
  .toArray(); // [[1, 2], [3, 4], [5, 6]]

// Allow partial windows at the end
asSequence([1, 2, 3, 4, 5])
  .windowed(3, 3, true)
  .toArray(); // [[1, 2, 3], [4, 5]]

// Transform windows directly (moving average)
asSequence([10, 20, 30, 40, 50, 60])
  .windowed(3, 1, false, window =>
    window.reduce((a, b) => a + b) / window.length
  )
  .toArray(); // [20, 30, 40, 50]

import { sequenceOf } from 'kotlinify-ts/sequences';

// Zip with next element
sequenceOf(1, 2, 3, 4)
  .zipWithNext()
  .toArray(); // [[1, 2], [2, 3], [3, 4]]

// Transform pairs directly
sequenceOf(10, 15, 12, 18, 20)
  .zipWithNext((prev, curr) => curr - prev)
  .toArray(); // [5, -3, 6, 2]

// Zip two sequences together
sequenceOf(1, 2, 3)
  .zip(['a', 'b', 'c'])
  .toArray(); // [[1, 'a'], [2, 'b'], [3, 'c']]

// Zip stops at shortest sequence
sequenceOf(1, 2, 3, 4, 5)
  .zip(['a', 'b'])
  .toArray(); // [[1, 'a'], [2, 'b']]

import { sequenceOf } from 'kotlinify-ts/sequences';

// Convert to collections
sequenceOf(1, 2, 2, 3).toArray(); // [1, 2, 2, 3]
sequenceOf(1, 2, 2, 3).toSet(); // Set(1, 2, 3)
sequenceOf(['a', 1], ['b', 2]).toMap(); // Map { 'a' => 1, 'b' => 2 }

// Find elements
sequenceOf(1, 2, 3, 4).first(); // 1
sequenceOf(1, 2, 3, 4).last(); // 4
sequenceOf(1, 2, 3, 4).find(x => x > 2); // 3

// Single element (throws if not exactly one)
sequenceOf(42).single(); // 42
sequenceOf(1, 2).single(); // throws Error
sequenceOf().single(); // throws Error

// Safe single (returns null if not exactly one)
sequenceOf(42).singleOrNull(); // 42
sequenceOf(1, 2).singleOrNull(); // null
sequenceOf().singleOrNull(); // null

// With predicates
sequenceOf(1, 2, 3, 4).single(x => x > 3); // 4
sequenceOf(1, 2, 3, 4).singleOrNull(x => x > 10); // null

// Safe versions return null instead of throwing
sequenceOf().firstOrNull(); // null
sequenceOf().lastOrNull(); // null

// Check conditions
sequenceOf(2, 4, 6).all(x => x % 2 === 0); // true
sequenceOf(1, 2, 3).any(x => x > 2); // true
sequenceOf(1, 2, 3).none(x => x > 5); // true
sequenceOf(1, 2, 3).count(); // 3
sequenceOf(1, 2, 3, 4).count(x => x % 2 === 0); // 2

import { sequenceOf } from 'kotlinify-ts/sequences';

// Reduce and fold
sequenceOf(1, 2, 3, 4)
  .reduce((acc, x) => acc + x, 0); // 10

sequenceOf(1, 2, 3, 4)
  .fold(10, (acc, x) => acc + x); // 20 (starts with 10)

// Running fold - yields intermediate results
sequenceOf(1, 2, 3, 4)
  .runningFold(0, (acc, x) => acc + x)
  .toArray(); // [0, 1, 3, 6, 10]

// Scan is an alias for runningFold
sequenceOf(1, 2, 3, 4)
  .scan(0, (acc, x) => acc + x)
  .toArray(); // [0, 1, 3, 6, 10]

// Math operations
sequenceOf(1, 2, 3, 4).sum(); // 10
sequenceOf(1, 2, 3, 4).average(); // 2.5

// Sum/average by selector
sequenceOf(
  { name: 'Alice', score: 90 },
  { name: 'Bob', score: 85 },
  { name: 'Charlie', score: 95 }
)
  .sumBy(student => student.score); // 270

// sumOf is Kotlin-standard alias for sumBy
sequenceOf(
  { name: 'Alice', score: 90 },
  { name: 'Bob', score: 85 },
  { name: 'Charlie', score: 95 }
)
  .sumOf(student => student.score); // 270

sequenceOf(
  { product: 'A', price: 10 },
  { product: 'B', price: 20 },
  { product: 'C', price: 30 }
)
  .averageBy(item => item.price); // 20

// Min/Max by selector
sequenceOf(
  { name: 'Alice', age: 30 },
  { name: 'Bob', age: 25 },
  { name: 'Charlie', age: 35 }
)
  .minBy(person => person.age); // { name: 'Bob', age: 25 }

sequenceOf(
  { id: 1, value: 10 },
  { id: 2, value: 30 },
  { id: 3, value: 20 }
)
  .maxBy(item => item.value); // { id: 2, value: 30 }

import { sequenceOf } from 'kotlinify-ts/sequences';

// Group by key - returns Map
const groups = sequenceOf(1, 2, 3, 4, 5, 6)
  .groupBy(x => x % 2 === 0 ? 'even' : 'odd');
// Map { 'odd' => [1, 3, 5], 'even' => [2, 4, 6] }

// Iterate over grouped results
for (const [key, values] of groups) {
  console.log(`${key}: ${values.length} items`);
}

// Group objects by property
const byDept = sequenceOf(
  { name: 'Alice', dept: 'Engineering' },
  { name: 'Bob', dept: 'Sales' },
  { name: 'Charlie', dept: 'Engineering' },
  { name: 'David', dept: 'Sales' }
)
  .groupBy(person => person.dept);
// Map { 'Engineering' => [...], 'Sales' => [...] }

byDept.get('Engineering'); // [{ name: 'Alice', ... }, { name: 'Charlie', ... }]

// Partition into two arrays
const [evens, odds] = sequenceOf(1, 2, 3, 4, 5)
  .partition(x => x % 2 === 0);
// evens: [2, 4], odds: [1, 3, 5]

// Associate operations - return Map
sequenceOf(1, 2, 3)
  .associateWith(x => x * 10);
// Map { 1 => 10, 2 => 20, 3 => 30 }

sequenceOf(
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' }
)
  .associateBy(user => user.id);
// Map { 1 => { id: 1, name: 'Alice' }, 2 => { id: 2, name: 'Bob' } }

sequenceOf('apple', 'banana', 'cherry')
  .associate(fruit => [fruit[0], fruit.length]);
// Map { 'a' => 5, 'b' => 6, 'c' => 6 }

import { sequenceOf } from 'kotlinify-ts/sequences';

// onEach - returns sequence for chaining
sequenceOf(1, 2, 3)
  .onEach(x => console.log('Processing:', x))
  .map(x => x * 2)
  .onEach(x => console.log('Doubled:', x))
  .toArray();
// Logs: Processing: 1, Doubled: 2, Processing: 2, Doubled: 4, ...

// forEach - terminal operation, returns void
sequenceOf(1, 2, 3)
  .map(x => x * 2)
  .forEach(x => console.log(x));
// Logs: 2, 4, 6

import { sequenceOf } from 'kotlinify-ts/sequences';

// Basic join
sequenceOf(1, 2, 3).joinToString(); // "1, 2, 3"
sequenceOf(1, 2, 3).joinToString(' - '); // "1 - 2 - 3"

// With prefix and postfix
sequenceOf(1, 2, 3)
  .joinToString(', ', '[', ']'); // "[1, 2, 3]"

// Limit elements shown
sequenceOf(1, 2, 3, 4, 5)
  .joinToString(', ', '', '', 3); // "1, 2, 3..."

// Custom transformation
sequenceOf('apple', 'banana', 'cherry')
  .joinToString(
    ', ',
    'Fruits: ',
    '.',
    -1,
    '...',
    fruit => fruit.toUpperCase()
  ); // "Fruits: APPLE, BANANA, CHERRY."

import { asSequence } from 'kotlinify-ts/sequences';

// Process log file entries
function processLogs(logLines: string[]) {
  return asSequence(logLines)
    .filter(line => line.includes('ERROR'))
    .map(line => {
      const match = line.match(/\[(\d{4}-\d{2}-\d{2})\] (.+)/);
      return match ? { date: match[1], message: match[2] } : null;
    })
    .filter(entry => entry !== null)
    .distinctBy(entry => entry!.message)
    .take(100)
    .toArray();
}

// Pagination example
function paginate<T>(items: T[], pageSize: number) {
  return asSequence(items)
    .chunked(pageSize)
    .map((page, index) => ({
      page: index + 1,
      items: page,
      total: page.length
    }))
    .toArray();
}

// Time series analysis
function movingAverage(values: number[], windowSize: number) {
  return asSequence(values)
    .windowed(windowSize)
    .map(window =>
      window.reduce((sum, val) => sum + val, 0) / window.length
    )
    .toArray();
}

// Data pipeline
function analyzeUserActivity(events: UserEvent[]) {
  return asSequence(events)
    .filter(e => e.type === 'purchase')
    .groupBy(e => e.userId)
    .associate(([userId, userEvents]) => [
      userId,
      {
        totalPurchases: userEvents.length,
        totalSpent: asSequence(userEvents)
          .sumBy(e => e.amount),
        avgPurchase: asSequence(userEvents)
          .averageBy(e => e.amount)
      }
    ]);
}