Skip to main content

CowBackend

Struct CowBackend 

Source
pub struct CowBackend<'a, FEN: FoundryEvmNetwork> {
    pub backend: Cow<'a, Backend<FEN>>,
    pending_init: Option<(Address, TxKind)>,
}
Expand description

A clone-on-write Backend.

Reads and executions that discard their state (Backend::create_evm) borrow the wrapped backend. The first mutable access, such as a cheatcode that switches forks, clones it and applies the pending test initialization, so the original backend is never modified.

Entire purpose of this type is for fuzzing. A test function fuzzer will repeatedly execute the function via immutable raw (no state changes) calls.

N.B.: we’re assuming cheatcodes that alter the state (like multi fork swapping) are niche. If they executed, it will require a clone of the initial input database. This way we can support these cheatcodes cheaply without adding overhead for tests that don’t make use of them. Alternatively each test case would require its own Backend clone, which would add significant overhead for large fuzz sets even if the Database is not big after setup.

Fields§

§backend: Cow<'a, Backend<FEN>>

The underlying Backend.

No calls on the CowBackend will ever persistently modify the backend’s state.

§pending_init: Option<(Address, TxKind)>

Test initialization applied on first mutable access.

Implementations§

Source§

impl<'a, FEN: FoundryEvmNetwork> CowBackend<'a, FEN>

Source

