Struct AsCharacterVec 

pub struct AsCharacterVec(pub Vec<Option<String>>);

A character vector read like R’s as.character(): from an atomic vector of any type, a factor by its labels. NA of any type is None.

Identifiers in R data often arrive as numbers or factors: subject IDs, visit numbers, or grouping columns read by read.csv(). A Vec<String> parameter accepts character input only, so a function that treats such values as labels would need an R wrapper calling as.character() first. This marker does that conversion itself, and the strings are exactly the ones R produces elsewhere, because R makes them.

Reading rules

R input	Result
character	as is; NA_character_ → None. "NA" and "" stay values
integer, double	R’s own formatting (doubles to 15 significant digits): 0.1 + 0.2 → "0.3", 1e6 → "1e+06", 100 → "100", NaN → "NaN", Inf → "Inf"; NA → None
logical	"TRUE" / "FALSE"; NA → None
complex	"1+2i"; NA → None
raw	two hex digits: as.raw(255) → "ff"
classed object (factor, Date, POSIXct, …)	its as.character() method: factor labels (never the codes), "2024-01-15" for a Date, "2024-01-15 10:30:00" for a POSIXct
list, data frame, NULL, …	SexpError::Type

A plain atomic vector is converted with R’s coerceVector() (what the as.character() primitive does for it); the text never comes from Rust formatting, which would give "0.30000000000000004" for 0.1 + 0.2. A vector with a class attribute (is.object(x)) is passed to as.character(x), evaluated as if at top level: base R’s as.character (a user binding of that name does not interfere), with S3 and S4 methods registered by packages or defined in the global environment. A Date is a double underneath, and coerceVector() alone would give its day count ("19737"). An error in the method becomes the conversion error, as does a method that returns something other than a character vector.

Names and dim are dropped, as as.character() drops them: a matrix is read in column-major order. Zero-length input gives an empty vector.

Unlike AsNumericVec, which reads the token "NA" and blank strings as missing, only NA itself is None here: as.character() keeps "NA" and "" as strings. NaN becomes "NaN" (no_na refuses it in R, as anyNA() counts it). no_na also checks the converted value after the call, so it refuses an NA only the conversion produces: a factor NA level (factor(x, exclude = NULL), whose code is not NA) or a class’s as.character() method returning NA. A type alias or a #[derive(TryFromSexp)] newtype of the marker is checked the same way.

Option<AsCharacterVec> (and Option<AsCharacter>) also accept NULL as None.

IntoR

The markers convert to R as their inner Vec<Option<String>> / Option<String>: a character vector with NA_character_ for None, which the marker reads back unchanged ("NA" and "" stay strings), and Option<marker> gives NULL for None. That is what lets a #[miniextendr] trait method take a marker parameter: the trait’s View converts each argument with IntoR and the implementing side reads it back with TryFromSexp. A #[miniextendr] function returning a marker gives the same R value as returning .0; returning .0 stays the idiom.

Example

use miniextendr_api::{miniextendr, AsCharacterVec};
use std::collections::HashSet;

#[miniextendr]
fn n_subjects(ids: AsCharacterVec) -> i32 {
    let distinct: HashSet<String> = ids.0.into_iter().flatten().collect();
    i32::try_from(distinct.len()).expect("fewer than 2^31 subjects")
}
// R: n_subjects(c(101L, 102L, 101L))         → 2
//    n_subjects(factor(c("S1", "S2", NA)))    → 2   (labels, not codes)
//    n_subjects(c(0.1 + 0.2, 0.3))            → 1   (both read as "0.3")
//    n_subjects(list(1))                      → error: 'ids' must be atomic

Tuple Fields

0: Vec<Option<String>>

Trait Implementations

impl Clone for AsCharacterVec

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AsCharacterVec

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

Formats the value using the given formatter.

impl Default for AsCharacterVec

fn default() -> Self

Returns the “default value” for a type.

impl Eq for AsCharacterVec

#[doc(hidden)]

fn assert_fields_are_eq(&self)

🔬This is a nightly-only experimental API. (derive_eq_internals)

#[doc(hidden)]

fn assert_receiver_is_total_eq(&self)

👎Deprecated since 1.95.0:

implementation detail of #[derive(Eq)]

impl IntoR for AsCharacterVec

type Error = <Vec<Option<String>> as IntoR>::Error

The error type for fallible conversions.

fn try_into_sexp(self) -> Result<SEXP, Self::Error>

Try to convert this value to an R SEXP.

unsafe fn try_into_sexp_unchecked(self) -> Result<SEXP, Self::Error>

Try to convert to SEXP without thread safety checks.

fn into_sexp(self) -> SEXP

Convert this value to an R SEXP, panicking on error.

unsafe fn into_sexp_unchecked(self) -> SEXP

Convert to SEXP without thread safety checks, panicking on error.

impl PartialEq for AsCharacterVec

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for AsCharacterVec

impl TryFromSexp for AsCharacterVec

type Error = SexpError

The error type returned when conversion fails.

fn __mx_has_na(&self) -> bool

Whether the converted argument holds a value #[miniextendr(no_na)] refuses after the conversion.

fn try_from_sexp(sexp: SEXP) -> Result<Self, Self::Error>

Attempt to convert an R SEXP to this Rust type.

const NATIVE_BORROW: Option<NativeBorrow> = None

Native vector storage retained by this conversion, if any.

const CHARACTER_ONLY: bool = false

Whether this conversion accepts only character input: every value it converts, other than NULL, is a character vector or a factor.

#[doc(hidden)]

const __MX_EXPECTATION: Option<&'static str> = None

What an argument of this type must be, in R terms, when #[miniextendr] cannot tell from the type as written: the <expected> of a failed conversion’s '<p>' must be <expected>: ....

unsafe fn try_from_sexp_unchecked(sexp: SEXP) -> Result<Self, Self::Error>

Convert from SEXP without thread safety checks.

#[doc(hidden)]

unsafe fn __mx_try_from_rooted(root: Root<'_>) -> Result<Self, Self::Error>

Convert with a scope able to retain uncached ALTREP elements. Custom reference converters keep their existing behavior by default.

#[doc(hidden)]

fn __mx_input_has_na(&self, input: SEXP) -> bool

Whether #[miniextendr(no_na)] refuses this converted argument, read from input (the R value it converted from), when no R guard ran.

#[doc(hidden)]

fn __mx_try_from_sexp_with_check( sexp: SEXP, check: &ElementCheck<'_>, ) -> Result<Self, SexpError>

where Self::Error: Into<SexpError>,

Convert, running check, an element type’s TryFromSexpElement::check_sexp, on the R value that carries an element’s class (#1837).

#[doc(hidden)]

unsafe fn __mx_try_from_sexp_unchecked_with_check( sexp: SEXP, check: &ElementCheck<'_>, ) -> Result<Self, SexpError>

where Self::Error: Into<SexpError>,

__mx_try_from_sexp_with_check through try_from_sexp_unchecked. Not public API.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes