Enum Str 

pub enum Str {
    Static(&'static str),
    Rc(Arc<String>),
    Owned(String),
}

A string type that can hold either a 'static string slice, an Arc<String> for cheap cloning, or an owned String.

This enum is useful when you need to store string data that may be static, shared, or owned without incurring unnecessary allocations.

Variants

• Static(&'static str) – A reference to a compile‑time constant string.
• Rc(Arc<String>) – A reference‑counted pointer to a String, allowing cheap cloning of the underlying data.
• Owned(String) – An owned heap‑allocated String.

Variants

Static(&'static str)

A reference to a compile‑time constant string.

Rc(Arc<String>)

A reference‑counted pointer to a String.

Owned(String)

An owned heap‑allocated String.

Implementations

impl Str

pub fn as_str(&self) -> &str

Returns a string slice (&str) that references the data inside the Str, regardless of which variant it holds.

Examples

use anyval::Str;
let s = Str::from_static("hello");
assert_eq!(s.as_str(), "hello");

pub fn from_static(s: &'static str) -> Self

Constructs a Str from a 'static string slice.

This does not allocate; the variant stored is Str::Static.

Examples

use anyval::Str;
let s = Str::from_static("static");
assert!(s.is_static());

pub fn from_owned(s: String) -> Self

Constructs a Str from an owned String.

The String is moved into the Str::Owned variant.

Examples

use anyval::Str;
let original = String::from("owned");
let s = Str::from_owned(original);
// `original` can no longer be used here

pub fn from_rc(s: Arc<String>) -> Self

Constructs a Str from an Arc<String>.

The Arc is moved into the Str::Rc variant, allowing cheap cloning.

Examples

use std::sync::Arc;
use anyval::Str;
let arc = Arc::new(String::from("shared"));
let s = Str::from_rc(arc.clone());
assert!(s.is_rc());

pub fn take(self) -> String

Consumes the Str and returns an owned String.

• For Str::Static, the static slice is cloned into a new String.
• For Str::Rc, the underlying String is cloned.
• For Str::Owned, the inner String is returned without allocation.

Examples

use anyval::Str;
let s = Str::from_owned(String::from("owned"));
let owned = s.take(); // `s` is moved
assert_eq!(owned, "owned");

pub fn into_string(self) -> String

Alias for [take]; consumes the Str and returns an owned String.

This method exists for API symmetry with other types that provide an into_* conversion.

pub fn is_static(&self) -> bool

Returns true if the Str is the Static variant.

Examples

use anyval::Str;
let s = Str::from_static("static");
assert!(s.is_static());

pub fn is_owned(&self) -> bool

Returns true if the Str is the Owned variant.

Examples

use anyval::Str;
let s = Str::from_owned(String::from("owned"));
assert!(s.is_owned());

pub fn is_rc(&self) -> bool

Returns true if the Str is the Rc variant.

Examples

use anyval::Str;
use std::sync::Arc;
let s = Str::from_rc(Arc::new(String::from("shared")));
assert!(s.is_rc());

Trait Implementations

impl Clone for Str

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 Str

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

Formats the value using the given formatter.

impl Display for Str

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

Formats the value using the given formatter.

impl From<&'static str> for Str

fn from(s: &'static str) -> Self

Converts to this type from the input type.

impl From<Arc<String>> for Str

fn from(s: Arc<String>) -> Self

Converts to this type from the input type.

impl From<Str> for String

fn from(s: Str) -> Self

Converts to this type from the input type.

impl From<Str> for Value

fn from(s: Str) -> Self

Converts to this type from the input type.

impl From<String> for Str

fn from(s: String) -> Self

Converts to this type from the input type.