Struct magnus::symbol::Symbol

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

A type wrapping either a StaticSymbol or a Value pointer to a RSymbol struct.

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

Implementations

impl Symbol

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

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

Examples

use magnus::{eval, Symbol};

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

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

Create a new Symbol from name.

Panics

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

Examples

use magnus::{rb_assert, Symbol};

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

pub fn is_static(self) -> bool

Returns whether self is static or not.

Static symbols won’t be garbage collected, so should be safe to store on the heap. See StaticSymbol.

Examples

use magnus::{eval, Symbol};

assert!(eval::<Symbol>(":foo").unwrap().is_static());
assert!(!Symbol::new("bar").is_static());
assert!(!eval::<Symbol>(r#""baz".to_sym"#).unwrap().is_static());

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

Return the symbol as a string. If the symbol is static this will be a &str, otherwise an owned String.

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

Examples

use magnus::Symbol;

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

pub fn as_static(self) -> Option<StaticSymbol>

If self is static, returns self as a StaticSymbol, otherwise returns None.

Examples

use magnus::{eval, Symbol};

assert!(eval::<Symbol>(":foo").unwrap().as_static().is_some());
assert!(Symbol::new("bar").as_static().is_none());
assert!(eval::<Symbol>(r#""baz".to_sym"#)
    .unwrap()
    .as_static()
    .is_none());

pub fn to_static(self) -> StaticSymbol

If self is already static simply returns self as a StaticSymbol. If self is not static it will be made so and returned as a StaticSymbol.

Be aware that once static a symbol will never be garbage collected.

Examples

use magnus::{rb_assert, Symbol};

let sym = Symbol::new("example");
let static_sym = sym.to_static();
rb_assert!("sym == static_sym", sym, static_sym);

Trait Implementations

impl Borrow<Symbol> for StaticSymbol

fn borrow(&self) -> &Symbol

Immutably borrows from an owned value.

impl Clone for Symbol

fn clone(&self) -> Symbol

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Symbol

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

Formats the value using the given formatter.

impl Display for Symbol

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

Formats the value using the given formatter.

impl EncodingCapable for Symbol

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 Symbol

fn from(id: Id) -> 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 From<Symbol> for Id

fn from(sym: Symbol) -> Self

Converts to this type from the input type.

impl From<Symbol> for OpaqueId

fn from(sym: Symbol) -> Self

Converts to this type from the input type.

impl IntoId for Symbol

fn into_id_with(self, _: &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 Symbol

fn into_symbol_with(self, _: &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 Symbol

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 Symbol

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 Symbol

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 Symbol

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 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 Id

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<Symbol> for LazyId

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

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<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 Symbol

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 ReprValue for Symbol

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 Symbol

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

Convert val into Self.

impl Copy for Symbol

impl Eq for Symbol

impl StructuralPartialEq for Symbol