Is it possible to express a type relationship between arrays with different numbers of dimensions?

mbauman · October 22, 2019, 4:57pm

I agree — the biggest inelegance IMO is the fact that declaring struct Foo{X <: Any} actually supports using things that aren’t subtype of Any!

julia> struct Foo{X<:Any} end

julia> Foo{1}()
Foo{1}()

julia> struct Bar{X<:Real} end

julia> Bar{1}()
ERROR: TypeError: in Bar, in X, expected X<:Real, got Int64
Stacktrace:
 [1] top-level scope at REPL[50]:1

This is of course necessitated by the fact that Foo{X} is the same as Foo{X<:Any}, but it is indeed a wart. It’d be great to support isa sorts of constraints directly some day. It’s a “bug”, but not a very high priority.

github.com/JuliaLang/julia

constraints on non-type as type parameters

opened 02:52PM - 03 Jan 15 UTC

closed 08:28PM - 21 Mar 23 UTC

yuyichao

types and dispatch feature

When a type parameter is specified to be `T <: Top`, it actually accept non-type… as parameters as well. ``` julia julia> type A{T<:Top} end julia> A{1} A{1} julia> A{1.2} A{1.2} ``` Although `1` and `1.2` are clearly not subtypes of `Top` ``` julia julia> 1 <: Top ERROR: type: subtype: expected Type{T<:Top}, got Int64 julia> 1.2 <: Top ERROR: type: subtype: expected Type{T<:Top}, got Float64 ``` This is also the case for the builtin `Type` (some other types like `Array` doesn't even have this constraint specified) ``` julia julia> Type Type{T<:Top} julia> Type{1} Type{1} julia> Type{1.2} Type{1.2} ``` No error is raised even if this parameter is used as a type of a field ``` julia julia> type A{T<:Top} a::T end julia> A{1} A{1} julia> A{1}.names (:a,) julia> A{1}.types (1,) ``` The same thing happens for `T <: Any` although this time it correctly reject `Core.Unref` ``` julia julia> type A{T <: Any} end julia> A{1} A{1} julia> A{1.2} A{1.2} julia> A{Core.Undef} ERROR: type: A: in T, expected T, got Type{Undef} julia> Core.Undef <: Any false ``` Specifying other types seems fine ``` julia julia> type C{T <: Integer} end julia> C{1} ERROR: type: C: in T, expected T<:Integer, got Int64 julia> C{Int} C{Int64} ``` Another related issue is that `Vararg` doesn't specify any constraint on the parameter and therefore the following syntax is allowed. ``` julia julia> (1...)[1] 1... julia> typeof((1...)[1]) DataType ```

In any case, check out Tamas’ PR again — I added a commit there (before I even saw your comment here) that addresses your comment a bit more directly.

bcmichael · October 22, 2019, 5:12pm

I guess that might help out somewhat with what I was asking about. It would definitely be more convenient if the hidden parameters could more deeply buried, so that it’s much less necessary to ever have to worry about their existence. I guess some of that has been discussed before, but with that solution you do still need to worry about the extra type parameters whenever you need to specify a concrete type (building a collection or using it as a field in another struct). Maybe I’m wrong, but it sounds like this would probably have to be baked into the language for avoiding that to really be possible.
https://github.com/JuliaLang/julia/issues/18466