Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://rustwasm.github.io/docs/wasm-bindgen/contributing/design/rust-type-conversions.html below:

Rust Type conversions - The `wasm-bindgen` Guide

1. Introduction
3. 1. Examples
4. 1. 1.1. Hello, World!
   2. 1.2. Using console.log
   3. 1.3. Small Wasm files
   4. 1.4. Without a Bundler
   5. 1.5. Synchronous Instantiation
   6. 1.6. Importing functions from JS
   7. 1.7. Working with char
   8. 1.8. js-sys: WebAssembly in WebAssembly
   9. 1.9. web-sys: DOM hello world
   10. 1.10. web-sys: Closures
   11. 1.11. web-sys: performance.now
   12. 1.12. web-sys: using fetch
   13. 1.13. web-sys: Weather report
   14. 1.14. web-sys: canvas hello world
   15. 1.15. web-sys: canvas Julia set
   16. 1.16. web-sys: WebAudio
   17. 1.17. web-sys: WebGL
   18. 1.18. web-sys: WebSockets
   19. 1.19. web-sys: WebRTC DataChannel
   20. 1.20. web-sys: requestAnimationFrame
   21. 1.21. web-sys: A Simple Paint Program
   22. 1.22. web-sys: Wasm in Web Worker
   23. 1.23. Parallel Raytracing
   24. 1.24. Wasm Audio Worklet
   25. 1.25. web-sys: A TODO MVC App
5. 2. Reference
6. 1. 2.1. Deployment
   2. 2.2. JS snippets
   3. 2.3. Static JS Objects
   4. 2.4. Passing Rust Closures to JS
   5. 2.5. Receiving JS Closures in Rust
   6. 2.6. Promises and Futures
   7. 2.7. Iterating over JS Values
   8. 2.8. Arbitrary Data with Serde
   9. 2.9. Accessing Properties of Untyped JS Values
   10. 2.10. Working with Duck-Typed Interfaces
   11. 2.11. Command Line Interface
   12. 2.12. Optimizing for Size
   13. 2.13. Supported Rust Targets
   14. 2.14. Supported Browsers
   15. 2.15. Support for Weak References
   16. 2.16. Support for Reference Types
   17. 2.17. Supported Types
   18. 1. 2.17.1. Imported JavaScript Types
       2. 2.17.2. Exported Rust Types
       3. 2.17.3. JsValue
       4. 2.17.4. Box<[T]> and Vec
       5. 2.17.5. *const T and *mut T
       6. 2.17.6. NonNull
       7. 2.17.7. Numbers
       8. 2.17.8. bool
       9. 2.17.9. char
       10. 2.17.10. str
       11. 2.17.11. String
       12. 2.17.12. Number Slices
       13. 2.17.13. Boxed Number Slices
       14. 2.17.14. Result<T, E>
   19. 2.18. #[wasm_bindgen] Attributes
   20. 1. 2.18.1. On JavaScript Imports
       2. 1. 2.18.1.1. catch
          2. 2.18.1.2. constructor
          3. 2.18.1.3. extends
          4. 2.18.1.4. getter and setter
          5. 2.18.1.5. final
          6. 2.18.1.6. indexing_getter, indexing_setter, and indexing_deleter
          7. 2.18.1.7. js_class = "Blah"
          8. 2.18.1.8. js_name
          9. 2.18.1.9. js_namespace
          10. 2.18.1.10. method
          11. 2.18.1.11. module = "blah"
          12. 2.18.1.12. raw_module = "blah"
          13. 2.18.1.13. no_deref
          14. 2.18.1.14. static_method_of = Blah
          15. 2.18.1.15. structural
          16. 2.18.1.16. typescript_type
          17. 2.18.1.17. variadic
          18. 2.18.1.18. vendor_prefix
       3. 2.18.2. On Rust Exports
       4. 1. 2.18.2.1. constructor
          2. 2.18.2.2. js_name = Blah
          3. 2.18.2.3. js_class = Blah
          4. 2.18.2.4. readonly
          5. 2.18.2.5. skip
          6. 2.18.2.6. skip_jsdoc
          7. 2.18.2.7. start
          8. 2.18.2.8. main
          9. 2.18.2.9. typescript_custom_section
          10. 2.18.2.10. getter and setter
          11. 2.18.2.11. inspectable
          12. 2.18.2.12. skip_typescript
          13. 2.18.2.13. getter_with_clone
          14. 2.18.2.14. unchecked_return_type and unchecked_param_type
          15. 2.18.2.15. return_description and param_description
7. 3. web-sys
8. 1. 3.1. Using web-sys
   2. 3.2. Cargo Features
   3. 3.3. Function Overloads
   4. 3.4. Type Translations
   5. 3.5. Inheritance
   6. 3.6. Unstable APIs
9. 4. Testing with wasm-bindgen-test
10. 1. 4.1. Usage
    2. 4.2. Writing Asynchronous Tests
    3. 4.3. Testing in Headless Browsers
    4. 4.4. Continuous Integration
    5. 4.5. Coverage (Experimental)
