Iterable

import { Iterable } from "effect"

const numbers = [1, 2, 3]
Array.from(Iterable.append(numbers, 4)) // => [1, 2, 3, 4]

import { Iterable } from "effect"

Array.from(Iterable.appendAll([1, 2, 3], [4, 5, 6])) // => [1, 2, 3, 4, 5, 6]

// Works with different iterable types
const numbers = [1, 2]
const letters = "abc"
const mixed = Iterable.appendAll(numbers, letters)
Array.from(mixed) // => [1, 2, "a", "b", "c"]

// Lazy evaluation - only consumes what's needed
const infinite = Iterable.range(1)
const finite = [0, -1, -2]
Array.from(Iterable.take(Iterable.appendAll(finite, infinite), 5)) // => [0, -1, -2, 1, 2]

import { Iterable } from "effect"

// All pairs of numbers and letters
const numbers = [1, 2, 3]
const letters = ["a", "b"]
const pairs = Iterable.cartesian(numbers, letters)
Array.from(pairs) // => [[1, "a"], [1, "b"], [2, "a"], [2, "b"], [3, "a"], [3, "b"]]

// Generate coordinate grid
const x = [0, 1, 2]
const y = [0, 1]
const grid = Iterable.cartesian(x, y)
Array.from(grid) // => [[0, 0], [0, 1], [1, 0], [1, 1], [2, 0], [2, 1]]

// All combinations for testing
const browsers = ["chrome", "firefox"]
const devices = ["desktop", "mobile", "tablet"]
const testMatrix = Iterable.cartesian(browsers, devices)
Array.from(testMatrix, ([browser, device]) => `${browser}:${device}`) // => ["chrome:desktop", "chrome:mobile", "chrome:tablet", "firefox:desktop", "firefox:mobile", "firefox:tablet"]

// Empty iterable results in empty cartesian product
const empty = Iterable.empty<number>()
const withEmpty = Iterable.cartesian([1, 2], empty)
Array.from(withEmpty) // => []

import { Iterable } from "effect"

// Create coordinate pairs
const xs = [1, 2]
const ys = ["a", "b", "c"]
const coordinates = Iterable.cartesianWith(xs, ys, (x, y) => `(${x},${y})`)
Array.from(coordinates) // => ["(1,a)", "(1,b)", "(1,c)", "(2,a)", "(2,b)", "(2,c)"]

// Generate all combinations of options
const sizes = ["S", "M", "L"]
const colors = ["red", "blue"]
const products = Iterable.cartesianWith(
  sizes,
  colors,
  (size, color) => ({ size, color })
)
Array.from(products, ({ color, size }) => `${size}:${color}`) // => ["S:red", "S:blue", "M:red", "M:blue", "L:red", "L:blue"]

// Mathematical operations on all pairs
const a = [1, 2, 3]
const b = [10, 20]
const mathProducts = Iterable.cartesianWith(a, b, (x, y) => x * y)
Array.from(mathProducts) // => [10, 20, 20, 40, 30, 60]

// Create test data combinations
const userTypes = ["admin", "user"]
const features = ["read", "write", "delete"]
const testCases = Iterable.cartesianWith(
  userTypes,
  features,
  (user, feature) => `${user}_can_${feature}`
)
Array.from(testCases) // => ["admin_can_read", "admin_can_write", "admin_can_delete", "user_can_read", "user_can_write", "user_can_delete"]

import { Iterable } from "effect"

// Join numbers with separator
const numbers = [1, 2, 3, 4]
const withCommas = Iterable.intersperse(numbers, ",")
Array.from(withCommas) // => [1, ",", 2, ",", 3, ",", 4]

// Join words with spaces
const words = ["hello", "world", "from", "effect"]
const sentence = Iterable.intersperse(words, " ")
Array.from(sentence).join("") // => "hello world from effect"

// Empty iterable remains empty
const empty = Iterable.empty<string>()
const stillEmpty = Iterable.intersperse(empty, "-")
Array.from(stillEmpty) // => []

