Orkuncakilkaya
71735b10a2
ludic.base's Queue<T> carries a QueueTag (its name and pending count): queue_new(name), q_push(q, v), q_drain(q), q_clear(q) take no BaseState, and core_undrained(tags) names the given queues still holding facts. A reducer on a package's state can now call that package's verbs (wallet_earn(wallet_st, n)). ludic migrate state --prune (ludicc --migrate-prune) takes out each state parameter a function no longer uses, nor anything it calls, and the argument that fills it - including an argument for a parameter the callee has dropped, which is taken out before the call is checked, so a generic's T is told by the argument that says it. A reducer keeps its state. --dry-run now counts the edits it would make. Every package was moved with it: 608 base_st parameters and their arguments, 1889 edits. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
75 lines
2.1 KiB
Text
75 lines
2.1 KiB
Text
# queue_test.ludic - Queue<T>: first in first out, drain empties, undrained queues are named.
|
|
# A generic call is not resolved inside a `test` body yet, so each case is a function.
|
|
import "ludic.base"
|
|
program QueueTest {
|
|
numbers float
|
|
property Caught { species: int = 0, weight: float = 0.0 }
|
|
|
|
function caught(sp: int, w: float) -> Caught {
|
|
let c = new Caught
|
|
c.species = sp
|
|
c.weight = w
|
|
return c
|
|
}
|
|
|
|
function fifo_case() -> void {
|
|
let q: Queue<int> = queue_new("ints")
|
|
q_push(q, 3)
|
|
q_push(q, 1)
|
|
q_push(q, 2)
|
|
expect_eq(q_len(q), 3)
|
|
let xs = q_drain(q)
|
|
expect_eq(len(xs), 3)
|
|
expect_eq(xs[0], 3)
|
|
expect_eq(xs[1], 1)
|
|
expect_eq(xs[2], 2)
|
|
expect_eq(q_len(q), 0)
|
|
expect_eq(len(q_drain(q)), 0)
|
|
}
|
|
|
|
function record_case() -> void {
|
|
let q: Queue<Caught> = queue_new("caught")
|
|
q_push(q, caught(2, 1.5))
|
|
q_push(q, caught(4, 0.25))
|
|
let cs = q_drain(q)
|
|
expect_eq(cs[1].species, 4)
|
|
expect(cs[0].weight == 1.5)
|
|
}
|
|
|
|
function clear_case() -> void {
|
|
let q: Queue<string> = queue_new("words")
|
|
q_push(q, "a")
|
|
q_clear(q)
|
|
expect_eq(q_len(q), 0)
|
|
}
|
|
|
|
# nothing but the queue says what T is: a drain and a clear still know it
|
|
function infer_case() -> void {
|
|
let q: Queue<Caught> = queue_new("told")
|
|
q_push(q, caught(1, 2.0))
|
|
expect_eq(q_drain(q)[0].species, 1)
|
|
q_push(q, caught(3, 1.0))
|
|
q_clear(q)
|
|
expect_eq(q_len(q), 0)
|
|
}
|
|
|
|
function undrained_case() -> void {
|
|
let a: Queue<int> = queue_new("left_behind")
|
|
let b: Queue<int> = queue_new("read")
|
|
q_push(a, 1)
|
|
q_push(b, 2)
|
|
q_drain(b)
|
|
let tags = [q_tag(a), q_tag(b)]
|
|
let names = core_undrained(tags)
|
|
expect_eq(len(names), 1)
|
|
expect(names[0] == "left_behind")
|
|
q_drain(a)
|
|
expect_eq(len(core_undrained(tags)), 0)
|
|
}
|
|
|
|
test "a queue drains in the order it was pushed" () { fifo_case() }
|
|
test "a queue holds records" () { record_case() }
|
|
test "clear drops what is waiting" () { clear_case() }
|
|
test "a queue's element type is told by the queue alone" () { infer_case() }
|
|
test "the undrained queues are named, and a drain clears the report" () { undrained_case() }
|
|
}
|