Struct magnus::value::StaticSymbol

pub struct StaticSymbol(/* private fields */);

A static Ruby symbol that will live for the life of the program and never be garbage collected.

See also Symbol.

See the ReprValue trait for additional methods available on this type. See Ruby for methods to create a StaticSymbol.

Implementations

impl StaticSymbol

pub fn from_value(val: Value) -> Option<Self>

Return Some(StaticSymbol) if val is a StaticSymbol, None otherwise.

Examples

use magnus::{eval, StaticSymbol};

assert!(StaticSymbol::from_value(eval(":foo").unwrap()).is_some());
assert!(StaticSymbol::from_value(eval(r#""bar""#).unwrap()).is_none());
assert!(StaticSymbol::from_value(eval(r#""baz".to_sym"#).unwrap()).is_none());

pub fn new<T>(name: T) -> Self

where T: IntoId,

Create a new StaticSymbol.

Panics

Panics if called from a non-Ruby thread. See Ruby::sym_new for the non-panicking version.

Examples

use magnus::{rb_assert, StaticSymbol};

let sym = StaticSymbol::new("example");
rb_assert!(":example == sym", sym);

pub fn check(name: &str) -> Option<Self>

Return the StaticSymbol for name, if one exists.

Panics

Panics if called from a non-Ruby thread. See Ruby::check_symbol for the non-panicking version.

Examples

use magnus::{eval, StaticSymbol};

assert!(StaticSymbol::check("example").is_none());
let _: StaticSymbol = eval(":example").unwrap();
assert!(StaticSymbol::check("example").is_some());

pub fn name(self) -> Result<&'static str, Error>

Return the symbol as a static string reference.

May error if the name is not valid utf-8.

Examples

use magnus::StaticSymbol;

let sym = StaticSymbol::new("example");
assert_eq!(sym.name().unwrap(), "example");

Trait Implementations

impl Borrow<Symbol> for StaticSymbol

fn borrow(&self) -> &Symbol

Immutably borrows from an owned value.

impl Clone for StaticSymbol

fn clone(&self) -> StaticSymbol

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StaticSymbol

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

Formats the value using the given formatter.

impl Display for StaticSymbol

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

Formats the value using the given formatter.

impl EncodingCapable for StaticSymbol

fn enc_get(self) -> Index

Get the encoding of self.

fn enc_set<T>(self, enc: T) -> Result<(), Error>

where T: Into<Index>,

Set self’s encoding.

fn enc_associate<T>(self, enc: T) -> Result<(), Error>

where T: Into<Index>,

Set self’s encoding, along with performing additional fix-up self’s contents.

impl From<Id> for StaticSymbol

fn from(id: Id) -> Self

Converts to this type from the input type.

impl From<StaticSymbol> for Id

fn from(sym: StaticSymbol) -> Self

Converts to this type from the input type.

impl From<StaticSymbol> for OpaqueId

fn from(sym: StaticSymbol) -> Self

Converts to this type from the input type.

impl From<StaticSymbol> for Symbol

fn from(s: StaticSymbol) -> Self

Converts to this type from the input type.

impl Hash for StaticSymbol

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 IntoId for StaticSymbol

fn into_id_with(self, handle: &Ruby) -> Id

Convert self into Id.

fn into_id(self) -> Id

Convert self into Id.

unsafe fn into_id_unchecked(self) -> Id

Convert self into Id.

impl IntoSymbol for StaticSymbol

fn into_symbol_with(self, handle: &Ruby) -> Symbol

Convert self into Symbol.

fn into_symbol(self) -> Symbol

Convert self into Symbol.

unsafe fn into_symbol_unchecked(self) -> Symbol

Convert self into Symbol.

impl IntoValue for StaticSymbol

fn into_value_with(self, _: &Ruby) -> Value

Convert self into Value.

fn into_value(self) -> Value

Convert self into Value.

unsafe fn into_value_unchecked(self) -> Value

Convert self into Value.

impl PartialEq<Id> for StaticSymbol

fn eq(&self, other: &Id) -> 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 PartialEq<LazyId> for StaticSymbol

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

Panics

Panics if the first call is from a non-Ruby thread. The LazyId will then be poisoned and all future use of it will panic.

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 PartialEq<OpaqueId> for StaticSymbol

fn eq(&self, other: &OpaqueId) -> 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 PartialEq<StaticSymbol> for Id

fn eq(&self, other: &StaticSymbol) -> 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 PartialEq<StaticSymbol> for LazyId

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

Panics

Panics if the first call is from a non-Ruby thread. This LazyId will then be poisoned and all future use of it will panic.

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 PartialEq<StaticSymbol> for OpaqueId

fn eq(&self, other: &StaticSymbol) -> 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 PartialEq<StaticSymbol> for Symbol

fn eq(&self, other: &StaticSymbol) -> 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 PartialEq<Symbol> for StaticSymbol

fn eq(&self, other: &Symbol) -> 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 PartialEq for StaticSymbol

fn eq(&self, other: &StaticSymbol) -> 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 ReprValue for StaticSymbol

fn as_value(self) -> Value

Return self as a Value.

fn is_nil(self) -> bool

Returns whether self is Ruby’s nil value.

fn equal<T>(self, other: T) -> Result<bool, Error>

where T: ReprValue,

Checks for equality, delegating to the Ruby method #==.

fn eql<T>(self, other: T) -> Result<bool, Error>

where T: ReprValue,

Checks for equality, delegating to the Ruby method #eql?.

fn hash(self) -> Result<Integer, Error>

Returns an integer non-uniquely identifying self.

fn class(self) -> RClass

Returns the class that self is an instance of.

fn is_frozen(self) -> bool

Returns whether self is ‘frozen’.

fn check_frozen(self) -> Result<(), Error>

Returns an error if self is ‘frozen’.

fn freeze(self)

Mark self as frozen.

fn to_bool(self) -> bool

Convert self to a bool, following Ruby’s rules of false and nil as boolean false and everything else boolean true.

fn funcall<M, A, T>(self, method: M, args: A) -> Result<T, Error>

where M: IntoId, A: ArgList, T: TryConvert,

Call the method named method on self with args.

fn funcall_public<M, A, T>(self, method: M, args: A) -> Result<T, Error>

where M: IntoId, A: ArgList, T: TryConvert,

Call the public method named method on self with args.

fn check_funcall<M, A, T>(self, method: M, args: A) -> Option<Result<T, Error>>

where M: IntoId, A: ArgList, T: TryConvert,

If self responds to the method named method, call it with args.

fn funcall_with_block<M, A, T>( self, method: M, args: A, block: Proc ) -> Result<T, Error>

where M: IntoId, A: ArgList, T: TryConvert,

Call the method named method on self with args and block.

fn block_call<M, A, R, T>( self, method: M, args: A, block: fn(_: &[Value], _: Option<Proc>) -> R ) -> Result<T, Error>

where M: IntoId, A: ArgList, R: BlockReturn, T: TryConvert,

Call the method named method on self with args and block.

fn respond_to<M>(self, method: M, include_private: bool) -> Result<bool, Error>

where M: IntoId,

Check if self responds to the given Ruby method.

fn to_r_string(self) -> Result<RString, Error>

Convert self to a Ruby String.

unsafe fn to_s(&self) -> Result<Cow<'_, str>, Error>

Convert self to a Rust string.

fn inspect(self) -> String

Convert self to its Ruby debug representation.

unsafe fn classname(&self) -> Cow<'_, str>

Return the name of self’s class.

fn is_kind_of<T>(self, class: T) -> bool

where T: ReprValue + Module,

Returns whether or not self is an instance of class.

fn enumeratorize<M, A>(self, method: M, args: A) -> Enumerator

where M: IntoSymbol, A: ArgList,

Generate an Enumerator from method on self, passing args to method.

impl TryConvert for StaticSymbol

fn try_convert(val: Value) -> Result<Self, Error>

Convert val into Self.

impl Copy for StaticSymbol

impl Eq for StaticSymbol

impl StructuralPartialEq for StaticSymbol

impl TryConvertOwned for StaticSymbol