Skip to content

Commit 46055b4

Browse files
s-arashs-arash
committed
cargo fmt
1 parent d0fe74b commit 46055b4

File tree

91 files changed

+15035
-14751
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

91 files changed

+15035
-14751
lines changed

‎ascent/examples/ascent_agg_clause.rs

+14-13
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,15 @@
11
//! Aggregate `agg` clause
22
3-
use ascent::{aggregators::{count, max, mean, min, sum}, ascent};
3+
use ascent::aggregators::{count, max, mean, min, sum};
4+
use ascent::ascent;
45

56
ascent! {
67
// Facts:
78

89
relation number(i32);
9-
10+
1011
// Rules:
11-
12+
1213
relation lowest(i32);
1314

1415
lowest(y) <-- agg y = min(x) in number(x);
@@ -31,17 +32,17 @@ ascent! {
3132
}
3233

3334
fn main() {
34-
let mut prog = AscentProgram::default();
35-
36-
prog.number = (1..=5).map(|n| (n,)).collect();
35+
let mut prog = AscentProgram::default();
36+
37+
prog.number = (1..=5).map(|n| (n,)).collect();
3738

38-
prog.run();
39+
prog.run();
3940

40-
let AscentProgram { lowest, greatest, average, total, cardinality, ..} = prog;
41+
let AscentProgram { lowest, greatest, average, total, cardinality, .. } = prog;
4142

42-
assert_eq!(lowest, vec![(1,)]);
43-
assert_eq!(greatest, vec![(5,)]);
44-
assert_eq!(average, vec![(3,)]);
45-
assert_eq!(total, vec![(15,)]);
46-
assert_eq!(cardinality, vec![(5,)]);
43+
assert_eq!(lowest, vec![(1,)]);
44+
assert_eq!(greatest, vec![(5,)]);
45+
assert_eq!(average, vec![(3,)]);
46+
assert_eq!(total, vec![(15,)]);
47+
assert_eq!(cardinality, vec![(5,)]);
4748
}

‎ascent/examples/ascent_disjunction_clause.rs

+9-17
Original file line numberDiff line numberDiff line change
@@ -6,9 +6,9 @@ ascent! {
66
// Facts:
77

88
relation number(i32);
9-
9+
1010
// Rules:
11-
11+
1212
relation square(i32);
1313

1414
square(y * y) <-- number(y), number(y * y);
@@ -23,23 +23,15 @@ ascent! {
2323
}
2424

2525
fn main() {
26-
let mut prog = AscentProgram::default();
27-
28-
prog.number = (1..=10).map(|n| (n,)).collect();
26+
let mut prog = AscentProgram::default();
27+
28+
prog.number = (1..=10).map(|n| (n,)).collect();
2929

30-
prog.run();
30+
prog.run();
3131

32-
let AscentProgram { mut even_or_square, ..} = prog;
32+
let AscentProgram { mut even_or_square, .. } = prog;
3333

34-
even_or_square.sort_by_key(|(key,)| *key);
34+
even_or_square.sort_by_key(|(key,)| *key);
3535

36-
assert_eq!(even_or_square, vec![
37-
(1,),
38-
(2,),
39-
(4,),
40-
(6,),
41-
(8,),
42-
(9,),
43-
(10,),
44-
]);
36+
assert_eq!(even_or_square, vec![(1,), (2,), (4,), (6,), (8,), (9,), (10,),]);
4537
}

‎ascent/examples/ascent_for_in_clause.rs

+13-23
Original file line numberDiff line numberDiff line change
@@ -8,32 +8,22 @@ ascent! {
88
relation seed(i32);
99

1010
// Rules:
11-
11+
1212
relation number(i32);
13-
13+
1414
number(x + y) <-- seed(x), for y in 0..3;
1515
}
1616

1717
fn main() {
18-
let mut prog = AscentProgram::default();
19-
20-
prog.seed = vec![
21-
(0,),
22-
(10,),
23-
];
24-
25-
prog.run();
26-
27-
let AscentProgram { mut number, ..} = prog;
28-
29-
number.sort_by_key(|(key,)| *key);
30-
31-
assert_eq!(number, vec![
32-
(0,),
33-
(1,),
34-
(2,),
35-
(10,),
36-
(11,),
37-
(12,),
38-
]);
18+
let mut prog = AscentProgram::default();
19+
20+
prog.seed = vec![(0,), (10,)];
21+
22+
prog.run();
23+
24+
let AscentProgram { mut number, .. } = prog;
25+
26+
number.sort_by_key(|(key,)| *key);
27+
28+
assert_eq!(number, vec![(0,), (1,), (2,), (10,), (11,), (12,),]);
3929
}

‎ascent/examples/ascent_generic_program.rs

+15-26
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ pub struct Node(&'static str);
1111

1212
ascent! {
1313
struct AscentProgram<N> where N: Clone + Eq + Hash;
14-
14+
1515
// Facts:
1616

1717
relation node(N);
@@ -26,29 +26,18 @@ ascent! {
2626
}
2727

2828
fn main() {
29-
let mut prog: AscentProgram<Node> = AscentProgram::default();
30-
31-
prog.node = vec![
32-
(Node("A"),),
33-
(Node("B"),),
34-
(Node("C"),),
35-
];
36-
37-
prog.edge = vec![
38-
(Node("A"), Node("B")),
39-
(Node("B"), Node("C")),
40-
];
41-
42-
prog.run();
43-
44-
let AscentProgram { mut reachable, ..} = prog;
45-
46-
reachable.sort_by_key(|(_, key)| key.0);
47-
reachable.sort_by_key(|(key, _)| key.0);
48-
49-
assert_eq!(reachable, vec![
50-
(Node("A"), Node("B")),
51-
(Node("A"), Node("C")),
52-
(Node("B"), Node("C")),
53-
]);
29+
let mut prog: AscentProgram<Node> = AscentProgram::default();
30+
31+
prog.node = vec![(Node("A"),), (Node("B"),), (Node("C"),)];
32+
33+
prog.edge = vec![(Node("A"), Node("B")), (Node("B"), Node("C"))];
34+
35+
prog.run();
36+
37+
let AscentProgram { mut reachable, .. } = prog;
38+
39+
reachable.sort_by_key(|(_, key)| key.0);
40+
reachable.sort_by_key(|(key, _)| key.0);
41+
42+
assert_eq!(reachable, vec![(Node("A"), Node("B")), (Node("A"), Node("C")), (Node("B"), Node("C")),]);
5443
}

‎ascent/examples/ascent_if_clause.rs

+12-19
Original file line numberDiff line numberDiff line change
@@ -6,39 +6,32 @@ ascent! {
66
// Facts:
77

88
relation number(isize);
9-
9+
1010
// Rules:
11-
11+
1212
relation even(isize);
1313

1414
even(x) <-- number(x), if x % 2 == 0;
15-
15+
1616
relation odd(isize);
1717

1818
odd(x) <-- number(x), if x % 2 != 0;
1919
}
2020

2121
fn main() {
22-
let mut prog = AscentProgram::default();
23-
24-
prog.number = (1..=5).map(|n| (n,)).collect();
22+
let mut prog = AscentProgram::default();
23+
24+
prog.number = (1..=5).map(|n| (n,)).collect();
2525

26-
prog.run();
26+
prog.run();
2727

28-
let AscentProgram { mut even, mut odd, ..} = prog;
28+
let AscentProgram { mut even, mut odd, .. } = prog;
2929

30-
even.sort_by_key(|(key,)| *key);
30+
even.sort_by_key(|(key,)| *key);
3131

32-
assert_eq!(even, vec![
33-
(2,),
34-
(4,),
35-
]);
32+
assert_eq!(even, vec![(2,), (4,),]);
3633

37-
odd.sort_by_key(|(key,)| *key);
34+
odd.sort_by_key(|(key,)| *key);
3835

39-
assert_eq!(odd, vec![
40-
(1,),
41-
(3,),
42-
(5,),
43-
]);
36+
assert_eq!(odd, vec![(1,), (3,), (5,),]);
4437
}

‎ascent/examples/ascent_if_let_clause.rs

+13-22
Original file line numberDiff line numberDiff line change
@@ -6,9 +6,9 @@ ascent! {
66
// Facts:
77

88
relation option(Option<isize>);
9-
9+
1010
// Rules:
11-
11+
1212
relation some(isize);
1313

1414
some(y) <-- option(x), if let Some(y) = x;
@@ -19,24 +19,15 @@ ascent! {
1919
}
2020

2121
fn main() {
22-
let mut prog = AscentProgram::default();
23-
24-
prog.option = vec![
25-
(None,),
26-
(Some(1),),
27-
(Some(2),),
28-
(Some(3),),
29-
];
30-
31-
prog.run();
32-
33-
let AscentProgram { mut some, ..} = prog;
34-
35-
some.sort_by_key(|(key,)| *key);
36-
37-
assert_eq!(some, vec![
38-
(1,),
39-
(2,),
40-
(3,),
41-
]);
22+
let mut prog = AscentProgram::default();
23+
24+
prog.option = vec![(None,), (Some(1),), (Some(2),), (Some(3),)];
25+
26+
prog.run();
27+
28+
let AscentProgram { mut some, .. } = prog;
29+
30+
some.sort_by_key(|(key,)| *key);
31+
32+
assert_eq!(some, vec![(1,), (2,), (3,),]);
4233
}

‎ascent/examples/ascent_lattice.rs

+23-29
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,12 @@
11
//! Aggregate `agg` clause
22
3-
use ascent::{ascent, Dual};
3+
use ascent::{Dual, ascent};
44

55
pub type Node = &'static str;
66

77
ascent! {
88
// Facts:
9-
9+
1010
relation edge(Node, Node, u32);
1111

1212
// Rules:
@@ -15,35 +15,29 @@ ascent! {
1515

1616
shortest_path(x, y, Dual(*w)) <-- edge(x, y, w);
1717

18-
shortest_path(x, z, Dual(w + l)) <--
19-
edge(x, y, w),
18+
shortest_path(x, z, Dual(w + l)) <--
19+
edge(x, y, w),
2020
shortest_path(y, z, ?Dual(l));
2121
}
2222

2323
fn main() {
24-
let mut prog = AscentProgram::default();
25-
26-
prog.edge = vec![
27-
("A", "B", 1),
28-
("A", "D", 4),
29-
("B", "C", 1),
30-
("B", "D", 1),
31-
("C", "D", 2),
32-
];
33-
34-
prog.run();
35-
36-
let AscentProgram { mut shortest_path, ..} = prog;
37-
38-
shortest_path.sort_by_key(|(_, key, _)| *key);
39-
shortest_path.sort_by_key(|(key, _, _)| *key);
40-
41-
assert_eq!(shortest_path, vec![
42-
("A", "B", Dual(1)),
43-
("A", "C", Dual(2)),
44-
("A", "D", Dual(2)),
45-
("B", "C", Dual(1)),
46-
("B", "D", Dual(1)),
47-
("C", "D", Dual(2)),
48-
]);
24+
let mut prog = AscentProgram::default();
25+
26+
prog.edge = vec![("A", "B", 1), ("A", "D", 4), ("B", "C", 1), ("B", "D", 1), ("C", "D", 2)];
27+
28+
prog.run();
29+
30+
let AscentProgram { mut shortest_path, .. } = prog;
31+
32+
shortest_path.sort_by_key(|(_, key, _)| *key);
33+
shortest_path.sort_by_key(|(key, _, _)| *key);
34+
35+
assert_eq!(shortest_path, vec![
36+
("A", "B", Dual(1)),
37+
("A", "C", Dual(2)),
38+
("A", "D", Dual(2)),
39+
("B", "C", Dual(1)),
40+
("B", "D", Dual(1)),
41+
("C", "D", Dual(2)),
42+
]);
4943
}

0 commit comments

Comments
 (0)