// Single element has no separators added
const single = [42]
const noSeparator = Iterable.intersperse(single, "|")
Array.from(noSeparator) // => [42]

// Build CSS-like strings
const styles = ["color: red", "font-size: 14px", "margin: 10px"]
const css = Iterable.intersperse(styles, "; ")
Array.from(css).join("") // => "color: red; font-size: 14px; margin: 10px"

import { Iterable } from "effect"

const numbers = [2, 3, 4]
const withOne = Iterable.prepend(numbers, 1)
Array.from(withOne) // => [1, 2, 3, 4]

// Works with any iterable
const letters = "abc"
const withZ = Iterable.prepend(letters, "z")
Array.from(withZ) // => ["z", "a", "b", "c"]

import { Iterable } from "effect"

Array.from(Iterable.prependAll([1, 2], ["a", "b"])) // => ["a", "b", 1, 2]

import { Iterable } from "effect"

Array.from(Iterable.empty<string>()) // => []

import { Iterable } from "effect"

// Generate first 5 even numbers
const evens = Iterable.makeBy((n) => n * 2, { length: 5 })
Array.from(evens) // => [0, 2, 4, 6, 8]

// Generate squares
const squares = Iterable.makeBy((n) => n * n, { length: 4 })
Array.from(squares) // => [0, 1, 4, 9]

// Infinite sequence (be careful when consuming!)
const naturals = Iterable.makeBy((n) => n)
const first10 = Iterable.take(naturals, 10)
Array.from(first10) // => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

import { Iterable } from "effect"

const single = Iterable.of(42)
Array.from(single) // => [42]

// Useful for creating homogeneous sequences
const sequences = [
  Iterable.of("hello"),
  Iterable.range(1, 3),
  Iterable.empty<string>()
]

// Can be used with flatMap for conditional inclusion
const numbers = [1, 2, 3, 4, 5]
const evensOnly = Iterable.flatMap(
  numbers,
  (n) => n % 2 === 0 ? Iterable.of(n) : Iterable.empty()
)
Array.from(evensOnly) // => [2, 4]

import { Iterable } from "effect"

Array.from(Iterable.range(1, 3)) // => [1, 2, 3]

import { Iterable } from "effect"

Array.from(Iterable.replicate("a", 3)) // => ["a", "a", "a"]

import { Iterable, Option } from "effect"

// Generate Fibonacci sequence
const fibonacci = Iterable.unfold([0, 1], ([a, b]) => Option.some([a, [b, a + b]]))
const first10Fib = Iterable.take(fibonacci, 10)
Array.from(first10Fib) // => [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

// Generate powers of 2 up to a limit
const powersOf2 = Iterable.unfold(1, (n) => n <= 1000 ? Option.some([n, n * 2]) : Option.none())
Array.from(powersOf2) // => [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]

// Generate countdown
const countdown = Iterable.unfold(5, (n) => n > 0 ? Option.some([n, n - 1]) : Option.none())
Array.from(countdown) // => [5, 4, 3, 2, 1]

// Generate collatz sequence
const collatz = Iterable.unfold(7, (n) => {
  if (n === 1) return Option.none()
  const next = n % 2 === 0 ? n / 2 : n * 3 + 1
  return Option.some([n, next])
})
Array.from(collatz) // => [7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2]

import { Iterable } from "effect"

const x = { a: 1, b: 2, c: 3 }
Array.from(Iterable.fromRecord(x)) // => [["a", 1], ["b", 2], ["c", 3]]

import { Iterable } from "effect"

// Remove adjacent duplicate numbers
const numbers = [1, 1, 2, 2, 2, 3, 1, 1]
const deduped = Iterable.dedupeAdjacent(numbers)
Array.from(deduped) // => [1, 2, 3, 1]

// Remove adjacent duplicate characters
const letters = "aabbccaa"
const dedupedLetters = Iterable.dedupeAdjacent(letters)
Array.from(dedupedLetters) // => ["a", "b", "c", "a"]

