Struct postgres::types::Type

pub struct Type(_);
Expand description

A Postgres type.

Implementations§

§

impl Type

pub const BOOL: Type = Type(Inner::Bool)

BOOL - boolean, 'true'/'false'

pub const BYTEA: Type = Type(Inner::Bytea)

BYTEA - variable-length string, binary values escaped

pub const CHAR: Type = Type(Inner::Char)

CHAR - single character

pub const NAME: Type = Type(Inner::Name)

NAME - 63-byte type for storing system identifiers

pub const INT8: Type = Type(Inner::Int8)

INT8 - ~18 digit integer, 8-byte storage

pub const INT2: Type = Type(Inner::Int2)

INT2 - -32 thousand to 32 thousand, 2-byte storage

pub const INT2_VECTOR: Type = Type(Inner::Int2Vector)

INT2VECTOR - array of int2, used in system tables

pub const INT4: Type = Type(Inner::Int4)

INT4 - -2 billion to 2 billion integer, 4-byte storage

pub const REGPROC: Type = Type(Inner::Regproc)

REGPROC - registered procedure

pub const TEXT: Type = Type(Inner::Text)

TEXT - variable-length string, no limit specified

pub const OID: Type = Type(Inner::Oid)

OID - object identifier(oid), maximum 4 billion

pub const TID: Type = Type(Inner::Tid)

TID - (block, offset), physical location of tuple

pub const XID: Type = Type(Inner::Xid)

XID - transaction id

pub const CID: Type = Type(Inner::Cid)

CID - command identifier type, sequence in transaction id

pub const OID_VECTOR: Type = Type(Inner::OidVector)

OIDVECTOR - array of oids, used in system tables

pub const PG_DDL_COMMAND: Type = Type(Inner::PgDdlCommand)

PG_DDL_COMMAND - internal type for passing CollectedCommand

pub const JSON: Type = Type(Inner::Json)

JSON - JSON stored as text

pub const XML: Type = Type(Inner::Xml)

XML - XML content

pub const XML_ARRAY: Type = Type(Inner::XmlArray)

XML[]

pub const PG_NODE_TREE: Type = Type(Inner::PgNodeTree)

PG_NODE_TREE - string representing an internal node tree

pub const JSON_ARRAY: Type = Type(Inner::JsonArray)

JSON[]

pub const TABLE_AM_HANDLER: Type = Type(Inner::TableAmHandler)

TABLE_AM_HANDLER

pub const XID8_ARRAY: Type = Type(Inner::Xid8Array)

XID8[]

pub const INDEX_AM_HANDLER: Type = Type(Inner::IndexAmHandler)

INDEX_AM_HANDLER - pseudo-type for the result of an index AM handler function

pub const POINT: Type = Type(Inner::Point)

POINT - geometric point '(x, y)'

pub const LSEG: Type = Type(Inner::Lseg)

LSEG - geometric line segment '(pt1,pt2)'

pub const PATH: Type = Type(Inner::Path)

PATH - geometric path '(pt1,…)'

pub const BOX: Type = Type(Inner::Box)

BOX - geometric box '(lower left,upper right)'

pub const POLYGON: Type = Type(Inner::Polygon)

POLYGON - geometric polygon '(pt1,…)'

pub const LINE: Type = Type(Inner::Line)

LINE - geometric line

pub const LINE_ARRAY: Type = Type(Inner::LineArray)

LINE[]

pub const CIDR: Type = Type(Inner::Cidr)

CIDR - network IP address/netmask, network address

pub const CIDR_ARRAY: Type = Type(Inner::CidrArray)

CIDR[]

pub const FLOAT4: Type = Type(Inner::Float4)

FLOAT4 - single-precision floating point number, 4-byte storage

pub const FLOAT8: Type = Type(Inner::Float8)

FLOAT8 - double-precision floating point number, 8-byte storage

pub const UNKNOWN: Type = Type(Inner::Unknown)

UNKNOWN - pseudo-type representing an undetermined type

pub const CIRCLE: Type = Type(Inner::Circle)

CIRCLE - geometric circle '(center,radius)'

pub const CIRCLE_ARRAY: Type = Type(Inner::CircleArray)

CIRCLE[]

pub const MACADDR8: Type = Type(Inner::Macaddr8)

MACADDR8 - XX:XX:XX:XX:XX:XX:XX:XX, MAC address

pub const MACADDR8_ARRAY: Type = Type(Inner::Macaddr8Array)

MACADDR8[]

pub const MONEY: Type = Type(Inner::Money)

MONEY - monetary amounts, $d,ddd.cc

pub const MONEY_ARRAY: Type = Type(Inner::MoneyArray)

