Iteration utilities

Base.Iterators.Stateful — Type
Stateful(itr)

このイテレーターラッパーについては、いくつかの異なる捉え方があります。

  1. イテレーターとその反復状態を、可変なラッパーで包むもの。
  2. イテレーターのような抽象を、Channelのような抽象に変換するもの。
  3. 要素を生成するたびに自身を残りのイテレーターへと変化させるイテレーター。

Statefulは、標準的なイテレーターインターフェースを提供します。他の可変イテレーター(例:Base.Channel)と同様に、反復を途中で停止した場合(たとえば、forループ内でbreakを使った場合)、同じイテレーターオブジェクトで反復を続ければ、停止した位置から再開できます(不変イテレーターの場合は、先頭から再開します)。

Examples

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

julia> isempty(a)
false

julia> popfirst!(a)
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> collect(Iterators.take(a, 3))
3-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)

julia> collect(a)
2-element Vector{Char}:
 'e': ASCII/Unicode U+0065 (category Ll: Letter, lowercase)
 'f': ASCII/Unicode U+0066 (category Ll: Letter, lowercase)

julia> Iterators.reset!(a); popfirst!(a)
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> Iterators.reset!(a, "hello"); popfirst!(a)
'h': ASCII/Unicode U+0068 (category Ll: Letter, lowercase)
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) # Sum the remaining elements
7
source
Base.Iterators.zip — Function
zip(iters...)

複数のイテレータを同時に実行し、いずれかが終了するまで続けます。zip の値の型は、そのサブイテレータの値を要素とするタプルです。

Note

zip は、あるイテレータが現在の反復で終了したときに、状態を持つほかのイテレータが進まないよう、サブイテレータの呼び出し順序を調整します。

Note

引数なしの zip() は、空のタプルを無限に返すイテレータを生成します。

関連項目: enumerate、Base.splat。

Examples

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")
source
Base.Iterators.enumerate — Function
enumerate(iter)

(i, x)を返すイテレータです。iは1から始まるカウンターで、xは、指定したイテレータから得られるi番目の値です。反復対象の値xだけでなく、これまでの反復回数も必要な場合に便利です。

iは、iterのインデックスとして有効とは限らず、別の要素を指す場合もあります。これは、iterのインデックスが1から始まらない場合に起こります。また、文字列や辞書などでも起こることがあります。iがインデックスであることを確実にしたい場合は、pairs(IndexLinear(), iter)メソッドを参照してください。

Examples

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'
source
Base.Iterators.rest — Function
rest(iter, state)

iterと同じ要素を返すイテレータ。ただし、指定されたstateから開始します。この状態は、iterate(iter[, state])を1回以上呼び出すことで到達できる状態でなければなりません。

関連項目: Iterators.drop、Iterators.peel、Base.rest。

Examples

julia> iter = [1,2,3,4];

julia> val, state = iterate(iter)
(1, 2)

julia> collect(Iterators.rest(iter, state))
3-element Vector{Int64}:
 2
 3
 4
source
Base.Iterators.countfrom — Function
countfrom(start=1, step=1)

startから始まり、stepずつ増加しながら無限に数え続けるイテレータ。

Examples

julia> for v in Iterators.countfrom(5, 2)
           v > 10 && break
           println(v)
       end
5
7
9
source
Base.Iterators.take — Function
take(iter, n)

iter の要素を先頭から最大 n 個生成するイテレータ。

関連項目: drop, peel, first, Base.take!.

Examples

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
source
Base.Iterators.takewhile — Function
takewhile(pred, iter)

述語 pred が真である間、iter から要素を生成し、その後はすべての要素を破棄するイテレーターです。

Julia 1.4

この関数を使用するには、Julia 1.4 以降が必要です。

Examples

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
source
Base.Iterators.drop — Function
drop(iter, n)

n の最初の要素を除いたすべての要素を生成するイテレータです。iter

Examples

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
source
Base.Iterators.dropwhile — Function
dropwhile(pred, iter)

述語 pred が真である間、iter から要素を取り除き、その後はすべての要素を返すイテレータです。

Julia 1.4

この関数を使用するには、Julia 1.4 以降が必要です。

