ELChainReader

eigensdk::client_elcontracts::reader

Struct ELChainReader 

Source 
pub struct ELChainReader {
    pub provider: String,
    /* private fields */
}
Available on crate feature client-elcontracts only.

Fields§

§provider: String

Implementations§

Source§

impl ELChainReader

Source

pub fn new( allocation_manager: Option<Address>, delegation_manager: Address, rewards_coordinator: Address, avs_directory: Address, permission_controller: Option<Address>, provider: String, ) -> ELChainReader

Creates a new ELChainReader instance with the given parameters.

§Arguments
  • allocation_manager - The address of the allocation manager contract.
  • delegation_manager - The address of the delegation manager contract.
  • rewards_coordinator - The address of the rewards coordinator contract.
  • avs_directory - The address of the avs directory contract.
  • permission_controller - The address of the permission controller contract.
  • provider - The provider to use for the RPC client.
§Returns

A new ELChainReader instance.

Source

pub async fn build( delegation_manager: Address, avs_directory: Address, rewards_coordinator: Address, client: &String, ) -> Result<ELChainReader, ElContractsError>

Builds a new ELChainReader instance, getting the AllocationManager and PermissionController addresses from the delegation manager.

§Arguments
  • delegation_manager - The address of the delegation manager contract.
  • avs_directory - The address of the avs directory contract.
  • rewards_coordinator - The address of the rewards coordinator contract.
  • client - The provider to use for the RPC client to call the contracts.
§Returns

A new ELChainReader instance.

§Errors
Source

pub async fn calculate_delegation_approval_digest_hash( &self, staker: Address, operator: Address, delegation_approver: Address, approve_salt: FixedBytes<32>, expiry: Uint<256, 4>, ) -> Result<FixedBytes<32>, ElContractsError>

Calculate the delegation approval digest hash

§Arguments
  • staker - The staker’s address
  • operator - The operator’s address
  • delegation_approver - The delegation approver’s address
  • approve_salt - The approve salt
  • expiry - The expiry
§Returns
  • FixedBytes<32> - The delegation approval digest hash
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn calculate_operator_avs_registration_digest_hash( &self, operator: Address, avs: Address, salt: FixedBytes<32>, expiry: Uint<256, 4>, ) -> Result<FixedBytes<32>, ElContractsError>

Calculate the operator avs registration digest hash

§Arguments
  • operator - The operator’s address
  • avs - The avs’s address
  • salt - The salt
  • expiry - The expiry
§Returns
  • FixedBytes<32> - The operator avs registration digest hash
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_distribution_roots_length( &self, ) -> Result<Uint<256, 4>, ElContractsError>

Get the length of the distribution roots.

§Returns
  • Result<U256, ElContractsError> - The length of the distribution roots if the call is successful, otherwise an error.
§Errors
  • ElContractsError - if the call to the contract fails.
Source

pub async fn curr_rewards_calculation_end_timestamp( &self, ) -> Result<u32, ElContractsError>

Get the current rewards calculation end timestamp (the timestamp until which rewards have been calculated).

§Returns
  • Result<u32, ElContractsError> - The current rewards calculation end timestamp if the call is successful.
§Errors
  • ElContractsError - if the call to the contract fails.
Source

pub async fn get_current_claimable_distribution_root( &self, ) -> Result<DistributionRoot, ElContractsError>

Get the latest claimable distribution root.

§Returns
  • Result<DistributionRoot, ElContractsError> - The latest claimable distribution root if the call is successful.
§Errors
  • ElContractsError - if the call to the contract fails.
Source

pub async fn get_root_index_from_hash( &self, hash: FixedBytes<32>, ) -> Result<u32, ElContractsError>

Get the root index from a given hash.

§Arguments
  • hash - The hash to get the root index from.
§Returns
  • Result<u32, ElContractsError> - The root index if the call is successful.
§Errors
  • ElContractsError - if the call to the contract fails.
Source