pub const fn new_borrowed(backend: &'a Backend<FEN>) -> Self

Creates a new CowBackend with the given Backend.

Source

pub const fn initialize(&mut self, caller: Address, kind: TxKind)

Records the caller and test contract of the next execution, applied with Backend::initialize on first mutable access.

Source

pub const fn is_owned(&self) -> bool

Returns whether the backend was cloned.

Source

pub fn park_detached(&mut self, evm: FoundryEvmFor<'_, FEN>)

Parks accepted state on owned backends; leaves pending writes uncommitted.

Methods from Deref<Target = Backend<FEN>>§

Source

pub fn set_bal(&mut self, bal: Arc<Bal>, index: BlockAccessIndex)

Serves reads of state the block wrote before index from bal, and everything else from the underlying database.

Index 0 holds the pre-block system writes and transaction i is index i + 1, so positioning the reads at a transaction’s own index yields its prestate without replaying the earlier transactions. The list applies to EVMs created afterwards; parking an EVM removes it again, so the backend must not execute further transactions of that block afterwards.

Source

pub(super) fn apply_bal(&self, evm: &mut FoundryEvmFor<'_, FEN>)

Attaches the pending block access list to a newly created EVM.

Source

pub fn clone_with_fork_scope(&self) -> Result<Self>

Clones execution state with an independent registry for newly created forks.

Remote caches remain shared, but forks created by this execution are released with it.

Source

pub fn clone_empty(&self) -> Self

Creates an empty local backend sharing this backend’s fork manager and environment.

Source

pub fn clone_empty_with_env(&self, env: EvmEnvFor<FEN>) -> Self

Creates an empty local backend sharing this backend’s fork manager, with network state seeded at env.

Network state can depend on the hardfork, such as Tempo’s genesis, so a test contract pinned to another hardfork needs its own seed.

Source

pub fn replace_fork( &mut self, fork: Option<CreateFork>, local_env: EvmEnvFor<FEN>, ) -> Result<()>

Replaces this backend with one starting on fork at its resolved block’s environment, or locally with local_env, reusing the fork manager’s remote caches.

Source

pub fn fork(&self) -> Option<RemoteFork>

Returns the remote fork of the active context, if execution is forked over RPC.

Source

pub async fn env( &self, opts: &EvmOpts, ) -> Result<(EvmEnvFor<FEN>, TransactionRequestFor<FEN>)>

Builds execution environments from this backend’s selected remote block.

Source

pub async fn can_use_create2_deployer(&self, deployer: Address) -> Result<bool>

Checks library-linking availability against this backend’s remote state.

Source

pub async fn transaction_count(&self, sender: Address) -> Result<u64>

Reads a sender nonce at this backend’s remote block before local execution.

Source

pub fn networks(&self) -> NetworkConfigs

Returns the active network configuration.

Source

pub fn set_networks(&mut self, networks: NetworkConfigs)

Sets the active network configuration.

Source

pub fn set_fork_block_number_override(&mut self, block_number: u64)

Sets the block number the active fork reports while executing transactions of that block on top of its parent’s state.

Source

pub fn factory(&self) -> &EvmFactoryFor<FEN>

Returns the EVM factory.

Source

pub fn lifecycle(&self) -> &ExecutionLifecycle<EvmFactoryFor<FEN>>

Returns the execution lifecycle, for read-only inspection of contexts and forks.

Source

pub fn evm_env(&self) -> EvmEnvFor<FEN>

Returns the environment of the active context, as of the last park, with a fork’s own chain ID.

Source

pub fn evm_env_mut(&mut self) -> &mut EvmEnvFor<FEN>

Returns the environment of the active context for modification between executions.

Source

pub fn set_spec_id(&mut self, spec: impl Into<SpecFor<FEN>>) -> &mut Self

Sets the spec of the active context, keeping Foundry’s execution policy.

Source

pub fn create_evm<'a>(&self) -> FoundryEvmFor<'a, FEN>

Creates an EVM over the active context. See the module documentation.

Source

pub fn park(&mut self, evm: FoundryEvmFor<'_, FEN>)

Accepts a committed EVM’s state, environment and network state into the active context, and detaches the block access list set with Self::set_bal.

Source

pub fn remove_prewarm(&mut self, state: &mut State<'_>, address: &Address)

Removes address from the running transaction’s base warmth, see ExecutionLifecycle::remove_prewarm.

Source

pub fn take_persistent_warmth( &mut self, ) -> Vec<(Option<U256>, AddressMap<HashSet<U256>>)>

Takes the persistent warmth contexts kept for the running transaction, see ExecutionLifecycle::take_persistent_warmth.

Source

pub fn restore_persistent_warmth( &mut self, warmth: Vec<(Option<U256>, AddressMap<HashSet<U256>>)>, )

Hands back persistent warmth taken with Self::take_persistent_warmth.

Source

pub fn inspect_commit<'a>( &mut self, tx: &Recovered<TxFor<FEN>>, inspector: impl Inspector<TypesFor<FEN>> + 'a, ) -> Result<TxResultFor<FEN>>

Executes tx over the active context with inspector and accepts its state.

Source

pub fn initialize(&mut self, caller: Address, kind: TxKind)

Records the caller and test contract of the next test execution.

The test contract is the call target, or the address caller creates at its current nonce.

Source

pub fn basic(&self, address: Address) -> DbResult<Option<AccountInfo>>

Returns an account of the active context’s accepted state.

Source

pub fn code_by_hash(&self, code_hash: B256) -> DbResult<Bytecode>

Returns code of the active context’s accepted state.

Source

pub fn storage(&self, address: Address, slot: U256) -> DbResult<U256>

Returns a storage slot of the active context’s accepted state.

Source

pub fn block_hash(&self, number: U256) -> DbResult<B256>

Returns a block hash of the active context.

Source

pub fn insert_account_info(&mut self, address: Address, account: AccountInfo)

Inserts account info into the active context’s accepted state.

Use this between executions only; a running EVM does not observe it.

Source

pub fn insert_account_storage( &mut self, address: Address, slot: U256, value: U256, )

Inserts a value into an account’s storage without overriding account info.

Use this between executions only; a running EVM does not observe it.

Source

pub fn replace_account_storage( &mut self, address: Address, storage: impl IntoIterator<Item = (U256, U256)>, )

Replaces an account’s storage without overriding account info.

When forking, every slot not in storage reads as zero instead of being fetched. Use this between executions only; a running EVM does not observe it.

Source

pub fn set_env( &mut self, evm: &mut FoundryEvmFor<'_, FEN>, env: EvmEnvFor<FEN>, phase: ExecutionPhase, )

Switches the running evm to env, such as for vm.chainId or vm.setEvmVersion. See ExecutionLifecycle::set_env.

Source

pub fn commit_pending(&mut self, pending: &PendingState)

Accepts a detached transaction’s state, such as a call’s, into the active context’s accepted state.

Use this between executions only; a running EVM does not observe it.

Source

pub fn set_test_contract(&mut self, account: Address) -> &mut Self

Sets the address of the DSTest contract that is being executed.

This marks the contract as persistent and grants it cheatcode access.

Source

pub fn set_caller(&mut self, account: Address) -> &mut Self

Sets the caller address and grants it cheatcode access.

Source

pub fn has_state_snapshot_failure(&self) -> bool

Returns whether a reverted state snapshot recorded a test failure.

If an error occurs in a restored state snapshot, the test is considered failed.

Source

pub fn set_state_snapshot_failure(&mut self, has_state_snapshot_failure: bool)

Sets the state snapshot failure flag.

Source

pub fn is_persistent(&self, account: &Address) -> bool

Returns whether account persists across fork switches.

Source

pub fn add_persistent_account(&mut self, account: Address) -> bool

Marks account as persistent across fork switches. Returns whether it was not yet.

Source

pub fn remove_persistent_account(&mut self, account: &Address) -> bool

Stops account from persisting across fork switches. Returns whether it was persistent.

Source

pub fn extend_persistent_accounts( &mut self, accounts: impl IntoIterator<Item = Address>, )

Marks all accounts as persistent.

Source

pub fn allow_cheatcode_access(&mut self, account: Address) -> bool

Grants account cheatcode access. Returns whether it did not have access yet.

Source

pub fn has_cheatcode_access(&self, account: &Address) -> bool

Returns whether account has cheatcode access.

Source

pub fn ensure_cheatcode_access( &self, account: &Address, ) -> Result<(), BackendError>

Ensures that account has cheatcode access.

Source

pub fn ensure_cheatcode_access_forking_mode( &self, account: &Address, ) -> Result<(), BackendError>

Like Self::ensure_cheatcode_access, but only enforced while forked.

Source

pub fn active_fork_id(&self) -> Option<LocalForkId>

Returns the active fork, or None for local execution.

Source

pub fn is_forked_mode(&self) -> bool

Returns whether execution is forked.

Source

pub fn is_active_fork(&self, id: LocalForkId) -> bool

Returns whether id is the active fork.

Source

pub fn active_fork_info(&self) -> Option<&ForkInfo>

Returns the identity of the active fork.

Source

pub fn active_fork_url(&self) -> Option<String>

Returns the RPC URL of the active fork.

Source

pub fn active_fork_options(&self) -> Option<CreateFork>

Returns the configuration the active fork was created with.

Source

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

Returns the source chain ID of the active fork, independent of chain ID overrides.

Source

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

Returns the RPC block number of the active fork.

Source

pub fn ensure_fork(&self, id: Option<LocalForkId>) -> Result<LocalForkId>

Returns id, or the active fork for None, if it exists.

Source

fn fork_info(&self, id: LocalForkId) -> Result<&ForkInfo>

Source

fn set_fork_info(&mut self, id: LocalForkId, info: ForkInfo)

Source

fn fork_options(&self, id: &ForkId) -> Result<CreateFork>

Source

pub fn create_fork(&mut self, fork: CreateFork) -> Result<LocalForkId>

Creates a fork without selecting it.

Source

pub fn create_fork_at_transaction( &mut self, fork: CreateFork, transaction: B256, ) -> Result<LocalForkId>

Creates a fork positioned right before transaction without selecting it.

Source

pub fn create_select_fork( &mut self, fork: CreateFork, evm: &mut FoundryEvmFor<'_, FEN>, phase: ExecutionPhase, ) -> Result<LocalForkId>

Creates a fork and selects it.

Source

pub fn create_select_fork_at_transaction( &mut self, fork: CreateFork, evm: &mut FoundryEvmFor<'_, FEN>, phase: ExecutionPhase, transaction: B256, ) -> Result<LocalForkId>

Creates a fork positioned right before transaction and selects it.

Source

pub fn select_fork( &mut self, id: LocalForkId, evm: &mut FoundryEvmFor<'_, FEN>, phase: ExecutionPhase, ) -> Result<()>

Makes fork id the running context of evm.

The running spec and fee-charge policy carry over to the fork; persistent accounts carry their state into it.

Source

pub fn roll_fork( &mut self, id: Option<LocalForkId>, block_number: u64, evm: &mut FoundryEvmFor<'_, FEN>, phase: ExecutionPhase, ) -> Result<()>

Moves fork id, or the active fork for None, to block_number.

Source

fn roll_lifecycle_fork( &mut self, evm: &mut FoundryEvmFor<'_, FEN>, id: LocalForkId, db: impl BackingDb, env: EvmEnvFor<FEN>, cache: Option<Cache>, phase: ExecutionPhase, ) -> Result<()>

Moves fork id onto db and env in the lifecycle.

Rolling the active fork keeps the test caller’s state like a persistent account’s, so a sender that is not persistent keeps changes such as vm.deal.

Source

pub fn roll_fork_to_transaction( &mut self, id: Option<LocalForkId>, transaction: B256, evm: &mut FoundryEvmFor<'_, FEN>, phase: ExecutionPhase, ) -> Result<()>

Moves fork id, or the active fork for None, to the state right before transaction: the transaction’s block environment over its parent’s state with the block’s preceding transactions replayed natively.

Source

pub fn prepare_transact( &self, id: Option<LocalForkId>, transaction: B256, evm: &mut FoundryEvmFor<'_, FEN>, depth: u16, isolation_env: Option<&EvmEnvFor<FEN>>, ) -> Result<(PreparedTx<TypesFor<FEN>>, CowBackend<'_, FEN>)>

Prepares the mined transaction of fork id, or of the active fork for None, to execute with its block’s environment, such as for vm.transact, and returns it with the throwaway backend it executes over. Store the outcome with Self::store_executed.

On the active fork the transaction runs as a nested transaction of the running one, whose writes are journaled; on another fork it is accepted there and its changes to persistent accounts are merged into the running transaction. Its root frame runs at depth.

Cheatcodes running in the transaction see the throwaway backend with the target fork active at the transaction’s block; their changes to it are discarded.

isolation_env is the environment of the transaction an isolated call runs in, whose fee charge and sender balance checks apply on the active fork instead of the isolated call’s.

Source

pub fn transact_from_tx( &mut self, tx: &Recovered<TxFor<FEN>>, evm: &mut FoundryEvmFor<'_, FEN>, env: Option<EvmEnvFor<FEN>>, inspector: Option<&mut dyn Inspector<TypesFor<FEN>>>, ) -> Result<(TxResultFor<FEN>, Vec<PersistentWrite>)>

Executes tx as a nested transaction of the running one, in env or the running environment for None, and merges its changes into the running transaction so that they survive reverts of the enclosing calls.

Source

pub fn prepare_nested( &self, tx: Recovered<TxFor<FEN>>, evm: &mut FoundryEvmFor<'_, FEN>, env: Option<EvmEnvFor<FEN>>, ) -> (PreparedTx<TypesFor<FEN>>, CowBackend<'_, FEN>)

Prepares Self::transact_from_tx, such as for vm.broadcastRawTransaction, and returns it with the throwaway backend it executes over. Store the outcome with Self::store_executed.

Cheatcodes running in the transaction see the throwaway backend, a copy-on-write view of this one; their changes to it are discarded.

Source

pub fn store_executed( &mut self, evm: &mut FoundryEvmFor<'_, FEN>, executed: ExecutedNested<TypesFor<FEN>>, ) -> TxResultFor<FEN>

Stores the outcome of a transaction prepared with Self::prepare_transact or Self::prepare_nested.

A replayed canonical transaction advances its fork’s position; its changes merged into the running transaction evm are not the running transaction’s execution.

Source

pub fn diagnose_revert( &self, callee: Address, evm: &mut FoundryEvmFor<'_, FEN>, ) -> Option<RevertDiagnostic>

Explains a revert of a call to callee in multi-fork mode: whether callee has no code on the active fork, and on which other forks it does.

Handling multiple accounts/new contracts in a multifork environment can be challenging since every fork has its own standalone storage section:

function testCanDeploy() public {
   vm.selectFork(mainnetFork);
   // contract created while on `mainnetFork`
   DummyContract dummy = new DummyContract();
   // this will succeed
   dummy.hello();

   vm.selectFork(optimismFork);

   vm.expectRevert();
   // this will revert since `dummy` contract only exists on `mainnetFork`
   dummy.hello();
}
Source

pub fn load_allocs( &self, allocs: &BTreeMap<Address, GenesisAccount>, evm: &mut FoundryEvmFor<'_, FEN>, ) -> Result<(), BackendError>

Loads genesis allocs into the running transaction as journaled writes.

Source

pub fn clone_account( &self, source: &GenesisAccount, target: &Address, evm: &mut FoundryEvmFor<'_, FEN>, ) -> Result<(), BackendError>

Writes the code, storage, nonce and balance of source to target in the running transaction as journaled writes, and warms target. Code is kept when source has none.

Source

pub fn set_blockhash( &self, number: U256, hash: B256, evm: &mut FoundryEvmFor<'_, FEN>, )

Sets the hash of block number in the running context.

Source

pub fn refresh_fork_account( &self, address: Address, field: ForkAccountField, evm: &mut FoundryEvmFor<'_, FEN>, ) -> Result<(), BackendError>

Refetches field of address from the active fork’s remote, after an out-of-band RPC mutation, and updates the running context with it.

Balance and nonce are overridden without journaling, so they survive reverts; code is set as a journaled write.

Source

pub fn refresh_fork_storage( &mut self, address: Address, slot: U256, evm: &mut FoundryEvmFor<'_, FEN>, ) -> Result<Option<PersistentWrite>, BackendError>

Refetches storage slot of address from the active fork’s remote, after an out-of-band RPC mutation, and updates the running context with it.

A slot the running transaction already loaded takes the refreshed value across reverts of the enclosing calls. Its transaction-start original is kept.

Source

pub fn prefetch_call( &self, caller: Address, target: Address, value: U256, input: Bytes, top_level: bool, )

Prefetches the remote state a call is about to read, if the active context is an RPC fork.

A top_level call is simulated with the local state that differs from the remote, such as the test contract, as overrides. A nested call is simulated as is.

Source

pub fn snapshot_state(&mut self, evm: &mut FoundryEvmFor<'_, FEN>) -> U256

Captures the running context and every fork, and returns the snapshot ID.

Source

pub fn revert_state( &mut self, id: U256, evm: &mut FoundryEvmFor<'_, FEN>, action: RevertStateSnapshotAction, phase: ExecutionPhase, ) -> Option<StateSnapshot>

Restores snapshot id and returns the running state it replaced, or returns None if it does not exist.

Logs emitted since the snapshot, persistent accounts and forks created after it survive. A test failure recorded in the reverted state sets Self::has_state_snapshot_failure.

Source

pub fn delete_state_snapshot(&mut self, id: U256) -> bool

Deletes a snapshot, returning whether it existed.

Source

pub fn delete_state_snapshots(&mut self)

Deletes every snapshot.

Source

fn insert_fork( &mut self, fork: CreateFork, env: Option<EvmEnvFor<FEN>>, track: bool, ) -> Result<LocalForkId>

Registers an RPC fork, with env or the environment derived from its block, retaining its block cursor if track.

Source

fn insert_prepared_fork( &mut self, url: String, resolved: ForkResult, env: EvmEnvFor<FEN>, track: bool, ) -> Result<LocalForkId>

Registers a resolved fork without refetching its block, retaining its block cursor if track.

Source

fn tracks_position(&self, fork: &CreateFork) -> bool

Returns whether forks created from fork retain their canonical block cursor.

Source

fn fork_position(&self, id: LocalForkId) -> Result<ForkPosition>

Returns the canonical position of fork id: the one retained by a replay, or the end of its pinned block.

Source

fn block_end_cursor( &self, backend: &SharedBackend<AnyNetwork, BlockEnv>, remote: &RemoteFork, env: &EvmEnvFor<FEN>, ) -> Result<(ForkPosition, ChainFor<FEN>)>

Returns the position and block cursor at the end of remote’s pinned block.

Source

fn retain_cursor( &mut self, id: LocalForkId, position: ForkPosition, cursor: &ChainFor<FEN>, evm: Option<&mut FoundryEvmFor<'_, FEN>>, )

Retains position and its block cursor as fork id’s canonical position.

The active fork’s cursor lives in the running EVM: it moves under the running transaction, whose network state is rebased onto it. Synthetic transactions never call this.

Source

fn fork_env( &self, opts: &EvmOpts, remote: &RemoteFork, block: &AnyRpcBlock, spec: SpecFor<FEN>, ) -> EvmEnvFor<FEN>

Returns the environment of remote at block with spec.

Source

fn fork_source_chain_id(&self, id: LocalForkId) -> Result<ChainId>

Source

fn shared_backend( &self, id: LocalForkId, ) -> Result<SharedBackend<AnyNetwork, BlockEnv>>

Source

fn transaction_target( &self, id: LocalForkId, transaction: B256, ) -> Result<TransactionForkTarget>

Fetches transaction and the block it executes in from fork id.

Source

fn prepare_roll_to_transaction( &self, id: LocalForkId, transaction: B256, spec: SpecFor<FEN>, ) -> Result<(RpcForkDb, EvmEnvFor<FEN>, Option<Cache>, ForkInfo, Option<(ForkPosition, ChainFor<FEN>)>, bool)>

Resolves the backing database, environment, replayed accepted state, identity, for networks with block-position state, canonical position and block cursor of fork id positioned right before transaction, and whether preceding transactions were replayed.

Source

fn replay_until( &self, db: &impl BackingDb, env: EvmEnvFor<FEN>, block: &AnyRpcBlock, index: usize, context: Option<BlockContext<FEN>>, source_chain_id: ChainId, ) -> Result<Cache>

Replays the transactions of block before index over db and returns the resulting accepted state.

context positions network state that depends on the block, such as Monad’s. System transactions are skipped, except deposits and canonical protocol transactions, which networks that support them execute natively.

Trait Implementations§

Source§

impl<'a, FEN: Clone + FoundryEvmNetwork> Clone for CowBackend<'a, FEN>

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more
Source§

impl<'a, FEN: Debug + FoundryEvmNetwork> Debug for CowBackend<'a, FEN>

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<FEN: FoundryEvmNetwork> Deref for CowBackend<'_, FEN>

Source§

type Target = Backend<FEN>

The resulting type after dereferencing.
Source§

fn deref(&self) -> &Self::Target

Dereferences the value.
Source§

impl<FEN: FoundryEvmNetwork> DerefMut for CowBackend<'_, FEN>

Source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

Auto Trait Implementations§

§

impl<'a, FEN> !RefUnwindSafe for CowBackend<'a, FEN>

§

impl<'a, FEN> !UnwindSafe for CowBackend<'a, FEN>

§

impl<'a, FEN> Freeze for CowBackend<'a, FEN>
where Cow<'a, Backend<FEN>>: Freeze,

§

impl<'a, FEN> Send for CowBackend<'a, FEN>
where Cow<'a, Backend<FEN>>: Send,

§

impl<'a, FEN> Sync for CowBackend<'a, FEN>
where Cow<'a, Backend<FEN>>: Sync,

§

impl<'a, FEN> Unpin for CowBackend<'a, FEN>
where Cow<'a, Backend<FEN>>: Unpin,

§

impl<'a, FEN> UnsafeUnpin for CowBackend<'a, FEN>
where Cow<'a, Backend<FEN>>: UnsafeUnpin,

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
§

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

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
§

impl<T, R> CollectAndApply<T, R> for T

§

fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to f(&iter.collect::<Vec<_>>()).

§

type Output = R

§

impl<T> Conv for T

§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
Source§

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

§

impl<T> FmtForward for T

§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<TxEnv, T> FromRecoveredTx<&T> for TxEnv
where TxEnv: FromRecoveredTx<T>,

§

fn from_recovered_tx(tx: &&T, sender: Address) -> TxEnv

Builds a [TxEnv] from a transaction and a sender address.
§

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

§

fn from_ref(input: &T) -> T

Converts to this type from a reference to the input type.
§

impl<TxEnv, T> FromTxWithEncoded<&T> for TxEnv
where TxEnv: FromTxWithEncoded<T>,

§

fn from_encoded_tx(tx: &&T, sender: Address, encoded: Bytes) -> TxEnv

Builds a [TxEnv] from a transaction, its sender, and encoded transaction bytes.
§

impl<T> Instrument for T

§

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

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

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
§

impl<T> IntoRequest<T> for T

§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
§

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

§

fn into_shared(self) -> Shared

Creates a shared type from an unshared type.
§

impl<L> LayerExt<L> for L

§

fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>
where L: Layer<S>,

Applies the layer to a service and wraps it in [Layered].
§

impl<T> MaybeCompact for T

§

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

§

fn type_id(&self) -> TypeId

Returns the lifetime-erased type ID of self.
§

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

§

fn fg(&self, value: Color) -> Painted<&T>

Returns a styled value derived from self with the foreground set to value.

This method should be used rarely. Instead, prefer to use color-specific builder methods like red() and green(), which have the same functionality but are pithier.

§Example

Set foreground color to white using fg():

use yansi::{Paint, Color};

painted.fg(Color::White);

Set foreground color to white using white().

use yansi::Paint;

painted.white();
§

fn primary(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Primary].

§Example
println!("{}", value.primary());
§

fn fixed(&self, color: u8) -> Painted<&T>

Returns self with the fg() set to [Color :: Fixed].

§Example
println!("{}", value.fixed(color));
§

fn rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>

Returns self with the fg() set to [Color :: Rgb].

§Example
println!("{}", value.rgb(r, g, b));
§

fn black(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Black].

§Example
println!("{}", value.black());
§

fn red(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Red].

§Example
println!("{}", value.red());
§

fn green(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Green].

§Example
println!("{}", value.green());
§

fn yellow(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Yellow].

§Example
println!("{}", value.yellow());
§

fn blue(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Blue].

§Example
println!("{}", value.blue());
§

fn magenta(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Magenta].

§Example
println!("{}", value.magenta());
§

fn cyan(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: Cyan].

§Example
println!("{}", value.cyan());
§

fn white(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: White].

§Example
println!("{}", value.white());
§

fn bright_black(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightBlack].

§Example
println!("{}", value.bright_black());
§

fn bright_red(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightRed].

§Example
println!("{}", value.bright_red());
§

fn bright_green(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightGreen].

§Example
println!("{}", value.bright_green());
§

fn bright_yellow(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightYellow].

§Example
println!("{}", value.bright_yellow());
§

fn bright_blue(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightBlue].

§Example
println!("{}", value.bright_blue());
§

fn bright_magenta(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightMagenta].

§Example
println!("{}", value.bright_magenta());
§

fn bright_cyan(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightCyan].

§Example
println!("{}", value.bright_cyan());
§

fn bright_white(&self) -> Painted<&T>

Returns self with the fg() set to [Color :: BrightWhite].

§Example
println!("{}", value.bright_white());
§

fn bg(&self, value: Color) -> Painted<&T>

Returns a styled value derived from self with the background set to value.

This method should be used rarely. Instead, prefer to use color-specific builder methods like on_red() and on_green(), which have the same functionality but are pithier.

§Example

Set background color to red using fg():

use yansi::{Paint, Color};

painted.bg(Color::Red);

Set background color to red using on_red().

use yansi::Paint;

painted.on_red();
§

fn on_primary(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Primary].

§Example
println!("{}", value.on_primary());
§

fn on_fixed(&self, color: u8) -> Painted<&T>

Returns self with the bg() set to [Color :: Fixed].

§Example
println!("{}", value.on_fixed(color));
§

fn on_rgb(&self, r: u8, g: u8, b: u8) -> Painted<&T>

Returns self with the bg() set to [Color :: Rgb].

§Example
println!("{}", value.on_rgb(r, g, b));
§

fn on_black(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Black].

§Example
println!("{}", value.on_black());
§

fn on_red(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Red].

§Example
println!("{}", value.on_red());
§

fn on_green(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Green].

§Example
println!("{}", value.on_green());
§

fn on_yellow(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Yellow].

§Example
println!("{}", value.on_yellow());
§

fn on_blue(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Blue].

§Example
println!("{}", value.on_blue());
§

fn on_magenta(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Magenta].

§Example
println!("{}", value.on_magenta());
§

fn on_cyan(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: Cyan].

§Example
println!("{}", value.on_cyan());
§

fn on_white(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: White].

§Example
println!("{}", value.on_white());
§

fn on_bright_black(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightBlack].

§Example
println!("{}", value.on_bright_black());
§

fn on_bright_red(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightRed].

§Example
println!("{}", value.on_bright_red());
§

fn on_bright_green(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightGreen].

§Example
println!("{}", value.on_bright_green());
§

fn on_bright_yellow(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightYellow].

§Example
println!("{}", value.on_bright_yellow());
§

fn on_bright_blue(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightBlue].

§Example
println!("{}", value.on_bright_blue());
§

fn on_bright_magenta(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightMagenta].

§Example
println!("{}", value.on_bright_magenta());
§

fn on_bright_cyan(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightCyan].

§Example
println!("{}", value.on_bright_cyan());
§

fn on_bright_white(&self) -> Painted<&T>

Returns self with the bg() set to [Color :: BrightWhite].

§Example
println!("{}", value.on_bright_white());
§

fn attr(&self, value: Attribute) -> Painted<&T>

Enables the styling [Attribute] value.

This method should be used rarely. Instead, prefer to use attribute-specific builder methods like bold() and underline(), which have the same functionality but are pithier.

§Example

Make text bold using attr():

use yansi::{Paint, Attribute};

painted.attr(Attribute::Bold);

Make text bold using using bold().

use yansi::Paint;

painted.bold();
§

fn bold(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Bold].

§Example
println!("{}", value.bold());
§

fn dim(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Dim].

§Example
println!("{}", value.dim());
§

fn italic(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Italic].

§Example
println!("{}", value.italic());
§

fn underline(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Underline].

§Example
println!("{}", value.underline());

Returns self with the attr() set to [Attribute :: Blink].

§Example
println!("{}", value.blink());

Returns self with the attr() set to [Attribute :: RapidBlink].

§Example
println!("{}", value.rapid_blink());
§

fn invert(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Invert].

§Example
println!("{}", value.invert());
§

fn conceal(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Conceal].

§Example
println!("{}", value.conceal());
§

fn strike(&self) -> Painted<&T>

Returns self with the attr() set to [Attribute :: Strike].

§Example
println!("{}", value.strike());
§

fn quirk(&self, value: Quirk) -> Painted<&T>

Enables the yansi [Quirk] value.

This method should be used rarely. Instead, prefer to use quirk-specific builder methods like mask() and wrap(), which have the same functionality but are pithier.

§Example

Enable wrapping using .quirk():

use yansi::{Paint, Quirk};

painted.quirk(Quirk::Wrap);

Enable wrapping using wrap().

use yansi::Paint;

painted.wrap();
§

fn mask(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Mask].

§Example
println!("{}", value.mask());
§

fn wrap(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Wrap].

§Example
println!("{}", value.wrap());
§

fn linger(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Linger].

§Example
println!("{}", value.linger());
§

fn clear(&self) -> Painted<&T>

👎Deprecated since 1.0.1:

renamed to resetting() due to conflicts with Vec::clear(). The clear() method will be removed in a future release.

Returns self with the quirk() set to [Quirk :: Clear].

§Example
println!("{}", value.clear());
§

fn resetting(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Resetting].

§Example
println!("{}", value.resetting());
§

fn bright(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: Bright].

§Example
println!("{}", value.bright());
§

fn on_bright(&self) -> Painted<&T>

Returns self with the quirk() set to [Quirk :: OnBright].

§Example
println!("{}", value.on_bright());
§

fn whenever(&self, value: Condition) -> Painted<&T>

Conditionally enable styling based on whether the [Condition] value applies. Replaces any previous condition.

See the crate level docs for more details.

§Example

Enable styling painted only when both stdout and stderr are TTYs:

use yansi::{Paint, Condition};

painted.red().on_yellow().whenever(Condition::STDOUTERR_ARE_TTY);
§

fn new(self) -> Painted<Self>
where Self: Sized,

Create a new [Painted] with a default [Style]. Read more
§

fn paint<S>(&self, style: S) -> Painted<&Self>
where S: Into<Style>,

Apply a style wholesale to self. Any previous style is replaced. Read more
§

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

§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
§

impl<T> Pointable for T

§

const ALIGN: usize

The alignment of pointer.
§

type Init = T

The type for initializers.
§

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

Initializes a with the given initializer. Read more
§

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

Dereferences the given pointer. Read more
§

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

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

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

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

§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Sized + 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
§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Sized + 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
§

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
§

impl<T> Tap for T

§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
§

impl<T> Threaded<T> for T

§

type Rest = ()

The outputs beyond the threaded value.
§

fn split(self) -> (T, ())

Splits into the threaded value and the extra outputs.
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
§

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

§

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

Clones self, possibly returning an error.
§

impl<T> TryConv for T

§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

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

Source§

type Error = !

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

fn try_from(value: U) -> Result<T, !>

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

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

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

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
§

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

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

Layout§

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.