MONEY[]

pub const MACADDR: Type = Type(Inner::Macaddr)

MACADDR - XX:XX:XX:XX:XX:XX, MAC address

pub const INET: Type = Type(Inner::Inet)

INET - IP address/netmask, host address, netmask optional

pub const BOOL_ARRAY: Type = Type(Inner::BoolArray)

BOOL[]

pub const BYTEA_ARRAY: Type = Type(Inner::ByteaArray)

BYTEA[]

pub const CHAR_ARRAY: Type = Type(Inner::CharArray)

CHAR[]

pub const NAME_ARRAY: Type = Type(Inner::NameArray)

NAME[]

pub const INT2_ARRAY: Type = Type(Inner::Int2Array)

INT2[]

pub const INT2_VECTOR_ARRAY: Type = Type(Inner::Int2VectorArray)

INT2VECTOR[]

pub const INT4_ARRAY: Type = Type(Inner::Int4Array)

INT4[]

pub const REGPROC_ARRAY: Type = Type(Inner::RegprocArray)

REGPROC[]

pub const TEXT_ARRAY: Type = Type(Inner::TextArray)

TEXT[]

pub const TID_ARRAY: Type = Type(Inner::TidArray)

TID[]

pub const XID_ARRAY: Type = Type(Inner::XidArray)

XID[]

pub const CID_ARRAY: Type = Type(Inner::CidArray)

CID[]

pub const OID_VECTOR_ARRAY: Type = Type(Inner::OidVectorArray)

OIDVECTOR[]

pub const BPCHAR_ARRAY: Type = Type(Inner::BpcharArray)

BPCHAR[]

pub const VARCHAR_ARRAY: Type = Type(Inner::VarcharArray)

VARCHAR[]

pub const INT8_ARRAY: Type = Type(Inner::Int8Array)

INT8[]

pub const POINT_ARRAY: Type = Type(Inner::PointArray)

POINT[]

pub const LSEG_ARRAY: Type = Type(Inner::LsegArray)

LSEG[]

pub const PATH_ARRAY: Type = Type(Inner::PathArray)

PATH[]

pub const BOX_ARRAY: Type = Type(Inner::BoxArray)

BOX[]

pub const FLOAT4_ARRAY: Type = Type(Inner::Float4Array)

FLOAT4[]

pub const FLOAT8_ARRAY: Type = Type(Inner::Float8Array)

FLOAT8[]

pub const POLYGON_ARRAY: Type = Type(Inner::PolygonArray)

POLYGON[]

pub const OID_ARRAY: Type = Type(Inner::OidArray)

OID[]

pub const ACLITEM: Type = Type(Inner::Aclitem)

ACLITEM - access control list

pub const ACLITEM_ARRAY: Type = Type(Inner::AclitemArray)

ACLITEM[]

pub const MACADDR_ARRAY: Type = Type(Inner::MacaddrArray)

MACADDR[]

pub const INET_ARRAY: Type = Type(Inner::InetArray)

INET[]

pub const BPCHAR: Type = Type(Inner::Bpchar)

BPCHAR - char(length), blank-padded string, fixed storage length

pub const VARCHAR: Type = Type(Inner::Varchar)

VARCHAR - varchar(length), non-blank-padded string, variable storage length

pub const DATE: Type = Type(Inner::Date)

DATE - date

pub const TIME: Type = Type(Inner::Time)

TIME - time of day

pub const TIMESTAMP: Type = Type(Inner::Timestamp)

TIMESTAMP - date and time

pub const TIMESTAMP_ARRAY: Type = Type(Inner::TimestampArray)

TIMESTAMP[]

pub const DATE_ARRAY: Type = Type(Inner::DateArray)

DATE[]

pub const TIME_ARRAY: Type = Type(Inner::TimeArray)

TIME[]

pub const TIMESTAMPTZ: Type = Type(Inner::Timestamptz)

TIMESTAMPTZ - date and time with time zone

pub const TIMESTAMPTZ_ARRAY: Type = Type(Inner::TimestamptzArray)

TIMESTAMPTZ[]

pub const INTERVAL: Type = Type(Inner::Interval)

INTERVAL - @ <number> <units>, time interval

pub const INTERVAL_ARRAY: Type = Type(Inner::IntervalArray)

INTERVAL[]

pub const NUMERIC_ARRAY: Type = Type(Inner::NumericArray)

NUMERIC[]

pub const CSTRING_ARRAY: Type = Type(Inner::CstringArray)

CSTRING[]

pub const TIMETZ: Type = Type(Inner::Timetz)

TIMETZ - time of day with time zone