11. 5. Contributing to wasm-bindgen
12. 1. 5.1. Testing
    2. 5.2. Internal Design
    3. 1. 5.2.1. JS Objects in Rust
       2. 5.2.2. Exporting a function to JS
       3. 5.2.3. Exporting a struct to JS
       4. 5.2.4. Importing a function from JS
       5. 5.2.5. Importing a class from JS
       6. 5.2.6. Rust Type conversions
       7. 5.2.7. Types in wasm-bindgen
    4. 5.3. js-sys
    5. 1. 5.3.1. Testing
       2. 5.3.2. Adding More APIs
    6. 5.4. web-sys
    7. 1. 5.4.1. Overview
       2. 5.4.2. Testing
       3. 5.4.3. Logging
       4. 5.4.4. Supporting More Web APIs
    8. 5.5. Publishing
    9. 5.6. Team

Previously we've been seeing mostly abridged versions of type conversions when values enter Rust. Here we'll go into some more depth about how this is implemented. There are two categories of traits for converting values, traits for converting values from Rust to JS and traits for the other way around.

First up let's take a look at going from Rust to JS:

# #![allow(unused_variables)]
#fn main() {
pub trait IntoWasmAbi: WasmDescribe {
    type Abi: WasmAbi;
    fn into_abi(self) -> Self::Abi;
}
#}

And that's it! This is actually the only trait needed currently for translating a Rust value to a JS one. There's a few points here:

• We'll get to WasmDescribe later in this section.

• The associated type Abi is the type of the raw data that we actually want to pass to JS. The bound WasmAbi is implemented for primitive types like u32 and f64, which can be represented directly as WebAssembly values, as well of a couple of other types like WasmSlice:

  
  # #![allow(unused_variables)]
  #fn main() {
  pub struct WasmSlice {
      pub ptr: u32,
      pub len: u32,
  }
  #}

  This struct, which is how things like strings are represented in FFI, isn't a WebAssembly primitive type, and so it can't be mapped directly to a WebAssembly parameter / return value. This is why WasmAbi lets types specify how they can be split up into multiple WebAssembly parameters:

  
  # #![allow(unused_variables)]
  #fn main() {
  impl WasmAbi for WasmSlice {
      fn split(self) -> (u32, u32, (), ()) {
          (self.ptr, self.len, (), ())
      }
  
      // some other details to specify return type of `split`, go in the other direction
  }
  #}

  This means that a WasmSlice gets split up into two u32 parameters. The extra unit types on the end are there because Rust doesn't let us make WasmAbi generic over variable-length tuples, so we just take tuples of 4 elements. The unit types still end up getting passed to/from JS, but the C ABI just completely ignores them and doesn't generate any arguments.

  Since we can't return multiple values, when returning a WasmSlice we instead put the two u32s into a #[repr(C)] struct and return that.

• And finally we have the into_abi function, returning the Abi associated type which will be actually passed to JS.

This trait is implemented for all types that can be converted to JS and is unconditionally used during codegen. For example you'll often see IntoWasmAbi for Foo but also IntoWasmAbi for &'a Foo.

The IntoWasmAbi trait is used in two locations. First it's used to convert return values of Rust exported functions to JS. Second it's used to convert the Rust arguments of JS functions imported to Rust.

Unfortunately the opposite direction from above, going from JS to Rust, is a bit more complicated. Here we've got three traits:

# #![allow(unused_variables)]
#fn main() {
pub trait FromWasmAbi: WasmDescribe {
    type Abi: WasmAbi;
    unsafe fn from_abi(js: Self::Abi) -> Self;
}

pub trait RefFromWasmAbi: WasmDescribe {
    type Abi: WasmAbi;
    type Anchor: Deref<Target=Self>;
    unsafe fn ref_from_abi(js: Self::Abi) -> Self::Anchor;
}

pub trait RefMutFromWasmAbi: WasmDescribe {
    type Abi: WasmAbi;
    type Anchor: DerefMut<Target=Self>;
    unsafe fn ref_mut_from_abi(js: Self::Abi) -> Self::Anchor;
}
#}

The FromWasmAbi is relatively straightforward, basically the opposite of IntoWasmAbi. It takes the ABI argument (typically the same as IntoWasmAbi::Abi) to produce an instance of Self. This trait is implemented primarily for types that don't have internal lifetimes or are references.

The latter two traits here are mostly the same, and are intended for generating references (both shared and mutable references). They look almost the same as FromWasmAbi except that they return an Anchor type which implements a Deref trait rather than Self.

The Ref* traits allow having arguments in functions that are references rather than bare types, for example &str, &JsValue, or &[u8]. The Anchor here is required to ensure that the lifetimes don't persist beyond one function call and remain anonymous.

The From* family of traits are used for converting the Rust arguments in Rust exported functions to JS. They are also used for the return value in JS functions imported into Rust.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4