// Works with objects using deep equality
const objects = [
  { type: "A" },
  { type: "A" },
  { type: "B" },
  { type: "B" },
  { type: "A" }
]
const dedupedObjects = Iterable.dedupeAdjacent(objects)
Array.from(dedupedObjects, (object) => object.type) // => ["A", "B", "A"]

// Clean up streaming data
const sensorData = [100, 100, 100, 101, 101, 102, 102, 102, 100]
const cleanedData = Iterable.dedupeAdjacent(sensorData)
Array.from(cleanedData) // => [100, 101, 102, 100]

import { Iterable } from "effect"

// Remove adjacent duplicates with custom equality
const numbers = [1, 1, 2, 2, 3, 1, 1]
const dedupedNumbers = Iterable.dedupeAdjacentWith(numbers, (a, b) => a === b)
Array.from(dedupedNumbers) // => [1, 2, 3, 1]

// Case-insensitive deduplication
const words = ["Hello", "HELLO", "world", "World", "test"]
const caseInsensitive = (a: string, b: string) =>
  a.toLowerCase() === b.toLowerCase()
const dedupedWords = Iterable.dedupeAdjacentWith(words, caseInsensitive)
Array.from(dedupedWords) // => ["Hello", "world", "test"]

// Deduplication by object property
const users = [
  { id: 1, name: "Alice" },
  { id: 1, name: "Alice Updated" }, // different name, same id
  { id: 2, name: "Bob" },
  { id: 2, name: "Bob" },
  { id: 3, name: "Charlie" }
]
const byId = (a: typeof users[0], b: typeof users[0]) => a.id === b.id
const dedupedUsers = Iterable.dedupeAdjacentWith(users, byId)
Array.from(dedupedUsers, (user) => user.id) // => [1, 2, 3]

// Approximate numeric equality
const floats = [1.0, 1.01, 1.02, 2.0, 2.01, 3.0]
const approxEqual = (a: number, b: number) => Math.abs(a - b) < 0.1
const dedupedFloats = Iterable.dedupeAdjacentWith(floats, approxEqual)
Array.from(dedupedFloats) // => [1, 2, 3]

import { Iterable } from "effect"

// Filter even numbers
const numbers = [1, 2, 3, 4, 5, 6]
const evens = Iterable.filter(numbers, (x) => x % 2 === 0)
Array.from(evens) // => [2, 4, 6]

// Filter with index
const items = ["a", "b", "c", "d"]
const oddPositions = Iterable.filter(items, (_, i) => i % 2 === 1)
Array.from(oddPositions) // => ["b", "d"]

// Type refinement
const mixed: Array<string | number> = ["hello", 42, "world", 100]
const onlyStrings = Iterable.filter(
  mixed,
  (x): x is string => typeof x === "string"
)
Array.from(onlyStrings) // => ["hello", "world"]

// Combine with map
const processed = Iterable.map(
  Iterable.filter([1, 2, 3, 4, 5], (x) => x > 2),
  (x) => x * 10
)
Array.from(processed) // => [30, 40, 50]

import { Iterable, Result } from "effect"

// Parse strings to numbers, keeping only valid ones
const strings = ["1", "2", "invalid", "4", "not-a-number"]
const numbers = Iterable.filterMap(strings, (s) => {
  const num = parseInt(s)
  return isNaN(num) ? Result.failVoid : Result.succeed(num)
})
Array.from(numbers) // => [1, 2, 4]

// Extract specific properties from objects
const users = [
  { name: "Alice", age: 25, email: "alice@example.com" },
  { name: "Bob", age: 17, email: undefined },
  { name: "Charlie", age: 30, email: "charlie@example.com" },
  { name: "David", age: 16, email: undefined }
]
const adultEmails = Iterable.filterMap(
  users,
  (user) =>
    user.age >= 18 && user.email ? Result.succeed(user.email) : Result.failVoid
)
Array.from(adultEmails) // => ["alice@example.com", "charlie@example.com"]

// Use index in transformation
const items = ["a", "b", "c", "d", "e"]
const evenIndexItems = Iterable.filterMap(
  items,
  (item, i) => i % 2 === 0 ? Result.succeed(`${i}: ${item}`) : Result.failVoid
)
Array.from(evenIndexItems) // => ["0: a", "2: c", "4: e"]

