Trait oso::FromPolar

pub trait FromPolar: Sized {
    fn from_polar(term: &Term, host: &mut Host) -> Result<Self>;

    fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self> { ... }
}

Convert Polar types to Rust types.

This trait is automatically implemented for any type that implements the PolarClass trait, which should be preferred.

This is also implemented automatically using the #[derive(PolarClass)] macro.

Required methods

fn from_polar(term: &Term, host: &mut Host) -> Result<Self>

Loading content...

Provided methods

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

Loading content...

Implementations on Foreign Types

impl FromPolar for bool

fn from_polar(term: &Term, _host: &mut Host) -> Result<Self>

impl FromPolar for u8

fn from_polar(term: &Term, _host: &mut Host) -> Result<Self>

impl FromPolar for i8

fn from_polar(term: &Term, _host: &mut Host) -> Result<Self>

impl FromPolar for u16

fn from_polar(term: &Term, _host: &mut Host) -> Result<Self>

impl FromPolar for i16

fn from_polar(term: &Term, _host: &mut Host) -> Result<Self>

impl FromPolar for u32

fn from_polar(term: &Term, _host: &mut Host) -> Result<Self>

impl FromPolar for i32

fn from_polar(term: &Term, _host: &mut Host) -> Result<Self>

impl FromPolar for i64

fn from_polar(term: &Term, _host: &mut Host) -> Result<Self>

impl FromPolar for f64

fn from_polar(term: &Term, _host: &mut Host) -> Result<Self>

impl FromPolar for String

fn from_polar(term: &Term, _host: &mut Host) -> Result<Self>

impl<T: FromPolar> FromPolar for Vec<T>

fn from_polar(term: &Term, host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<T: FromPolar> FromPolar for HashMap<String, T>

fn from_polar(term: &Term, host: &mut Host) -> Result<Self>

impl FromPolar for ()

fn from_polar(term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], _host: &mut Host) -> Result<Self>

impl<A> FromPolar for (A,) where
    A: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<A, B> FromPolar for (A, B) where
    A: FromPolar,
    B: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<A, B, C> FromPolar for (A, B, C) where
    A: FromPolar,
    B: FromPolar,
    C: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<A, B, C, D> FromPolar for (A, B, C, D) where
    A: FromPolar,
    B: FromPolar,
    C: FromPolar,
    D: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<A, B, C, D, E> FromPolar for (A, B, C, D, E) where
    A: FromPolar,
    B: FromPolar,
    C: FromPolar,
    D: FromPolar,
    E: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<A, B, C, D, E, G> FromPolar for (A, B, C, D, E, G) where
    A: FromPolar,
    B: FromPolar,
    C: FromPolar,
    D: FromPolar,
    E: FromPolar,
    G: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<A, B, C, D, E, G, H> FromPolar for (A, B, C, D, E, G, H) where
    A: FromPolar,
    B: FromPolar,
    C: FromPolar,
    D: FromPolar,
    E: FromPolar,
    G: FromPolar,
    H: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<A, B, C, D, E, G, H, I> FromPolar for (A, B, C, D, E, G, H, I) where
    A: FromPolar,
    B: FromPolar,
    C: FromPolar,
    D: FromPolar,
    E: FromPolar,
    G: FromPolar,
    H: FromPolar,
    I: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<A, B, C, D, E, G, H, I, J> FromPolar for (A, B, C, D, E, G, H, I, J) where
    A: FromPolar,
    B: FromPolar,
    C: FromPolar,
    D: FromPolar,
    E: FromPolar,
    G: FromPolar,
    H: FromPolar,
    I: FromPolar,
    J: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<A, B, C, D, E, G, H, I, J, K> FromPolar for (A, B, C, D, E, G, H, I, J, K) where
    A: FromPolar,
    B: FromPolar,
    C: FromPolar,
    D: FromPolar,
    E: FromPolar,
    G: FromPolar,
    H: FromPolar,
    I: FromPolar,
    J: FromPolar,
    K: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<A, B, C, D, E, G, H, I, J, K, L> FromPolar for (A, B, C, D, E, G, H, I, J, K, L) where
    A: FromPolar,
    B: FromPolar,
    C: FromPolar,
    D: FromPolar,
    E: FromPolar,
    G: FromPolar,
    H: FromPolar,
    I: FromPolar,
    J: FromPolar,
    K: FromPolar,
    L: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<A, B, C, D, E, G, H, I, J, K, L, M> FromPolar for (A, B, C, D, E, G, H, I, J, K, L, M) where
    A: FromPolar,
    B: FromPolar,
    C: FromPolar,
    D: FromPolar,
    E: FromPolar,
    G: FromPolar,
    H: FromPolar,
    I: FromPolar,
    J: FromPolar,
    K: FromPolar,
    L: FromPolar,
    M: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<A, B, C, D, E, G, H, I, J, K, L, M, N> FromPolar for (A, B, C, D, E, G, H, I, J, K, L, M, N) where
    A: FromPolar,
    B: FromPolar,
    C: FromPolar,
    D: FromPolar,
    E: FromPolar,
    G: FromPolar,
    H: FromPolar,
    I: FromPolar,
    J: FromPolar,
    K: FromPolar,
    L: FromPolar,
    M: FromPolar,
    N: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<A, B, C, D, E, G, H, I, J, K, L, M, N, O> FromPolar for (A, B, C, D, E, G, H, I, J, K, L, M, N, O) where
    A: FromPolar,
    B: FromPolar,
    C: FromPolar,
    D: FromPolar,
    E: FromPolar,
    G: FromPolar,
    H: FromPolar,
    I: FromPolar,
    J: FromPolar,
    K: FromPolar,
    L: FromPolar,
    M: FromPolar,
    N: FromPolar,
    O: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<A, B, C, D, E, G, H, I, J, K, L, M, N, O, P> FromPolar for (A, B, C, D, E, G, H, I, J, K, L, M, N, O, P) where
    A: FromPolar,
    B: FromPolar,
    C: FromPolar,
    D: FromPolar,
    E: FromPolar,
    G: FromPolar,
    H: FromPolar,
    I: FromPolar,
    J: FromPolar,
    K: FromPolar,
    L: FromPolar,
    M: FromPolar,
    N: FromPolar,
    O: FromPolar,
    P: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

impl<A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q> FromPolar for (A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q) where
    A: FromPolar,
    B: FromPolar,
    C: FromPolar,
    D: FromPolar,
    E: FromPolar,
    G: FromPolar,
    H: FromPolar,
    I: FromPolar,
    J: FromPolar,
    K: FromPolar,
    L: FromPolar,
    M: FromPolar,
    N: FromPolar,
    O: FromPolar,
    P: FromPolar,
    Q: FromPolar, 

fn from_polar(_term: &Term, _host: &mut Host) -> Result<Self>

fn from_polar_list(terms: &[Term], host: &mut Host) -> Result<Self>

Loading content...

Implementors

impl FromPolar for Value

fn from_polar(term: &Term, _host: &mut Host) -> Result<Self>

impl<C: 'static + Clone + PolarClass> FromPolar for C

fn from_polar(term: &Term, host: &mut Host) -> Result<Self>

Loading content...