array-mumu 0.2.0-rc.5

Array tools plugin for the Mumu ecosystem
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

// src/lib.rs
#![allow(dead_code)]
#![allow(unused_imports)]

use mumu::{
    parser::interpreter::Interpreter,
    parser::types::{Value, FunctionValue},
};
use std::sync::{Arc, Mutex};

mod simple;
mod append;
mod apply;
mod assoc;
mod collect;
mod each;
mod join;
mod keys;
mod key_eq;
mod length;
mod map;
mod multi;
mod nth;
mod prop;
mod range;
mod reduce;
mod search;
mod sort;
mod tail;
mod util;
mod transform; // directory of transforms

/// Register every `array:*` bridge into the provided interpreter.
/// This is suitable for *embedded/static* usage (e.g., WASM builds),
/// so callers don’t need `extend("array")`.
pub fn register_all(interp: &mut Interpreter) {
    macro_rules! reg {
        ($name:expr, $f:expr) => {{
            let func = Arc::new(Mutex::new($f));
            interp.register_dynamic_function($name, func);
            interp.set_variable(
                $name,
                Value::Function(Box::new(FunctionValue::Named($name.into()))),
            );
        }};
    }

    // Keep this list in sync with the Cargo_lock FFI path below.
    reg!("array:filter", simple::array_filter);
    reg!("array:sort", sort::array_sort_bridge);
    reg!("array:flatten", simple::array_flatten);
    reg!("array:join", join::array_join_bridge);
    reg!("array:zip", simple::array_zip);
    reg!("array:zip_with", multi::array_zip_with_bridge);
    reg!("array:prop", prop::array_prop_bridge);

    reg!("array:append", append::array_append_bridge);
    reg!("array:apply", apply::array_apply_bridge);
    reg!("array:assoc", assoc::array_assoc_bridge);
    reg!("array:chunk", transform::chunk::array_chunk_bridge);
    reg!("array:collect", collect::array_collect_bridge);
    reg!("array:compact", util::array_compact_bridge);
    reg!("array:drop", transform::drop::array_drop_bridge);
    reg!("array:drop_while", transform::drop_while::array_drop_while_bridge);
    reg!("array:each", each::array_each_bridge);
    reg!("array:every", search::array_every_bridge);
    reg!("array:find", search::array_find_bridge);
    reg!("array:findIndex", search::array_find_index_bridge);
    reg!("array:flatten_deep", util::array_flatten_deep_bridge);
    reg!("array:group_by", transform::group_by::array_group_by_bridge);
    reg!("array:head", util::array_head_bridge);
    reg!("array:includes", search::array_includes_bridge);
    reg!("array:init", transform::init::array_init_bridge);
    reg!("array:last", util::array_last_bridge);
    reg!("array:length", length::array_length_bridge);
    reg!("array:map", map::array_map_bridge);
    reg!("array:multi_concat", multi::array_concat_bridge);
    reg!("array:multi_difference", multi::array_difference_bridge);
    reg!("array:multi_intersection", multi::array_intersection_bridge);
    reg!("array:multi_union", multi::array_union_bridge);
    reg!("array:multi_zip", multi::array_zip_bridge);
    reg!("array:multi_zip_with", multi::array_zip_with_bridge);
    reg!("array:nth", nth::array_nth_bridge);
    reg!("array:partition", transform::partition::array_partition_bridge);
    reg!("array:pluck", transform::pluck::array_pluck_bridge);
    reg!("array:prop_partial", prop::array_prop_bridge);
    reg!("array:range", range::array_range_bridge);
    reg!("array:reduce", reduce::array_reduce_bridge);
    reg!("array:repeat", transform::fill::array_repeat_bridge);
    reg!("array:reverse", util::array_reverse_bridge);
    reg!("array:slice", transform::slice::array_slice_bridge);
    reg!("array:some", search::array_some_bridge);
    reg!("array:sort_by", sort::array_sort_by_bridge);
    reg!("array:sort_with", sort::array_sort_with_bridge);
    reg!("array:tail", tail::array_tail_bridge);
    reg!("array:take", transform::take::array_take_bridge);
    reg!("array:take_while", transform::take_while::array_take_while_bridge);
    reg!("array:uniq", util::array_uniq_bridge);
    reg!("array:shuffle", util::array_shuffle_bridge);
    reg!("array:keys", keys::array_keys_bridge);

    // Ramda-like propEq
    reg!("array:key_eq", key_eq::array_key_eq_bridge);
}

/// Dynamic-loader entry point used by native (non-wasm) builds.
/// For embedded/static (e.g., WASM), call `register_all(...)` directly.
#[cfg(not(target_arch = "wasm32"))]
#[no_mangle]
pub unsafe extern "C" fn Cargo_lock(
    interp_ptr: *mut std::ffi::c_void,
    _extra_str: *const std::ffi::c_void,
) -> i32 {
    let interp = &mut *(interp_ptr as *mut Interpreter);
    register_all(interp);
    0
}