pub async fn get_cumulative_claimed( &self, earner_address: Address, token: Address, ) -> Result<Uint<256, 4>, ElContractsError>

Get the cumulative claimed amount for a given earner address and token.

§Arguments
  • earner_address - The address of the earner.
  • token - The address of the token.
§Returns
  • Result<U256, ElContractsError> - The cumulative claimed amount if the call is successful.
§Errors
  • ElContractsError - if the call to the contract fails.
Source

pub async fn check_claim( &self, claim: RewardsMerkleClaim, ) -> Result<bool, ElContractsError>

Check if a claim would currently pass the validations in process_claim

§Arguments
  • claim - The claim to check
§Returns
  • Result<bool, ElContractsError> - True if the claim would pass the validations, false otherwise
§Errors
  • ElContractsError - if the call to the contract fails. Also fails if no root has been submitted yet.
Source

pub async fn get_operator_avs_split( &self, operator: Address, avs: Address, ) -> Result<u16, ElContractsError>

Gets the split of a specific operator for a specific avs

§Arguments
  • operator - The operator address
  • avs - The AVS address
§Returns
  • u16 - The split of the operator for the AVS, if the call is successful
§Errors
  • ElContractsError - if the call to the contract fails.
Source

pub async fn get_operator_pi_split( &self, operator: Address, ) -> Result<u16, ElContractsError>

Gets the split of a specific operator for Programmatic Incentives

§Arguments
  • operator - The operator address
§Returns
  • u16 - The split of the operator for PI, if the call is successful
§Errors
  • ElContractsError - if the call to the contract fails.
Source

pub async fn get_operator_set_split( &self, operator: Address, operator_set: OperatorSet, ) -> Result<u16, ElContractsError>

Gets the split for a specific operator for a given OperatorSet

§Arguments
  • operator - The operator address
  • OperatorSet - The operator set which consists of avs address and id.
§Returns
  • u16 - The split for a specific operator for a given OperatorSet, if the call is successful
§Errors
  • ElContractsError - if the call to the contract fails.
Source

pub async fn get_operator_shares_in_strategy( &self, operator_addr: Address, strategy_addr: Address, ) -> Result<Uint<256, 4>, ElContractsError>

Get the operator’s shares in a strategy

§Arguments
  • operator_addr - The operator’s address
  • strategy_addr - The strategy’s address
§Returns
  • U256 - The operator’s shares in the strategy
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_strategy_and_underlying_erc20_token( &self, strategy_addr: Address, ) -> Result<(IStrategyInstance<FillProvider<JoinFill<Identity, JoinFill<GasFiller, JoinFill<BlobGasFiller, JoinFill<NonceFiller, ChainIdFiller>>>>, RootProvider>>, IERC20Instance<FillProvider<JoinFill<Identity, JoinFill<GasFiller, JoinFill<BlobGasFiller, JoinFill<NonceFiller, ChainIdFiller>>>>, RootProvider>>, Address), ElContractsError>

Get strategy and underlying ERC-20 token

§Arguments
  • strategy_addr - The strategy’s address
§Returns
  • the strategy contract,
  • the erc20 bindings for the underlying token
  • and the underlying token address
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn is_operator_registered( &self, operator: Address, ) -> Result<bool, ElContractsError>

Check if the operator is registered

§Arguments
  • operator - The operator’s address
§Returns
  • bool - true if the operator is registered, false otherwise
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_staker_shares( &self, staker_address: Address, ) -> Result<(Vec<Address>, Vec<Uint<256, 4>>), ElContractsError>

Get the staker’s shares in all of the strategies in which they have nonzero shares

§Arguments
  • staker_address - The staker’s address
  • block_number - The block number
§Returns
  • Vec<Address> - An array of strategy addresses
  • Vec<U256> - An array with the amount of shares the staker has in each strategy
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_delegated_operator( &self, staker_address: Address, ) -> Result<Address, ElContractsError>

