fun[T:openArray](a:T) != fun[T](a:openArray[T])

[timotheecour]

/cc @zah
Why is fun[T:openArray](a:T) not the same as fun[T](a:openArray[T]) ?

proc foo1[T:openArray](a:T):auto = low(a)
proc foo2[T](a:openArray[T]):auto = low(a)

proc test()=
  var a: array[3..6, int]
  echo (foo1(a), foo2(a)) # prints (Field0: 3, Field1: 0)

test()

I was looking at #9002 and was wondering how it worked with openArrays with different low values (eg array[3..6, int] and array[2..5, int]); it somehow works "thanks" to the fact that fun[T:openArray](a:T) != fun[T](a:openArray[T]) , but is this desired behavior?

[Clyybber]

They are not the same. The meaning of T in foo1 is different from its meaning in foo2.
In foo1 it is the type of a, but in foo2 it is the type of the fields of a.
The fact that it prints different things is wierd though, and most likely a bug.

[metagn]

I think it's to allow this:

proc foo[T](s: openarray[T]) =
  echo s[0]

let a: array[3..6, int] = [10, 11, 12]
let s = @[10, 11, 12] 
foo(a)
foo(s)

The manual states that openarray parameters always start with 0. The difference with T: openarray is that the openarray typeclass/concept is used instead of the openarray parameter type.

[krux02]

I am closing this, because I collect issues like this in my own issue here: #9592

[timotheecour]

I collect issues like this in my own issue here

fine, but the title you picked doesn't reflect that issue