Merge pull request #675 from TimelyDataflow/master-next

Integrate master-next into master

Author: antiguru

.github/workflows/deploy.yml

@@ -5,12 +5,15 @@ on:
     branches:
       - master
 
+concurrency:
+  group: deploy
+
 jobs:
   deploy:
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
-      - run: cargo install mdbook --version 0.4.44
+      - run: cargo install mdbook --version 0.5.2
       - name: Patch sample Cargo.toml versions
         run: |
           export DIFFERENTIAL_VERSION=$(cargo metadata --format-version 1 | jq -r '.packages[] | select(.name == "differential-dataflow") | .version')

.github/workflows/release-plz.yml

@@ -9,6 +9,9 @@ on:
     branches:
       - master
 
+concurrency:
+  group: release-plz
+
 jobs:
   release-plz:
     name: Release-plz

.github/workflows/test-timely-master.yml

@@ -36,7 +36,7 @@ jobs:
 
   notify:
     name: Notify failed build
-    if: failure() && github.event.pull_request == null
+    if: failure() && github.repository == 'TimelyDataflow/differential-dataflow'
     needs: [tests]
     permissions:
       contents: read

.github/workflows/test.yml

@@ -6,16 +6,28 @@ on:
   pull_request:
 
 jobs:
+  msrv:
+    name: Determine MSRV
+    runs-on: ubuntu-latest
+    outputs:
+      msrv: ${{ steps.msrv.outputs.msrv }}
+    steps:
+      - uses: actions/checkout@v6
+      - id: msrv
+        run: echo "msrv=$(grep '^rust-version' Cargo.toml | sed 's/.*"\(.*\)"/\1/')" >> "$GITHUB_OUTPUT"
+
   test:
+    needs: msrv
     strategy:
       matrix:
         os:
           - ubuntu
           - macos
-          # - windows
+# Linking fails on Windows.
+#           - windows
         toolchain:
           - stable
-          - 1.79
+          - ${{ needs.msrv.outputs.msrv }}
     name: cargo test on ${{ matrix.os }}, rust ${{ matrix.toolchain }}
     runs-on: ${{ matrix.os }}-latest
     steps:
@@ -27,3 +39,17 @@ jobs:
         run: cargo test --workspace --all-targets
       - name: Cargo doc test
         run: cargo test --doc
+
+  # Check for clippy warnings
+  clippy:
+    name: Cargo clippy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          components: clippy
+      - name: Cargo clippy
+        run: cargo clippy --workspace --all-targets
+        env:
+          RUSTFLAGS: "" # Don't make test fail on clippy

Cargo.toml

@@ -11,20 +11,85 @@ members = [
     "server/dataflows/random_graph",
     "server/dataflows/reachability",
     #"tpchlike",
-    "doop",
+    #"doop",
     "mdbook",
 ]
 resolver = "2"
 
 [workspace.package]
 edition = "2021"
+rust-version = "1.86"
 
 [workspace.dependencies]
 differential-dataflow = { path = "differential-dataflow", default-features = false, version = "0.19.1" }
-timely = { version = "0.26", default-features = false }
+timely = { version = "0.27", default-features = false }
 columnar = { version = "0.11", default-features = false }
+#timely = { git = "https://github.com/TimelyDataflow/timely-dataflow" }
 #timely = { path = "../timely-dataflow/timely/", default-features = false }
 
