Skip to content

Commit 8e95c00

Browse files
raphael-goetzraphael-goetz
committed
ref: cargo fmt
1 parent f83029d commit 8e95c00

File tree

7 files changed

+312
-70
lines changed

7 files changed

+312
-70
lines changed

‎taurus/src/context/registry.rs‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7,8 +7,11 @@ use std::collections::HashMap;
77
/// - For eager params, the executor will already convert them to Argument::Eval(Value).
88
/// - For lazy params, the executor will pass Argument::Thunk(node_id).
99
/// - If a handler wants to execute a lazy arg, it calls run(node_id).
10-
pub type HandlerFn =
11-
fn(args: &[Argument], ctx: &mut Context, run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal;
10+
pub type HandlerFn = fn(
11+
args: &[Argument],
12+
ctx: &mut Context,
13+
run: &mut dyn FnMut(i64, &mut Context) -> Signal,
14+
) -> Signal;
1215

1316
pub struct HandlerFunctionEntry {
1417
pub handler: HandlerFn,

‎taurus/src/implementation/array.rs‎

Lines changed: 116 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -28,10 +28,7 @@ pub fn collect_array_functions() -> Vec<(&'static str, HandlerFunctionEntry)> {
2828
("std::list::index_of", HandlerFn::eager(index_of, 2)),
2929
("std::list::to_unique", HandlerFn::eager(to_unique, 1)),
3030
("std::list::sort", HandlerFn::eager(sort, 2)),
31-
(
32-
"std::list::sort_reverse",
33-
HandlerFn::eager(sort_reverse, 2),
34-
),
31+
("std::list::sort_reverse", HandlerFn::eager(sort_reverse, 2)),
3532
("std::list::reverse", HandlerFn::eager(reverse, 1)),
3633
("std::list::flat", HandlerFn::eager(flat, 1)),
3734
("std::list::min", HandlerFn::eager(min, 1)),
@@ -41,7 +38,11 @@ pub fn collect_array_functions() -> Vec<(&'static str, HandlerFunctionEntry)> {
4138
]
4239
}
4340

44-
fn at(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
41+
fn at(
42+
args: &[Argument],
43+
_ctx: &mut Context,
44+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
45+
) -> Signal {
4546
// array, index
4647
args!(args => array: ListValue, index: f64);
4748

@@ -61,7 +62,11 @@ fn at(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Cont
6162
}
6263
}
6364

64-
fn concat(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
65+
fn concat(
66+
args: &[Argument],
67+
_ctx: &mut Context,
68+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
69+
) -> Signal {
6570
args!(args => lhs_v: Value, rhs_v: Value);
6671

6772
let Kind::ListValue(lhs) = lhs_v.kind.clone().ok_or(()).unwrap_or(Kind::NullValue(0)) else {
@@ -91,7 +96,11 @@ fn concat(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut
9196
})
9297
}
9398

94-
fn filter(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
99+
fn filter(
100+
args: &[Argument],
101+
_ctx: &mut Context,
102+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
103+
) -> Signal {
95104
args!(args => array_v: Value, predicate_v: Value);
96105
let Kind::ListValue(array) = array_v.kind.ok_or(()).unwrap_or(Kind::NullValue(0)) else {
97106
return Signal::Failure(RuntimeError::simple(
@@ -132,7 +141,11 @@ fn filter(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut
132141
})
133142
}
134143

135-
fn find(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
144+
fn find(
145+
args: &[Argument],
146+
_ctx: &mut Context,
147+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
148+
) -> Signal {
136149
args!(args => array_v: Value, predicate_v: Value);
137150
let Kind::ListValue(array) = array_v.kind.ok_or(()).unwrap_or(Kind::NullValue(0)) else {
138151
return Signal::Failure(RuntimeError::simple_str(
@@ -176,7 +189,11 @@ fn find(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Co
176189
}
177190
}
178191

179-
fn find_last(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
192+
fn find_last(
193+
args: &[Argument],
194+
_ctx: &mut Context,
195+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
196+
) -> Signal {
180197
args!(args => array_v: Value, predicate_v: Value);
181198
let Kind::ListValue(array) = array_v.kind.ok_or(()).unwrap_or(Kind::NullValue(0)) else {
182199
return Signal::Failure(RuntimeError::simple_str(
@@ -267,7 +284,11 @@ fn find_index(
267284
}
268285
}
269286

270-
fn first(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
287+
fn first(
288+
args: &[Argument],
289+
_ctx: &mut Context,
290+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
291+
) -> Signal {
271292
args!(args => array: ListValue);
272293

273294
match array.values.first() {
@@ -279,7 +300,11 @@ fn first(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut C
279300
}
280301
}
281302

282-
fn last(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
303+
fn last(
304+
args: &[Argument],
305+
_ctx: &mut Context,
306+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
307+
) -> Signal {
283308
args!(args => array: ListValue);
284309
match array.values.last() {
285310
Some(v) => Signal::Success(v.clone()),
@@ -296,14 +321,22 @@ fn last(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Co
296321
/// The definition itself takes in an array and a node
297322
/// The node itself will be executed on the arrays elements
298323
/// If the node is (CONSUMER) resolved it goes in this function --> therefor all code is already executed
299-
fn for_each(_args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
324+
fn for_each(
325+
_args: &[Argument],
326+
_ctx: &mut Context,
327+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
328+
) -> Signal {
300329
// Already executed by the engine (consumer); return Null
301330
Signal::Success(Value {
302331
kind: Some(Kind::NullValue(0)),
303332
})
304333
}
305334

306-
fn map(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
335+
fn map(
336+
args: &[Argument],
337+
_ctx: &mut Context,
338+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
339+
) -> Signal {
307340
// (array, transformed_results[])
308341
args!(args => _array_v: Value, transform_v: Value);
309342
let Kind::ListValue(transform_result) =
@@ -319,7 +352,11 @@ fn map(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Con
319352
})
320353
}
321354

322-
fn push(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
355+
fn push(
356+
args: &[Argument],
357+
_ctx: &mut Context,
358+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
359+
) -> Signal {
323360
args!(args => array_v: Value, item: Value);
324361
let Kind::ListValue(mut array) = array_v.kind.ok_or(()).unwrap_or(Kind::NullValue(0)) else {
325362
return Signal::Failure(RuntimeError::simple_str(
@@ -333,7 +370,11 @@ fn push(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Co
333370
})
334371
}
335372

336-
fn pop(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
373+
fn pop(
374+
args: &[Argument],
375+
_ctx: &mut Context,
376+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
377+
) -> Signal {
337378
args!(args => array_v: Value);
338379
let Kind::ListValue(mut array) = array_v.kind.ok_or(()).unwrap_or(Kind::NullValue(0)) else {
339380
return Signal::Failure(RuntimeError::simple_str(
@@ -347,7 +388,11 @@ fn pop(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Con
347388
})
348389
}
349390

350-
fn remove(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
391+
fn remove(
392+
args: &[Argument],
393+
_ctx: &mut Context,
394+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
395+
) -> Signal {
351396
args!(args => array_v: Value, item: Value);
352397
let Kind::ListValue(mut array) = array_v.kind.ok_or(()).unwrap_or(Kind::NullValue(0)) else {
353398
return Signal::Failure(RuntimeError::simple_str(
@@ -369,7 +414,11 @@ fn remove(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut
369414
}
370415
}
371416

372-
fn is_empty(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
417+
fn is_empty(
418+
args: &[Argument],
419+
_ctx: &mut Context,
420+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
421+
) -> Signal {
373422
args!(args => array_v: Value);
374423
let Kind::ListValue(array) = array_v.kind.ok_or(()).unwrap_or(Kind::NullValue(0)) else {
375424
return Signal::Failure(RuntimeError::simple_str(
@@ -382,7 +431,11 @@ fn is_empty(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mu
382431
})
383432
}
384433

385-
fn size(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
434+
fn size(
435+
args: &[Argument],
436+
_ctx: &mut Context,
437+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
438+
) -> Signal {
386439
args!(args => array_v: Value);
387440
let Kind::ListValue(array) = array_v.kind.ok_or(()).unwrap_or(Kind::NullValue(0)) else {
388441
return Signal::Failure(RuntimeError::simple_str(
@@ -395,7 +448,11 @@ fn size(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Co
395448
})
396449
}
397450

398-
fn index_of(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
451+
fn index_of(
452+
args: &[Argument],
453+
_ctx: &mut Context,
454+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
455+
) -> Signal {
399456
args!(args => array_v: Value, item: Value);
400457
let Kind::ListValue(array) = array_v.kind.ok_or(()).unwrap_or(Kind::NullValue(0)) else {
401458
return Signal::Failure(RuntimeError::simple_str(
@@ -415,7 +472,11 @@ fn index_of(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mu
415472
}
416473
}
417474

418-
fn to_unique(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
475+
fn to_unique(
476+
args: &[Argument],
477+
_ctx: &mut Context,
478+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
479+
) -> Signal {
419480
args!(args => array_v: Value);
420481
let Kind::ListValue(array) = array_v.kind.ok_or(()).unwrap_or(Kind::NullValue(0)) else {
421482
return Signal::Failure(RuntimeError::simple_str(
@@ -436,7 +497,11 @@ fn to_unique(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &m
436497
})
437498
}
438499

439-
fn sort(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
500+
fn sort(
501+
args: &[Argument],
502+
_ctx: &mut Context,
503+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
504+
) -> Signal {
440505
// array, resolved comparator yields -1/0/1 sequence
441506
args!(args => array_v: Value, cmp_v: Value);
442507
let Kind::ListValue(mut arr) = array_v.kind.ok_or(()).unwrap_or(Kind::NullValue(0)) else {
@@ -519,7 +584,11 @@ fn sort_reverse(
519584
})
520585
}
521586

522-
fn reverse(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
587+
fn reverse(
588+
args: &[Argument],
589+
_ctx: &mut Context,
590+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
591+
) -> Signal {
523592
args!(args => array_v: Value);
524593
let Kind::ListValue(mut array) = array_v.kind.ok_or(()).unwrap_or(Kind::NullValue(0)) else {
525594
return Signal::Failure(RuntimeError::simple_str(
@@ -533,7 +602,11 @@ fn reverse(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut
533602
})
534603
}
535604

536-
fn flat(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
605+
fn flat(
606+
args: &[Argument],
607+
_ctx: &mut Context,
608+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
609+
) -> Signal {
537610
args!(args => array_v: Value);
538611
let Kind::ListValue(array) = array_v.kind.ok_or(()).unwrap_or(Kind::NullValue(0)) else {
539612
return Signal::Failure(RuntimeError::simple_str(
@@ -555,7 +628,11 @@ fn flat(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Co
555628
})
556629
}
557630

558-
fn min(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
631+
fn min(
632+
args: &[Argument],
633+
_ctx: &mut Context,
634+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
635+
) -> Signal {
559636
args!(args => array: ListValue);
560637

561638
let mut nums: Vec<f64> = Vec::new();
@@ -576,7 +653,11 @@ fn min(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Con
576653
}
577654
}
578655

579-
fn max(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
656+
fn max(
657+
args: &[Argument],
658+
_ctx: &mut Context,
659+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
660+
) -> Signal {
580661
args!(args => array: ListValue);
581662

582663
let mut nums: Vec<f64> = Vec::new();
@@ -597,7 +678,11 @@ fn max(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Con
597678
}
598679
}
599680

600-
fn sum(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
681+
fn sum(
682+
args: &[Argument],
683+
_ctx: &mut Context,
684+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
685+
) -> Signal {
601686
args!(args => array: ListValue);
602687

603688
let mut s = 0.0;
@@ -612,7 +697,11 @@ fn sum(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Con
612697
})
613698
}
614699

615-
fn join(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
700+
fn join(
701+
args: &[Argument],
702+
_ctx: &mut Context,
703+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
704+
) -> Signal {
616705
args!(args => array: ListValue, separator: String);
617706

618707
let mut parts: Vec<String> = Vec::new();

‎taurus/src/implementation/boolean.rs‎

Lines changed: 25 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -19,14 +19,22 @@ pub fn collect_boolean_functions() -> Vec<(&'static str, HandlerFunctionEntry)>
1919
]
2020
}
2121

22-
fn as_number(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
22+
fn as_number(
23+
args: &[Argument],
24+
_ctx: &mut Context,
25+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
26+
) -> Signal {
2327
args!(args => value: bool);
2428
Signal::Success(Value {
2529
kind: Some(Kind::NumberValue((value as i64) as f64)),
2630
})
2731
}
2832

29-
fn as_text(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
33+
fn as_text(
34+
args: &[Argument],
35+
_ctx: &mut Context,
36+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
37+
) -> Signal {
3038
args!(args => value: bool);
3139
Signal::Success(Value {
3240
kind: Some(Kind::StringValue(value.to_string())),
@@ -45,7 +53,11 @@ fn from_number(
4553
})
4654
}
4755

48-
fn from_text(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
56+
fn from_text(
57+
args: &[Argument],
58+
_ctx: &mut Context,
59+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
60+
) -> Signal {
4961
args!(args => text: String);
5062

5163
match text.to_lowercase().parse::<bool>() {
@@ -59,14 +71,22 @@ fn from_text(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &m
5971
}
6072
}
6173

62-
fn is_equal(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
74+
fn is_equal(
75+
args: &[Argument],
76+
_ctx: &mut Context,
77+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
78+
) -> Signal {
6379
args!(args => lhs: bool, rhs: bool);
6480
Signal::Success(Value {
6581
kind: Some(Kind::BoolValue(lhs == rhs)),
6682
})
6783
}
6884

69-
fn negate(args: &[Argument], _ctx: &mut Context, _run: &mut dyn FnMut(i64, &mut Context) -> Signal) -> Signal {
85+
fn negate(
86+
args: &[Argument],
87+
_ctx: &mut Context,
88+
_run: &mut dyn FnMut(i64, &mut Context) -> Signal,
89+
) -> Signal {
7090
args!(args => value: bool);
7191
Signal::Success(Value {
7292
kind: Some(Kind::BoolValue(!value)),

0 commit comments

Comments
 (0)