@dayme/alien-utils 0.1.0

package/dist/iterator/iterator.d.ts

@@ -0,0 +1,821 @@
+import { Option } from '../option/option';
+/**
+ * Типы операций в pipeline
+ */
+type OpType = "map" | "filter" | "flatMap" | "flatten" | "take" | "takeWhile" | "skip" | "skipWhile" | "enumerate" | "zip" | "chain" | "stepBy" | "inspect" | "unique" | "uniqueBy";
+/**
+ * Операция в pipeline
+ */
+interface Op {
+    type: OpType;
+    fn: Function;
+    param?: unknown;
+}
+/**
+ * Lazy iterator в стиле Rust с оптимизированным pipeline-based подходом.
+ * Все промежуточные операции (map, filter, take и т.д.) не создают промежуточных массивов,
+ * а формируют цепочку трансформаций, которая применяется при финальном потреблении.
+ *
+ * Оптимизации:
+ * - Pipeline-based архитектура вместо вложенных итераторов
+ * - Единый цикл выполнения для всех операций
+ * - Fast paths для частых случаев
+ * - Минимизация создания closures и объектов
+ * - Оптимизация для массивов с прямым доступом
+ *
+ * @template T - Тип элементов в итераторе
+ *
+ * @example
+ * ```ts
+ * const result = Iter.from([1, 2, 3, 4, 5])
+ *   .map(x => x * 2)
+ *   .filter(x => x > 5)
+ *   .take(2)
+ *   .collect();
+ * // [6, 8] - выполняется один проход, нет промежуточных массивов
+ * ```
+ */
+export declare class Iter<T> implements Iterable<T> {
+    /**
+     * Исходный итерируемый объект
+     */
+    private readonly source;
+    /**
+     * Массив операций pipeline
+     */
+    private readonly ops;
+    /**
+     * Битовая маска операций для оптимизации
+     */
+    private readonly opsMask;
+    /**
+     * Создаёт новый Iter из итерируемого объекта.
+     *
+     * @param source - Исходный итерируемый объект
+     * @param ops - Массив операций pipeline (внутреннее использование)
+     */
+    constructor(source: Iterable<T>, ops?: Op[], opsMask?: number);
+    /**
+     * Проверяет, является ли итерируемый объект массивом (для оптимизаций).
+     */
+    private get isArray();
+    /**
+     * Проверяет, является ли источник typed array для SIMD-оптимизаций.
+     */
+    private get isTypedArray();
+    /**
+     * Создаёт Iter из итерируемого объекта.
+     *
+     * @template T - Тип элементов
+     * @param iterable - Итерируемый объект
+     * @returns Новый Iter
+     *
+     * @example
+     * ```ts
+     * const iter = Iter.from([1, 2, 3]);
+     * const iter2 = Iter.from(new Set([1, 2, 3]));
+     * const iter3 = Iter.from("abc"); // ['a', 'b', 'c']
+     * ```
+     */
+    static from<T>(iterable: Iterable<T>): Iter<T>;
+    /**
+     * Создаёт Iter из диапазона чисел [start, end).
+     *
+     * @param start - Начальное значение (включительно)
+     * @param end - Конечное значение (не включительно)
+     * @param step - Шаг (по умолчанию 1)
+     * @returns Новый Iter с числами
+     *
+     * @example
+     * ```ts
+     * Iter.range(0, 5).collect(); // [0, 1, 2, 3, 4]
+     * Iter.range(0, 10, 2).collect(); // [0, 2, 4, 6, 8]
+     * ```
+     */
+    static range(start: number, end: number, step?: number): Iter<number>;
+    /**
+     * Создаёт бесконечный Iter, который повторяет значение.
+     *
+     * @template T - Тип значения
+     * @param value - Значение для повторения
+     * @returns Бесконечный Iter
+     *
+     * @example
+     * ```ts
+     * Iter.repeat(42).take(3).collect(); // [42, 42, 42]
+     * ```
+     */
+    static repeat<T>(value: T): Iter<T>;
+    /**
+     * Создаёт бесконечный Iter, генерируя значения функцией.
+     *
+     * @template T - Тип значений
+     * @param fn - Функция генерации значений
+     * @returns Бесконечный Iter
+     *
+     * @example
+     * ```ts
+     * let n = 0;
+     * Iter.generate(() => n++).take(5).collect(); // [0, 1, 2, 3, 4]
+     * ```
+     */
+    static generate<T>(fn: () => T): Iter<T>;
+    /**
+     * Создаёт пустой Iter.
+     *
+     * @template T - Тип элементов
+     * @returns Пустой Iter
+     *
+     * @example
+     * ```ts
+     * Iter.empty<number>().collect(); // []
+     * ```
+     */
+    static empty<T>(): Iter<T>;
+    /**
+     * Создаёт Iter из одного элемента.
+     *
+     * @template T - Тип элемента
+     * @param value - Значение
+     * @returns Iter с одним элементом
+     *
+     * @example
+     * ```ts
+     * Iter.once(42).collect(); // [42]
+     * ```
+     */
+    static once<T>(value: T): Iter<T>;
+    /**
+     * Реализация Symbol.iterator для поддержки for..of и других итераций.
+     * Выполняет все операции pipeline в едином цикле.
+     *
+     * @returns Iterator
+     */
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * Выполняет все операции pipeline в едином цикле.
+     * Это ключевая оптимизация - все операции выполняются за один проход.
+     *
+     * Оптимизации на основе битовой маски операций:
+     * - Отсутствие Filter: пропускаем проверки фильтрации
+     * - Fast path для Map-only: без фильтрации и сложных операций
+     * - Уменьшение количества ветвлений в горячем коде
+     */
+    private executePipeline;
+    /**
+     * Fast path для pipeline с только Map операциями.
+     * Это самый частый сценарий в реальном коде.
+     * Оптимизация: никаких проверок фильтрации, только трансформация.
+     */
+    private executeMapOnlyPipeline;
+    /**
+     * Применяет функцию к каждому элементу (ленивая операция).
+     *
+     * @template U - Тип результата
+     * @param fn - Функция трансформации
+     * @returns Новый Iter с трансформированными элементами
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3])
+     *   .map(x => x * 2)
+     *   .collect(); // [2, 4, 6]
+     * ```
+     */
+    map<U>(fn: (value: T, index: number) => U): Iter<U>;
+    /**
+     * Фильтрует элементы по предикату (ленивая операция).
+     *
+     * @param predicate - Функция-предикат
+     * @returns Новый Iter только с элементами, прошедшими фильтр
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3, 4])
+     *   .filter(x => x % 2 === 0)
+     *   .collect(); // [2, 4]
+     * ```
+     */
+    filter(predicate: (value: T, index: number) => boolean): Iter<T>;
+    /**
+     * Применяет функцию и разворачивает результат (ленивая операция).
+     * Аналог flatMap в JS или flat_map в Rust.
+     *
+     * @template U - Тип элементов результата
+     * @param fn - Функция, возвращающая итерируемый объект
+     * @returns Новый Iter с развёрнутыми элементами
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3])
+     *   .flatMap(x => [x, x * 10])
+     *   .collect(); // [1, 10, 2, 20, 3, 30]
+     * ```
+     */
+    flatMap<U>(fn: (value: T, index: number) => Iterable<U>): Iter<U>;
+    /**
+     * Развёртывает вложенные итераторы на один уровень (ленивая операция).
+     *
+     * @template U - Тип элементов внутри T
+     * @returns Новый Iter с развёрнутыми элементами
+     *
+     * @example
+     * ```ts
+     * Iter.from([[1, 2], [3, 4]])
+     *   .flatten()
+     *   .collect(); // [1, 2, 3, 4]
+     * ```
+     */
+    flatten<U>(this: Iter<Iterable<U>>): Iter<U>;
+    /**
+     * Берёт первые n элементов (ленивая операция).
+     *
+     * @param n - Количество элементов
+     * @returns Новый Iter с первыми n элементами
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3, 4, 5])
+     *   .take(3)
+     *   .collect(); // [1, 2, 3]
+     * ```
+     */
+    take(n: number): Iter<T>;
+    /**
+     * Берёт элементы пока предикат возвращает true (ленивая операция).
+     *
+     * @param predicate - Функция-предикат
+     * @returns Новый Iter с элементами до первого false
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3, 4, 1, 2])
+     *   .takeWhile(x => x < 4)
+     *   .collect(); // [1, 2, 3]
+     * ```
+     */
+    takeWhile(predicate: (value: T, index: number) => boolean): Iter<T>;
+    /**
+     * Пропускает первые n элементов (ленивая операция).
+     *
+     * @param n - Количество элементов для пропуска
+     * @returns Новый Iter без первых n элементов
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3, 4, 5])
+     *   .skip(2)
+     *   .collect(); // [3, 4, 5]
+     * ```
+     */
+    skip(n: number): Iter<T>;
+    /**
+     * Пропускает элементы пока предикат возвращает true (ленивая операция).
+     *
+     * @param predicate - Функция-предикат
+     * @returns Новый Iter без элементов до первого false
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3, 4, 1, 2])
+     *   .skipWhile(x => x < 3)
+     *   .collect(); // [3, 4, 1, 2]
+     * ```
+     */
+    skipWhile(predicate: (value: T, index: number) => boolean): Iter<T>;
+    /**
+     * Добавляет индекс к каждому элементу (ленивая операция).
+     *
+     * @returns Новый Iter с кортежами [индекс, значение]
+     *
+     * @example
+     * ```ts
+     * Iter.from(['a', 'b', 'c'])
+     *   .enumerate()
+     *   .collect(); // [[0, 'a'], [1, 'b'], [2, 'c']]
+     * ```
+     */
+    enumerate(): Iter<[number, T]>;
+    /**
+     * Объединяет два итератора в пары (ленивая операция).
+     * Останавливается когда любой из итераторов заканчивается.
+     *
+     * @template U - Тип элементов второго итератора
+     * @param other - Второй итератор
+     * @returns Новый Iter с кортежами
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3])
+     *   .zip(['a', 'b', 'c'])
+     *   .collect(); // [[1, 'a'], [2, 'b'], [3, 'c']]
+     * ```
+     */
+    zip<U>(other: Iterable<U>): Iter<[T, U]>;
+    /**
+     * Соединяет этот итератор с другим (ленивая операция).
+     *
+     * @param other - Второй итератор
+     * @returns Новый Iter с элементами обоих итераторов
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2])
+     *   .chain([3, 4])
+     *   .collect(); // [1, 2, 3, 4]
+     * ```
+     */
+    chain(other: Iterable<T>): Iter<T>;
+    /**
+     * Берёт каждый n-ный элемент (ленивая операция).
+     *
+     * @param step - Шаг
+     * @returns Новый Iter с каждым n-ным элементом
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3, 4, 5, 6])
+     *   .stepBy(2)
+     *   .collect(); // [1, 3, 5]
+     * ```
+     */
+    stepBy(step: number): Iter<T>;
+    /**
+     * Выполняет действие для каждого элемента без изменения (ленивая операция).
+     * Полезно для отладки или побочных эффектов.
+     *
+     * @param fn - Функция для выполнения
+     * @returns Тот же Iter
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3])
+     *   .inspect(x => console.log('processing:', x))
+     *   .map(x => x * 2)
+     *   .collect();
+     * ```
+     */
+    inspect(fn: (value: T, index: number) => void): Iter<T>;
+    /**
+     * Удаляет дубликаты (ленивая операция).
+     * Использует Set для отслеживания уникальности.
+     *
+     * @returns Новый Iter без дубликатов
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 2, 3, 1, 4])
+     *   .unique()
+     *   .collect(); // [1, 2, 3, 4]
+     * ```
+     */
+    unique(): Iter<T>;
+    /**
+     * Удаляет дубликаты по ключу (ленивая операция).
+     *
+     * @template K - Тип ключа
+     * @param keyFn - Функция получения ключа
+     * @returns Новый Iter без дубликатов по ключу
+     *
+     * @example
+     * ```ts
+     * Iter.from([{id: 1, name: 'A'}, {id: 1, name: 'B'}, {id: 2, name: 'C'}])
+     *   .uniqueBy(obj => obj.id)
+     *   .collect(); // [{id: 1, name: 'A'}, {id: 2, name: 'C'}]
+     * ```
+     */
+    uniqueBy<K>(keyFn: (value: T) => K): Iter<T>;
+    /**
+     * Собирает все элементы в массив (потребляющая операция).
+     *
+     * @returns Массив со всеми элементами
+     *
+     * @example
+     * ```ts
+     * const arr = Iter.from([1, 2, 3]).collect();
+     * ```
+     */
+    collect(): T[];
+    /**
+     * Fast path для typed array с только map операциями.
+     * Прямой доступ без iterator overhead.
+     */
+    private collectTypedArrayMapOnly;
+    /**
+     * Свёртывает итератор в одно значение слева направо (потребляющая операция).
+     * Аналог reduce в JS или fold в Rust.
+     *
+     * @template U - Тип аккумулятора
+     * @param initial - Начальное значение аккумулятора
+     * @param fn - Функция свёртки
+     * @returns Финальное значение аккумулятора
+     *
+     * @example
+     * ```ts
+     * const sum = Iter.from([1, 2, 3, 4])
+     *   .fold(0, (acc, x) => acc + x); // 10
+     * ```
+     */
+    fold<U>(initial: U, fn: (acc: U, value: T, index: number) => U): U;
+    /**
+     * Свёртывает итератор справа налево (потребляющая операция).
+     * Требует полной материализации в память.
+     *
+     * @template U - Тип аккумулятора
+     * @param initial - Начальное значение аккумулятора
+     * @param fn - Функция свёртки
+     * @returns Финальное значение аккумулятора
+     *
+     * @example
+     * ```ts
+     * const result = Iter.from(['a', 'b', 'c'])
+     *   .foldRight('', (acc, x) => acc + x); // "cba"
+     * ```
+     */
+    foldRight<U>(initial: U, fn: (acc: U, value: T, index: number) => U): U;
+    /**
+     * Свёртывает непустой итератор, используя первый элемент как начальное значение.
+     * Возвращает None если итератор пустой.
+     *
+     * @param fn - Функция свёртки
+     * @returns Option со значением или None
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3, 4])
+     *   .reduce((acc, x) => acc + x); // Some(10)
+     * Iter.empty<number>()
+     *   .reduce((acc, x) => acc + x); // None
+     * ```
+     */
+    reduce(fn: (acc: T, value: T, index: number) => T): Option<T>;
+    /**
+     * Выполняет функцию для каждого элемента (потребляющая операция).
+     *
+     * @param fn - Функция для выполнения
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3]).forEach(x => console.log(x));
+     * ```
+     */
+    forEach(fn: (value: T, index: number) => void): void;
+    /**
+     * Считает количество элементов (потребляющая операция).
+     *
+     * @returns Количество элементов
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3]).count(); // 3
+     * ```
+     */
+    count(): number;
+    /**
+     * Находит первый элемент, удовлетворяющий предикату (потребляющая операция).
+     *
+     * @param predicate - Функция-предикат
+     * @returns Option с найденным элементом или None
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3, 4])
+     *   .find(x => x > 2); // Some(3)
+     * ```
+     */
+    find(predicate: (value: T, index: number) => boolean): Option<T>;
+    /**
+     * Находит первый элемент, удовлетворяющий предикату (потребляющая операция).
+     * Аналог find в JS массивах.
+     *
+     * @param predicate - Функция-предикат
+     * @returns Найденный элемент или undefined если не найден
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3, 4]).findJS(x => x > 2); // 3
+     * Iter.from([1, 2, 3, 4]).findJS(x => x > 10); // undefined
+     * ```
+     */
+    findJS(predicate: (value: T, index: number) => boolean): T | undefined;
+    /**
+     * Находит позицию первого элемента, удовлетворяющего предикату (потребляющая операция).
+     *
+     * @param predicate - Функция-предикат
+     * @returns Option с индексом или None
+     *
+     * @example
+     * ```ts
+     * Iter.from(['a', 'b', 'c'])
+     *   .position(x => x === 'b'); // Some(1)
+     * ```
+     */
+    position(predicate: (value: T, index: number) => boolean): Option<number>;
+    /**
+     * Находит индекс первого элемента, удовлетворяющего предикату (потребляющая операция).
+     * Аналог findIndex в JS массивах.
+     *
+     * @param predicate - Функция-предикат
+     * @returns Индекс найденного элемента или -1 если не найден
+     *
+     * @example
+     * ```ts
+     * Iter.from(['a', 'b', 'c']).findIndex(x => x === 'b'); // 1
+     * Iter.from(['a', 'b', 'c']).findIndex(x => x === 'd'); // -1
+     * ```
+     */
+    findIndex(predicate: (value: T, index: number) => boolean): number;
+    /**
+     * Проверяет, что все элементы удовлетворяют предикату (потребляющая операция).
+     *
+     * @param predicate - Функция-предикат
+     * @returns true если все элементы удовлетворяют предикату
+     *
+     * @example
+     * ```ts
+     * Iter.from([2, 4, 6]).all(x => x % 2 === 0); // true
+     * Iter.from([2, 3, 6]).all(x => x % 2 === 0); // false
+     * ```
+     */
+    all(predicate: (value: T, index: number) => boolean): boolean;
+    /**
+     * Проверяет, что все элементы удовлетворяют предикату (потребляющая операция).
+     * Аналог every в JS массивах.
+     *
+     * @param predicate - Функция-предикат
+     * @returns true если все элементы удовлетворяют предикату
+     *
+     * @example
+     * ```ts
+     * Iter.from([2, 4, 6]).everyJS(x => x % 2 === 0); // true
+     * Iter.from([2, 3, 6]).everyJS(x => x % 2 === 0); // false
+     * ```
+     */
+    everyJS(predicate: (value: T, index: number) => boolean): boolean;
+    /**
+     * Проверяет, что хотя бы один элемент удовлетворяет предикату (потребляющая операция).
+     *
+     * @param predicate - Функция-предикат
+     * @returns true если хотя бы один элемент удовлетворяет предикату
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3]).any(x => x > 2); // true
+     * Iter.from([1, 2, 3]).any(x => x > 5); // false
+     * ```
+     */
+    any(predicate: (value: T, index: number) => boolean): boolean;
+    /**
+     * Проверяет, что хотя бы один элемент удовлетворяет предикату (потребляющая операция).
+     * Аналог some в JS массивах.
+     *
+     * @param predicate - Функция-предикат
+     * @returns true если хотя бы один элемент удовлетворяет предикату
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3]).someJS(x => x > 2); // true
+     * Iter.from([1, 2, 3]).someJS(x => x > 5); // false
+     * ```
+     */
+    someJS(predicate: (value: T, index: number) => boolean): boolean;
+    /**
+     * Разделяет итератор на две группы по предикату (потребляющая операция).
+     *
+     * @param predicate - Функция-предикат
+     * @returns Кортеж [элементы true, элементы false]
+     *
+     * @example
+     * ```ts
+     * const [evens, odds] = Iter.from([1, 2, 3, 4])
+     *   .partition(x => x % 2 === 0);
+     * // evens: [2, 4], odds: [1, 3]
+     * ```
+     */
+    partition(predicate: (value: T, index: number) => boolean): [T[], T[]];
+    /**
+     * Находит первый элемент (потребляющая операция).
+     *
+     * @returns Option с первым элементом или None
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3]).first(); // Some(1)
+     * Iter.empty<number>().first(); // None
+     * ```
+     */
+    first(): Option<T>;
+    /**
+     * Находит последний элемент (потребляющая операция).
+     *
+     * @returns Option с последним элементом или None
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3]).last(); // Some(3)
+     * Iter.empty<number>().last(); // None
+     * ```
+     */
+    last(): Option<T>;
+    /**
+     * Находит n-ный элемент (потребляющая операция).
+     *
+     * @param n - Индекс элемента
+     * @returns Option с n-ным элементом или None
+     *
+     * @example
+     * ```ts
+     * Iter.from(['a', 'b', 'c']).nth(1); // Some('b')
+     * Iter.from(['a', 'b']).nth(5); // None
+     * ```
+     */
+    nth(n: number): Option<T>;
+    /**
+     * Проверяет, содержит ли итератор указанный элемент (потребляющая операция).
+     * Аналог includes в JS массивах.
+     *
+     * @param searchElement - Искомый элемент
+     * @param fromIndex - Индекс начала поиска (опционально)
+     * @returns true если элемент найден, иначе false
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3]).includes(2); // true
+     * Iter.from([1, 2, 3]).includes(4); // false
+     * ```
+     */
+    includes(searchElement: T, fromIndex?: number): boolean;
+    /**
+     * Находит максимальный элемент (потребляющая операция).
+     *
+     * @returns Option с максимальным элементом или None
+     *
+     * @example
+     * ```ts
+     * Iter.from([3, 1, 4, 1, 5]).max(); // Some(5)
+     * Iter.empty<number>().max(); // None
+     * ```
+     */
+    max(): Option<T>;
+    /**
+     * Находит минимальный элемент (потребляющая операция).
+     *
+     * @returns Option с минимальным элементом или None
+     *
+     * @example
+     * ```ts
+     * Iter.from([3, 1, 4, 1, 5]).min(); // Some(1)
+     * Iter.empty<number>().min(); // None
+     * ```
+     */
+    min(): Option<T>;
+    /**
+     * Находит максимальный элемент по ключу (потребляющая операция).
+     *
+     * @template K - Тип ключа для сравнения
+     * @param keyFn - Функция получения ключа
+     * @returns Option с элементом, имеющим максимальный ключ, или None
+     *
+     * @example
+     * ```ts
+     * Iter.from([{age: 20}, {age: 30}, {age: 25}])
+     *   .maxBy(x => x.age); // Some({age: 30})
+     * ```
+     */
+    maxBy<K>(keyFn: (value: T) => K): Option<T>;
+    /**
+     * Находит минимальный элемент по ключу (потребляющая операция).
+     *
+     * @template K - Тип ключа для сравнения
+     * @param keyFn - Функция получения ключа
+     * @returns Option с элементом, имеющим минимальный ключ, или None
+     *
+     * @example
+     * ```ts
+     * Iter.from([{age: 20}, {age: 30}, {age: 25}])
+     *   .minBy(x => x.age); // Some({age: 20})
+     * ```
+     */
+    minBy<K>(keyFn: (value: T) => K): Option<T>;
+    /**
+     * Суммирует числовые элементы (потребляющая операция).
+     *
+     * @returns Сумма всех элементов
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3, 4]).sum(); // 10
+     * ```
+     */
+    sum(this: Iter<number>): number;
+    /**
+     * Перемножает числовые элементы (потребляющая операция).
+     *
+     * @returns Произведение всех элементов
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3, 4]).product(); // 24
+     * ```
+     */
+    product(this: Iter<number>): number;
+    /**
+     * Объединяет строковые элементы в одну строку (потребляющая операция).
+     *
+     * @param separator - Разделитель (по умолчанию '')
+     * @returns Объединённая строка
+     *
+     * @example
+     * ```ts
+     * Iter.from(['a', 'b', 'c']).join('-'); // "a-b-c"
+     * ```
+     */
+    join(this: Iter<string>, separator?: string): string;
+    /**
+     * Собирает элементы в Set (потребляющая операция).
+     *
+     * @returns Set со всеми элементами
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 2, 3, 1]).toSet(); // Set {1, 2, 3}
+     * ```
+     */
+    toSet(): Set<T>;
+    /**
+     * Собирает пары ключ-значение в Map (потребляющая операция).
+     *
+     * @template K - Тип ключа
+     * @template V - Тип значения
+     * @returns Map со всеми парами
+     *
+     * @example
+     * ```ts
+     * Iter.from([[1, 'a'], [2, 'b']]).toMap();
+     * // Map {1 => 'a', 2 => 'b'}
+     * ```
+     */
+    toMap<K, V>(this: Iter<[K, V]>): Map<K, V>;
+    /**
+     * Группирует элементы по ключу (потребляющая операция).
+     *
+     * @template K - Тип ключа
+     * @param keyFn - Функция получения ключа
+     * @returns Map с группами элементов
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3, 4, 5, 6])
+     *   .groupBy(x => x % 2 === 0 ? 'even' : 'odd');
+     * // Map {'odd' => [1, 3, 5], 'even' => [2, 4, 6]}
+     * ```
+     */
+    groupBy<K>(keyFn: (value: T) => K): Map<K, T[]>;
+    /**
+     * Сортирует элементы (потребляющая операция).
+     * Требует полной материализации в память.
+     *
+     * @param compareFn - Функция сравнения (опциональная)
+     * @returns Новый Iter с отсортированными элементами
+     *
+     * @example
+     * ```ts
+     * Iter.from([3, 1, 4, 1, 5])
+     *   .sort()
+     *   .collect(); // [1, 1, 3, 4, 5]
+     * ```
+     */
+    sort(compareFn?: (a: T, b: T) => number): Iter<T>;
+    /**
+     * Сортирует элементы по ключу (потребляющая операция).
+     * Требует полной материализации в память.
+     *
+     * @template K - Тип ключа для сортировки
+     * @param keyFn - Функция получения ключа
+     * @returns Новый Iter с отсортированными элементами
+     *
+     * @example
+     * ```ts
+     * Iter.from([{age: 30}, {age: 20}, {age: 25}])
+     *   .sortBy(x => x.age)
+     *   .collect(); // [{age: 20}, {age: 25}, {age: 30}]
+     * ```
+     */
+    sortBy<K>(keyFn: (value: T) => K): Iter<T>;
+    /**
+     * Разворачивает порядок элементов (потребляющая операция).
+     * Требует полной материализации в память.
+     *
+     * @returns Новый Iter с элементами в обратном порядке
+     *
+     * @example
+     * ```ts
+     * Iter.from([1, 2, 3])
+     *   .reverse()
+     *   .collect(); // [3, 2, 1]
+     * ```
+     */
+    reverse(): Iter<T>;
+}
+export {};
+//# sourceMappingURL=iterator.d.ts.map