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
use Scored;
use crateScore;
// Data belonging to no family: not a record's address and not an index's, just a value. Holding it
// is what living at the seam layer MEANS, and it is what a re-narrowing to one engine's key type
// would take away.
//
// NOT `Copy`, which is the other half of what it stands for: a `String`-shaped key is a key, and it
// reaches every method here except the one that hands a copy back.
;
// A score shape implementing NOTHING — not `Copy`, not `PartialOrd`, not even `Debug`. Any bound
// added to `S` on the STRUCT makes this instantiation red, which is the no-bound rule stated as a
// type rather than as a sentence.
//
// Its payload is read below through `score_ref`: a shape with no capability at all is still one a
// caller can look at and take apart, which is what the borrow accessor and `into_components` are
// there for.
;
/// The two halves come back independently, and this hit's score is the machine-raw `f32` an engine
/// measured in: `12.5` is a distance, not a confidence, and nothing normalises it on the way
/// through.
///
/// The annotation is the other half of the assertion — the raw shape is SPELLED, because there is
/// no default left to carry it unsaid. `Scored<Anything>` is `E0107` here, which is the law: a hit
/// names its currency at every site that holds one, and `f32` is a backend's answer rather than the
/// family's.
/// The MARKED form: a hit whose SCORE TYPE states that something normalised it.
///
/// [`Score`] is the closed unit interval, so spelling it is the claim — and it is a different type
/// from the raw `f32` above, which is what makes fusing the two lists an explicit conversion rather
/// than an addition nobody notices.
/// The emitted accessor pair under this type's own names: the BORROW is always there, and the copy
/// sits beside it where the half is `Copy`.
///
/// Both halves are `Copy` here, so all four answer. `Anything` is not, and the tests either side of
/// this one reach it through `data_ref` alone — the gate is on the METHOD, so a shape that cannot
/// be copied loses one call rather than the type.
/// The score parameter carries no bound at all, so a shape implementing nothing instantiates it —
/// which is what keeps a fused rank, a tuple of sub-scores or a backend's own scale spellable here.
///
/// And a score that bare is not WRITE-ONLY: `score_ref` reads it back with nothing required of it,
/// and `into_components` hands over both halves without a clone. `matched` is the same statement
/// about the TYPE — naming `Scored<D, S>` in a signature needs nothing of either parameter.