Allow conversion between constant-size and variable-size arrays

[bluesign]

Issue to be solved

Inspired by recent issue on codeHash in events, I think we should allow some conversion with arrays of different static type.

// https://run.dnz.dev/snippet/1f8bfbdc77297319

pub fun main(){
    var a : [UInt8; 8] = [1,2,3,4,5,6,7,8]
    var b : [UInt8] = [10,11,12,13,14,15,16,17,18]

    var c : [UInt8] = a as! [UInt8]
    var d : [UInt8; 8] = b as! [UInt8; 8]
}

if we don't allow this, only solution is ugly loop.

Suggested Solution

Conversion can allow ( with force cast for example ) conversion between 2 types. As force cast has T as right side, I don't think it will create any problems.

[turbolent]

Good idea, this could be easily added, PRs are very welcome.

as/as?/! are casting operators and do not perform conversion. Instead, the standard library offers conversion functions. The same should be done here, though naming it might be a bit tough.

[bluesign]

Good idea, this could be easily added, PRs are very welcome.

as/as?/! are casting operators and do not perform conversion. Instead, the standard library offers conversion functions. The same should be done here, though naming it might be a bit tough.

I can take a stab at this, can something like generic convert<T>(AnyStruct): T work ? Do we have conversion somehow behind the scenes?

[PratikDhanave]

@j1010001 @bluesign @turbolent is this issue is resolved ? if yes humble request please can we mark it as closed ?

[turbolent]

No, this feature has not been added yet

[darkdrag00nv2]

I believe we have two options:

Option 1

We could introduce names for the variable and constant sized array types. Then we could declare conversion functions

VariableSizedArray.fromConstantSizedArray<C: [T; _]>(param: C) : [T]
ConstantSizedArray.fromVariableSizedArray<C: [T; _]>(param: [T]) : C

Option 2

Declare two standard library functions:

VariableSizedArrayToConstantSizedArray<C: [T; _]>(param: [T]) : C // or ConstantSizedArrayFromVariableSizedArray
ConstantSizedArrayToVariableSizedArray<C: [T; _]>(param: C) : [T] // or VariableSizedArrayFromConstantSizedArray

---

In either of these two options, I am not sure if it would be feasible to add the type bound C : [T; _].

[bluesign]

Another option:
.asFixedSizeArray(): T to variable sized arrays.

And .asVariableSizeArray(): T to fixed sized arrays

Ofc naming can be improved.

[turbolent]

Agreed, it might be better to not "pollute" the global namespace and just have functions on the types.

Maybe something short that omits the result kind (array) will be sufficient, given that the source is the same kind, e.g. toConstantSized and toVariableSized.

For example, Rust has a generalized way of implementing conversions with the TryInto trait / the try_into function (e.g. see https://stackoverflow.com/a/37669259/2779550).
Similarly, maybe the functions could/should return optionals so that a failure can be handled?

[darkdrag00nv2]

@turbolent Sounds good.

Regarding the toConstantSized function on the VariableSizedType, it will need a type parameter to statically get the size of the constant sized array.

let intArray = [1, 2, 3]
let constArray = intArray.toConstantSized<[Int; 3]>()  // expected usage

// checker will allow this since we don't know the size of array statically but will lead to a runtime error or return a Nil optional value if we make the function return an Option.
let constArray2 = intArray.toConstantSized<[Int; 2]>() 

[turbolent]

Regarding the toConstantSized function on the VariableSizedType, it will need a type parameter to statically get the size of the constant sized array.

Correct, toConstantSized will need a type parameter, and toVariableSized doesn't 👍