I thought I understood the `where`

syntax but apparently I don’t. I have a parameterised structure along the lines of

```
struct MyStruct{T <: Number, F}
u::Vector{T}
f::F
end
```

and I’d like to have a vector of these structures such that the underlying numerical type is the same but the `f`

field can be different (it’s a function). For example

```
v1 = MyStruct([1.0], sin)
v2 = MyStruct([2.0], cos)
v = [v1, v2]
```

In this case, as I understand it, the appropriate type signature is `Vector{MyStruct{T, F} where F} where T`

and, as desired,

```
v isa Vector{MyStruct{T, F} where F} where T == true
```

However, if I just have a single element in the vector

```
vv = [v1]
vv isa Vector{MyStruct{T, F} where F} where T == false
```

but I don’t understand why.

I’d like to be able to handle both these cases. Is there a type signature that can handle both? (I know I can use a union with `Vector{MyStruct{T, F}} where {T, F}`

but I was expecting the `where`

syntax to be able to handle this directly.)