pub const TIMETZ_ARRAY: Type = Type(Inner::TimetzArray)

TIMETZ[]

pub const BIT: Type = Type(Inner::Bit)

BIT - fixed-length bit string

pub const BIT_ARRAY: Type = Type(Inner::BitArray)

BIT[]

pub const VARBIT: Type = Type(Inner::Varbit)

VARBIT - variable-length bit string

pub const VARBIT_ARRAY: Type = Type(Inner::VarbitArray)

VARBIT[]

pub const NUMERIC: Type = Type(Inner::Numeric)

NUMERIC - numeric(precision, decimal), arbitrary precision number

pub const REFCURSOR: Type = Type(Inner::Refcursor)

REFCURSOR - reference to cursor (portal name)

pub const REFCURSOR_ARRAY: Type = Type(Inner::RefcursorArray)

REFCURSOR[]

pub const REGPROCEDURE: Type = Type(Inner::Regprocedure)

REGPROCEDURE - registered procedure (with args)

pub const REGOPER: Type = Type(Inner::Regoper)

REGOPER - registered operator

pub const REGOPERATOR: Type = Type(Inner::Regoperator)

REGOPERATOR - registered operator (with args)

pub const REGCLASS: Type = Type(Inner::Regclass)

REGCLASS - registered class

pub const REGTYPE: Type = Type(Inner::Regtype)

REGTYPE - registered type

pub const REGPROCEDURE_ARRAY: Type = Type(Inner::RegprocedureArray)

REGPROCEDURE[]

pub const REGOPER_ARRAY: Type = Type(Inner::RegoperArray)

REGOPER[]

pub const REGOPERATOR_ARRAY: Type = Type(Inner::RegoperatorArray)

REGOPERATOR[]

pub const REGCLASS_ARRAY: Type = Type(Inner::RegclassArray)

REGCLASS[]

pub const REGTYPE_ARRAY: Type = Type(Inner::RegtypeArray)

REGTYPE[]

pub const RECORD: Type = Type(Inner::Record)

RECORD - pseudo-type representing any composite type

pub const CSTRING: Type = Type(Inner::Cstring)

CSTRING - C-style string

pub const ANY: Type = Type(Inner::Any)

ANY - pseudo-type representing any type

pub const ANYARRAY: Type = Type(Inner::Anyarray)

ANYARRAY - pseudo-type representing a polymorphic array type

pub const VOID: Type = Type(Inner::Void)

VOID - pseudo-type for the result of a function with no real result

pub const TRIGGER: Type = Type(Inner::Trigger)

TRIGGER - pseudo-type for the result of a trigger function

pub const LANGUAGE_HANDLER: Type = Type(Inner::LanguageHandler)

LANGUAGE_HANDLER - pseudo-type for the result of a language handler function

pub const INTERNAL: Type = Type(Inner::Internal)

INTERNAL - pseudo-type representing an internal data structure

pub const ANYELEMENT: Type = Type(Inner::Anyelement)

ANYELEMENT - pseudo-type representing a polymorphic base type

pub const RECORD_ARRAY: Type = Type(Inner::RecordArray)

RECORD[]

pub const ANYNONARRAY: Type = Type(Inner::Anynonarray)

ANYNONARRAY - pseudo-type representing a polymorphic base type that is not an array

pub const TXID_SNAPSHOT_ARRAY: Type = Type(Inner::TxidSnapshotArray)

TXID_SNAPSHOT[]

pub const UUID: Type = Type(Inner::Uuid)

UUID - UUID datatype

pub const UUID_ARRAY: Type = Type(Inner::UuidArray)

UUID[]

pub const TXID_SNAPSHOT: Type = Type(Inner::TxidSnapshot)

TXID_SNAPSHOT - txid snapshot

pub const FDW_HANDLER: Type = Type(Inner::FdwHandler)

FDW_HANDLER - pseudo-type for the result of an FDW handler function

pub const PG_LSN: Type = Type(Inner::PgLsn)

PG_LSN - PostgreSQL LSN datatype

pub const PG_LSN_ARRAY: Type = Type(Inner::PgLsnArray)

PG_LSN[]

pub const TSM_HANDLER: Type = Type(Inner::TsmHandler)

TSM_HANDLER - pseudo-type for the result of a tablesample method function

pub const PG_NDISTINCT: Type = Type(Inner::PgNdistinct)

PG_NDISTINCT - multivariate ndistinct coefficients

pub const PG_DEPENDENCIES: Type = Type(Inner::PgDependencies)

PG_DEPENDENCIES - multivariate dependencies

pub const ANYENUM: Type = Type(Inner::Anyenum)

