mylsm.bend source

mylsm.bend on the hub · documented module

import Baseimport ./src/Keys.bend as Keysimport ./src/MemTable.bend as MemTableimport ./src/SortedRun.bend as SortedRunimport ./src/Sstable.bend as Sstableimport ./src/SstFile.bend as SstFileimport ./src/Wal.bend as Walimport ./src/Manifest.bend as Manifestimport ./src/MergeIter.bend as MergeIterimport ./src/Db.bend as Db# --- Level 2: part control (1:1 delegates) ---def cmp(+a: String, +b: String) -> Cmp:  Keys.cmp(a, b)def eq(+a: String, +b: String) -> Bool:  Keys.eq(a, b)def mem_empty() -> MemTable.MemTable:  MemTable.empty()def mem_put(t: MemTable.MemTable, k: String, v: String) -> MemTable.MemTable:  MemTable.put(t, k, v)def mem_del(t: MemTable.MemTable, k: String) -> MemTable.MemTable:  MemTable.del(t, k)def mem_get(t: MemTable.MemTable, +k: String) -> Maybe<&2, String>:  MemTable.get(t, k)def mem_count(t: MemTable.MemTable) -> Nat:  MemTable.count(t)def sort_newest(entries: List<&2, MemTable.Entry>) -> List<&2, MemTable.Entry>:  SortedRun.sort_newest(entries)def range_scan(+merged: List<&2, MemTable.Entry>, lo: String, hi: String) -> List<&2, MemTable.Entry>:  MergeIter.scan(merged, lo, hi)def sst_build(+entries: List<&2, MemTable.Entry>, level: Nat, est_keys: Nat) -> Sstable.Table:  Sstable.build(entries, level, est_keys)def sst_from_sorted_unique(+entries: List<&2, MemTable.Entry>, level: Nat) -> Sstable.Table:  Sstable.from_sorted_unique(entries, level)def sst_build_sorted(+entries: List<&2, MemTable.Entry>, level: Nat, est_keys: Nat) -> Sstable.Table:  Sstable.build_sorted(entries, level, est_keys)def wal_encode(b: Wal.Batch) -> String:  Wal.encode(b)def wal_decode(+s: String) -> Maybe<&2, Wal.Batch>:  Wal.decode(s)def sst_serialize(+entries: List<&2, MemTable.Entry>, +level: Nat) -> String:  SstFile.serialize(entries, level)def sst_parse(+encoded: String) -> Maybe<&2, Sstable.Table>:  SstFile.parse(encoded)def mfst_serialize(m: Manifest.Manifest) -> String:  Manifest.serialize(m)def mfst_parse(+s: String) -> Maybe<&2, Manifest.Manifest>:  Manifest.parse(s)# --- Level 1: Sess session monad (primary API) ---type Sess<a, -A: Kind(a)> is Kind(a <&> &1):  Sess{run: Db.Db -> (Db.Db & A)}def Sess.pure(a, -A: Kind(a), x: A) -> Sess<a, A>:  Sess{db => (db, x)}def Sess.run_go(b, -B: Kind(b), s: Sess<b, B>, st: Db.Db) -> Db.Db & B:  match s:    case Sess{run}: run(st)def Sess.apply(a, -A: Kind(a), b, -B: Kind(b), p: Db.Db & A, f: A -> Sess<b, B>) -> Db.Db & B:  match p:    case (st, x): Sess.run_go(b, B, f(x), st)def Sess.bind(a, -A: Kind(a), -B: Kind(a), m: Sess<a, A>, f: A -> Sess<a, B>) -> Sess<a, B>:  Sess{st => Sess.apply(a, A, a, B, Sess.run_go(a, A, m, st), f)}def open(+dir: String) -> Db.Db:  Db.open_db(dir)def put_go(+db: Db.Db, +k: String, +v: String) -> Db.Db:  match db:    case Db.Db{dir, mem, levels, flushed, manifest_token}:      Db.Db{dir, Db.apply_batch(Con{Wal.Put{k, v}, Nil{}}, mem), levels, flushed, manifest_token}def del_go(+db: Db.Db, +k: String) -> Db.Db:  match db:    case Db.Db{dir, mem, levels, flushed, manifest_token}:      Db.Db{dir, Db.apply_batch(Con{Wal.Del{k}, Nil{}}, mem), levels, flushed, manifest_token}def batch_go(+db: Db.Db, +muts: List<&2, Wal.Mut>) -> Db.Db:  match db:    case Db.Db{dir, mem, levels, flushed, manifest_token}:      Db.Db{dir, Db.apply_batch(muts, mem), levels, flushed, manifest_token}def sget_go(+db: Db.Db, +k: String) -> Db.Db & Maybe<&2, String>:  (db, Db.db_get(db, k))def sput(+k: String, +v: String) -> Sess<&2, Unit>:  Sess{db => (put_go(db, k, v), Unit{})}def sdel(+k: String) -> Sess<&2, Unit>:  Sess{db => (del_go(db, k), Unit{})}def sbatch(+muts: List<&2, Wal.Mut>) -> Sess<&2, Unit>:  Sess{db => (batch_go(db, muts), Unit{})}def sget(+k: String) -> Sess<&2, Maybe<&2, String>>:  Sess{db => sget_go(db, k)}def run_sess(a, -A: Kind(a), st: Db.Db, s: Sess<a, A>) -> Db.Db & A:  Sess.run_go(a, A, s, st)def value_of(a, -A: Kind(a), p: Db.Db & A) -> A:  match p:    case (db, x): xdef encode_batch(b: Wal.Batch) -> String:  Wal.encode(b)