Get the delegated operator

§Arguments
  • staker_address - The staker’s address
  • block_number - The block number
§Returns
  • Address - The address of the operator to whom the staker has delegated their shares
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_strategy_and_underlying_token( &self, strategy_addr: Address, ) -> Result<(IStrategyInstance<FillProvider<JoinFill<Identity, JoinFill<GasFiller, JoinFill<BlobGasFiller, JoinFill<NonceFiller, ChainIdFiller>>>>, RootProvider>>, Address), ElContractsError>

§Returns the strategy contract and the underlying token address.
§Arguments
  • strategy_addr - The strategy’s address
§Returns
  • the strategy contract address,
  • and the underlying token address
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_allocatable_magnitude( &self, operator_address: Address, strategy_address: Address, ) -> Result<u64, ElContractsError>

For a strategy, get the amount of magnitude not currently allocated to any operator set

§Arguments
  • operator_address - The operator’s address to query
  • strategy_address - The strategy’s address to get allocatable magnitude for
§Returns
  • u64 - The magnitude available to be allocated to an operator set
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_max_magnitudes( &self, operator_address: Address, strategy_addresses: Vec<Address>, ) -> Result<Vec<u64>, ElContractsError>

Get the maximum magnitude an operator can allocate for the given strategies

§Arguments
  • operator_address - The operator’s address to query
  • strategy_addresses - The strategy’s addresses to get max magnitudes for
§Returns
  • Vec<u64> - The maximum magnitudes for the strategies
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_allocation_info( &self, operator_address: Address, strategy_address: Address, ) -> Result<Vec<AllocationInfo>, ElContractsError>

Get the allocation info given a strategy and an operator. Returns the info for each operator set where an operator has allocation.

§Arguments
  • operator_address - The operator’s address to query
  • strategy_address - The strategy’s address to get allocation info for
§Returns
  • Vec<AllocationInfo> - The allocation info for each operator set
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_operator_shares( &self, operator_address: Address, strategy_addresses: Vec<Address>, ) -> Result<Vec<Uint<256, 4>>, ElContractsError>

Get the shares that an operator owns in a set of strategies

§Arguments
  • operator_address - The operator’s address to get shares for
  • strategy_addresses - The strategy’s addresses to get shares for
§Returns
  • Vec<U256> - The list of shares for each strategy
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_operators_shares( &self, operator_addresses: Vec<Address>, strategy_addresses: Vec<Address>, ) -> Result<Vec<Vec<Uint<256, 4>>>, ElContractsError>

Get the shares that a list of operators own in a set of strategies

§Arguments
  • operator_addresses - The list of operators’ addresses to get shares for
  • strategy_addresses - The strategy’s addresses to get shares for
§Returns
  • Vec<Vec<U256>> - The list of shares for each operator
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_num_operator_sets_for_operator( &self, operator_addr: Address, ) -> Result<Uint<256, 4>, ElContractsError>

Get the number of operator sets that an operator is part of. Doesn’t include M2 AVSs

§Arguments
  • operator_addr - The operator’s address to query
§Returns
  • U256 - The number of operator sets the operator is part of
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_operator_sets_for_operator( &self, operator_addr: Address, ) -> Result<Vec<OperatorSet>, ElContractsError>

Get the operator sets that an operator is part of. Doesn’t include M2 AVSs

§Arguments
  • operator_addr - The operator’s address to query
§Returns
  • Vec<OperatorSet> - The operator sets the operator is part of
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn is_operator_registered_with_operator_set( &self, operator_address: Address, operator_set: OperatorSet, ) -> Result<bool, ElContractsError>

Check if an operator is registered with a specific operator set

§Arguments
  • operator_address - The operator’s address to query
  • operator_set - The operator set to check if the operator is registered with
§Returns
  • bool - true if the operator is registered with the operator set, false otherwise
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_operators_for_operator_set( &self, operator_set: OperatorSet, ) -> Result<Vec<Address>, ElContractsError>

