Struct Fixnum 

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

A Value known to be a fixnum, Ruby’s internal representation of small integers.

See also Integer.

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

Implementations

impl Fixnum

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

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

Examples

use magnus::{eval, Fixnum};

assert!(Fixnum::from_value(eval("0").unwrap()).is_some());
// too big
assert!(Fixnum::from_value(eval("9223372036854775807").unwrap()).is_none());
// not an int
assert!(Fixnum::from_value(eval("1.23").unwrap()).is_none());

pub fn from_i64(n: i64) -> Result<Self, RBignum>

Available on crate feature old-api only.

Create a new Fixnum from an i64.

Returns Ok(Fixnum) if n is in range for Fixnum, otherwise returns Err(RBignum).

Panics

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

Examples

use magnus::Fixnum;

assert!(Fixnum::from_i64(0).is_ok());
// too big
assert!(Fixnum::from_i64(4611686018427387904).is_err());
assert!(Fixnum::from_i64(-4611686018427387905).is_err());

pub fn from_u64(n: u64) -> Result<Self, RBignum>

Available on crate feature old-api only.

Create a new Fixnum from a u64.

Returns Ok(Fixnum) if n is in range for Fixnum, otherwise returns Err(RBignum).

Panics

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

Examples

use magnus::Fixnum;

assert!(Fixnum::from_u64(0).is_ok());
// too big
assert!(Fixnum::from_u64(4611686018427387904).is_err());

pub fn to_i8(self) -> Result<i8, Error>

Convert self to an i8. Returns Err if self is out of range for i8.

Examples

use magnus::{Error, Fixnum, Ruby};

fn example(ruby: &Ruby) -> Result<(), Error> {
    assert_eq!(ruby.eval::<Fixnum>("127")?.to_i8()?, 127);
    assert!(ruby.eval::<Fixnum>("128")?.to_i8().is_err());
    assert_eq!(ruby.eval::<Fixnum>("-128")?.to_i8()?, -128);
    assert!(ruby.eval::<Fixnum>("-129")?.to_i8().is_err());

    Ok(())
}

pub fn to_i16(self) -> Result<i16, Error>

Convert self to an i16. Returns Err if self is out of range for i16.

Examples

use magnus::{Error, Fixnum, Ruby};

fn example(ruby: &Ruby) -> Result<(), Error> {
    assert_eq!(ruby.eval::<Fixnum>("32767")?.to_i16()?, 32767);
    assert!(ruby.eval::<Fixnum>("32768")?.to_i16().is_err());
    assert_eq!(ruby.eval::<Fixnum>("-32768")?.to_i16()?, -32768);
    assert!(ruby.eval::<Fixnum>("-32769")?.to_i16().is_err());

    Ok(())
}

pub fn to_i32(self) -> Result<i32, Error>

Convert self to an i32. Returns Err if self is out of range for i32.

Examples

use magnus::{Error, Fixnum, Ruby};

fn example(ruby: &Ruby) -> Result<(), Error> {
    assert_eq!(ruby.eval::<Fixnum>("2147483647")?.to_i32()?, 2147483647);
    assert!(ruby.eval::<Fixnum>("2147483648")?.to_i32().is_err());
    assert_eq!(ruby.eval::<Fixnum>("-2147483648")?.to_i32()?, -2147483648);
    assert!(ruby.eval::<Fixnum>("-2147483649")?.to_i32().is_err());

    Ok(())
}

pub fn to_i64(self) -> i64

Convert self to an i64. This is infallible as i64 can represent a larger range than Fixnum.

Examples

use magnus::{Error, Fixnum, Ruby};

fn example(ruby: &Ruby) -> Result<(), Error> {
    assert_eq!(
        ruby.eval::<Fixnum>("4611686018427387903")?.to_i64(),
        4611686018427387903
    );
    assert_eq!(
        ruby.eval::<Fixnum>("-4611686018427387904")?.to_i64(),
        -4611686018427387904
    );

    Ok(())
}

pub fn to_i128(self) -> i128

Convert self to an i128. This is infallible as i128 can represent a larger range than Fixnum.

Examples

use magnus::{Error, Fixnum, Ruby};

fn example(ruby: &Ruby) -> Result<(), Error> {
    assert_eq!(
        ruby.eval::<Fixnum>("4611686018427387903")?.to_i128(),
        4611686018427387903
    );
    assert_eq!(
        ruby.eval::<Fixnum>("-4611686018427387904")?.to_i128(),
        -4611686018427387904
    );

    Ok(())
}

pub fn to_isize(self) -> isize

Convert self to an isize. Returns Err if self is out of range for isize.

Examples

use magnus::{Error, Fixnum, Ruby};