+[workspace.lints.clippy]
+type_complexity = "allow"
+option_map_unit_fn = "allow"
+wrong_self_convention = "allow"
+should_implement_trait = "allow"
+module_inception = "allow"
+
+#as_conversions = "warn"
+bool_comparison = "warn"
+borrow_interior_mutable_const = "warn"
+borrowed_box = "warn"
+builtin_type_shadow = "warn"
+clone_on_ref_ptr = "warn"
+crosspointer_transmute = "warn"
+dbg_macro = "warn"
+deref_addrof = "warn"
+disallowed_macros = "warn"
+disallowed_methods = "warn"
+disallowed_types = "warn"
+double_must_use = "warn"
+double_parens = "warn"
+duplicate_underscore_argument = "warn"
+excessive_precision = "warn"
+extra_unused_lifetimes = "warn"
+from_over_into = "warn"
+match_overlapping_arm = "warn"
+must_use_unit = "warn"
+mut_mutex_lock = "warn"
+needless_borrow = "warn"
+needless_pass_by_ref_mut = "warn"
+needless_question_mark = "warn"
+needless_return = "warn"
+no_effect = "warn"
+panicking_overflow_checks = "warn"
+partialeq_ne_impl = "warn"
+print_literal = "warn"
+redundant_closure = "warn"
+redundant_closure_call = "warn"
+redundant_field_names = "warn"
+redundant_pattern = "warn"
+redundant_slicing = "warn"
+redundant_static_lifetimes = "warn"
+same_item_push = "warn"
+shadow_unrelated = "warn"
+single_component_path_imports = "warn"
+suspicious_assignment_formatting = "warn"
+suspicious_else_formatting = "warn"
+suspicious_unary_op_formatting = "warn"
+todo = "warn"
+transmutes_expressible_as_ptr_casts = "warn"
+unnecessary_cast = "warn"
+unnecessary_lazy_evaluations = "warn"
+unnecessary_mut_passed = "warn"
+unnecessary_unwrap = "warn"
+unused_async = "warn"
+useless_asref = "warn"
+useless_conversion = "warn"
+useless_format = "warn"
+wildcard_in_or_patterns = "warn"
+write_literal = "warn"
+zero_divided_by_zero = "warn"
+zero_prefixed_literal = "warn"
+
 [profile.release]
 opt-level = 3
 debug = true

README.md

