[jerome-white]

Closes #41. Part of #38.

What this does

randomized_tukey_hsd now accepts a Tables.jl table (a DataFrame, a NamedTuple of columns, a vector of rows, ...), so the treatment names come with the data and there is no separate systems argument for them:

# wide: each column is a treatment, each row a block
randomized_tukey_hsd(Xoshiro(1), df; trials=10_000)
randomized_tukey_hsd(Xoshiro(1), df; trials=10_000, block=:dataset)   # leave an id column out

# tidy: one row per block and treatment
randomized_tukey_hsd(Xoshiro(1), df; trials=10_000,
                     block=:dataset, treatment=:model, value=:accuracy)

The matrix method is untouched and stays the core. The table methods (new src/tables.jl) convert with scores_matrix and wide_scores from #37, then call it. The generator stays optional as the first argument, as on the matrix method.

Decisions

• Which shape is told by the keywords. None given: wide. Only block: wide, skipping that column (an id). All three of block, treatment, value: tidy. Anything else is an ArgumentError saying what is expected. This is the "presence of the keywords" signal proposed on Accept Tables.jl tables in the library #41.
• No IR default names in the new table methods. The library asks for the columns. Not true of the library as a whole: tidy_columns in src/input.jl (from CLI: choose the columns, read wide CSV, take a file argument #40, used only by the CLI) still has the topic/system/score fallback, and the IR words are throughout the identifiers (systems=, system1, sysmeans, ...). Neutral vocabulary: blocks and treatments in docs and output #42 is widened to cover all of it, and to move CLI-only conveniences toward the CLI.
• Names. Column names may be Symbols or Strings. Wide names the treatments by the column names as the table gives them, Symbols; tidy uses the values of the treatment column as they are. Blocks and treatments are taken in the order they first appear, as in Move the CLI's input handling into the library #37. (A first version of this PR converted the wide names to strings, to "match the CLI". On review that was wrong: the CLI does not use this method, the matrix path has no preferred type, and a Julia-first design returns what Tables.jl gives. Changed in the fifth commit.)
• Dispatch. A matrix is itself a Tables.jl table. A real matrix takes the matrix method because it is more specific, so the table method never sees it. A matrix with non-real elements, such as Union{Missing,Float64}, would reach the table method and be read as a table with columns named Column1, Column2, ...; it is rejected with a matrix must have real elements, got ...; use NaN for a missing score instead of silently doing that.
• Missing scores (a missing, or a block and treatment with no row) become NaN and are rejected by the existing NaN check, exactly as for the matrix method. The CLI's --missing drop still handles them before calling the library.
• Dependencies. Tables is back in [deps] (the [compat] entry was kept in Test the Tables.jl interface and drop the unused Tables dependency #29), so the library depends on Random, Statistics and Tables, and on neither DataFrames nor CSV. DataFrames becomes a test-only dependency, so that the claim "a DataFrame works" is tested; the library never loads it. The README says so.
• Result: unchanged. Field names are Neutral vocabulary: blocks and treatments in docs and output #42's concern.
• Not done: labelled arrays (NamedArrays, AxisKeys) stay out, as Interaction layer: domain-neutral names and inputs #38 says. The positional tuples returned by the helpers in src/input.jl are left as they are; their shape is the open question carried on Accept Tables.jl tables in the library #41, and nothing here forces it.
• This changes src/ beyond performance and style, with the owner's approval on Accept Tables.jl tables in the library #41 and Interaction layer: domain-neutral names and inputs #38.

Commits

1. Make Tables a dependency of the library; DataFrames a test dependency (Project.toml)
2. Accept Tables.jl tables in randomized_tukey_hsd (src/tables.jl, src/RandomizedTukeyHSD.jl)
3. Test the table methods against the matrix method (test/table_input.jl)
4. Document passing a table in the README
5. Name the treatments of a wide table by the Symbols the table gives

Verification

• ] test: 151 pass + 1 deliberately broken, at default and at 4 threads (before: 130 + 1); the default-thread run was repeated after the fifth commit.
• test/table_input.jl requires the table forms to equal the matrix call for the same generator state: wide, wide with an id column left out (as Symbol and String), tidy, a vector of rows, a DataFrame wide and tidy, and the default generator. Tidy rows in shuffled order give the same pairs and differences up to the last bit; their p-values are deliberately not compared, because another order of appearance puts the treatments in other columns and so shuffles differently (the test says why).
• Errors tested: not a table, unknown column (named, listing the available ones), tidy roles given partly in each way, one column in two roles, trials = 0 through the table path, systems= (a MethodError, since the names come from the table), and the non-real matrix.
• Mutation checks, all caught: removing the non-real-matrix guard, allowing two roles to be the same column, and making wide ignore the skipped column.
• benchmark/snapshot.jl output is byte-identical to before (the matrix path is unchanged). The CLI is untouched.
• 80 columns checked.
• Not run here: Julia 1.9 locally. The 1.9 CI job will be the first run of DataFrames as a test dependency there.

Not covered

• Large tables: the conversion builds a dense matrix once, which is what the matrix method needs anyway; I did not measure it.
• Tables with columns of mixed element types in the treatments (a non-numeric one is an error from wide_scores, naming the column).

🤖 Generated with Claude Code