lernie 0.1.99

lernie: the operator seat — the window and wire client for a yog server
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

//! **What the window holds between frames**, and the one door a reply comes in
//! through.
//!
//! This file is the module list and the re-export surface; the struct itself
//! is [`held`], split out at the 300-line cap on the one seam left here. The
//! two change for different reasons: a pane that learns to hold something
//! grows the struct, and a pane that learns to DO something grows the list.
//!
//! Nothing here paints and nothing here dials. It is the snapshot a frame reads
//! and the rules for changing it, so every one of them is a pure function a
//! test reads back as a value.
//!
//! **[`Model::absorb`] is the single door, and it drops nothing.** A frame that
//! arrives is either content this build paints or a [`Notice`] the shell paints
//! *where that content would have been* — which is the reply vocabulary's own
//! policy (`crate::reply`, rung 2) honoured on the screen rather than only in
//! the type: a refusal and an unreadable frame are both visible rows, and
//! neither is a silent drop.

/// The one door a reply comes in through, and the leg that brought none.
mod absorb;
/// What a control does, whichever control did it.
mod acts;
/// Which wall the window is aimed at, and the two questions asked of a name.
mod aim;
/// The ball pane between frames: the boards, the bindings, and the wall's own.
mod board;
/// What a channel is, and what a gesture aimed down one must be addressed as.
mod channel;
/// The claim a start leaves on the selection, and the row it stands in for.
mod claim;
/// The clients pane between frames: whether it is open, and what it filed.
mod clients;
/// The config pane between frames: which file it is pointed at.
mod config;
/// The deeper records between frames: the one read the pane posts.
mod deep;
/// The doctor pane between frames: open or not, and each channel's checks.
mod doctor;
/// A selector's dropup on the rule: which is open and whether it reloaded.
mod dropup;
/// **The accordion**: which engine is open, and how the rest are ordered.
mod engines;
/// An enrollment, between the control that opened it and the symbol it ends at.
mod enroll;
/// Which composer box a row menu's navigation asked for the cursor in.
mod fill;
/// The fleet pane between frames: three words, five acts and two reads.
mod fleet;
/// One engine, every name it is held under: the roster folded by address.
mod fold;
/// A selection the engine no longer knows, and what retires it.
mod gone;
/// **What the window holds between frames** — the struct itself.
mod held;
/// The three panes that are pure listings, and the field that says which is up.
mod listing;
/// The login pane between frames: what it asks about, and the acts it spends.
mod login;
/// What the seat last heard that was not content, and how the shell says it.
mod notice;
/// What a frame composed, and what a lost reply would mean for it.
mod posted;
/// The prices pane between frames: each channel's table and the acts' draft.
pub(crate) mod pricing;
/// The decision queue between frames: what is asking, and the acts on a row.
mod queue;
/// The records pane between frames: open or not, and what its two reads filed.
mod records;
/// What this seat sent and has not yet seen come back as the engine's row.
mod sent;
/// The spine's own state: the draft a fork is composed from.
mod spine;
/// A start, between its two acts.
mod start;
/// What hangs under a conversation, and whether it is on the glass.
mod subtree;
/// Which conversations are open as tabs, and what opens and closes one.
mod tabs;
/// The trail pane between frames: open or not, and what each channel has done.
mod trail;
/// The tuning pane between frames, and the four acts its controls spend.
mod tuning;
/// An unmaking between frames: its subject, its arming, and whether it is asked.
mod unmake;
/// The window's own two panes: the engines' verb table, and what a needle found.
mod window;

pub use aim::{Aim, Stand};
pub use board::block::Authoring;
pub use board::{Bindings, Columns};
pub use channel::{Channel, Chunk, Held, UNHELD};
pub use config::{Configuring, Proposing};
pub use doctor::Diagnosis;
pub(crate) use dropup::choices::lane;
pub use dropup::{Choice, Dropup, Pick, Reload, Selector, WORKER};
pub use engines::Engines;
pub use enroll::{Enrolling, Grade, Shown};
pub use fill::Fill;
pub use fleet::{Armed, Fleet};
pub use fold::Engine;
pub use held::Model;
pub use listing::Listing;
pub use login::Login;
pub use notice::{CONFIG_DOOR, Notice};
pub use posted::Posted;
pub use pricing::{Pricing, Table as PriceTable};
pub use queue::{Asking, Section};
pub use records::Records;
pub use sent::Sent;
pub use spine::Forking;
pub use start::{Phase, Spread, Start};
pub use tabs::Tab;
pub use trail::Trail;
pub use tuning::{Edit, Tuning};
pub use unmake::Unmaking;
pub use window::{Hits, Lookup, Pages};

#[cfg(test)]
mod tests;