Struct trillium_http_types::Request[−][src]

pub struct Request { /* fields omitted */ }

Expand description

An HTTP request.

Examples

use http_types::Request;

let mut req = Request::get("https://example.com");
req.set_body("Hello, Nori!");

Implementations

[src]

impl Request

[src]

pub fn new<U>(method: Method, url: U) -> Self where
    U: TryInto<Url>,
    U::Error: Debug,

Create a new request.

[src]

pub fn set_peer_addr(&mut self, peer_addr: Option<impl ToString>)

Sets a string representation of the peer address of this request. This might take the form of an ip/fqdn and port or a local socket address.

[src]

pub fn set_local_addr(&mut self, local_addr: Option<impl ToString>)

Sets a string representation of the local address that this request was received on. This might take the form of an ip/fqdn and port, or a local socket address.

[src]

pub fn peer_addr(&self) -> Option<&str>

Get the peer socket address for the underlying transport, if that information is available for this request.

[src]

pub fn local_addr(&self) -> Option<&str>

Get the local socket address for the underlying transport, if that information is available for this request.

[src]

pub fn remote(&self) -> Option<&str>

Get the remote address for this request.

This is determined in the following priority:

Forwarded header for key
The first X-Forwarded-For header
Peer address of the transport

[src]

pub fn host(&self) -> Option<&str>

Get the destination host for this request.

This is determined in the following priority:

Forwarded header host key
The first X-Forwarded-Host header
Host header
URL domain, if any

[src]

pub fn method(&self) -> Method

Get the HTTP method

[src]

pub fn set_method(&mut self, method: Method)

Set the HTTP method.

[src]

pub fn url(&self) -> &Url

Get a reference to the url.

Examples

use http_types::{Request, Response, StatusCode};
let mut req = Request::get("https://example.com");
assert_eq!(req.url().scheme(), "https");

[src]

pub fn url_mut(&mut self) -> &mut Url

Get a mutable reference to the url.

Examples

use http_types::{Method, Request, Response, StatusCode, Url};
let mut req = Request::get("https://example.com");
req.url_mut().set_scheme("http");
assert_eq!(req.url().scheme(), "http");

[src]

pub fn set_body(&mut self, body: impl Into<Body>)

Set the request body.

Examples

use http_types::{Method, Request};

let mut req = Request::get("https://example.com");
req.set_body("Hello, Nori!");

[src]

pub fn replace_body(&mut self, body: impl Into<Body>) -> Body

Swaps the value of the body with another body, without deinitializing either one.

Examples

use http_types::{Body, Method, Request};

let mut req = Request::get("https://example.com");
req.set_body("Hello, Nori!");
let mut body: Body = req.replace_body("Hello, Chashu!");

let mut string = String::new();
body.read_to_string(&mut string).await?;
assert_eq!(&string, "Hello, Nori!");

[src]

pub fn swap_body(&mut self, body: &mut Body)

Replace the request body with a new body, and return the old body.

Examples

use http_types::{Body, Request};

let mut req = Request::get("https://example.com");
req.set_body("Hello, Nori!");
let mut body = "Hello, Chashu!".into();
req.swap_body(&mut body);

let mut string = String::new();
body.read_to_string(&mut string).await?;
assert_eq!(&string, "Hello, Nori!");

[src]

pub fn take_body(&mut self) -> Body

Take the request body, replacing it with an empty body.

Examples

use http_types::{Body, Request};

let mut req = Request::get("https://example.com");
req.set_body("Hello, Nori!");
let mut body: Body = req.take_body();

let mut string = String::new();
body.read_to_string(&mut string).await?;
assert_eq!(&string, "Hello, Nori!");

[src]

pub async fn body_string(&mut self) -> Result<String>

Read the body as a string.

This consumes the request. If you want to read the body without consuming the request, consider using the take_body method and then calling Body::into_string or using the Request’s AsyncRead implementation to read the body.

Examples

use async_std::io::Cursor;
use http_types::{Body, Request};