Get the operators in a specific operator set. Not supported for M2 AVSs

§Arguments
  • operator_set - The operator set to query
§Returns
  • Vec<Address> - The list of operator’s addresses in the operator set
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_num_operators_for_operator_set( &self, operator_set: OperatorSet, ) -> Result<Uint<256, 4>, ElContractsError>

Get the number of operators in a specific operator set. Not supported for M2 AVSs

§Arguments
  • operator_set - The operator set to query
§Returns
  • U256 - The number of operators in the operator set
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_strategies_for_operator_set( &self, operator_set: OperatorSet, ) -> Result<Vec<Address>, ElContractsError>

Get the strategies in a specific operator set. Not supported for M2 AVSs

§Arguments
  • operator_set - The operator set to query
§Returns
  • Vec<Address> - The list of strategy’s addresses in the operator set
§Errors
Source

pub async fn get_slashable_shares( &self, operator_address: Address, operator_set: OperatorSet, strategies: Vec<Address>, ) -> Result<Vec<Uint<256, 4>>, ElContractsError>

Get the slashable shares for an operator.

§Arguments
  • operator_address - The operator’s address to query
  • operator_set - The operator set to query
  • strategies - The strategies to query
§Returns
  • Vec<U256> - The amount of slashable shares for each strategy
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_slashable_shares_for_operator_sets( &self, operator_sets: Vec<OperatorSet>, ) -> Result<Vec<OperatorSetStakes>, ElContractsError>

Get the minimum amount of shares that are slashable by the operator sets. Not supported for M2 AVSs.

§Arguments
  • operator_sets - The operator sets to query
§Returns
  • Vec<OperatorSetStakes> - The operator sets, their strategies, operators, and slashable stakes
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_slashable_shares_for_operator_sets_before( &self, operator_sets: Vec<OperatorSet>, future_block: u32, ) -> Result<Vec<OperatorSetStakes>, ElContractsError>

Given a list of operator sets, for each one get:

  • the operators,
  • the strategies,
  • the minimum amount of shares that are slashable before a given block. Not supported for M2 AVSs.
§Arguments
  • operator_sets - The operator sets to query
  • future_block - The block at which to get allocation information. It must be greater that the current block number.
§Returns
  • Vec<OperatorSetStakes> - The operator sets, their strategies, operators, and slashable stakes
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn get_allocation_delay( &self, operator_address: Address, ) -> Result<u32, ElContractsError>

Get the allocation delay for an operator. Is the number of blocks between an operator allocating slashable magnitude and the magnitude becoming slashable.

§Arguments
  • operator_address - The operator’s address to query
§Returns
  • u32 - The allocation delay
§Errors
  • ElContractsError - if the call to the contract fails
  • AllocationDelayNotSet - if the allocation delay is not set
Source

pub async fn get_registered_sets( &self, operator_address: Address, ) -> Result<Vec<OperatorSet>, ElContractsError>

Get the operator sets that the operator is registered for

§Arguments
  • operator_address - The operator’s address to query
§Returns
  • Vec<OperatorSet> - The operator sets the operator is registered for
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn can_call( &self, account_address: Address, appointee_address: Address, target: Address, selector: FixedBytes<4>, ) -> Result<bool, ElContractsError>

Check if the given caller has permissions to call the function

§Arguments
  • account_address - The account address to check
  • appointee_address - The caller address to check permissions for
  • target - The target address to check permissions for
  • selector - The selector of the function to check permissions for
§Returns
  • bool - true if the account has permissions to call the function, false otherwise
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn list_appointees( &self, account_address: Address, target: Address, selector: FixedBytes<4>, ) -> Result<Vec<Address>, ElContractsError>

Get the list of appointees for a given account and function

§Arguments
  • account_address - The account address to get appointees for
  • target - The target address to get appointees for
  • selector - The selector of the function to get appointees for