Examples

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
source
Base.Iterators.findeach — Function
findeach(f, it)
findeach(it)

pairs(it) のキーと値のペアから、f(value) が true を返す場合に、すべてのキーを生成するイテレーターです。

f が指定されていない場合、デフォルトは identity です。

Iterators.findeach は、findall に相当する遅延評価版です。

Julia 1.13

findeach を使用するには、Julia 1.13 以降が必要です。

Examples

julia> collect(Iterators.findeach(isodd, Dict(2 => 3, 3 => 2)))
1-element Vector{Int64}:
 2

julia> only(Iterators.findeach(==(1), [3,6,2,1]))
4
source
Base.Iterators.nth — Function
nth(n::Integer)

渡された任意のイテレータから、n 番目の要素を取得する関数を返します。Base.Fix2(nth, n) または itr -> nth(itr, n) と同等です。

関連項目: nth、Base.Fix2

Examples

julia> fifth_element = Iterators.nth(5)
(::Base.Fix2{typeof(Base.Iterators.nth), Int64}) (generic function with 2 methods)

julia> fifth_element(reshape(1:30, (5,6)))
5

julia> map(fifth_element, ("Willis", "Jovovich", "Oldman"))
('i', 'v', 'a')
source
nth(itr, n::Integer)

反復可能なコレクションのn番目の要素を取得します。要素が存在しない場合は、BoundsError[@ref]をスローします。Stateful[@ref]イテレーターは進みます。

関連項目: first、last

Examples

julia> Iterators.nth(2:2:10, 4)
8

julia> Iterators.nth(reshape(1:30, (5,6)), 6)
6

julia> stateful = Iterators.Stateful(1:10); Iterators.nth(stateful, 7)
7

julia> first(stateful)
8
Julia 1.13

この関数を使用するには、Julia 1.13以降が必要です。

source
Base.Iterators.cycle — Function
cycle(iter[, n::Int])

iterを無限に繰り返すイテレータです。nを指定すると、iterをその回数だけ繰り返します。iterが空の場合、cycle(iter)とcycle(iter, n)も空になります。

Iterators.cycle(iter, n)はBase.repeat(vector, n)の遅延評価版です。一方、Iterators.repeated(iter, n)はBase.fill(item, n)の遅延評価版です。

Julia 1.11

メソッドcycle(iter, n)はJulia 1.11で追加されました。

Examples

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
source
Base.Iterators.repeated — Function
repeated(x[, n::Int])

値 x を無限に生成するイテレーターです。n を指定すると、その回数だけ x を生成します(take(repeated(x), n) と同等です)。

fill も参照してください。また、Iterators.cycle と比較してください。

Examples

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]
source
Base.Iterators.product — Function
product(iters...)

複数のイテレータの直積を走査するイテレータを返します。生成される各要素はタプルであり、そのi番目の要素は、引数として渡されたi番目のイテレータから取得されます。最初のイテレータが最も速く変化します。

関連項目: zip、Iterators.flatten。

Examples

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]  # collects a generator involving Iterators.product
true
source
Base.Iterators.flatten — Function
flatten(iter)

イテレータを生成するイテレータを受け取り、それらのイテレータの要素を生成するイテレータを返します。言い換えると、引数のイテレータが生成する要素を連結します。

Examples

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']  # collects generators involving Iterators.flatten
6-element Vector{Tuple{Int64, Char}}:
 (0, 'a')
 (0, 'b')
 (0, 'c')
 (1, 'a')
 (1, 'b')
 (1, 'c')
source
Base.Iterators.flatmap — Function
Iterators.flatmap(f, iterators...)

flatten(map(f, iterators...))と同等です。

関連項目:Iterators.flatten、Iterators.map。

Julia 1.9

この関数はJulia 1.9で追加されました。

Examples

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
source
Base.Iterators.partition — Function
partition(collection, n)

コレクションを、1回につきn個の要素ずつ反復処理します。

Examples

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]
source
Base.Iterators.map — Function
Iterators.map(f, iterators...)

遅延マッピングを作成します。これは、(f(args...) for args in zip(iterators...)) を記述する別の構文です。

