Add the of_type and cast operators

Ports Enumerable.OfType and Cast.

of_type keeps the elements that are instances of T and narrows the element
type to T, which is useful for sources whose element type is Any or a Union
and a no-op filter on a homogeneously typed table.

.NET's Cast is a type assertion; the Julia counterpart is a conversion, so
cast runs every element through convert and fails the way convert would on an
element that cannot be represented as T.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: davidanthoff

src/QueryOperators.jl

@@ -41,6 +41,7 @@ include("enumerable/enumerable_index.jl")
 include("enumerable/enumerable_append.jl")
 include("enumerable/enumerable_prepend.jl")
 include("enumerable/enumerable_zip.jl")
+include("enumerable/enumerable_oftype.jl")
 include("enumerable/enumerable_pivot.jl")
 include("enumerable/enumerable_summarize.jl")
 include("enumerable/enumerable_countby.jl")

src/enumerable/enumerable_oftype.jl

@@ -0,0 +1,55 @@
+struct EnumerableOfType{T,S} <: Enumerable
+    source::S
+end
+
+# Enumerable.OfType: keeps only the elements that are instances of T, and
+# narrows the element type to T. Useful for sources whose element type is Any
+# or a Union; a no-op filter on a homogeneously typed table.
+function of_type(source::Enumerable, ::Type{T}) where {T}
+    return EnumerableOfType{T,typeof(source)}(source)
+end
+
+Base.eltype(::Type{EnumerableOfType{T,S}}) where {T,S} = T
+
+Base.iterate(iter::EnumerableOfType) = _of_type_next(iter, _NotStarted())
+
+Base.iterate(iter::EnumerableOfType, state) = _of_type_next(iter, state)
+
+function _of_type_next(iter::EnumerableOfType{T,S}, source_state) where {T,S}
+    while true
+        ret = _iterate_from(iter.source, source_state)
+        ret === nothing && return nothing
+
+        element, source_state = ret
+        element isa T && return element, source_state
+    end
+end
+
+struct EnumerableCast{T,S} <: Enumerable
+    source::S
+end
+
+# Enumerable.Cast. .NET's Cast is a type assertion; the Julia counterpart is a
+# conversion, so `cast` runs every element through `convert` and fails the same
+# way `convert` would on an element that cannot be represented as T.
+function cast(source::Enumerable, ::Type{T}) where {T}
+    return EnumerableCast{T,typeof(source)}(source)
+end
+
+Base.IteratorSize(::Type{EnumerableCast{T,S}}) where {T,S} = haslength(S)
+
+Base.eltype(::Type{EnumerableCast{T,S}}) where {T,S} = T
+
+Base.length(iter::EnumerableCast) = length(iter.source)
+
+function Base.iterate(iter::EnumerableCast{T,S}) where {T,S}
+    ret = iterate(iter.source)
+    ret === nothing && return nothing
+    return convert(T, ret[1]), ret[2]
+end
+
+function Base.iterate(iter::EnumerableCast{T,S}, state) where {T,S}
+    ret = iterate(iter.source, state)
+    ret === nothing && return nothing
+    return convert(T, ret[1]), ret[2]
+end

src/operators.jl

@@ -225,3 +225,9 @@ function last end
 function single end
 
 function element_at end
+
+# Type filtering.
+
+function of_type end
+
+function cast end

test/runtests.jl

@@ -8,6 +8,7 @@ include("test_enumerable_keyed_aggregation.jl")
 include("test_enumerable_partitioning.jl")
 include("test_enumerable_combining.jl")
 include("test_enumerable_terminal.jl")
+include("test_enumerable_typefiltering.jl")
 include("test_enumerable_unique.jl")
 include("test_enumerable_summarize.jl")
 include("test_namedtupleutilities.jl")

test/test_enumerable_typefiltering.jl

@@ -0,0 +1,89 @@
+@testitem "of_type" begin
+    source = QueryOperators.query(Any[1, "a", 2, "b", 3.0])
+
+    ints = QueryOperators.of_type(source, Int)
+
+    @test collect(ints) == [1, 2]
+    @test eltype(ints) == Int
+
+    strings = QueryOperators.of_type(source, String)
+    @test collect(strings) == ["a", "b"]
+    @test eltype(strings) == String
+end
+
+@testitem "of_type keeps subtypes" begin
+    source = QueryOperators.query(Any[1, 2.0, "a"])
+
+    numbers = QueryOperators.of_type(source, Number)
+
+    @test collect(numbers) == [1, 2.0]
+    @test eltype(numbers) == Number
+end
+
+@testitem "of_type over a Union element type" begin
+    source = QueryOperators.query(Union{Int,String}[1, "a", 2])
+
+    @test collect(QueryOperators.of_type(source, Int)) == [1, 2]
+end
+
+@testitem "of_type matching nothing or everything" begin
+    source = QueryOperators.query(Any[1, 2, 3])
+
+    @test collect(QueryOperators.of_type(source, String)) == String[]
+    @test collect(QueryOperators.of_type(source, Int)) == [1, 2, 3]
+end
+
+@testitem "of_type on an empty source" begin
+    source = QueryOperators.query(Any[])
+
+    @test collect(QueryOperators.of_type(source, Int)) == Int[]
+end
+
+@testitem "cast" begin
+    source = QueryOperators.query([1, 2, 3])
+
+    res = QueryOperators.cast(source, Float64)
+
+    @test collect(res) == [1.0, 2.0, 3.0]
+    @test eltype(res) == Float64
+    @test Base.IteratorSize(typeof(res)) == Base.HasLength()
+    @test length(res) == 3
+end
+
+@testitem "cast widens an Any source to a concrete type" begin
+    source = QueryOperators.query(Any[1, 2, 3])
+
+    res = QueryOperators.cast(source, Int)
+
+    @test collect(res) == [1, 2, 3]
+    @test eltype(res) == Int
+end
+
+@testitem "cast fails on an element that cannot be converted" begin
+    source = QueryOperators.query(Any[1, "a"])
+
+    res = QueryOperators.cast(source, Int)
+
+    @test_throws MethodError collect(res)
+end
+
+@testitem "cast fails on a lossy conversion" begin
+    source = QueryOperators.query([1.5])
+
+    @test_throws InexactError collect(QueryOperators.cast(source, Int))
+end
+
+@testitem "cast on an empty source" begin
+    source = QueryOperators.query(Int[])
+
+    @test collect(QueryOperators.cast(source, Float64)) == Float64[]
+end
+
+@testitem "of_type and cast compose with other operators" begin
+    source = QueryOperators.query(Any[1, "a", 2, "b", 3])
+
+    res = QueryOperators.cast(QueryOperators.of_type(source, Int), Float64)
+
+    @test collect(res) == [1.0, 2.0, 3.0]
+    @test eltype(res) == Float64
+end