accept slice as CCallArg

[clouds56]

I'm new to jlrs, and would like to try to port polars.jl using jlrs.
Now in polars.jl it accept Array like this

#[no_mangle]
pub unsafe extern "C" fn polars_lazy_frame_select(
    df: *mut polars_lazy_frame_t,
    exprs: *const *const polars_expr_t,
    nexprs: usize,
)

and I think it would be better to have API like

impl polars_lazy_frame_t {
  pub fn select(&mut self, exprs: &[polars_expr_t])
}

How to achieve this?

[Taaitaaiger]

Are you looking at this package? https://github.com/Pangoraw/Polars.jl

It's using a custom C API between Rust and Julia, which is where these types come from. This API would be replaced with opaque types and functions that can be exported with the julia_module macro, which will generate all necessary glue code.

I don't think implementing CCallArg for slices in jlrs is the best choice here. I think it would be better to take a TypedVector, create an accessor (should be a ValueAccessor), and converting that to a slice.

[clouds56]

Thanks for quick reply.
I'm now writing code like this

pub type TypedVec<'scope, 'data, T> = TypedVector<'scope, 'data, TypedValue<'scope, 'data, T>>;
pub trait TypedVecExt<'scope, 'data, T> {
    fn as_slice(&self) -> &'data [T];
}
impl<'scope, 'data, T> TypedVecExt<'scope, 'data, T> for TypedVec<'scope, 'data, T> {
    fn as_slice(&self) -> &'data [T] {
        unsafe { std::slice::from_raw_parts(self.data_ptr() as *const T, self.length()) }
    }
}
julia_module! {
  become polars_init;
  struct polars_expr_t;
  struct polars_lazy_frame_t;
  in polars_lazy_frame_t fn select(&mut self, expr: TypedVec<polars_expr_t>) as polars_lazy_frame_select;
}

impl polars_lazy_frame_t {
    pub fn select(&mut self, exprs: TypedVec<polars_expr_t>) {
        let exprs: Vec<_> = exprs.as_slice().iter().map(|expr| expr.inner.clone()).collect();
        self.inner = self.inner.clone().select(exprs);
    }
}

Would this work?

Could you show me an example of ValueAccessor

[Taaitaaiger]

No, I mean jlrs's TypedVector: https://docs.rs/jlrs/latest/jlrs/data/managed/array/type.TypedVector.html

If you want to use jlrs to generate this interface, you need to start over from scratch to define it in terms jlrs will understand:

• Define wrapper types for types from Polars, not the C-wrapper library (you should forget about that C library and any types defined in it completely)
• Implement OpaqueType for these new wrapper types
• Implement the functionality you need as methods for these wrapper types
• Export everything to Julia

If this is your first time using jlrs, I recommend reading the tutorial first to familiarize yourself with this crate first: https://taaitaaiger.github.io/jlrs-tutorial/. The wrapper crate I've written for RustFFT should also be useful: https://github.com/Taaitaaiger/rustfft-jl/