import { Iterable, Result } from "effect"

// Parse numbers until we hit an invalid one
const strings = ["1", "2", "3", "invalid", "4", "5"]
const numbers = Iterable.filterMapWhile(strings, (s) => {
  const num = parseInt(s)
  return isNaN(num) ? Result.failVoid : Result.succeed(num)
})
Array.from(numbers) // => [1, 2, 3]

// Take elements while they meet a condition and transform them
const values = [2, 4, 6, 7, 8, 10]
const doubledEvens = Iterable.filterMapWhile(
  values,
  (n) => n % 2 === 0 ? Result.succeed(n * 2) : Result.failVoid
)
Array.from(doubledEvens) // => [4, 8, 12]

// Process with index until condition fails
const letters = ["a", "b", "c", "d", "e"]
const indexedUntilC = Iterable.filterMapWhile(
  letters,
  (letter, i) => letter !== "c" ? Result.succeed(`${i}: ${letter}`) : Result.failVoid
)
Array.from(indexedUntilC) // => ["0: a", "1: b"]

import { Iterable, Result } from "effect"

Array.from(Iterable.getFailures([
  Result.succeed(1),
  Result.fail("err"),
  Result.succeed(2)
])) // => ["err"]

import { Iterable, Option } from "effect"

Array.from(Iterable.getSomes([Option.some(1), Option.none(), Option.some(2)])) // => [1, 2]

import { Iterable, Result } from "effect"

Array.from(Iterable.getSuccesses([
  Result.succeed(1),
  Result.fail("err"),
  Result.succeed(2)
])) // => [1, 2]

import { Iterable } from "effect"

Iterable.countBy([1, 2, 3, 4, 5], (n) => n % 2 === 0) // => 2

import { Iterable } from "effect"

// Sum all numbers
const numbers = [1, 2, 3, 4, 5]
const sum = Iterable.reduce(numbers, 0, (acc, n) => acc + n)
sum // => 15

// Find maximum value
const values = [3, 1, 4, 1, 5, 9, 2]
Iterable.reduce(values, -Infinity, (max, value) => Math.max(max, value)) // => 9

// Build an object from key-value pairs
const pairs = [["a", 1], ["b", 2], ["c", 3]] as const
const obj = Iterable.reduce(
  pairs,
  {} as Record<string, number>,
  (acc, [key, value]) => {
    acc[key] = value
    return acc
  }
)
obj // => { a: 1, b: 2, c: 3 }

// Use index in the reducer
const letters = ["a", "b", "c"]
const indexed = Iterable.reduce(
  letters,
  [] as Array<string>,
  (acc, letter, i) => {
    acc.push(`${i}: ${letter}`)
    return acc
  }
)
indexed // => ["0: a", "1: b", "2: c"]

import { Iterable } from "effect"

// Running sum of numbers
const numbers = [1, 2, 3, 4, 5]
const runningSum = Iterable.scan(numbers, 0, (acc, n) => acc + n)
Array.from(runningSum) // => [0, 1, 3, 6, 10, 15]

// Build strings progressively
const letters = ["a", "b", "c"]
const progressive = Iterable.scan(letters, "", (acc, letter) => acc + letter)
Array.from(progressive) // => ["", "a", "ab", "abc"]

// Track maximum values seen so far
const values = [3, 1, 4, 1, 5, 9, 2]
const runningMax = Iterable.scan(values, -Infinity, Math.max)
Array.from(runningMax) // => [-Infinity, 3, 3, 4, 4, 5, 9, 9]

import { Iterable } from "effect"

const numbers = [1, 2, 3, 4, 5]
const withoutFirstTwo = Iterable.drop(numbers, 2)
Array.from(withoutFirstTwo) // => [3, 4, 5]

// Dropping more than available returns empty
const withoutFirstTen = Iterable.drop(numbers, 10)
Array.from(withoutFirstTen) // => []

// Dropping 0 or negative returns all elements
const all = Iterable.drop(numbers, 0)
Array.from(all) // => [1, 2, 3, 4, 5]

