Iteration utilities

Stateful(itr)

Hay varias formas diferentes de pensar en este envoltorio de iterador:

1. Proporciona un envoltorio mutable alrededor de un iterador y su estado de iteración.
2. Convierte una abstracción similar a un iterador en una abstracción similar a un Channel.
3. Es un iterador que se muta para convertirse en su propio iterador de resto cada vez que se produce un elemento.

Stateful proporciona la interfaz de iterador regular. Al igual que otros iteradores mutables (por ejemplo, Base.Channel), si la iteración se detiene prematuramente (por ejemplo, mediante un break en un bucle for), la iteración se puede reanudar desde el mismo lugar al continuar iterando sobre el mismo objeto iterador (en contraste, un iterador inmutable se reiniciaría desde el principio).

Ejemplos

julia> a = Iterators.Stateful("abcdef");

julia> isempty(a)
false

julia> popfirst!(a)
'a': ASCII/Unicode U+0061 (categoría Ll: Letra, minúscula)

julia> collect(Iterators.take(a, 3))
3-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (categoría Ll: Letra, minúscula)
 'c': ASCII/Unicode U+0063 (categoría Ll: Letra, minúscula)
 'd': ASCII/Unicode U+0064 (categoría Ll: Letra, minúscula)

julia> collect(a)
2-element Vector{Char}:
 'e': ASCII/Unicode U+0065 (categoría Ll: Letra, minúscula)
 'f': ASCII/Unicode U+0066 (categoría Ll: Letra, minúscula)

julia> Iterators.reset!(a); popfirst!(a)
'a': ASCII/Unicode U+0061 (categoría Ll: Letra, minúscula)

julia> Iterators.reset!(a, "hello"); popfirst!(a)
'h': ASCII/Unicode U+0068 (categoría Ll: Letra, minúscula)

julia> a = Iterators.Stateful([1,1,1,2,3,4]);

julia> for x in a; x == 1 || break; end

julia> peek(a)
3

julia> sum(a) # Sumar los elementos restantes
7

zip(iters...)

Ejecuta múltiples iteradores al mismo tiempo, hasta que cualquiera de ellos se agote. El tipo de valor del iterador zip es una tupla de valores de sus subiteradores.

Véase también: enumerate, Base.splat.

Ejemplos

julia> a = 1:5
1:5

julia> b = ["e","d","b","c","a"]
5-element Vector{String}:
 "e"
 "d"
 "b"
 "c"
 "a"

julia> c = zip(a,b)
zip(1:5, ["e", "d", "b", "c", "a"])

julia> length(c)
5

julia> first(c)
(1, "e")

enumerar(iter)

Un iterador que produce (i, x) donde i es un contador que comienza en 1, y x es el valor i-ésimo del iterador dado. Es útil cuando necesitas no solo los valores x sobre los que estás iterando, sino también el número de iteraciones hasta ahora.

Ten en cuenta que i puede no ser válido para indexar iter, o puede indexar un elemento diferente. Esto sucederá si iter tiene índices que no comienzan en 1, y puede suceder con cadenas, diccionarios, etc. Consulta el método pares(IndexLinear(), iter) si deseas asegurarte de que i sea un índice.

Ejemplos

julia> a = ["a", "b", "c"];

julia> for (index, value) in enumerate(a)
           println("$index $value")
       end
1 a
2 b
3 c

julia> str = "naïve";

julia> for (i, val) in enumerate(str)
           print("i = ", i, ", val = ", val, ", ")
           try @show(str[i]) catch e println(e) end
       end
i = 1, val = n, str[i] = 'n'
i = 2, val = a, str[i] = 'a'
i = 3, val = ï, str[i] = 'ï'
i = 4, val = v, StringIndexError("naïve", 4)
i = 5, val = e, str[i] = 'v'

rest(iter, state)

Un iterador que produce los mismos elementos que iter, pero comenzando en el estado dado.

Véase también: Iterators.drop, Iterators.peel, Base.rest.

Ejemplos

julia> collect(Iterators.rest([1,2,3,4], 2))
3-element Vector{Int64}:
 2
 3
 4

countfrom(start=1, step=1)

Un iterador que cuenta para siempre, comenzando en start e incrementando por step.

Ejemplos

julia> for v in Iterators.countfrom(5, 2)
           v > 10 && break
           println(v)
       end
5
7
9

take(iter, n)

Un iterador que genera como máximo los primeros n elementos de iter.

Véase también: drop, peel, first, Base.take!.

Ejemplos

julia> a = 1:2:11
1:2:11

julia> collect(a)
6-element Vector{Int64}:
  1
  3
  5
  7
  9
 11

