Enum Successor

pub enum Successor<T, U = T> {
    Continue(U),
    Terminate,
    Interrupt(T),
}

The successor state or outcome of an episode step.

The purpose of the second generic parameter U is to control the ownership of the following state or observation when the episode continues. By default the successor is owned but it can also be borrowed U = &T or omitted U = (). This is useful because users might want to extract the next observation without copying.

Variants

Continue(U)

The episode continues with the given state.

Terminate

The episode ends by entering a terminal state.

A terminal state is one from which all possible trajectories would have 0 reward.

Interrupt(T)

The episode ends despite entering the given non-terminal state.

Had the episode continued, non-zero future rewards might have been possible. For example, the episode may have been interrupted due to a step limit.

Implementations

impl<T, U> Successor<T, U>

pub fn into_continue(self) -> Option<U>

Unwrap into the contained Continue value if possible.

pub fn into_interrupt(self) -> Option<T>

Unwrap into the contained Interrupt value if possible.

pub const fn episode_done(&self) -> bool

Whether this successor marks the end of an episode

pub fn into_partial(self) -> PartialSuccessor<T>

Drop any stored Continue state, converting into PartialSuccessor.

pub fn map_continue<F, V>(self, f: F) -> Successor<T, V>

where F: FnOnce(U) -> V,

Apply a function to just the successor Continue variant.

pub fn into_partial_continue(self) -> (PartialSuccessor<T>, Option<U>)

Partition into a PartialSuccessor and the Continue state, if any.

impl<T> Successor<T>

pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Successor<U>

Apply a transformation to the inner state when present.

pub fn then_interrupt_if<F>(self, f: F) -> Self

where F: FnOnce(&T) -> bool,

Interrupt the successor if it is Continue and the condition evaluates true.

pub fn into_inner(self) -> Option<T>

Get the inner state of Continue and Interrupt variants.

impl<T, U: Borrow<T>> Successor<T, U>

pub fn as_ref(&self) -> Successor<&T>

Convert &Successor<T, U> to Successor<&T>.

impl<T: Clone, U: Clone> Successor<&T, &U>

pub fn cloned(self) -> Successor<T, U>

Convert Successor<&T, &U> to Successor<T, U> by cloning its contents

impl<T: Clone> Successor<T, &T>

pub fn into_owned(self) -> Successor<T>

Convert into an owned successor by cloning any borrowed successor observation.

Trait Implementations

impl<T: Clone, U: Clone> Clone for Successor<T, U>

fn clone(&self) -> Successor<T, U>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, U: Debug> Debug for Successor<T, U>

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

Formats the value using the given formatter.

impl<'de, T, U> Deserialize<'de> for Successor<T, U>

where T: Deserialize<'de>, U: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Hash, U: Hash> Hash for Successor<T, U>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq, U: PartialEq> PartialEq for Successor<T, U>

fn eq(&self, other: &Successor<T, U>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T, U> Serialize for Successor<T, U>

where T: Serialize, U: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Copy, U: Copy> Copy for Successor<T, U>

impl<T: Eq, U: Eq> Eq for Successor<T, U>

impl<T, U> StructuralPartialEq for Successor<T, U>