// Combine with take for slicing
const slice = Iterable.take(Iterable.drop(numbers, 1), 3)
Array.from(slice) // => [2, 3, 4]

import { Iterable, Option } from "effect"

const numbers = [1, 2, 3]
Iterable.head(numbers) // => Option.some(1)

const empty = Iterable.empty<number>()
Iterable.head(empty) // => Option.none()

// Safe way to get first element
const firstEven = Iterable.head(
  Iterable.filter([1, 3, 4, 5], (x) => x % 2 === 0)
)
firstEven // => Option.some(4)

// Use with Option methods
const doubled = Option.map(Iterable.head([5, 10, 15]), (x) => x * 2)
doubled // => Option.some(10)

import { Iterable } from "effect"

const numbers = [1, 2, 3]
Iterable.headUnsafe(numbers) // => 1

const letters = "hello"
Iterable.headUnsafe(letters) // => "h"

// Iterable.headUnsafe(Iterable.empty<number>())
// throws Error: "headUnsafe: empty iterable"

// Use only when you're certain the iterable is non-empty
const nonEmpty = Iterable.range(1, 10)
Iterable.headUnsafe(nonEmpty) // => 1

import { Iterable } from "effect"

const numbers = [1, 2, 3, 4, 5]
Iterable.size(numbers) // => 5

const empty = Iterable.empty<number>()
Iterable.size(empty) // => 0

// Works with any iterable
const letters = "hello"
Iterable.size(letters) // => 5

// Note: This consumes the entire iterable
const range = Iterable.range(1, 100)
Iterable.size(range) // => 100

import { Iterable } from "effect"

const numbers = [1, 2, 3, 4, 5]
const firstThree = Iterable.take(numbers, 3)
Array.from(firstThree) // => [1, 2, 3]

// Taking more than available returns all elements
const firstTen = Iterable.take(numbers, 10)
Array.from(firstTen) // => [1, 2, 3, 4, 5]

// Taking 0 or negative returns empty
const none = Iterable.take(numbers, 0)
Array.from(none) // => []

// Useful with infinite iterables
const naturals = Iterable.range(1)
const firstFive = Iterable.take(naturals, 5)
Array.from(firstFive) // => [1, 2, 3, 4, 5]

import { Iterable } from "effect"

const numbers = [2, 4, 6, 8, 3, 10, 12]
const evenPrefix = Iterable.takeWhile(numbers, (x) => x % 2 === 0)
Array.from(evenPrefix) // => [2, 4, 6, 8]

// With index
const letters = ["a", "b", "c", "d", "e"]
const firstThreeByIndex = Iterable.takeWhile(letters, (_, i) => i < 3)
Array.from(firstThreeByIndex) // => ["a", "b", "c"]

// Stops at first non-matching element
const mixed = [1, 3, 5, 4, 7, 9]
const oddPrefix = Iterable.takeWhile(mixed, (x) => x % 2 === 1)
Array.from(oddPrefix) // => [1, 3, 5]

// Type refinement
const values: Array<string | number> = ["a", "b", "c", 1, "d"]
const stringPrefix = Iterable.takeWhile(
  values,
  (x): x is string => typeof x === "string"
)
Array.from(stringPrefix) // => ["a", "b", "c"]

import { Iterable } from "effect"

const numbers = [1, 1, 2, 2, 2, 3, 1, 1]
const grouped = Iterable.group(numbers)
Array.from(grouped) // => [[1, 1], [2, 2, 2], [3], [1, 1]]

const letters = "aabbccaa"
const groupedLetters = Iterable.group(letters)
Array.from(groupedLetters) // => [["a", "a"], ["b", "b"], ["c", "c"], ["a", "a"]]

// Works with objects using deep equality
const objects = [
  { type: "A", value: 1 },
  { type: "A", value: 1 },
  { type: "B", value: 2 },
  { type: "A", value: 1 }
]
const groupedObjects = Iterable.group(objects)
Array.from(groupedObjects).length // => 3
// Note: Only consecutive equal objects are grouped together