#[repr(transparent)]pub struct Proc(_);
Expand description
Implementations
sourceimpl Proc
impl Proc
sourcepub fn from_value(val: Value) -> Option<Self>
pub fn from_value(val: Value) -> Option<Self>
Return Some(Proc)
if val
is a Proc
, None
otherwise.
sourcepub fn new<F, R>(block: F) -> Self where
F: FnMut(&[Value], Option<Proc>) -> R,
R: BlockReturn,
pub fn new<F, R>(block: F) -> Self where
F: FnMut(&[Value], Option<Proc>) -> R,
R: BlockReturn,
Create a new Proc
.
Examples
use magnus::{block::Proc, eval};
let proc = Proc::new(|args, _block| {
let acc = args.get(0).unwrap().try_convert::<i64>()?;
let i = args.get(1).unwrap().try_convert::<i64>()?;
Ok(acc + i)
});
let res: bool = eval!("proc.call(1, 2) == 3", proc).unwrap();
assert!(res);
let res: bool = eval!("[1, 2, 3, 4, 5].inject(&proc) == 15", proc).unwrap();
assert!(res);
sourcepub fn call<A, T>(self, args: A) -> Result<T, Error> where
A: RArrayArgList,
T: TryConvert,
pub fn call<A, T>(self, args: A) -> Result<T, Error> where
A: RArrayArgList,
T: TryConvert,
Call the proc with args
.
Returns Ok(T)
if the proc runs without error and the return value
converts into a T
, or returns Err
if the proc raises or the
conversion fails.
sourcepub fn arity(self) -> i64
pub fn arity(self) -> i64
Returns the number of arguments self
takes.
If self
takes no arguments, returns 0
.
If self
takes only required arguments, returns the number of required
arguments.
If self
is a lambda and has optional arguments, or is not a lambda
and takes a splat argument, returns -n-1
, where n
is the number of
required arguments.
If self
is not a lambda, and takes a finite number of optional
arguments, returns the number of required arguments.
Keyword arguments are considered as a single additional argument, that
argument being required if any keyword argument is required.
Examples
use magnus::{block::Proc, eval};
let proc = eval::<Proc>("proc {nil}", ).unwrap();
assert_eq!(proc.arity(), 0);
let proc = eval::<Proc>("proc {|a| a + 1}", ).unwrap();
assert_eq!(proc.arity(), 1);
let proc = eval::<Proc>("proc {|a, b| a + b}", ).unwrap();
assert_eq!(proc.arity(), 2);
let proc = eval::<Proc>("proc {|*args| args.sum}", ).unwrap();
assert_eq!(proc.arity(), -1);
Methods from Deref<Target = Value>
sourcepub unsafe fn to_s(&self) -> Result<Cow<'_, str>, Error>
pub unsafe fn to_s(&self) -> Result<Cow<'_, str>, Error>
Convert self
to a Rust string.
Safety
This may return a direct view of memory owned and managed by Ruby. Ruby may modify or free the memory backing the returned str, the caller must ensure this does not happen.
This can be used safely by immediately calling
into_owned
on the return value.
Examples
use magnus::{eval, QTRUE};
let value = QTRUE;
// safe as we neve give Ruby a chance to free the string.
let s = unsafe { value.to_s() }.unwrap().into_owned();
assert_eq!(s, "true");
sourcepub unsafe fn classname(&self) -> Cow<'_, str>
pub unsafe fn classname(&self) -> Cow<'_, str>
Return the name of self
’s class.
Safety
Ruby may modify or free the memory backing the returned str, the caller must ensure this does not happen.
This can be used safely by immediately calling
into_owned
on the return value.
Examples
use magnus::{eval, RHash};
let value = RHash::new();
// safe as we neve give Ruby a chance to free the string.
let s = unsafe { value.classname() }.into_owned();
assert_eq!(s, "Hash");
sourcepub fn try_convert<T>(&self) -> Result<T, Error> where
T: TryConvert,
pub fn try_convert<T>(&self) -> Result<T, Error> where
T: TryConvert,
Convert self
to the Rust type T
.
See the types that TryConvert
is implemented on for what this
method can convert to.
Examples
use magnus::{eval, Value};
assert_eq!(eval::<Value>("42").unwrap().try_convert::<i64>().unwrap(), 42);
assert_eq!(eval::<Value>("1.23").unwrap().try_convert::<i64>().unwrap(), 1);
assert_eq!(eval::<Value>("1").unwrap().try_convert::<f64>().unwrap(), 1.0);
assert_eq!(eval::<Value>("nil").unwrap().try_convert::<Option<i64>>().unwrap(), None);
assert_eq!(eval::<Value>("42").unwrap().try_convert::<Option<i64>>().unwrap(), Some(42));
Trait Implementations
sourceimpl TryConvert for Proc
impl TryConvert for Proc
sourcefn try_convert(val: &Value) -> Result<Self, Error>
fn try_convert(val: &Value) -> Result<Self, Error>
Convert val
into Self
.
impl Copy for Proc
impl ReprValue for Proc
Auto Trait Implementations
impl RefUnwindSafe for Proc
impl Send for Proc
impl Sync for Proc
impl Unpin for Proc
impl UnwindSafe for Proc
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more