Support for u8 slices

[nickbabcock]

wasm_bindgen! {
    pub fn parse_data(data: &[u8]) -> i32 {
        data.len() as i32
    }
}

Returns

unsupported reference type

I'm hoping that you'd be open to more borrowed types (specifically &[u8]) in addition to BorrowedStr. This could be part of a larger issue to support Vec and other slices, but I figure &[u8] might be easiest and would be implemented very closely to BorrowedStr.

Use case:

After I use a FileReader to read a binary file into an ArrayBuffer and create WebAssembly.Memory (I believe that flow is correct), I want to send the data to rust for parsing.

[alexcrichton]

Ah yes, definitely!

Just to confirm (as I'm not so sure myself), what types would work on the JS side of things? Or rather, what type would this expect from JS?

[nickbabcock]

If I had to choose one: Uint8Array as "array of 8-bit unsigned integers" certainly is a close to fit for &[u8]. ArrayBuffer may also work, but maybe not as important.

[TimHambourger]

Besides Uint8Array, it'd be great to have conventions for targeting all the JS TypedArray types with both borrowed (&[T]) and owned (Vec<T> ??) variants on the Rust side.

[alexcrichton]

Er sorry meant to respond, but @nickbabcock sounds good to me! @TimHambourger also I'd totally be down with that as well, sounds like a great idea!

I think we could pretty easily add bindings for both &[u32] and Vec<u32> (and other integer types) like &str and String work today. Keep in mind though that whenever an array crosses the wasm boundary it'll copy the entire array!

[MaxGraey]

I very interesting in use this great project, but lack of array binding forcing me to use stdweb. It will be great have borrowed or/and owned arrays.

[itsybitesyspider]

The README for this issue says "Vectors and slices of supported integer types", however, the change in git history (3c58aa7) extensively mentions floating point types.

[alexcrichton]

@clanehin ah yes indeed, all of the primitive typed array views are supported, including floats!

[aschampion]

Likely I'm missing something obvious, but while this works great across the js boundary, I can't seem to find the right traits to get this to work within Rust itself for these js_sys types, e.g.:

some_fetch_request.and_then(|resp_value| {
    assert!(resp_value.is_instance_of::<Response>());
    let resp: Response = resp_value.dyn_into().unwrap();

    JsFuture::from(resp.array_buffer().unwrap())
}).map(|arrbuff_value| {
    assert!(arrbuff_value.is_instance_of::<ArrayBuffer>());
    // let arrbuff: ArrayBuffer = arrbuff_value.dyn_into().unwrap();
    let typebuff: js_sys::Uint8Array = js_sys::Uint8Array::new(&arrbuff_value);

    // Great so far...
    // Now imagine we have some function `foo(&[u8])` or `foo<T: std::io::Read>(T)`, none of the normal tricks work:
    foo(&typebuff);
    foo((&typebuff).into());
    foo(&typebuff[..]);
    foo(typebuff.as_ref());
    // etc, etc.
});

[alexcrichton]

@aschampion ah currently that's not supported unfortunately! Want to open a separate issue for that though? (converting Uint8Array to Vec<u8>)

[jvallikivi]

Is there an update to the issue mentioned by @aschampion (getting Uint8Array -> &[u8]/&mut [u8] without having to copy into a vector)?

[kartva]

You may find this useful:
#1079 (comment)