let mut req = Request::get("https://example.com");

let cursor = Cursor::new("Hello Nori");
let body = Body::from_reader(cursor, None);
req.set_body(body);
assert_eq!(&req.body_string().await.unwrap(), "Hello Nori");

[src]

pub async fn body_bytes(&mut self) -> Result<Vec<u8>>

Read the body as bytes.

This consumes the Request. If you want to read the body without consuming the request, consider using the take_body method and then calling Body::into_bytes or using the Request’s AsyncRead implementation to read the body.

Examples

use http_types::{Body, Request};

let bytes = vec![1, 2, 3];
let mut req = Request::get("https://example.com");
req.set_body(Body::from_bytes(bytes));

let bytes = req.body_bytes().await?;
assert_eq!(bytes, vec![1, 2, 3]);

[src]

pub async fn body_json<T: DeserializeOwned>(&mut self) -> Result<T>

Read the body as JSON.

This consumes the request. If you want to read the body without consuming the request, consider using the take_body method and then calling Body::into_json or using the Request’s AsyncRead implementation to read the body.

Examples

use http_types::convert::{Deserialize, Serialize};
use http_types::{Body, Request};

#[derive(Debug, Serialize, Deserialize)]
struct Cat {
    name: String,
}

let cat = Cat {
    name: String::from("chashu"),
};
let mut req = Request::get("https://example.com");
req.set_body(Body::from_json(&cat)?);

let cat: Cat = req.body_json().await?;
assert_eq!(&cat.name, "chashu");

[src]

pub async fn body_form<T: DeserializeOwned>(&mut self) -> Result<T>

Read the body as x-www-form-urlencoded.

This consumes the request. If you want to read the body without consuming the request, consider using the take_body method and then calling Body::into_json or using the Request’s AsyncRead implementation to read the body.

Examples

use http_types::convert::{Deserialize, Serialize};
use http_types::{Body, Request};

#[derive(Debug, Serialize, Deserialize)]
struct Cat {
    name: String,
}

let cat = Cat {
    name: String::from("chashu"),
};
let mut req = Request::get("https://example.com");
req.set_body(Body::from_form(&cat)?);

let cat: Cat = req.body_form().await?;
assert_eq!(&cat.name, "chashu");

[src]

pub fn header(&self, name: impl Into<HeaderName>) -> Option<&HeaderValues>

Get an HTTP header.

[src]

pub fn header_mut(
    &mut self, 
    name: impl Into<HeaderName>
) -> Option<&mut HeaderValues>

Get a mutable reference to a header.

[src]

pub fn remove_header(
    &mut self, 
    name: impl Into<HeaderName>
) -> Option<HeaderValues>

Remove a header.

[src]

pub fn insert_header(
    &mut self, 
    name: impl Into<HeaderName>, 
    values: impl ToHeaderValues
) -> Option<HeaderValues>

Set an HTTP header.

Examples

use http_types::Request;

let mut req = Request::get("https://example.com");
req.insert_header("Content-Type", "text/plain");

[src]

pub fn append_header(
    &mut self, 
    name: impl Into<HeaderName>, 
    values: impl ToHeaderValues
)

Append a header to the headers.

Unlike insert this function will not override the contents of a header, but insert a header if there aren’t any. Or else append to the existing list of headers.

Examples

use http_types::Request;

let mut req = Request::get("https://example.com");
req.append_header("Content-Type", "text/plain");

[src]

pub fn set_content_type(&mut self, mime: Mime) -> Option<HeaderValues>

Set the response MIME.

[src]

pub fn content_type(&self) -> Option<Mime>

Get the current content type

[src]

pub fn len(&self) -> Option<u64>

Get the length of the body stream, if it has been set.

This value is set when passing a fixed-size object into as the body. E.g. a string, or a buffer. Consumers of this API should check this value to decide whether to use Chunked encoding, or set the response length.

[src]

pub fn is_empty(&self) -> Option<bool>

