|
| 1 | +# This file is a part of Julia. License is MIT: https://julialang.org/license |
| 2 | + |
| 3 | +module TupleFromIterator |
| 4 | + |
| 5 | +import ..TypeIntersectExact as TIE |
| 6 | + |
| 7 | +incremented(n::Int) = Core.Intrinsics.add_int(n, 1) |
| 8 | +decremented(n::Int) = Core.Intrinsics.sub_int(n, 1) |
| 9 | + |
| 10 | +function _totuple_err(@nospecialize T) |
| 11 | + @noinline |
| 12 | + throw(ArgumentError("too few or too many elements for tuple type $T")) |
| 13 | +end |
| 14 | + |
| 15 | +function iterator_to_ntuple_recur(::Type{Tuple{}}, iter, state::Union{Tuple{},Tuple{Any}}) |
| 16 | + i = iterate(iter, state...)::Union{Nothing,Tuple{Any,Any}} |
| 17 | + isnothing(i) || |
| 18 | + throw(ArgumentError("iterator has too many elements for the tuple type")) |
| 19 | + () |
| 20 | +end |
| 21 | +function iterator_to_ntuple_recur(::Type{NTuple{len,E}}, iter, state::Union{Tuple{},Tuple{Any}}) where {len,E} |
| 22 | + T2 = Tuple{E,Any} |
| 23 | + ItUn = Union{Nothing,T2} |
| 24 | + i = iterate(iter, state...)::ItUn |
| 25 | + T = NTuple{len,E} |
| 26 | + isnothing(i) && |
| 27 | + throw(ArgumentError("iterator has too few elements for the tuple type")) |
| 28 | + (e, s) = i::T2 |
| 29 | + Next = NTuple{decremented(len),E} |
| 30 | + t = iterator_to_ntuple_recur(Next, iter, (s,))::Next |
| 31 | + (e, t...)::T |
| 32 | +end |
| 33 | + |
| 34 | +function iterator_to_ntuple(::Type{T}, iter) where {len,T<:NTuple{len,Any}} |
| 35 | + if len < 100 |
| 36 | + iterator_to_ntuple_recur(T, iter, ())::T |
| 37 | + else |
| 38 | + # prevent stack overflow during type inference |
| 39 | + let |
| 40 | + f(i) = (collect(i)...,) |
| 41 | + f(i::Tuple) = i |
| 42 | + f(i::Union{NamedTuple,Core.SimpleVector,Array,Pair}) = (i...,) |
| 43 | + f(i::Array{<:Any,0}) = (first(i),) |
| 44 | + f(i::Union{AbstractArray{<:Any,0},Number,Ref}) = (first(i),) |
| 45 | + f(i::Pair) = (first(i), last(i)) |
| 46 | + f(iter)::T |
| 47 | + end |
| 48 | + end::T |
| 49 | +end |
| 50 | + |
| 51 | +function iterator_to_tuple(::Type{R}, iter) where {R<:Tuple} |
| 52 | + f(i) = collect(i) |
| 53 | + f(i::Union{Tuple,NamedTuple,Core.SimpleVector,Array,AbstractArray{<:Any,0},Number,Ref,Pair}) = i |
| 54 | + |
| 55 | + c = f(iter) |
| 56 | + len = length(c)::Int |
| 57 | + E = eltype(c)::Type |
| 58 | + T = NTuple{len,E} |
| 59 | + r = iterator_to_ntuple(T, c)::Tuple{Vararg{E}}::T |
| 60 | + (r isa R) || _totuple_err(R) |
| 61 | + r::R |
| 62 | +end |
| 63 | + |
| 64 | +""" |
| 65 | + ntuple_any(::Type{<:NTuple{len,Any}}) where {len} |
| 66 | +
|
| 67 | +Like `ntuple(Returns(Any), Val(len))`. |
| 68 | +""" |
| 69 | +ntuple_any(::Type{Tuple{}}) = () |
| 70 | +function ntuple_any(::Type{<:NTuple{len,Any}}) where {len} |
| 71 | + T = NTuple{decremented(len),DataType} |
| 72 | + t = ntuple_any(T)::T |
| 73 | + (Any, t...)::NTuple{len,DataType} |
| 74 | +end |
| 75 | + |
| 76 | +""" |
| 77 | + tuple_va_type_length(::Val) |
| 78 | +
|
| 79 | +Creates a `Vararg` `<:Tuple` type of specified minimal length. |
| 80 | +""" |
| 81 | +function tuple_va_type_length(::Val{len}) where {len} |
| 82 | + Tuple{ntuple_any(NTuple{len,DataType})...,Vararg} |
| 83 | +end |
| 84 | +tuple_va_type_length(n::Int) = tuple_va_type_length(Val(n))::Type{<:Tuple} |
| 85 | + |
| 86 | +tuple_length_type_va(::Type{T}, ::Val{n}, ::Type{S}) where {T<:Tuple,n,S<:Tuple} = Val(decremented(n)) |
| 87 | +function tuple_length_type_va(::Type{T}, ::Val{n}, ::Type{S}) where {n,S<:Tuple,T<:S} |
| 88 | + v = Val(incremented(n)) |
| 89 | + tuple_length_type_va(T, v, tuple_va_type_length(v)::Type{<:Tuple})::Val |
| 90 | +end |
| 91 | + |
| 92 | +""" |
| 93 | + tuple_length_type(::Type{<:Tuple}) |
| 94 | +
|
| 95 | +Strips the element type information from a tuple type while keeping |
| 96 | +the information about the length. |
| 97 | +""" |
| 98 | +function tuple_length_type(::Type{T}) where {T<:Tuple} |
| 99 | + v = Val(1) |
| 100 | + r = tuple_length_type_va(T, v, tuple_va_type_length(v)::Type{<:Tuple})::Val |
| 101 | + tuple_va_type_length(r)::Type{<:Tuple} |
| 102 | +end |
| 103 | +tuple_length_type(::Type{T}) where {len,T<:NTuple{len,Any}} = NTuple{len,Any} |
| 104 | + |
| 105 | +""" |
| 106 | + fieldtype_typeintersect_ntuple(::Type{T}, ::Type{<:NTuple{len,Any}}, ::Val{ind}) where {T<:Tuple, len, ind} |
| 107 | +
|
| 108 | +Returns the type of the field `ind` in the type intersection of `T` with |
| 109 | +`NTuple{len,Any}`. Failing to compute the exact intersection, the field `ind` of |
| 110 | +`T` is returned. |
| 111 | +""" |
| 112 | +function fieldtype_typeintersect_ntuple( |
| 113 | + (@nospecialize T::Type{<:Tuple}), ::Type{<:NTuple{len,Any}}, ::Val{ind} |
| 114 | +) where {len,ind} |
| 115 | + Core.@_foldable_meta |
| 116 | + (1 ≤ (ind::Int) ≤ len) || throw(ArgumentError("`ind` out of bounds")) |
| 117 | + S = NTuple{len,Any} |
| 118 | + ST = typeintersect(S, T)::Type |
| 119 | + TS = typeintersect(T, S)::Type |
| 120 | + X = fieldtype(T, ind)::Type |
| 121 | + Y = fieldtype(ST, ind)::Type |
| 122 | + Z = fieldtype(TS, ind)::Type |
| 123 | + type_intrs = TIE.type_intersect_exact(X, Y, Z) |
| 124 | + TIE.get_result(X, type_intrs)::Type |
| 125 | +end |
| 126 | + |
| 127 | +function tuple_converted_elem(::Type{T}, t::NTuple{len,Any}, ::Val{ind}) where {T<:Tuple,len,ind} |
| 128 | + (1 ≤ (ind::Int) ≤ len) || throw(ArgumentError("`ind` out of bounds")) |
| 129 | + S = fieldtype_typeintersect_ntuple(T, NTuple{len,Any}, Val(ind))::Type |
| 130 | + e = t[ind] |
| 131 | + ((e isa S) ? e : convert(S, e))::S |
| 132 | +end |
| 133 | + |
| 134 | +function tuple_with_converted_elems_recur(::Type{T}, ::NTuple{len,Any}, r::NTuple{len,Any}) where {T<:Tuple,len} |
| 135 | + r::T |
| 136 | +end |
| 137 | +function tuple_with_converted_elems_recur(::Type{T}, t::NTuple{len,Any}, r::NTuple{n,Any}) where {T<:Tuple,len,n} |
| 138 | + (n < len) || throw(ArgumentError("`n` out of bounds")) |
| 139 | + m = n + 1 |
| 140 | + s = (r..., tuple_converted_elem(T, t, Val(m)))::NTuple{m,Any} |
| 141 | + tuple_with_converted_elems_recur(T, t, s)::NTuple{len,Any} |
| 142 | +end |
| 143 | + |
| 144 | +function tuple_with_converted_elems(::Type{T}, t::NTuple{len,Any}) where {T<:Tuple,len} |
| 145 | + NT = NTuple{len,Any} |
| 146 | + type_intrs = TIE.type_intersect_exact(NT, T) |
| 147 | + S = TIE.get_result(T, type_intrs)::Type{<:Tuple} |
| 148 | + (S <: Union{}) && _totuple_err(T) |
| 149 | + tuple_with_converted_elems_recur(S, t, ())::T::NT::S |
| 150 | +end |
| 151 | + |
| 152 | +function iterator_to_tuple_with_element_types(::Type{T}, iter) where {T<:Tuple} |
| 153 | + R = tuple_length_type(T)::Type{<:Tuple} |
| 154 | + t = iterator_to_tuple(R, iter)::R |
| 155 | + tuple_with_converted_elems(T, t)::T |
| 156 | +end |
| 157 | + |
| 158 | +# As an optimization, special case some tuple types with no constraints on the |
| 159 | +# types of the elements. |
| 160 | +iterator_to_tuple_with_element_types(T::Type{NTuple{len,Any}}, i) where {len} = iterator_to_tuple(T, i)::T |
| 161 | +iterator_to_tuple_with_element_types(T::Type{tuple_va_type_length(0)}, i) = iterator_to_tuple(T, i)::T |
| 162 | +iterator_to_tuple_with_element_types(T::Type{tuple_va_type_length(1)}, i) = iterator_to_tuple(T, i)::T |
| 163 | +iterator_to_tuple_with_element_types(T::Type{tuple_va_type_length(2)}, i) = iterator_to_tuple(T, i)::T |
| 164 | +iterator_to_tuple_with_element_types(T::Type{tuple_va_type_length(3)}, i) = iterator_to_tuple(T, i)::T |
| 165 | +iterator_to_tuple_with_element_types(T::Type{tuple_va_type_length(4)}, i) = iterator_to_tuple(T, i)::T |
| 166 | + |
| 167 | +end |
0 commit comments