[myzie]

What changes for the user

Check keeps the element type of a list when an empty list [] is the fallback. xs || [], if(c, xs, []) and a host function such as coalesce(xs, []) now type as list<T>, not list<any>. So a misspelled field on an item is reported, not left for Run to fail on.

See it

any(xn || [], it.nope == 1)
    before: passes Check, fails in Run: key "nope" not found
    after:  `it.nope`: no field "nope" in {a: number}

Why

[] is the usual fallback for a list that may be nil. The workflow library's random-definition soundness test (deepnoodle-ai/workflow, soundness_fuzz_test.go) found definitions that passed Check and then failed in Run, all through this join.

Decisions to check

• An empty list literal has its own element type, which takes the other side's type only when two lists are joined. Reason: a list with no elements fits every element type. Where the element escapes as a value, as in first([]), it is unchecked, like Any, and it still prints as list<any>. Rejected: absorbing it in every Join. Then first([]) typed as a value that is never nil. Rejected: typing [] as list<never> with a new exported kind. That adds public API for one case.
• Only the literal [], not every list<any>. A list<any> from an untyped value may hold anything. Joining it to list<T> must stay list<any>.

How to verify

go test ./...

TestCheckMatchesRun has the new cases. Three rejects are checked against Run failing. Four accepts are checked against Run succeeding, including if(c, first([]), "s") == 1 from the review. The workflow library's random-definition test passes 30,000 definitions against this branch.

Risk and rollout

• Behavior change: expressions that passed Check may now be rejected, but only where Run could fail on a missing field.
• No API change.
• After merge, tag v1.3.2. Workflow then moves to it and unskips TestEmptyListFallbackKeepsItemType.

🤖 Generated with Claude Code

[mobiusops]

Approve: The empty-list join is sound on the paths I traced, and the one gap I found is narrow enough to fix after merge.

This is the join side of the empty-list fallback that the workflow fuzz test found. I read Join, the ||, ??, if, and list-literal paths, and the builtins that return an element type.

Should fix

S1. first([]) and find([]) drop the nil from the element type (types.go:89)
OrNil returns an empty-list element unchanged, because isAny() is true for it. So first([]) and find([], ...) type as a non-nil empty (check.go:735, check.go:1006). Joined with a string, if(c, first([]), "s") == 1 is rejected as "never true", but Run returns false with no error when c is true. Only a literal [] passed straight into first, last, or find hits this. Fix: in OrNil, return Any when t == empty, so the element of a literal empty list reads as unknown.

Prompt for your AI tool: fix S1

Fix this review finding in deepnoodle-ai/expr, PR #31.

1. S1, types.go, func OrNil: OrNil returns an empty-list element type
   unchanged, because isAny() is true for it. So first([]), last([]) and
   find([], ...) (check.go elemOrNil and the find case) type as a non-nil
   empty type. Joined with a string, `if(c, first([]), "s") == 1` is
   rejected as "never true", but Run returns false with no error. Wanted:
   OrNil returns Any when t == empty, so the element of a literal empty
   list reads as unknown. Test: add `if(c, first([]), "s") == 1` to the
   accept cases in TestCheckMatchesRun, and check that it passes.

Run the existing tests after the changes.

[myzie]

S1. first([]) and find([]) drop the nil from the element type

Fixed in 03762e9. The empty-list element now takes the other side's type only when two lists are joined. Anywhere else it is unchecked, like Any. That covers first, last, find and indexing, not only OrNil. if(c, first([]), "s") == 1 and if(c, "s", find([], it > 1)) == 1 are new accept cases, and Run returns no error on either. The workflow library's concat function type now joins lists for the same reason (deepnoodle-ai/workflow 7da76b1).

🤖 Generated with Claude Code

[mobiusops]

Approve. Re-reviewed the new commit 03762e9 on top of the approved 25be60a.

S1 is resolved. The earlier finding was that first([]) and find([]) kept a non-nil empty type, so if(c, first([]), "s") == 1 was rejected even though it can be true at run time. This commit makes a bare empty join to Any (Join checks isAny() before the list case), so that expression now passes. The new TestCheckMatchesRun cases lock it in. The fix is not the OrNil change suggested in S1, but it reaches the same result. I did not change OrNil.

Checked the new join path:

• Join(list<empty>, list<T>) keeps T.
• Join(list<empty>, list<any>) gives any, so untyped lists stay permissive.
• Join(list<empty>, list<empty>) stays empty and still prints as list<any>.
• The list-literal path (check.go:770) is unchanged.

No blocking findings. Tests, builds and linters were not run, per the review rules.

[mobiusops]

S1: resolved. I confirmed this at 03762e9 in the approved review.

A bare empty now joins to Any in Join (types.go, the isAny() check runs before the list case). That covers first, last, find, and indexing, since they return empty through OrNil and then join like any other value. The new accept cases in TestCheckMatchesRun cover the first and find forms. I didn't trace the concat change in deepnoodle-ai/workflow, since it is outside this PR.

No new findings and no new review. The approval at 03762e9 stands.