Returns true if the request has a set body stream length of zero, false otherwise.

[src]

pub fn version(&self) -> Option<Version>

Get the HTTP version, if one has been set.

Examples

use http_types::{Request, Version};

let mut req = Request::get("https://example.com");
assert_eq!(req.version(), None);

req.set_version(Some(Version::Http2_0));
assert_eq!(req.version(), Some(Version::Http2_0));

[src]

pub fn set_version(&mut self, version: Option<Version>)

Set the HTTP version.

Examples

use http_types::{Request, Version};

let mut req = Request::get("https://example.com");
req.set_version(Some(Version::Http2_0));

[src]

pub fn send_trailers(&mut self) -> Sender

Sends trailers to the a receiver.

[src]

pub fn recv_trailers(&mut self) -> ReceiverⓘNotable traits for Receiver
impl Future for Receiver    type Output = Option<Trailers>;

Receive trailers from a sender.

[src]

pub fn has_trailers(&self) -> bool

Returns true if sending trailers is in progress.

[src]

pub fn iter(&self) -> Iter<'_>ⓘNotable traits for Iter<'a>
impl<'a> Iterator for Iter<'a>    type Item = (&'a HeaderName, &'a HeaderValues);

An iterator visiting all header pairs in arbitrary order.

[src]

pub fn iter_mut(&mut self) -> IterMut<'_>ⓘNotable traits for IterMut<'a>
impl<'a> Iterator for IterMut<'a>    type Item = (&'a HeaderName, &'a mut HeaderValues);

An iterator visiting all header pairs in arbitrary order, with mutable references to the values.

[src]

pub fn header_names(&self) -> Names<'_>ⓘNotable traits for Names<'a>
impl<'a> Iterator for Names<'a>    type Item = &'a HeaderName;

An iterator visiting all header names in arbitrary order.

[src]

pub fn header_values(&self) -> Values<'_>ⓘNotable traits for Values<'a>
impl<'a> Iterator for Values<'a>    type Item = &'a HeaderValue;

An iterator visiting all header values in arbitrary order.

[src]

pub fn ext(&self) -> &Extensions

Returns a reference to the existing local state.

[src]

pub fn ext_mut(&mut self) -> &mut Extensions

Returns a mutuable reference to the existing local state.

Examples

use http_types::{Request, Version};

let mut req = Request::get("https://example.com");
req.ext_mut().insert("hello from the extension");
assert_eq!(req.ext().get(), Some(&"hello from the extension"));

[src]

pub fn query<T: DeserializeOwned>(&self) -> Result<T>

Get the URL querystring.

Examples

use http_types::convert::Deserialize;
use http_types::Request;
use std::collections::HashMap;

#[derive(Deserialize)]
struct Index {
    page: u32,
    selections: HashMap<String, String>,
}

let mut req = Request::get("https://httpbin.org/get?page=2&selections[width]=narrow&selections[height]=tall");
let Index { page, selections } = req.query().unwrap();
assert_eq!(page, 2);
assert_eq!(selections["width"], "narrow");
assert_eq!(selections["height"], "tall");

[src]

pub fn set_query(&mut self, query: &impl Serialize) -> Result<()>

Set the URL querystring.

Examples

use http_types::convert::Serialize;
use http_types::{Method, Request};
use std::collections::HashMap;

#[derive(Serialize)]
struct Index {
    page: u32,
    topics: Vec<&'static str>,
}

let query = Index { page: 2, topics: vec!["rust", "crabs", "crustaceans"] };
let mut req = Request::get("https://httpbin.org/get");
req.set_query(&query).unwrap();
assert_eq!(req.url().query(), Some("page=2&topics[0]=rust&topics[1]=crabs&topics[2]=crustaceans"));

[src]

pub fn get<U>(url: U) -> Self where
    U: TryInto<Url>,
    U::Error: Debug,

Create a GET request.

The GET method requests a representation of the specified resource. Requests using GET should only retrieve data.