§Returns
  • Vec<Address> - The list of appointees
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn list_appointee_permissions( &self, account_address: Address, appointee_address: Address, ) -> Result<(Vec<Address>, Vec<FixedBytes<4>>), ElContractsError>

Get the list of permissions of an appointee for a given account

§Arguments
  • account_address - The account address to get appointee permissions for
  • appointee_address - The appointee address to get permissions
§Returns
  • Vec<Address> - The list of targets
  • Vec<FixedBytes<4>> - The list of selectors
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn list_pending_admins( &self, account_address: Address, ) -> Result<Vec<Address>, ElContractsError>

Get the list of pending admins of a given account

§Arguments
  • account_address - The account address to get pending admins of
§Returns
  • Vec<Address> - The list of pending admins
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn list_admins( &self, account_address: Address, ) -> Result<Vec<Address>, ElContractsError>

Get the list of admins of a given account

§Arguments
  • account_address - The account address
§Returns
  • Vec<Address> - The list of admins
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn is_pending_admin( &self, account_address: Address, pending_admin_address: Address, ) -> Result<bool, ElContractsError>

Check if an address is a pending admin of another account

§Arguments
  • account_address - The account address
  • pending_admin_address - The pending admin address to check
§Returns
  • bool - true if the pending_admin_address is a pending admin, false otherwise
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn is_admin( &self, account_address: Address, admin_address: Address, ) -> Result<bool, ElContractsError>

Check if an address is an admin of another account

§Arguments
  • account_address - The account address
  • admin_address - The admin address to check
§Returns
  • bool - true if the admin_address is an admin, false otherwise
§Errors
  • ElContractsError - if the call to the contract fails
Source

pub async fn is_operator_slashable( &self, operator_address: Address, operator_set: OperatorSet, ) -> Result<bool, ElContractsError>

Checks if an operator is slashable by an operator set.

§Arguments
  • operator_address - The operator to check slashability for
  • operator_set - The operator set to check slashability for
§Returns
  • bool - true if the operator is registered or their slashableUntil block has not passed. This is because even when operators are deregistered, they still remain slashable for a period of time.
§Errors
Source

pub async fn get_allocated_stake( &self, operator_set: OperatorSet, operators: Vec<Address>, strategies: Vec<Address>, ) -> Result<Vec<Vec<Uint<256, 4>>>, ElContractsError>

Returns the current allocated stake, irrespective of the operator’s slashable status for the OperatorSet.

§Arguments
  • operators - The operators to query
  • operator_set - The operator set to query
  • strategies - The strategies to query
§Returns
§Errors
Source

pub async fn get_encumbered_magnitude( &self, operator: Address, strategy_address: Address, ) -> Result<u64, ElContractsError>

For a strategy, get the amount of magnitude that is allocated across one or more operator sets

§Arguments
  • operator - The operator to query
  • strategy_address - The strategy to get allocatable magnitude for
§Returns

u64 - currently allocated magnitude

Trait Implementations§

Source§

impl Clone for ELChainReader

Source§

fn clone(&self) -> ELChainReader

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for ELChainReader

Source§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

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

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

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

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

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

Mutably borrows from an owned value. Read more
Source§

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

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. 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 T
where 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> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> IntoResult<T> for T

Source§

type Err = Infallible

Source§

fn into_result(self) -> Result<T, <T as IntoResult<T>>::Err>

Source§

impl<Unshared, Shared> IntoShared<Shared> for Unshared
where Shared: FromUnshared<Unshared>,

Source§

fn into_shared(self) -> Shared

Creates a shared type from an unshared type.
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

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

Source§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more
Source§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

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

Source§

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> TryClone for T
where T: Clone,

Source§

fn try_clone(&self) -> Result<T, Error>

Clones self, possibly returning an error.
Source§

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

Source§

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 T
where U: TryFrom<T>,

Source§

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.
Source§

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

Source§

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
Source§

impl<T> ErasedDestructor for T
where T: 'static,