julia> collect(Iterators.take(a,3))
3-element Vector{Int64}:
 1
 3
 5

takewhile(pred, iter)

Un iterador que genera elementos de iter mientras la predicción pred sea verdadera, después, descarta cada elemento.

Ejemplos

julia> s = collect(1:5)
5-element Vector{Int64}:
 1
 2
 3
 4
 5

julia> collect(Iterators.takewhile(<(3),s))
2-element Vector{Int64}:
 1
 2

drop(iter, n)

Un iterador que genera todos menos los primeros n elementos de iter.

Ejemplos

julia> a = 1:2:11
1:2:11

julia> collect(a)
6-element Vector{Int64}:
  1
  3
  5
  7
  9
 11

julia> collect(Iterators.drop(a,4))
2-element Vector{Int64}:
  9
 11

dropwhile(pred, iter)

Un iterador que descarta elementos de iter mientras la predicción pred sea verdadera, después devuelve cada elemento.

Ejemplos

julia> s = collect(1:5)
5-element Vector{Int64}:
 1
 2
 3
 4
 5

julia> collect(Iterators.dropwhile(<(3),s))
3-element Vector{Int64}:
 3
 4
 5

cycle(iter[, n::Int])

Un iterador que cicla a través de iter para siempre. Si se especifica n, entonces cicla a través de iter tantas veces. Cuando iter está vacío, también lo están cycle(iter) y cycle(iter, n).

Iterators.cycle(iter, n) es el equivalente perezoso de Base.repeat(vector, n), mientras que Iterators.repeated(iter, n) es el perezoso Base.fill(item, n).

Ejemplos

julia> for (i, v) in enumerate(Iterators.cycle("hello"))
           print(v)
           i > 10 && break
       end
hellohelloh

julia> foreach(print, Iterators.cycle(['j', 'u', 'l', 'i', 'a'], 3))
juliajuliajulia

julia> repeat([1,2,3], 4) == collect(Iterators.cycle([1,2,3], 4))
true

julia> fill([1,2,3], 4) == collect(Iterators.repeated([1,2,3], 4))
true

repeated(x[, n::Int])

Un iterador que genera el valor x para siempre. Si se especifica n, genera x esa cantidad de veces (equivalente a take(repeated(x), n)).

Véase también fill, y compare Iterators.cycle.

Ejemplos

julia> a = Iterators.repeated([1 2], 4);

julia> collect(a)
4-element Vector{Matrix{Int64}}:
 [1 2]
 [1 2]
 [1 2]
 [1 2]

julia> ans == fill([1 2], 4)
true

julia> Iterators.cycle([1 2], 4) |> collect |> println
[1, 2, 1, 2, 1, 2, 1, 2]

product(iters...)

Devuelve un iterador sobre el producto de varios iteradores. Cada elemento generado es una tupla cuyo i-ésimo elemento proviene del i-ésimo iterador de argumento. El primer iterador cambia más rápido.

Véase también: zip, Iterators.flatten.

Ejemplos

julia> collect(Iterators.product(1:2, 3:5))
2×3 Matrix{Tuple{Int64, Int64}}:
 (1, 3)  (1, 4)  (1, 5)
 (2, 3)  (2, 4)  (2, 5)

julia> ans == [(x,y) for x in 1:2, y in 3:5]  # recoge un generador que involucra Iterators.product
true

flatten(iter)

Dado un iterador que produce iteradores, devuelve un iterador que produce los elementos de esos iteradores. Dicho de otra manera, los elementos del iterador de argumento se concatenan.

Ejemplos

julia> collect(Iterators.flatten((1:2, 8:9)))
4-element Vector{Int64}:
 1
 2
 8
 9

julia> [(x,y) for x in 0:1 for y in 'a':'c']  # recoge generadores que involucran Iterators.flatten
6-element Vector{Tuple{Int64, Char}}:
 (0, 'a')
 (0, 'b')
 (0, 'c')
 (1, 'a')
 (1, 'b')
 (1, 'c')

Iterators.flatmap(f, iterators...)

Equivalente a flatten(map(f, iterators...)).

Véase también Iterators.flatten, Iterators.map.

Ejemplos

julia> Iterators.flatmap(n -> -n:2:n, 1:3) |> collect
9-element Vector{Int64}:
 -1
  1
 -2
  0
  2
 -3
 -1
  1
  3

julia> stack(n -> -n:2:n, 1:3)
ERROR: DimensionMismatch: stack expects uniform slices, got axes(x) == (1:3,) while first had (1:2,)
[...]

julia> Iterators.flatmap(n -> (-n, 10n), 1:2) |> collect
4-element Vector{Int64}:
 -1
 10
 -2
 20