ANYENUM - pseudo-type representing a polymorphic base type that is an enum

pub const TS_VECTOR: Type = Type(Inner::TsVector)

TSVECTOR - text representation for text search

pub const TSQUERY: Type = Type(Inner::Tsquery)

TSQUERY - query representation for text search

pub const GTS_VECTOR: Type = Type(Inner::GtsVector)

GTSVECTOR - GiST index internal text representation for text search

pub const TS_VECTOR_ARRAY: Type = Type(Inner::TsVectorArray)

TSVECTOR[]

pub const GTS_VECTOR_ARRAY: Type = Type(Inner::GtsVectorArray)

GTSVECTOR[]

pub const TSQUERY_ARRAY: Type = Type(Inner::TsqueryArray)

TSQUERY[]

pub const REGCONFIG: Type = Type(Inner::Regconfig)

REGCONFIG - registered text search configuration

pub const REGCONFIG_ARRAY: Type = Type(Inner::RegconfigArray)

REGCONFIG[]

pub const REGDICTIONARY: Type = Type(Inner::Regdictionary)

REGDICTIONARY - registered text search dictionary

pub const REGDICTIONARY_ARRAY: Type = Type(Inner::RegdictionaryArray)

REGDICTIONARY[]

pub const JSONB: Type = Type(Inner::Jsonb)

JSONB - Binary JSON

pub const JSONB_ARRAY: Type = Type(Inner::JsonbArray)

JSONB[]

pub const ANY_RANGE: Type = Type(Inner::AnyRange)

ANYRANGE - pseudo-type representing a range over a polymorphic base type

pub const EVENT_TRIGGER: Type = Type(Inner::EventTrigger)

EVENT_TRIGGER - pseudo-type for the result of an event trigger function

pub const INT4_RANGE: Type = Type(Inner::Int4Range)

INT4RANGE - range of integers

pub const INT4_RANGE_ARRAY: Type = Type(Inner::Int4RangeArray)

INT4RANGE[]

pub const NUM_RANGE: Type = Type(Inner::NumRange)

NUMRANGE - range of numerics

pub const NUM_RANGE_ARRAY: Type = Type(Inner::NumRangeArray)

NUMRANGE[]

pub const TS_RANGE: Type = Type(Inner::TsRange)

TSRANGE - range of timestamps without time zone

pub const TS_RANGE_ARRAY: Type = Type(Inner::TsRangeArray)

TSRANGE[]

pub const TSTZ_RANGE: Type = Type(Inner::TstzRange)

TSTZRANGE - range of timestamps with time zone

pub const TSTZ_RANGE_ARRAY: Type = Type(Inner::TstzRangeArray)

TSTZRANGE[]

pub const DATE_RANGE: Type = Type(Inner::DateRange)

DATERANGE - range of dates

pub const DATE_RANGE_ARRAY: Type = Type(Inner::DateRangeArray)

DATERANGE[]

pub const INT8_RANGE: Type = Type(Inner::Int8Range)

INT8RANGE - range of bigints

pub const INT8_RANGE_ARRAY: Type = Type(Inner::Int8RangeArray)

INT8RANGE[]

pub const JSONPATH: Type = Type(Inner::Jsonpath)

JSONPATH - JSON path

pub const JSONPATH_ARRAY: Type = Type(Inner::JsonpathArray)

JSONPATH[]

pub const REGNAMESPACE: Type = Type(Inner::Regnamespace)

REGNAMESPACE - registered namespace

pub const REGNAMESPACE_ARRAY: Type = Type(Inner::RegnamespaceArray)

REGNAMESPACE[]

pub const REGROLE: Type = Type(Inner::Regrole)

REGROLE - registered role

pub const REGROLE_ARRAY: Type = Type(Inner::RegroleArray)

REGROLE[]

pub const REGCOLLATION: Type = Type(Inner::Regcollation)

REGCOLLATION - registered collation

pub const REGCOLLATION_ARRAY: Type = Type(Inner::RegcollationArray)

REGCOLLATION[]

pub const INT4MULTI_RANGE: Type = Type(Inner::Int4multiRange)

INT4MULTIRANGE - multirange of integers

pub const NUMMULTI_RANGE: Type = Type(Inner::NummultiRange)

NUMMULTIRANGE - multirange of numerics

pub const TSMULTI_RANGE: Type = Type(Inner::TsmultiRange)

TSMULTIRANGE - multirange of timestamps without time zone

pub const TSTZMULTI_RANGE: Type = Type(Inner::TstzmultiRange)

TSTZMULTIRANGE - multirange of timestamps with time zone

pub const DATEMULTI_RANGE: Type = Type(Inner::DatemultiRange)