fn example(ruby: &Ruby) -> Result<(), Error> {
    assert_eq!(
        ruby.eval::<Fixnum>("4611686018427387903")?.to_isize(),
        4611686018427387903
    );
    assert_eq!(
        ruby.eval::<Fixnum>("-4611686018427387904")?.to_isize(),
        -4611686018427387904
    );

    Ok(())
}

pub fn to_u8(self) -> Result<u8, Error>

Convert self to a u8. Returns Err if self is negative or out of range for u8.

Examples

use magnus::{Error, Fixnum, Ruby};

fn example(ruby: &Ruby) -> Result<(), Error> {
    assert_eq!(ruby.eval::<Fixnum>("255")?.to_u8()?, 255);
    assert!(ruby.eval::<Fixnum>("256")?.to_u8().is_err());
    assert!(ruby.eval::<Fixnum>("-1")?.to_u8().is_err());

    Ok(())
}

pub fn to_u16(self) -> Result<u16, Error>

Convert self to a u16. Returns Err if self is negative or out of range for u16.

Examples

use magnus::{Error, Fixnum, Ruby};

fn example(ruby: &Ruby) -> Result<(), Error> {
    assert_eq!(ruby.eval::<Fixnum>("65535")?.to_u16()?, 65535);
    assert!(ruby.eval::<Fixnum>("65536")?.to_u16().is_err());
    assert!(ruby.eval::<Fixnum>("-1")?.to_u16().is_err());

    Ok(())
}

pub fn to_u32(self) -> Result<u32, Error>

Convert self to a u32. Returns Err if self is negative or out of range for u32.

Examples

use magnus::{Error, Fixnum, Ruby};

fn example(ruby: &Ruby) -> Result<(), Error> {
    assert_eq!(ruby.eval::<Fixnum>("4294967295")?.to_u32()?, 4294967295);
    assert!(ruby.eval::<Fixnum>("4294967296")?.to_u32().is_err());
    assert!(ruby.eval::<Fixnum>("-1")?.to_u32().is_err());

    Ok(())
}

pub fn to_u64(self) -> Result<u64, Error>

Convert self to a u64. Returns Err if self is negative.

Examples

use magnus::{Error, Fixnum, Ruby};

fn example(ruby: &Ruby) -> Result<(), Error> {
    assert_eq!(
        ruby.eval::<Fixnum>("4611686018427387903")?.to_u64()?,
        4611686018427387903
    );
    assert!(ruby.eval::<Fixnum>("-1")?.to_u64().is_err());

    Ok(())
}

pub fn to_u128(self) -> Result<u128, Error>

Convert self to a u128. Returns Err if self is negative.

Examples

use magnus::{Error, Fixnum, Ruby};

fn example(ruby: &Ruby) -> Result<(), Error> {
    assert_eq!(
        ruby.eval::<Fixnum>("4611686018427387903")?.to_u128()?,
        4611686018427387903
    );
    assert!(ruby.eval::<Fixnum>("-1")?.to_u128().is_err());

    Ok(())
}

pub fn to_usize(self) -> Result<usize, Error>

Convert self to a usize. Returns Err if self is negative or out of range for usize.

Examples

use magnus::{Error, Fixnum, Ruby};

fn example(ruby: &Ruby) -> Result<(), Error> {
    assert_eq!(
        ruby.eval::<Fixnum>("4611686018427387903")?.to_usize()?,
        4611686018427387903
    );
    assert!(ruby.eval::<Fixnum>("-1")?.to_usize().is_err());

    Ok(())
}

Trait Implementations

impl Clone for Fixnum

fn clone(&self) -> Fixnum

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Fixnum

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

Formats the value using the given formatter.

impl Display for Fixnum

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

Formats the value using the given formatter.

impl IntoValue for Fixnum

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

Convert self into Value.

fn into_value(self) -> Value

Available on crate feature old-api only.

Convert self into Value.

unsafe fn into_value_unchecked(self) -> Value

Convert self into Value.

impl Numeric for Fixnum

fn coerce_bin<T, ID, U>(self, other: T, op: ID) -> Result<U, Error>

where T: Numeric, ID: IntoId, U: TryConvert,

Apply the operator op with coercion.

fn coerce_cmp<T, ID, U>(self, other: T, op: ID) -> Result<U, Error>

where T: Numeric, ID: IntoId, U: TryConvert,

Apply the operator op with coercion.

fn coerce_relop<T, ID, U>(self, other: T, op: ID) -> Result<U, Error>

where T: Numeric, ID: IntoId, U: TryConvert,

Apply the operator op with coercion.

fn coerce_bit<T, ID, U>(self, other: T, op: ID) -> Result<U, Error>

where T: Numeric, ID: IntoId, U: TryConvert,

Apply the operator op with coercion.

impl ReprValue for Fixnum

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(&Ruby, &[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 Fixnum

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

Convert val into Self.

impl Copy for Fixnum

impl TryConvertOwned for Fixnum