macro_rules! function {
($name:expr, -2) => { ... };
($name:expr, -1) => { ... };
($name:expr, 0) => { ... };
($name:expr, 1) => { ... };
($name:expr, 2) => { ... };
($name:expr, 3) => { ... };
($name:expr, 4) => { ... };
($name:expr, 5) => { ... };
($name:expr, 6) => { ... };
($name:expr, 7) => { ... };
($name:expr, 8) => { ... };
($name:expr, 9) => { ... };
($name:expr, 10) => { ... };
($name:expr, 11) => { ... };
($name:expr, 12) => { ... };
($name:expr, 13) => { ... };
($name:expr, 14) => { ... };
($name:expr, 15) => { ... };
($name:expr, 16) => { ... };
($name:expr, $arity:expr) => { ... };
}
Expand description
Wrap a Rust function item with Ruby type conversion and error handling,
ignoring Ruby’s self
argument.
This macro wraps the given function and returns a function pointer
implementing the Method
trait, suitable for passing to functions that
define Ruby methods such as
define_method
.
Ruby code implicitly always has a self
parameter available. In the
extention API this is passed explicitly. The wrapper this macro generates
ignores that argument, and does not pass it to the wrapped function.
The values -2
and -1
for arity
have special meaning. Both indicate
functions with any number of arguments, with -2
the arguments are passed
as a RArray
, with -1
they are passed as a slice of Value
s.
Arity of -1
can be used with scan_args
and get_kwargs
for more complex method
signatures.
Arity | Signature |
---|---|
-2 | fn(arguments: RArray) -> Result<R, Error> |
-1 | fn(arguments: &[Value]) -> Result<R, Error> |
0 | fn()-> Result<R, Error> |
1 | fn(arg1: T) -> Result<R, Error> |
2 | fn(arg1: T, arg2: U) -> Result<R, Error> |
… | … |
16 | … |
Where T
, U
, and so on are any types that implement TryConvert
,
and R
implements Into<Value>
. It is also possible to return just R
rather than a Result
for functions that will never error, and omit the
return value (i.e. return ()
) for a function that returns nil
to Ruby.
See ReturnValue
for more details on what can be returned.
See the method
macro for cases where the self
argument is required.
Examples
fn distance(a: (f64, f64), b: (f64, f64)) -> f64 {
((b.0 - a.0).powi(2) + (b.0 - a.0).powi(2)).sqrt()
}
#[magnus::init]
fn init() {
magnus::define_global_function("distance", magnus::function!(distance, 2));
}