Is this in the cheap category — a checklist

Before you size an engineering effort, run the six tests. Half the time the problem is already solved.

1. 01
   The six tests as an enum the codebase carries. Each branch points at the right crate. Wire this into your planning template and the procurement question becomes a constructor argument, not a debate.

   enum CheapTest {
       GreedyWithExchange,   // sorting, scheduling, MST
       DynamicProgramming,   // counting, alignment, DAGs
       NetworkFlow,          // matching, allocation, partition
       TwoPieceConstraint,   // 2-SAT via SCC
       LinearProgramming,    // continuous vars + linear constraints
       LinearAlgebra,        // matrices, eigenvalues, factorization
   }
   
   fn crate_for(test: CheapTest) -> &'static str {
       match test {
           CheapTest::GreedyWithExchange => "std::slice::sort_unstable + a loop",
           CheapTest::DynamicProgramming => "hand-rolled table",
           CheapTest::NetworkFlow        => "petgraph::algo::ford_fulkerson",
           CheapTest::TwoPieceConstraint => "petgraph::algo::tarjan_scc on implication graph",
           CheapTest::LinearProgramming  => "good_lp with the HiGHS backend",
           CheapTest::LinearAlgebra      => "nalgebra or faer",
       }
   }

2. 02
   enum is Rust's tagged union — a single type whose values can be one of several named variants. Page 9's Option and Result were enums with data-carrying variants (Some(T) holding a value, Err(E) holding an error). This page's CheapTest is the simpler form — every variant is a unit variant, carrying no payload. Each variant is just a name that the type system treats as distinct. Compared to a plain integer or string constant, an enum gets you the exhaustiveness check (page 9 again): the compiler refuses to compile a match that doesn't cover every variant, so adding a seventh test means the compiler points at every match in the codebase that needs updating. That refactor-safety is the whole reason to reach for an enum instead of a string.

   // Unit variants — no payload, just a name.
   enum Direction { North, South, East, West }
   
   // Data-carrying variants — each variant holds different data.
   enum Shape {
       Circle(f64),               // tuple-style: one f64 (radius)
       Rect(f64, f64),            // tuple-style: width, height
       Point,                      // unit variant — no data
       Annotated { name: String, kind: u8 },   // struct-style: named fields
   }
   
   // Build a variant by writing its full path:
   let d = Direction::East;
   let s = Shape::Circle(3.0);
   
   
   // Why an enum and not a string constant or integer?
   //
   //   1. Exhaustiveness — match arms get checked at compile time.
   //      Add a variant → compiler points at every match that needs updating.
   //
   //   2. Type safety — you can't accidentally pass a Shape where a
   //      Direction is expected; the types are distinct.
   //
   //   3. Pattern matching — destructure data-carrying variants in one step.
   //      Strings can't do that.
   
   
   // Page 37 uses pure unit variants — the checklist categories.
   // The match in `crate_for` covers all six, and the compiler will
   // refuse to compile if a seventh category gets added without a
   // corresponding arm.
   
   
   // One last note — enums under the hood:
   //
   //   Rust stores an enum as a discriminant (small integer tag) plus
   //   enough space for the largest variant's data.  Unit-only enums
   //   compile down to just the tag — `size_of::<CheapTest>() == 1` byte.
   //   Data-carrying enums are bigger.  Either way, dispatch on the
   //   variant is a single comparison, not a function call or a hash.