julia> ans == vec(stack(n -> (-n, 10n), 1:2))
true

partition(colección, n)

Iterar sobre una colección n elementos a la vez.

Ejemplos

julia> collect(Iterators.partition([1,2,3,4,5], 2))
3-element Vector{SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}}:
 [1, 2]
 [3, 4]
 [5]

Iterators.map(f, iterators...)

Crea un mapeo perezoso. Esta es otra sintaxis para escribir (f(args...) for args in zip(iterators...)).

Ejemplos

julia> collect(Iterators.map(x -> x^2, 1:3))
3-element Vector{Int64}:
 1
 4
 9

Iterators.filter(flt, itr)

Dada una función de predicado flt y un objeto iterable itr, devuelve un objeto iterable que al iterar produce los elementos x de itr que satisfacen flt(x). El orden del iterador original se preserva.

Esta función es perezosa; es decir, se garantiza que devolverá en $Θ(1)$ tiempo y usará $Θ(1)$ espacio adicional, y flt no será llamada por una invocación de filter. Las llamadas a flt se realizarán al iterar sobre el objeto iterable devuelto. Estas llamadas no se almacenan en caché y se realizarán llamadas repetidas al reiterar.

Consulta Base.filter para una implementación ansiosa de filtrado para arreglos.

Ejemplos

julia> f = Iterators.filter(isodd, [1, 2, 3, 4, 5])
Base.Iterators.Filter{typeof(isodd), Vector{Int64}}(isodd, [1, 2, 3, 4, 5])

julia> foreach(println, f)
1
3
5

julia> [x for x in [1, 2, 3, 4, 5] if isodd(x)]  # recoge un generador sobre Iterators.filter
Vector{Int64} de 3 elementos:
 1
 3
 5

Iterators.accumulate(f, itr; [init])

Dada una función de 2 argumentos f y un iterador itr, devuelve un nuevo iterador que aplica sucesivamente f al valor anterior y al siguiente elemento de itr.

Esto es efectivamente una versión perezosa de Base.accumulate.

Ejemplos

julia> a = Iterators.accumulate(+, [1,2,3,4]);

julia> foreach(println, a)
1
3
6
10

julia> b = Iterators.accumulate(/, (2, 5, 2, 5); init = 100);

julia> collect(b)
4-element Vector{Float64}:
 50.0
 10.0
  5.0
  1.0

Iterators.reverse(itr)

Dado un iterador itr, entonces reverse(itr) es un iterador sobre la misma colección pero en el orden inverso. Este iterador es "perezoso" en el sentido de que no hace una copia de la colección para invertirla; consulta Base.reverse para una implementación ansiosa.

(Por defecto, esto devuelve un objeto Iterators.Reverse que envuelve itr, el cual es iterable si los métodos correspondientes iterate están definidos, pero algunos tipos de itr pueden implementar comportamientos más especializados de Iterators.reverse.)

No todos los tipos de iteradores T soportan la iteración en orden inverso. Si T no lo hace, entonces iterar sobre Iterators.reverse(itr::T) lanzará un MethodError debido a los métodos iterate faltantes para Iterators.Reverse{T}. (Para implementar estos métodos, el iterador original itr::T se puede obtener de un objeto r::Iterators.Reverse{T} mediante r.itr; más generalmente, se puede usar Iterators.reverse(r).)

Ejemplos

julia> foreach(println, Iterators.reverse(1:5))
5
4
3
2
1

only(x)

Devuelve el único y único elemento de la colección x, o lanza un ArgumentError si la colección tiene cero o múltiples elementos.

Véase también first, last.

Ejemplos

julia> only(["a"])
"a"

julia> only("a")
'a': ASCII/Unicode U+0061 (categoría Ll: Letra, minúscula)

julia> only(())
ERROR: ArgumentError: El tuple contiene 0 elementos, debe contener exactamente 1 elemento
Stacktrace:
[...]

julia> only(('a', 'b'))
ERROR: ArgumentError: El tuple contiene 2 elementos, debe contener exactamente 1 elemento
Stacktrace:
[...]

peel(iter)

Devuelve el primer elemento y un iterador sobre los elementos restantes.

Si el iterador está vacío, devuelve nothing (como iterate).

Véase también: Iterators.drop, Iterators.take.

Ejemplos

julia> (a, rest) = Iterators.peel("abc");

julia> a
'a': ASCII/Unicode U+0061 (categoría Ll: Letra, minúscula)

julia> collect(rest)
2-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (categoría Ll: Letra, minúscula)
 'c': ASCII/Unicode U+0063 (categoría Ll: Letra, minúscula)