Examples

use http_types::{Method, Request};

let mut req = Request::get("https://example.com");
req.set_body("Hello, Nori!");
assert_eq!(req.method(), Method::Get);

[src]

pub fn head<U>(url: U) -> Self where
    U: TryInto<Url>,
    U::Error: Debug,

Create a HEAD request.

The HEAD method asks for a response identical to that of a GET request, but without the response body.

Examples

use http_types::{Method, Request};

let mut req = Request::head("https://example.com");
assert_eq!(req.method(), Method::Head);

[src]

pub fn post<U>(url: U) -> Self where
    U: TryInto<Url>,
    U::Error: Debug,

Create a POST request.

The POST method is used to submit an entity to the specified resource, often causing a change in state or side effects on the server.

Examples

use http_types::{Method, Request};

let mut req = Request::post("https://example.com");
assert_eq!(req.method(), Method::Post);

[src]

pub fn put<U>(url: U) -> Self where
    U: TryInto<Url>,
    U::Error: Debug,

Create a PUT request.

The PUT method replaces all current representations of the target resource with the request payload.

Examples

use http_types::{Method, Request};

let mut req = Request::put("https://example.com");
assert_eq!(req.method(), Method::Put);

[src]

pub fn delete<U>(url: U) -> Self where
    U: TryInto<Url>,
    U::Error: Debug,

Create a DELETE request.

The DELETE method deletes the specified resource.

Examples

use http_types::{Method, Request};

let mut req = Request::delete("https://example.com");
assert_eq!(req.method(), Method::Delete);

[src]

pub fn connect<U>(url: U) -> Self where
    U: TryInto<Url>,
    U::Error: Debug,

Create a CONNECT request.

The CONNECT method establishes a tunnel to the server identified by the target resource.

Examples

use http_types::{Method, Request};

let mut req = Request::connect("https://example.com");
assert_eq!(req.method(), Method::Connect);

[src]

pub fn options<U>(url: U) -> Self where
    U: TryInto<Url>,
    U::Error: Debug,

Create a OPTIONS request.

The OPTIONS method is used to describe the communication options for the target resource.

Examples

use http_types::{Method, Request};

let mut req = Request::options("https://example.com");
assert_eq!(req.method(), Method::Options);

[src]

pub fn trace<U>(url: U) -> Self where
    U: TryInto<Url>,
    U::Error: Debug,

Create a TRACE request.

The TRACE method performs a message loop-back test along the path to the target resource.

Examples

use http_types::{Method, Request};

let mut req = Request::trace("https://example.com");
assert_eq!(req.method(), Method::Trace);

[src]

pub fn patch<U>(url: U) -> Self where
    U: TryInto<Url>,
    U::Error: Debug,

Create a PATCH request.

The PATCH method is used to apply partial modifications to a resource.

Examples

use http_types::{Method, Request};

let mut req = Request::patch("https://example.com");
assert_eq!(req.method(), Method::Patch);

Trait Implementations

[src]

impl AsMut<Headers> for Request

[src]

fn as_mut(&mut self) -> &mut Headers

Performs the conversion.

[src]

impl AsRef<Headers> for Request

[src]

fn as_ref(&self) -> &Headers

Performs the conversion.

[src]

impl AsyncBufRead for Request

[src]

fn poll_fill_buf(
    self: Pin<&mut Self>, 
    cx: &mut Context<'_>
) -> Poll<Result<&[u8]>>

Attempt to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty. Read more

[src]