DATEMULTIRANGE - multirange of dates

pub const INT8MULTI_RANGE: Type = Type(Inner::Int8multiRange)

INT8MULTIRANGE - multirange of bigints

pub const ANYMULTI_RANGE: Type = Type(Inner::AnymultiRange)

ANYMULTIRANGE - pseudo-type representing a polymorphic base type that is a multirange

pub const ANYCOMPATIBLEMULTI_RANGE: Type = Type(Inner::AnycompatiblemultiRange)

ANYCOMPATIBLEMULTIRANGE - pseudo-type representing a multirange over a polymorphic common type

pub const PG_BRIN_BLOOM_SUMMARY: Type = Type(Inner::PgBrinBloomSummary)

PG_BRIN_BLOOM_SUMMARY - BRIN bloom summary

pub const PG_BRIN_MINMAX_MULTI_SUMMARY: Type = Type(Inner::PgBrinMinmaxMultiSummary)

PG_BRIN_MINMAX_MULTI_SUMMARY - BRIN minmax-multi summary

pub const PG_MCV_LIST: Type = Type(Inner::PgMcvList)

PG_MCV_LIST - multivariate MCV list

pub const PG_SNAPSHOT: Type = Type(Inner::PgSnapshot)

PG_SNAPSHOT - snapshot

pub const PG_SNAPSHOT_ARRAY: Type = Type(Inner::PgSnapshotArray)

PG_SNAPSHOT[]

pub const XID8: Type = Type(Inner::Xid8)

XID8 - full transaction id

pub const ANYCOMPATIBLE: Type = Type(Inner::Anycompatible)

ANYCOMPATIBLE - pseudo-type representing a polymorphic common type

pub const ANYCOMPATIBLEARRAY: Type = Type(Inner::Anycompatiblearray)

ANYCOMPATIBLEARRAY - pseudo-type representing an array of polymorphic common type elements

pub const ANYCOMPATIBLENONARRAY: Type = Type(Inner::Anycompatiblenonarray)

ANYCOMPATIBLENONARRAY - pseudo-type representing a polymorphic common type that is not an array

pub const ANYCOMPATIBLE_RANGE: Type = Type(Inner::AnycompatibleRange)

ANYCOMPATIBLERANGE - pseudo-type representing a range over a polymorphic common type

pub const INT4MULTI_RANGE_ARRAY: Type = Type(Inner::Int4multiRangeArray)

INT4MULTIRANGE[]

pub const NUMMULTI_RANGE_ARRAY: Type = Type(Inner::NummultiRangeArray)

NUMMULTIRANGE[]

pub const TSMULTI_RANGE_ARRAY: Type = Type(Inner::TsmultiRangeArray)

TSMULTIRANGE[]

pub const TSTZMULTI_RANGE_ARRAY: Type = Type(Inner::TstzmultiRangeArray)

TSTZMULTIRANGE[]

pub const DATEMULTI_RANGE_ARRAY: Type = Type(Inner::DatemultiRangeArray)

DATEMULTIRANGE[]

pub const INT8MULTI_RANGE_ARRAY: Type = Type(Inner::Int8multiRangeArray)

INT8MULTIRANGE[]

§

impl Type

pub fn new(name: String, oid: u32, kind: Kind, schema: String) -> Type

Creates a new Type.

pub fn from_oid(oid: u32) -> Option<Type>

Returns the Type corresponding to the provided Oid if it corresponds to a built-in type.

pub fn oid(&self) -> u32

Returns the OID of the Type.

pub fn kind(&self) -> &Kind

Returns the kind of this type.

pub fn schema(&self) -> &str

Returns the schema of this type.

pub fn name(&self) -> &str

Returns the name of this type.

Trait Implementations§

§

impl Clone for Type

§

fn clone(&self) -> Type

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
§

impl Debug for Type

§

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

Formats the value using the given formatter. Read more
§

impl Display for Type

§

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

Formats the value using the given formatter. Read more
§

impl Hash for Type

§

fn hash<__H>(&self, state: &mut __H)where __H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
§

impl PartialEq<Type> for Type

§

fn eq(&self, other: &Type) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
§

impl Eq for Type

§

impl StructuralEq for Type

§

impl StructuralPartialEq for Type

Auto Trait Implementations§

§

impl RefUnwindSafe for Type

§

impl Send for Type

§

impl Sync for Type

§

impl Unpin for Type

§

impl UnwindSafe for Type

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

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

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> Same<T> for T

§

type Output = T

Should always be Self
source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

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

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

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

impl<T> ToString for Twhere T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

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

§

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

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
§

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

§

fn vzip(self) -> V

source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more