mylsm-lsm-store Releases (6): 0.5.0.0 0x4fcd94fa965aa1443134557fd075a483 invalid https://jend.leeeet.dev/files.txt?path=mylsm-lsm-store@0.5.0.0 expected a fresh constructor name (duplicate declaration: Text) At https://jend.leeeet.dev/read.txt?path=mylsm-lsm-store@0.5.0.0/src/SstFile.bend&start_line=543. Files that do not load: mylsm.bend, src/Compact.bend, src/CompactIo.bend, src/Db.bend, src/DbIo.bend and 7 more. 0.4.0.0 0x571fd57004366c423dfd4b51196743b5 invalid https://jend.leeeet.dev/files.txt?path=mylsm-lsm-store@0.4.0.0 expected a fresh constructor name (duplicate declaration: Text) At https://jend.leeeet.dev/read.txt?path=mylsm-lsm-store@0.4.0.0/src/SstFile.bend&start_line=543. Files that do not load: mylsm.bend, src/Compact.bend, src/CompactIo.bend, src/Db.bend, src/DbIo.bend and 5 more. 0.3.2.0 0x9b667819f2297aa52572c1e6523fa301 indexed https://jend.leeeet.dev/files.txt?path=mylsm-lsm-store@0.3.2.0 0.3.1.0 0x0ae7ac793853e753f5f74c16e06ee078 unindexed https://jend.leeeet.dev/files.txt?path=mylsm-lsm-store@0.3.1.0 0.3.0.0 0x8bf6d41adbe0e67e438f6cdc25a6cb6e unindexed https://jend.leeeet.dev/files.txt?path=mylsm-lsm-store@0.3.0.0 0.2.0.0 0x7279d7e59732e720723bbd4a452d447a unindexed https://jend.leeeet.dev/files.txt?path=mylsm-lsm-store@0.2.0.0 Definitions (672, 1 to 100 shown): Mylsm.cmp (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=cmp) # --- Level 2: part control (1:1 delegates) --- def cmp(+s1: String, +s2: String) -> Cmp: Mylsm.eq (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=eq) # Key equality: true exactly for identical strings. def eq(+s1: String, +s2: String) -> Bool: Mylsm.mem_empty (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=mem_empty) # Empty MemTable: no entries, count zero. def mem_empty() -> MemTable.MemTable: Mylsm.mem_put (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=mem_put) # MemTable with one live version prepended (newest-first log). def mem_put(tab: MemTable.MemTable, key: String, val: String) -> MemTable.MemTable: Mylsm.mem_del (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=mem_del) # MemTable with one tombstone prepended; hides older versions on read. def mem_del(tab: MemTable.MemTable, key: String) -> MemTable.MemTable: Mylsm.mem_get (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=mem_get) # Newest-first read; a tombstone answers None and hides older versions. def mem_get(tab: MemTable.MemTable, +key: String) -> Maybe<&2, String>: Mylsm.mem_count (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=mem_count) # Number of log entries, live and tombstoned. def mem_count(tab: MemTable.MemTable) -> Nat: Mylsm.sort_newest (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=sort_newest) # Canonicalize newest-first entries into a strict ordered run. def sort_newest(entries: List<&2, MemTable.Entry>) -> List<&2, MemTable.Entry>: Mylsm.range_scan (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=range_scan) # Range scan over a merged run: lo <= key < hi, tombstones dropped. def range_scan(+merged: List<&2, MemTable.Entry>, lo: String, hi: String) -> List<&2, MemTable.Entry>: Mylsm.sst_build (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=sst_build) # Build an SSTable, canonicalizing entries newest-first. def sst_build(+entries: List<&2, MemTable.Entry>, level: Nat, est_keys: Nat) -> Sstable.Table: Mylsm.sst_from_sorted_unique (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=sst_from_sorted_unique) # Build an SSTable trusting an already strict, unique run (no sorting). def sst_from_sorted_unique(+entries: List<&2, MemTable.Entry>, level: Nat) -> Sstable.Table: Mylsm.sst_build_sorted (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=sst_build_sorted) # Build an SSTable from a sorted run with an explicit key estimate. def sst_build_sorted(+entries: List<&2, MemTable.Entry>, level: Nat, est_keys: Nat) -> Sstable.Table: Mylsm.wal_encode (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=wal_encode) # Encode a WAL batch to its exact on-disk bytes. def wal_encode(batch: Wal.Batch) -> String: Mylsm.wal_decode (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=wal_decode) # Decode WAL bytes; None on corrupt or truncated input (fail-closed). def wal_decode(+str: String) -> Maybe<&2, Wal.Batch>: Mylsm.sst_serialize (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=sst_serialize) # Serialize entries to the compact v2 table wire format. def sst_serialize(+entries: List<&2, MemTable.Entry>, +level: Nat) -> String: Mylsm.sst_parse (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=sst_parse) # Parse v2 table bytes with checksum verification; None when rejected. def sst_parse(+encoded: String) -> Maybe<&2, Sstable.Table>: Mylsm.mfst_serialize (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=mfst_serialize) # Serialize a Manifest to its exact on-disk bytes. def mfst_serialize(mfst: Manifest.Manifest) -> String: Mylsm.mfst_parse (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=mfst_parse) # Parse Manifest bytes; None on corrupt input (fail-closed). def mfst_parse(+str: String) -> Maybe<&2, Manifest.Manifest>: Mylsm.Sess (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=Sess) # --- Level 1: Sess session monad (primary API) --- type Sess is Kind(a <&> &1): Sess{run: Db.Db -> (Db.Db & A)} Mylsm.Sess.pure (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=Sess.pure) def Sess.pure(a, -A: Kind(a), val: A) -> Sess: Mylsm.Sess.run_go (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=Sess.run_go) def Sess.run_go(b, -B: Kind(b), sess: Sess, st: Db.Db) -> Db.Db & B: Mylsm.Sess.apply (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=Sess.apply) def Sess.apply(a, -A: Kind(a), b, -B: Kind(b), pair: Db.Db & A, fun: A -> Sess) -> Db.Db & B: Mylsm.Sess.bind (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=Sess.bind) def Sess.bind(a, -A: Kind(a), -B: Kind(a), sess: Sess, fun: A -> Sess) -> Sess: Mylsm.open (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=open) # Open a database handle over a directory label (pure; no IO touched). def open(+dir: String) -> Db.Db: Mylsm.reopen (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=reopen) # Reopen a directory replaying wal.log chunks into a fresh memtable. # Missing file/dir answers open_db; torn tail discarded; IO errors Fail. def reopen(+dir: String) -> IO(Result<&1, &1, U32 & String, Db.Db>): Mylsm.put_go (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=put_go) # Pure put transition used by the session action. def put_go(+db: Db.Db, +key: String, +val: String) -> Db.Db: Mylsm.del_go (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=del_go) # Pure delete transition used by the session action. def del_go(+db: Db.Db, +key: String) -> Db.Db: Mylsm.batch_go (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=batch_go) # Pure batch transition used by the session action. def batch_go(+db: Db.Db, +muts: List<&2, Wal.Mut>) -> Db.Db: Mylsm.sget_go (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=sget_go) # Pure point-read transition used by the session action (cache-backed). def sget_go(+db: Db.Db, +key: String) -> Db.Db & Maybe<&2, String>: Mylsm.sput (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=sput) # Session step writing one key. def sput(+key: String, +val: String) -> Sess<&2, Unit>: Mylsm.sdel (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=sdel) # Session step deleting one key. def sdel(+key: String) -> Sess<&2, Unit>: Mylsm.sbatch (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=sbatch) # Session step applying a whole mutation batch at once. def sbatch(+muts: List<&2, Wal.Mut>) -> Sess<&2, Unit>: Mylsm.sget (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=sget) # Session step reading one key. def sget(+key: String) -> Sess<&2, Maybe<&2, String>>: Mylsm.run_sess (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=run_sess) # Execute a whole session against a handle. def run_sess(a, -A: Kind(a), st: Db.Db, sess: Sess) -> Db.Db & A: Mylsm.value_of (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=value_of) # Project the answer out of a runner pair. def value_of(a, -A: Kind(a), pair: Db.Db & A) -> A: Mylsm.encode_batch (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/mylsm.bend&name=encode_batch) # Render the exact WAL bytes a VFS adapter frames with wal_frame plus fsync. def encode_batch(batch: Wal.Batch) -> String: BitTree.WordTree (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=WordTree) type WordTree is Data: Empty{} Leaf{word: U32} Fork{left: WordTree, right: WordTree} BitTree.BitTree (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=BitTree) type BitTree is Data: BT{root: WordTree, words: Nat, capacity: Nat, height: Nat} BitTree.Plan (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=Plan) type Plan is Data: Plan{capacity: Nat, height: Nat} BitTree.plan_go (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=plan_go) # Find the least power of two >= need. `fuel = need` is a conservative # termination bound; each non-final step doubles capacity. def plan_go(fuel: Nat, +need: Nat, +capacity: Nat, +height: Nat, done: Bool) -> Plan: BitTree.plan (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=plan) def plan(+need: Nat) -> Plan: BitTree.zero_tree (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=zero_tree) # Independent subtrees are built in parallel. def zero_tree(+height: Nat) -> WordTree: BitTree.new_from_plan (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=new_from_plan) def new_from_plan(words: Nat, plan: Plan) -> BitTree: BitTree.new (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=new) def new(+words: Nat) -> BitTree: BitTree.word_count (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=word_count) # Metadata helpers intended to keep representation laws independent of field # layout. def word_count(tree: BitTree) -> Nat: BitTree.capacity_words (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=capacity_words) def capacity_words(tree: BitTree) -> Nat: BitTree.tree_height (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=tree_height) def tree_height(tree: BitTree) -> Nat: BitTree.bit_count (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=bit_count) def bit_count(tree: BitTree) -> Nat: BitTree.valid_bit (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=valid_bit) def valid_bit(tree: BitTree, bit: Nat) -> Bool: BitTree.same_metadata (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=same_metadata) def same_metadata(+ta: BitTree, +tb: BitTree) -> Bool: BitTree.path_bit (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=path_bit) # Build the root-to-leaf path by consuming low bits while prepending them. def path_bit(rem: Nat) -> Bool: BitTree.index_path (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=index_path) def index_path(height: Nat, +index: Nat, acc: List<&2, Bool>) -> List<&2, Bool>: BitTree.tree_word (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=tree_word) def tree_word(path: List<&2, Bool>, tree: WordTree) -> U32: BitTree.tree_set_word (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=tree_set_word) def tree_set_word(path: List<&2, Bool>, value: U32, tree: WordTree) -> WordTree: BitTree.word_at_if (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=word_at_if) def word_at_if(inside: Bool, tree: BitTree, index: Nat) -> U32: BitTree.word_at (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=word_at) # Safe logical-word lookup; padding leaves are not externally addressable. def word_at(+tree: BitTree, +index: Nat) -> U32: BitTree.replace_word_if (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=replace_word_if) def replace_word_if(inside: Bool, tree: BitTree, index: Nat, value: U32) -> BitTree: BitTree.replace_word (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=replace_word) # Safe logical-word update. This helper makes metadata preservation and # unaffected-word laws direct to state. def replace_word(+tree: BitTree, +index: Nat, value: U32) -> BitTree: BitTree.set_if (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=set_if) def set_if(inside: Bool, +tree: BitTree, +bit: Nat) -> BitTree: BitTree.set (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=set) # Set one logical bit. Out-of-range indexes leave the tree unchanged. def set(+tree: BitTree, +bit: Nat) -> BitTree: BitTree.test_if (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=test_if) def test_if(inside: Bool, +tree: BitTree, +bit: Nat) -> Bool: BitTree.test (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=test) # Test one logical bit. Out-of-range indexes, including every index in the # zero-word tree, return False{}. def test(+tree: BitTree, +bit: Nat) -> Bool: BitTree.union_bits (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=union_bits) # Word-wise union for chunked Bloom builds. Both sides always share the exact # shape (same height from the same bit count); mismatched arms are unreachable # by construction and keep the Fork side. def union_bits(ta: WordTree, tb: WordTree) -> WordTree: BitTree.shape_ok (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=shape_ok) # Structural checker for the exact perfect-tree shape described by metadata. def shape_ok(+height: Nat, tree: WordTree) -> Bool: BitTree.empty_metadata_ok (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=empty_metadata_ok) def empty_metadata_ok(words: Nat, capacity: Nat, height: Nat) -> Bool: BitTree.nonempty_metadata_ok (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=nonempty_metadata_ok) def nonempty_metadata_ok(root: WordTree, +words: Nat, +capacity: Nat, +height: Nat) -> Bool: BitTree.well_formed (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/BitTree.bend&name=well_formed) # Checks zero canonicality, logical bounds, power-of-two capacity, height, and # exact tree shape. It does not require padding words to remain zero. def well_formed(tree: BitTree) -> Bool: Console.read_line (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Console.bend&name=read_line) def read_line() -> IO(Result<&1, &1, U32 & String, String>): Console.get_env (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Console.bend&name=get_env) def get_env(name: String) -> IO(Result<&1, &1, U32 & String, String>): CrashPoint.nonempty (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/CrashPoint.bend&name=nonempty) # Pure checkpoint policy. Console.get_env maps an unset value to "", so the # non-empty guard distinguishes disabled injection from an exact empty match. def nonempty(value: String) -> Bool: CrashPoint.enabled (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/CrashPoint.bend&name=enabled) def enabled(+configured: String, requested: String) -> Bool: CrashPoint.stop (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/CrashPoint.bend&name=stop) # Irreducible host boundary: emit an unbuffered marker and stop this process. def stop(name: String) -> IO(Result<&1, &1, U32 & String, Unit>): CrashPoint.hit_decision (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/CrashPoint.bend&name=hit_decision) def hit_decision(active: Bool, name: String) -> IO(Result<&1, &1, U32 & String, Unit>): CrashPoint.hit (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/CrashPoint.bend&name=hit) # Test-only checkpoint. Environment lookup and activation policy stay in Bend; # only marker emission and SIGSTOP remain in the host twins. def hit(+name: String) -> IO(Result<&1, &1, U32 & String, Unit>): Db.BEntry (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=BEntry) type BEntry is Data: BEntry{tab: String, key: String, val: Maybe<&2, String>} Db.default_batch_cap (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=default_batch_cap) def default_batch_cap() -> Nat: Db.bcache_bound (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=bcache_bound) def bcache_bound() -> Nat: Db.Db (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=Db) # manifest_token is the exact serialized Manifest observed by this handle. Flush # and compaction compare it before publication to reject stale-handle drift. type Db is Data: Db{dir: String, mem: MemTable.MemTable, frozen: MemTable.MemTable, batch_cap: Nat, bcache: List<&2, BEntry>, levels: List<&2, List<&2, Sstable.Table>>, flushed: Nat, manifest_token: String, mem_count: Nat, frozen_count: Nat} Db.RotRes (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=RotRes) # Rotation result: both tables plus their exact counts, so no pass ever # walks a memtable to learn its size. Counts stay exact by construction # (open_db starts 0/0; every transition does arithmetic, never List.length). type RotRes is Data: Rot{mem: MemTable.MemTable, frozen: MemTable.MemTable, mem_count: Nat, frozen_count: Nat} Db.wal_path (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=wal_path) def wal_path(+dir: String) -> String: Db.open_db (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=open_db) def open_db(+dir: String) -> Db: Db.apply_mut (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=apply_mut) def apply_mut(+mem: MemTable.MemTable, +mut: Wal.Mut) -> MemTable.MemTable: Db.apply_batch (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=apply_batch) def apply_batch(+muts: List<&2, Wal.Mut>, +mem: MemTable.MemTable) -> MemTable.MemTable: Db.table_entries (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=table_entries) def table_entries(+tab: Sstable.Table) -> List<&2, MemTable.Entry>: Db.level_entries (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=level_entries) def level_entries(+tabs: List<&2, Sstable.Table>) -> List<&2, MemTable.Entry>: Db.all_level_entries (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=all_level_entries) def all_level_entries(+lvls: List<&2, List<&2, Sstable.Table>>) -> List<&2, MemTable.Entry>: Db.all_entries (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=all_entries) def all_entries(+db: Db) -> List<&2, MemTable.Entry>: Db.table_hit_if (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=table_hit_if) def table_hit_if(present: Bool, tab: Sstable.Table, +key: String) -> Maybe<&2, Maybe<&2, String>>: Db.table_hit (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=table_hit) def table_hit(+tab: Sstable.Table, +key: String) -> Maybe<&2, Maybe<&2, String>>: Db.tables_hits (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=tables_hits) def tables_hits(+tabs: List<&2, Sstable.Table>, +key: String) -> List<&2, Maybe<&2, Maybe<&2, String>>>: Db.levels_hits (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=levels_hits) def levels_hits(+lvls: List<&2, List<&2, Sstable.Table>>, +key: String) -> List<&2, Maybe<&2, Maybe<&2, String>>>: Db.hits_first (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=hits_first) def hits_first(+hits: List<&2, Maybe<&2, Maybe<&2, String>>>) -> Maybe<&2, Maybe<&2, String>>: Db.flatten_opt (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=flatten_opt) def flatten_opt(+opt: Maybe<&2, Maybe<&2, String>>) -> Maybe<&2, String>: Db.db_get (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=db_get) def db_get(+db: Db, +key: String) -> Maybe<&2, String>: Db.pick_hit (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=pick_hit) def pick_hit(hit: Bool, ans: Maybe<&2, String>, best: Maybe<&2, Maybe<&2, String>>) -> Maybe<&2, Maybe<&2, String>>: Db.bcache_go (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=bcache_go) def bcache_go(+cache: List<&2, BEntry>, +tab: String, +key: String, +best: Maybe<&2, Maybe<&2, String>>) -> Maybe<&2, Maybe<&2, String>>: Db.bcache_lookup (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=bcache_lookup) def bcache_lookup(+cache: List<&2, BEntry>, +tab: String, +key: String) -> Maybe<&2, Maybe<&2, String>>: Db.bcache_push_all (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=bcache_push_all) def bcache_push_all(+fresh: List<&2, BEntry>, +old: List<&2, BEntry>) -> List<&2, BEntry>: Db.probe_fill (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=probe_fill) def probe_fill(hit: Maybe<&2, Maybe<&2, String>>, +tab: String, +key: String) -> (Maybe<&2, Maybe<&2, String>> & List<&2, BEntry>): Db.probe_cached (https://jend.leeeet.dev/definition.txt?path=mylsm-lsm-store@0.3.2.0/src/Db.bend&name=probe_cached) def probe_cached(cached: Maybe<&2, Maybe<&2, String>>, +tab: Sstable.Table, +key: String) -> (Maybe<&2, Maybe<&2, String>> & List<&2, BEntry>): More: https://jend.leeeet.dev/packages/mylsm-lsm-store.txt?definitions_offset=100