Julia 1.6

この関数を使用するには、Julia 1.6 以降が必要です。

Examples

julia> collect(Iterators.map(x -> x^2, 1:3))
3-element Vector{Int64}:
 1
 4
 9
source
Base.Iterators.filter — Function
Iterators.filter(flt, itr)

述語関数 flt と反復可能オブジェクト itr を受け取り、反復時に itr の要素 x のうち、flt(x) を満たすものを返す反復可能オブジェクトを返します。元のイテレーターの順序は保持されます。

この関数は 遅延評価 されます。つまり、$Θ(1)$ 時間で返り、追加で使用する領域は $Θ(1)$ であることが保証されます。また、filter の呼び出し時に flt が呼び出されることはありません。flt は、返された反復可能オブジェクトを反復するときに呼び出されます。これらの呼び出しはキャッシュされないため、再度反復すると再び呼び出されます。

Warning

filter が返すイテレーターに対して、Iterators.reverse や cycle が行うような 遅延評価 の変換を続けて適用した場合も、返された反復可能オブジェクトを収集または反復するまで、flt の呼び出しは遅延されます。フィルター述語が非決定的である場合や、その戻り値が itr の要素を反復する順序に依存する場合、遅延変換を組み合わせると予期しない動作になることがあります。これを避けるには、flt が純粋関数であることを確認するか、後続の変換を行う前に中間の filter イテレーターを収集してください。

配列に対するフィルタリングの即時評価版については、Base.filter を参照してください。

Examples

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)]  # collects a generator over Iterators.filter
3-element Vector{Int64}:
 1
 3
 5
source
Base.Iterators.accumulate — Function
Iterators.accumulate(f, itr; [init])

2引数関数 f とイテレータ itr を受け取り、直前の値と itr の次の要素に f を順次適用する、新しいイテレータを返します。

これは実質的に、Base.accumulate の遅延評価版です。

Julia 1.5

キーワード引数 init は Julia 1.5 で追加されました。

Examples

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
source
Base.Iterators.reverse — Function
Iterators.reverse(itr)

イテレータ itr が与えられたとき、reverse(itr) は同じコレクションを逆順にたどるイテレータです。このイテレータは「遅延」型であり、逆順にするためにコレクションのコピーを作成しません。コピーを作成する実装については、Base.reverse を参照してください。

(デフォルトでは、itr をラップする Iterators.Reverse オブジェクトを返します。このオブジェクトは、対応する iterate メソッドが定義されていれば反復可能ですが、一部の itr 型では、より特化した Iterators.reverse の動作が実装されている場合があります。)

すべてのイテレータ型 T が逆順の反復をサポートしているわけではありません。T がサポートしていない場合、Iterators.reverse(itr::T) を反復すると、Iterators.Reverse{T} に必要な iterate メソッドがないため、MethodError がスローされます。(これらのメソッドを実装するには、r::Iterators.Reverse{T} オブジェクトから r.itr によって元のイテレータ itr::T を取得できます。より一般的には、Iterators.reverse(r) を使用できます。)

Examples

julia> foreach(println, Iterators.reverse(1:5))
5
4
3
2
1
source
Base.Iterators.only — Function
only(x)

コレクション x の要素が1つだけならそれを返し、要素が0個または複数ある場合は ArgumentError をスローします。

関連項目: first、last。

Julia 1.4

このメソッドを使用するには、Julia 1.4 以降が必要です。

Examples

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

julia> only("a")
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> only(())
ERROR: ArgumentError: Tuple contains 0 elements, must contain exactly 1 element
Stacktrace:
[...]

julia> only(('a', 'b'))
ERROR: ArgumentError: Tuple contains 2 elements, must contain exactly 1 element
Stacktrace:
[...]
source
Base.Iterators.peel — Function
peel(iter)

最初の要素と、残りの要素を反復するイテレータを返します。

イテレータが空の場合は、nothing(iterateなど)を返します。

Julia 1.7

以前のバージョンでは、イテレータが空の場合にBoundsErrorがスローされます。

関連項目: Iterators.drop、Iterators.take。

Examples

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

julia> a
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> collect(rest)
2-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
source