<< lib/boolean/boolean-demo.sleela SLeeLa Standard Library Definition. Definition: Runnable demonstrator for the boolean package — a Return Value may plainly imply TRUE/FALSE, or it may imply a further relation. This program reconstructs, inline, the HEAD (result) + CARRY (caveat) reading of Boolean/Binary syllable words at depth 8, 16, and 32. >> #sleela 2.5 material; < SLeeLa boolean package demonstrator. > < A word is BOOLEAN..... The HEAD syllable is the RESULT; > < every trailing syllable is CARRY (a caveat structure) that must be observed > < or agree. BOOLEAN.TRUE.FALSE says: result is TRUE, but FALSE is carried as a > < caveat — a concern of carry that must be observed. The split per-class files > < (BooleanTrue, BooleanFalse, boolean/8, boolean/16, boolean/32) are the full > < vocabulary; this file is the one-shot runnable walkthrough. > class BooleanDemo { < ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- > << Eleven catalogued attributes with getter/setter pairs, so a GUI, loader, or catalog can read and (where appropriate) override this record. Values are faithful to the subject's real origin where publicly known. >> String metaVersion = "1.0.0"; int metaId = 10827; String metaAuthor = "Kiro Agent"; String metaDate = "2026-10-16"; String metaCopyright = "SLeeLa project"; String metaTrademark = "none"; String metaCorporation = "none"; < metaOrigin: National | | International | Galactic > String metaOrigin = "International"; String metaBirthDate = "2026-10-10"; < metaScienceRating: maturity/robustness on a 1..10 scale > int metaScienceRating = 9; < metaNationalSchedule: a real, citable instrument or "none" > String metaNationalSchedule = "none"; String getMetaVersion() { return metaVersion; } void setMetaVersion(String v) { metaVersion = v; } int getMetaId() { return metaId; } void setMetaId(int v) { metaId = v; } String getAuthor() { return metaAuthor; } void setAuthor(String v) { metaAuthor = v; } String getDate() { return metaDate; } void setDate(String v) { metaDate = v; } String getCopyright() { return metaCopyright; } void setCopyright(String v) { metaCopyright = v; } String getTrademark() { return metaTrademark; } void setTrademark(String v) { metaTrademark = v; } String getCorporation() { return metaCorporation; } void setCorporation(String v) { metaCorporation = v; } String getOrigin() { return metaOrigin; } void setOrigin(String v) { metaOrigin = v; } String getBirthDate() { return metaBirthDate; } void setBirthDate(String v) { metaBirthDate = v; } int getScienceRating() { return metaScienceRating; } void setScienceRating(int v) { metaScienceRating = v; } String getNationalSchedule() { return metaNationalSchedule; } void setNationalSchedule(String v) { metaNationalSchedule = v; } String intToStr(int v) { return "" + v; } < Render a word from its summary: head bit (1=TRUE,0=FALSE) and the counts of > < carried TRUE / carried FALSE syllables, exactly as BooleanWord16/32 model it. > String headSyllable(int headBit) { return headBit == 1 ? "TRUE" : "FALSE"; } boolean caveat(int carryFalse) { return carryFalse > 0; } < The headline reading: result + whether a carry caveat must be observed. > String reading(String name, int depth, int headBit, int carryTrue, int carryFalse) { String head = name + " (depth " + intToStr(depth) + "): result " + headSyllable(headBit); if (caveat(carryFalse)) { return head + ", CAVEAT — " + intToStr(carryFalse) + " FALSE carried (must be observed); " + intToStr(carryTrue) + " TRUE carried."; } return head + ", CLEAN — carry agrees (" + intToStr(carryTrue) + " TRUE carried)."; } void banner(String t) { print("================================================================"); print(" " + t); print("================================================================"); } void main() { banner("SLeeLa BOOLEAN syllable words: result + carry (caveat)"); < The two primitive syllables. > print(reading("BOOLEAN.TRUE", 1, 1, 0, 0)); print(reading("BOOLEAN.FALSE", 1, 0, 0, 0)); < The canonical two-syllable caveat: TRUE result, one FALSE carried. > < BOOLEAN.TRUE.FALSE -> result TRUE, caveat on the carry. > print(reading("BOOLEAN.TRUE.FALSE", 2, 1, 0, 1)); < Depth 8 (enumerated as Bool_TFFFFFFF): TRUE result, 7 FALSE carried. > print(reading("BOOLEAN.TRUE.FALSE.FALSE.FALSE.FALSE.FALSE.FALSE.FALSE", 8, 1, 0, 7)); < Depth 16 (BooleanWord16): TRUE result, 15 FALSE carried -> full caveat. > print(reading("boolean/16 TRUE+carry-FALSE", 16, 1, 0, 15)); < Depth 32 (BooleanWord32): all-TRUE -> clean, no caveat. > print(reading("boolean/32 all-TRUE", 32, 1, 31, 0)); banner("Done"); print("TRUE is the result; a carried FALSE is a caveat that must be observed."); } }