meta.language.types.tuples

Parentheses always denote a tuple, including () and a single element with or without a trailing comma. (T) is distinct from T when result types are compared for an override.

Read in specification context · design/meta/language.md

Tests and review

Indexed tests and the implementation-completeness and test-adequacy review; no test run is implied.

Implemented sage_meta::parentheses_always_denote_tuples

crates/sage-meta/tests/value_types.rs · test:value_types

#![allow(unused)]
fn main() {
#[test]
#[sage::test(meta.language.types.tuples)]
fn parentheses_always_denote_tuples() {
    let document =
        parse_body("struct Tuples { zero: (), one: (bool), comma: (bool,), two: (bool, u32) }")
            .unwrap();
    let Declaration::Type(tuples) = &document.declarations[0] else {
        panic!("expected a value declaration")
    };
    let TypeShape::Struct(fields) = &tuples.shape else {
        panic!("expected a struct")
    };
    for (field, arity) in fields.iter().zip([0, 1, 1, 2]) {
        assert!(matches!(&field.ty.kind, TypeExprKind::Tuple(elements) if elements.len() == arity));
    }
    let errors = check(
        r#"class Base { """Base.""" fn value() -> bool { """Get.""" envelope {} } }
        class Child extends crate::Base { """Child."""
            override fn value() -> (bool) { """Get.""" envelope {} }
        }"#,
    );
    assert_eq!(errors.len(), 1, "{errors:?}");
    assert!(
        errors[0]
            .message
            .contains("preserve method kind and result type")
    );
}
}

See more source ↗

Review: Accepted · Codex /root/anchor_219.

Reviewed the complete claim, both ordinary implementation entries (parser and validate), and the sole ordinary test parentheses_always_denote_tuples; no TODO/N/A entries or prerequisites exist. Parser::type_expr unconditionally constructs Tuple on an opening parenthesis, and type_list accepts empty, singleton with or without comma, and multiple elements. The test parses (), (bool), (bool,), and (bool, u32), and asserts Tuple variants with arities 0, 1, 1, 2. The captured parse_body/check helpers invoke the actual parser and validator. resolve_type recursively preserves tuple parentheses in canonical spelling while named types have distinct canonical names; override comparison uses those resolved results. The same test changes a base bool result to (bool) in its override and asserts exactly one result-signature diagnostic, directly detecting accidental singleton grouping. These assertions and source paths account for every claim aspect. Baseline verification independently found parser.rs, validate.rs, and value_types.rs exactly match historical source snapshots; the earlier rationale remains supported by current captured evidence, not merely its approval. Execution: ran review start and review read and performed exact baseline comparisons; no behavioral tests or workspace build were run by this reviewer. The coordinator separately reports 321 functional sage-meta tests and root cargo build passing. No source edits or further dependencies are needed.

Browse meta anchors

116 anchors

Anchor Implementation Tests

meta (116) 102 Implemented24 TODO 103 Implemented36 TODO

meta.anchors (22) 22 Implemented 21 Implemented12 TODO

anchor_pages Implemented ImplementedTODO

Every specification anchor has a stable page identifying the rule and showing its definition, context, implementation entries, and tests/evidence. The page includes Rust excerpts and access to surrounding source, and exposes each entry’s placeholder status and explanation. Multiple sites remain individually inspectable rather than being reduced to a single coverage badge.

Symposiun AGentic Environment (SAGE)

meta.language.types.tuples

Implementation

Tests and review