@@ -21,8 +21,8 @@ Alternately, here is a fragment that computes the set of nodes reachable from a
 
 ```rust
 let reachable =
-roots.iterate(|reach|
-    edges.enter(&reach.scope())
+roots.iterate(|scope, reach|
+    edges.enter(&scope)
          .semijoin(reach)
          .map(|(src, dst)| dst)
          .concat(reach)
@@ -328,7 +328,7 @@ Here is a direct implementation, in which we repeatedly take determine the set o
 let k = 5;
 
 // iteratively thin edges.
-edges.iterate(|inner| {
+edges.iterate(|scope, inner| {
 
     // determine the active vertices        /-- this is a lie --\
     let active = inner.flat_map(|(src,dst)| [src,dst].into_iter())
@@ -337,7 +337,7 @@ edges.iterate(|inner| {
                       .map(|(node,_)| node);
 
     // keep edges between active vertices
-    edges.enter(&inner.scope())
+    edges.enter(&scope)
          .semijoin(active)
          .map(|(src,dst)| (dst,src))
          .semijoin(active)

advent_of_code_2017/Cargo.toml

@@ -3,6 +3,11 @@ name = "advent_of_code_2017"
 version = "0.1.0"
 authors = ["Frank McSherry <fmcsherry@me.com>"]
 publish = false
+edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 differential-dataflow = { workspace = true }

advent_of_code_2017/src/bin/day_01.rs

@@ -16,7 +16,7 @@ fn main() {
         let index = worker.index();
         let peers = worker.peers();
 
-        let worker_input = 
+        let worker_input =
         input
             .iter()
             .map(|digit| digit - b'0')
@@ -28,17 +28,17 @@ fn main() {
 
             let digits = scope.new_collection_from(worker_input).1;
 
-            // The two parts ask to line up elements with the next one in the sequence (part 1) and 
-            // the one half way around the sequence (part 2). To find matches, we will shift the 
-            // associated position field while keeping the part identifier as a field (`1` or `2` 
+            // The two parts ask to line up elements with the next one in the sequence (part 1) and
+            // the one half way around the sequence (part 2). To find matches, we will shift the
+            // associated position field while keeping the part identifier as a field (`1` or `2`
             // respectively). We then restrict both by the original `digits` to find matches.
 
             let part1 = digits.map(move |(digit, position)| ((digit, (position + 1) % length), 1));
             let part2 = digits.map(move |(digit, position)| ((digit, (position + length/2) % length), 2));
 
             part1
-                .concat(&part2)                                                         // merge collections.
-                .semijoin(&digits)                                                      // restrict to matches.
+                .concat(part2)                                                         // merge collections.
+                .semijoin(digits)                                                      // restrict to matches.
                 .explode(|((digit, _pos), part)| Some((part, digit as isize)))          // `part` with weight `digit`.
                 .consolidate()                                                          // consolidate weights by `part`.
                 .inspect(|elt| println!("part {} accumulation: {:?}", elt.0, elt.2));   // check out answers.

advent_of_code_2017/src/bin/day_03.rs

@@ -16,10 +16,10 @@ fn main() {
     //
     // The next odd square is arrived at by following four edges, each of which has length
     // equal to the even number between the odd numbers. To determine the position of any
-    // given number, we can subtract the largest odd square from it and then subtract the 
+    // given number, we can subtract the largest odd square from it and then subtract the
     // multiples of the even length, at which point we have a distance along an edge, from
     // which we can determine coordinates.
-    // 
+    //
     // Similarly, we can determine the sequence number from the coordinates, by determining
     // which layer the point is in, adding the appropriate squared odd number, and then some
     // cases to figure out where the point is in the sequence along that layer.
@@ -40,7 +40,7 @@ fn main() {
 
             values
                 .map(|_val| ((0, 0), (1, 1)))
-                .iterate(|inner| {
+                .iterate(|_scope, inner| {
 
                     inner
                         .filter(move |&(_, (_, val))| val < input)  // stop working when we've gotten enough
@@ -90,7 +90,7 @@ fn sequence(input: (isize, isize)) -> isize {
         if -input.1 > layer { layer = -input.1; }
 
         // input exists in layer from ((2 * layer - 1)^2, (2 * layer + 1)^2].
-        // note: excludes first number, includes last number. 
+        // note: excludes first number, includes last number.
 
         let base = (2 * layer - 1) * (2 * layer - 1);
 

advent_of_code_2017/src/bin/day_05.rs

@@ -11,7 +11,7 @@ use differential_dataflow::operators::iterate::Variable;
 
 fn main() {
 
-    let input = 
+    let input =
 "2
 0
 0
@@ -1051,7 +1051,7 @@ fn main() {
         let index = worker.index();
         let peers = worker.peers();
 
-        let worker_input = 
+        let worker_input =
         input
             .split('\n')
             .map(|phrase| phrase.parse::<isize>().unwrap())
@@ -1070,27 +1070,27 @@ fn main() {
                 let address = Variable::from(address.enter(nested));
 
                 // (addr, jump, steps)
-                let instruction = program.join(&address);
+                let instruction = program.join(address);
 
                 fn part1(jump: isize) -> isize { jump+1 }
                 // fn part2(jump: isize) -> isize { if jump >= 3 { jump-1 } else { jump+1 } }
 
-                let new_program = 
+                let new_program =
                 instruction
                     .map(move |(addr, jump, _)| (addr, part1(jump)))
-                    .concat(&instruction.map(|(addr, jump, _)| (addr, jump)).negate())
-                    .concat(&program)
+                    .concat(instruction.map(|(addr, jump, _)| (addr, jump)).negate())
+                    .concat(program)
                     .consolidate();
 
-                let new_address = 
+                let new_address =
                 instruction
                     .map(|(addr, jump, steps)| (addr + jump, steps + 1))
-                    .concat(&instruction.map(|(addr, _, steps)| (addr, steps)).negate())
-                    .concat(&address)
+                    .concat(instruction.map(|(addr, _, steps)| (addr, steps)).negate())
+                    .concat(address)
                     .consolidate();
 
-                program.set(&new_program);
-                address.set(&new_address)
+                program.set(new_program);
+                address.set(new_address)
                        .leave()
             })
             .consolidate()