I’m curious why Julia doesn’t let you define a parametric type that inherits from a parameter, e.g.
struct SomeType{T} <: T end
When I try this, Julia gives the error invalid subtyping in definition of SomeType.
It seems like this feature could be useful to systematically define types that behave like a T, but have a different implementation. For example, StructArrays.jl has the Lazy Iteration feature where it can create a LazyRow{T} that sort of behaves like a T (by having getproperty behave the same for a T and a LazyRow{T}). However, since LazyRow{T} cannot inherit from T (or in the case that T is a concrete type, inherit from supertype(T)), you can’t use a LazyRow{T} as an argument for a function that expects a T (or a supertype(T)).
E.g. I would like have something like:
abstract type AbstractFoo end
struct Foo
# some representation of a Foo
end
# some function that is specialized for AbstractFoo
bar(foo::AbstractFoo) = 0
# create a StructArray of Foos to get a different representation of a Vector{Foo}
using StructArrays
foos = StructArray(Foo() for i in 1:100)
# lazy representation of a Foo
lazy_foo = LazyRow(foos,1)
# I would like to be able to do this, but it doesn't work
bar(lazy_foo)
But since LazyRow{Foo} cannot automatically inherit from AbstractFoo, this can’t be done.