1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
//! [`RoutedProbe`] — one dispatch: which lane, and what to ask it.
use crateLaneIdent;
/// **ONE DISPATCH** — a lane, and the probe to ask it with.
///
/// # A NAMED CARRIER rather than a tuple
///
/// `(LaneIdent, R)` would say the same thing and say it worse: which half is which is positional,
/// two of them cannot be told apart in a signature, and neither half can grow a name. This is the
/// same construction [`Ranked`](crate::Ranked) and [`Rooted`](crate::Rooted) already make one layer
/// over, and it is a SISTER of the expand step's own carrier — same law, different road, and neither
/// names the other.
///
/// # THE CONSUMPTION CONTRACT
///
/// A router answers a `Vec` of these, and every element of it is **one independent dispatch and one
/// ranked stream**. Three things follow, and all three are the ruling's own:
///
/// - **Several probes may name ONE lane.** The mechanism allows it — a router that wants a lane
/// asked twice with two probes gets two streams and the fold counts both. Whether that is wise is
/// the router's own discipline, and the shipped [`ScriptRouter`](super::ScriptRouter) exercises it
/// by MERGING the runs that land in one lane rather than emitting them separately.
/// - **The order does not enter the score.** Reciprocal rank fusion reads each stream's own
/// ordinals, so where a probe sat in the `Vec` is worth nothing — what it is worth is the STABLE
/// TIE ORDER, because the fold's sort is stable and equal scores come back in first-sighting
/// order.
/// - **Empty is the empty set.** No probes means no streams means an empty answer, which is a
/// result rather than a refusal.
///
/// # The four-piece vocabulary, in full
///
/// Both seats carry the consuming [`with_`](Self::with_lane) and the in-place [`set_`](Self::set_lane)
/// forms beside the accessors, because both are genuinely narrowable: a middleware wrapping a router
/// re-points a probe at another lane, and one rewriting the probe's text leaves the lane alone. That
/// is the difference from [`ScriptRun`](crate::ScriptRun), whose three seats are one fact and carry
/// no setters at all.
/// # NO [`Eq`] AND NO [`Hash`], and the weight is why
///
/// A `f64` has neither, and this row carries one. That is the same trade
/// [`Member`](crate::Member) and [`Route`](crate::Route) already take one layer over — the two other
/// weight-carrying rows in this crate — and it costs nothing a dispatch plan does: a plan is walked
/// in order, never keyed on.