Enum extendr_api::wrapper::nullable::Nullable

pub enum Nullable<T> {
    NotNull(T),
    Null,
}

Wrapper for handling potentially NULL values.

use extendr_api::prelude::*;
test! {
    use extendr_api::wrapper::Nullable::*;

    // Plain integer.
    let s1 = r!(1);
    let n1 = <Nullable<i32>>::from_robj(&s1)?;
    assert_eq!(n1, NotNull(1));

    // NA integer - error.
    let sna = r!(NA_INTEGER);
    assert_eq!(<Nullable<i32>>::from_robj(&sna).is_err(), true);

    // NA integer - option gives none.
    assert_eq!(<Nullable<Option<i32>>>::from_robj(&sna)?, NotNull(None));

    // NULL object.
    let snull = r!(NULL);
    let nnull = <Nullable<i32>>::from_robj(&snull)?;
    assert_eq!(nnull, Null);

    assert_eq!(r!(Nullable::<i32>::Null), r!(NULL));
    assert_eq!(r!(Nullable::<i32>::NotNull(1)), r!(1));
}

Variants

NotNull(T)

Null

Implementations

impl<T> Nullable<T>

where T: TryFrom<Robj, Error = Error>,

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

Convert Nullable R object into Option

use extendr_api::prelude::*;
test! {
    assert_eq!(Nullable::<Rint>::Null.into_option(), None);
    assert_eq!(Nullable::<Rint>::NotNull(Rint::from(42)).into_option(), Some(Rint::from(42)));
}

impl<T> Nullable<T>

pub fn map<F, U>(self, f: F) -> Nullable<U>

where F: FnOnce(T) -> U,

Map Nullable<T> into Nullable<U>

use extendr_api::prelude::*;
test! {
    assert_eq!(Nullable::<Rfloat>::Null.map(|x| x.abs()), Nullable::<Rfloat>::Null);
    assert_eq!(Nullable::<Rfloat>::NotNull(Rfloat::from(42.0)).map(|x| x.abs()), Nullable::<Rfloat>::NotNull(Rfloat::from(42.0)));
}

Trait Implementations

impl<T: Clone> Clone for Nullable<T>

fn clone(&self) -> Nullable<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Nullable<T>

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

Formats the value using the given formatter.

impl<'a, T> From<&'a Nullable<T>> for Option<&'a T>

where T: TryFrom<Robj, Error = Error>,

fn from(value: &'a Nullable<T>) -> Self

Convert a Nullable reference type into Option containing reference

use extendr_api::prelude::*;
test! {
    assert_eq!(<Option<&i32>>::from(&Nullable::Null), None);
    assert_eq!(<Option<&i32>>::from(&Nullable::NotNull(42)), Some(&42));
}

impl<T> From<Nullable<T>> for Option<T>

where T: TryFrom<Robj, Error = Error>,

fn from(value: Nullable<T>) -> Self

Convert a Nullable type into Option

use extendr_api::prelude::*;
test! {
    assert_eq!(<Option<i32>>::from(Nullable::Null), None);
    assert_eq!(<Option<i32>>::from(Nullable::NotNull(42)), Some(42));
}

impl<T> From<Nullable<T>> for Robj

where T: Into<Robj>,

fn from(val: Nullable<T>) -> Self

Convert a rust object to NULL or another type.

use extendr_api::prelude::*;
test! {
    assert_eq!(r!(Nullable::<i32>::Null), r!(NULL));
    assert_eq!(r!(Nullable::<i32>::NotNull(1)), r!(1));
}

impl<T> From<Option<T>> for Nullable<T>

where T: Into<Robj>,

fn from(value: Option<T>) -> Self

Convert an Option into Nullable type

use extendr_api::prelude::*;
test! {
    let x : Nullable<_> = From::<Option<i32>>::from(None);
    assert_eq!(x, Nullable::<i32>::Null);
    let x : Nullable<_> = From::<Option<i32>>::from(Some(42));
    assert_eq!(x, Nullable::<i32>::NotNull(42));
}

impl<'a, T> FromRobj<'a> for Nullable<T>

where T: FromRobj<'a>,

fn from_robj(robj: &'a Robj) -> Result<Self, &'static str>

Convert an object that may be null to a rust type.

use extendr_api::prelude::*;
test! {
    let s1 = r!(1);
    let n1 = <Nullable<i32>>::from_robj(&s1)?;
    assert_eq!(n1, Nullable::NotNull(1));
    let snull = r!(NULL);
    let nnull = <Nullable<i32>>::from_robj(&snull)?;
    assert_eq!(nnull, Nullable::Null);
}

impl<T: PartialEq> PartialEq for Nullable<T>

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

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

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<'a, T> TryFrom<&'a Robj> for Nullable<T>

where T: TryFrom<&'a Robj, Error = Error>,

fn try_from(robj: &'a Robj) -> Result<Self, Self::Error>

Convert an object that may be null to a rust type.

use extendr_api::prelude::*;
test! {
    let s1 = r!(1);
    let n1 = <Nullable<i32>>::try_from(&s1)?;
    assert_eq!(n1, Nullable::NotNull(1));
    let snull = r!(NULL);
    let nnull = <Nullable<i32>>::try_from(&snull)?;
    assert_eq!(nnull, Nullable::Null);
}

type Error = Error

The type returned in the event of a conversion error.

impl<T> TryFrom<Robj> for Nullable<T>

where T: TryFrom<Robj, Error = Error>,

fn try_from(robj: Robj) -> Result<Self, Self::Error>

Convert an object that may be null to a rust type.

use extendr_api::prelude::*;
test! {
    let s1 = r!(1);
    let n1 = <Nullable<i32>>::try_from(s1)?;
    assert_eq!(n1, Nullable::NotNull(1));
    let snull = r!(NULL);
    let nnull = <Nullable<i32>>::try_from(snull)?;
    assert_eq!(nnull, Nullable::Null);
}

type Error = Error

The type returned in the event of a conversion error.

impl<T> StructuralPartialEq for Nullable<T>