fn consume(self: Pin<&mut Self>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read. Read more

[src]

impl AsyncRead for Request

[src]

fn poll_read(
    self: Pin<&mut Self>, 
    cx: &mut Context<'_>, 
    buf: &mut [u8]
) -> Poll<Result<usize>>

Attempt to read from the AsyncRead into buf. Read more

fn poll_read_vectored(
    self: Pin<&mut Self>, 
    cx: &mut Context<'_>, 
    bufs: &mut [IoSliceMut<'_>]
) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations. Read more

[src]

impl Clone for Request

[src]

fn clone(&self) -> Self

Clone the request, resolving the body to Body::empty() and removing extensions.

1.0.0[src]

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

[src]

impl Debug for Request

[src]

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

[src]

impl From<Request> for Body

[src]

fn from(req: Request) -> Body

Performs the conversion.

[src]

impl Index<&'_ str> for Request

[src]

fn index(&self, name: &str) -> &HeaderValues

Returns a reference to the value corresponding to the supplied name.

Panics

Panics if the name is not present in Request.

type Output = HeaderValues

The returned type after indexing.

[src]

impl Index<HeaderName> for Request

[src]

fn index(&self, name: HeaderName) -> &HeaderValues

Returns a reference to the value corresponding to the supplied name.

Panics

Panics if the name is not present in Request.

type Output = HeaderValues

The returned type after indexing.

[src]

impl IntoIterator for Request

[src]

fn into_iter(self) -> Self::IntoIter

Returns a iterator of references over the remaining items.

type Item = (HeaderName, HeaderValues)

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

[src]

impl<'a> IntoIterator for &'a Request

type Item = (&'a HeaderName, &'a HeaderValues)

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

[src]

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more

[src]

impl<'a> IntoIterator for &'a mut Request

type Item = (&'a HeaderName, &'a mut HeaderValues)

The type of the elements being iterated over.

type IntoIter = IterMut<'a>

Which kind of iterator are we turning this into?

[src]

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more

[src]

impl<'__pin> Unpin for Request where
    __Origin<'__pin>: Unpin,

Auto Trait Implementations

impl !RefUnwindSafe for Request

impl Send for Request

impl Sync for Request

impl !UnwindSafe for Request

Blanket Implementations

[src]

impl<T> Any for T where
    T: 'static + ?Sized,

[src]

pub fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

[src]

impl<R> AsyncBufReadExt for R where
    R: AsyncBufRead + ?Sized,

[src]

fn fill_buf(&mut self) -> FillBuf<'_, Self> where
    Self: Unpin,

Returns the contents of the internal buffer, filling it with more data if empty. Read more

[src]

fn consume(&mut self, amt: usize) where
    Self: Unpin,

Consumes amt buffered bytes. Read more

[src]

fn read_until(
    &'a mut self, 
    byte: u8, 
    buf: &'a mut Vec<u8, Global>
) -> ReadUntilFuture<'a, Self> where
    Self: Unpin,

Reads all bytes and appends them into buf until the delimiter byte or EOF is found. Read more

[src]

fn read_line(&'a mut self, buf: &'a mut String) -> ReadLineFuture<'a, Self> where
    Self: Unpin,

Reads all bytes and appends them into buf until a newline (the 0xA byte) or EOF is found. Read more

[src]

fn lines(self) -> Lines<Self> where
    Self: Unpin,

Returns a stream over the lines of this byte stream. Read more

[src]

fn split(self, byte: u8) -> Split<Self>

Returns a stream over the contents of this reader split on the specified byte. Read more

[src]

impl<R> AsyncReadExt for R where
    R: AsyncRead + ?Sized,

[src]

fn read(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self> where
    Self: Unpin,

Reads some bytes from the byte stream. Read more

[src]

fn read_vectored(
    &'a mut self, 
    bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self> where
    Self: Unpin,

Like read(), except it reads into a slice of buffers. Read more

[src]

fn read_to_end(
    &'a mut self, 
    buf: &'a mut Vec<u8, Global>
) -> ReadToEndFuture<'a, Self> where
    Self: Unpin,

Reads the entire contents and appends them to a Vec. Read more

[src]

fn read_to_string(
    &'a mut self, 
    buf: &'a mut String
) -> ReadToStringFuture<'a, Self> where
    Self: Unpin,

Reads the entire contents and appends them to a String. Read more

[src]

fn read_exact(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self> where
    Self: Unpin,

Reads the exact number of bytes required to fill buf. Read more

[src]

fn take(self, limit: u64) -> Take<Self>

Creates an adapter which will read at most limit bytes from it. Read more

[src]

fn bytes(self) -> Bytes<Self>

Converts this [AsyncRead] into a [Stream] of bytes. Read more

[src]

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: AsyncRead,

Creates an adapter which will chain this stream with another. Read more

[src]

fn boxed_reader<'a>(self) -> Pin<Box<dyn AsyncRead + Send + 'a, Global>> where
    Self: Send + 'a,

Boxes the reader and changes its type to dyn AsyncRead + Send + 'a. Read more

[src]

impl<T> Borrow<T> for T where
    T: ?Sized,

[src]

pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized,

[src]

pub fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

[src]

impl<T> BufReadExt for T where
    T: AsyncBufRead + ?Sized,

[src]

fn read_until(
    &'a mut self, 
    byte: u8, 
    buf: &'a mut Vec<u8, Global>
) -> ReadUntilFuture<'a, Self> where
    Self: Unpin,

Reads all bytes into buf until the delimiter byte or EOF is reached. Read more

[src]

fn read_line(&'a mut self, buf: &'a mut String) -> ReadLineFuture<'a, Self> where
    Self: Unpin,

Reads all bytes and appends them into buf until a newline (the 0xA byte) is reached. Read more

[src]

fn lines(self) -> Lines<Self> where
    Self: Unpin,

Returns a stream over the lines of this byte stream. Read more

[src]

fn split(self, byte: u8) -> Split<Self>

Returns a stream over the contents of this reader split on the byte byte. Read more

[src]

impl<T> From<T> for T

[src]

pub fn from(t: T) -> T

Performs the conversion.

[src]

impl<T, U> Into<U> for T where
    U: From<T>,

[src]

pub fn into(self) -> U

Performs the conversion.

[src]

impl<T> ReadExt for T where
    T: AsyncRead + ?Sized,

[src]

fn read(&'a mut self, buf: &'a mut [u8]) -> ReadFuture<'a, Self> where
    Self: Unpin,

Reads some bytes from the byte stream. Read more

[src]

fn read_vectored(
    &'a mut self, 
    bufs: &'a mut [IoSliceMut<'a>]
) -> ReadVectoredFuture<'a, Self> where
    Self: Unpin,

Like read, except that it reads into a slice of buffers. Read more

[src]

fn read_to_end(
    &'a mut self, 
    buf: &'a mut Vec<u8, Global>
) -> ReadToEndFuture<'a, Self> where
    Self: Unpin,

Reads all bytes from the byte stream. Read more

[src]

fn read_to_string(
    &'a mut self, 
    buf: &'a mut String
) -> ReadToStringFuture<'a, Self> where
    Self: Unpin,

Reads all bytes from the byte stream and appends them into a string. Read more

[src]

fn read_exact(&'a mut self, buf: &'a mut [u8]) -> ReadExactFuture<'a, Self> where
    Self: Unpin,

Reads the exact number of bytes required to fill buf. Read more

[src]

fn take(self, limit: u64) -> Take<Self>

Creates an adaptor which will read at most limit bytes from it. Read more

[src]

fn by_ref(&mut self) -> &mut Self

Creates a “by reference” adaptor for this instance of Read. Read more

[src]

fn bytes(self) -> Bytes<Self>

Transforms this Read instance to a Stream over its bytes. Read more

[src]

fn chain<R>(self, next: R) -> Chain<Self, R> where
    R: AsyncRead,

Creates an adaptor which will chain this stream with another. Read more

impl<T> Same<T> for T

type Output = T

Should always be Self

[src]

impl<T> ToOwned for T where
    T: Clone,

type Owned = T

The resulting type after obtaining ownership.

[src]

pub fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

[src]

pub fn clone_into(&self, target: &mut T)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

[src]

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

[src]

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

[src]

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>,

pub fn vzip(self) -> V