[DRAFT] Make an interpreter for this abomination

.gitignore

@@ -0,0 +1,3 @@
+venv/
+*.pyc
+test/db/db/*.js

.pre-commit-config.yaml

@@ -0,0 +1,37 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-ast
+      - id: check-yaml
+      - id: check-toml
+      - id: check-merge-conflict
+      - id: mixed-line-ending
+      - id: check-case-conflict
+  - repo: https://github.com/hadialqattan/pycln
+    rev: v2.1.5
+    hooks:
+      - id: pycln
+        args: [--config=pyproject.toml, src]
+        types: [file]
+        types_or: [python, pyi]
+  - repo: https://github.com/psf/black
+    rev: 23.3.0
+    hooks:
+      - id: black
+        language_version: python3.11
+  - repo: https://github.com/pycqa/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort
+        name: isort (python)
+        args: ["--profile", "black", "--filter-files"]
+
+ci:
+  autofix_commit_msg: "[pre-commit.ci] auto fixes from pre-commit.com hooks"
+  autofix_prs: true
+  autoupdate_commit_msg: "[pre-commit.ci] pre-commit autoupdate"
+  autoupdate_schedule: weekly
+  submodules: false

README.md

@@ -426,6 +426,8 @@ import add!
 add(3, 2)!
 ```
 
+Note that due to the fact that it is impossible to export all functions of a file to all other DreamBerd files in existence, there is __no__ DreamBerd standard library.
+
 By the way, to see DreamBerd in action, check out [this page](https://github.com/TodePond/DreamBerd/blob/main/LICENSE.md).
 
 ## Classes

built/helper.tsx

@@ -0,0 +1,211 @@
+export class VarState {
+    name: string
+    variable: any;
+    allow_reassign: boolean;
+    priority: number;
+    history: Array<any>;
+    updateCount: number;
+    onUpdatePromises: Array<UpdatePromise>;
+    expiry: number
+
+    constructor(name, variable, allow_reassign, priority, lifetime=-1) {
+        this.name = name
+        this.variable = variable;
+        this.allow_reassign = allow_reassign;
+        this.priority = priority;
+        this.history = [undefined];
+        this.expiry = Infinity
+
+        // Lifetime will be left as default unless infinity or seconds
+        // Line-based lifetime will be done manually with kill()
+        if (lifetime != -1) {
+            if (lifetime === Infinity) {
+                localStorage.setItem(name, variable);
+                this.expiry = -1
+            }
+            else {
+                this.expiry = Date.now() + (1000 * lifetime)
+            }
+        }
+
+        this.updateCount = 0;
+        this.onUpdatePromises = [];
+    }
+
+    get() {
+        if (this.dead()) {
+            this.kill()            
+        }
+        return this.variable;
+    }
+
+    dead() {
+        return this.expiry !== -1 && Date.now() >= this.expiry
+    }
+
+    kill() {
+        this.history.push(this.variable)
+        this.variable = undefined        
+    }
+
+    assign(value, priority) {        
+        if (this.dead()) {
+            this.kill()
+        }
+        if (!this.allow_reassign || priority < this.priority) {
+            return false;
+        } else {
+            this.history.push(this.variable);
+            if (this.expiry == -1) {
+                localStorage.setItem(this.name, value);
+            }            
+            this.variable = value;
+            this.updateCount++;
+
+            // Check all `next` calls
+            const resolvedPromises: Array<UpdatePromise> = [];
+            for (const promise of this.onUpdatePromises) {
+                if (this.updateCount >= promise.targetCount) {
+                    promise.resolve(this.variable);
+                    resolvedPromises.push(promise);
+                }
+            }
+
+            for (const promise of resolvedPromises) {
+                const index = this.onUpdatePromises.indexOf(promise);
+                if (index !== -1) {
+                    this.onUpdatePromises.splice(index, 1);
+                }
+            }
+
+            return true;
+        }
+    }
+
+    previous(prev_iter = 1) {
+        if (prev_iter > this.history.length) {
+            console.log(`Soft Error: Attempting to access prehistoric value of ${this.name}.`)
+            return Math.random() * Number.MAX_VALUE // Approximation of unassigned memory
+        }
+        return this.history[this.history.length - prev_iter];
+    }
+
+    next(count: number): Promise<any> {
+        const targetCount = this.updateCount + count;
+
+        if (targetCount <= this.updateCount) {
+            console.log(`Variable already updated ${count} times. Current value: ${this.get()}`);
+            return Promise.resolve(this.get());
+        }
+
+        return new Promise((resolve) => {
+            const promise: UpdatePromise = {
+                targetCount: targetCount,
+                resolve: resolve,
+            };
+            this.onUpdatePromises.push(promise);
+        });
+    }
+}
+
+export interface UpdatePromise {
+    targetCount: number;
+    resolve: Function;
+}
+/// USED FOR WHEN BLOCKS
+class ConditionBlockPair {
+    condition: () => boolean;
+    codeBlock: () => void;
+
+    constructor(condition: () => boolean, codeBlock: () => void) {
+        this.condition = condition;
+        this.codeBlock = codeBlock;
+    }
+}
+
+// Define a class to manage the conditions and code blocks
+export class ConditionBlockManager {
+    pairs: ConditionBlockPair[];
+
+    constructor() {
+        this.pairs = [];
+    }
+
+    addPair(condition: () => boolean, codeBlock: () => void) {
+        const pair = new ConditionBlockPair(condition, codeBlock);
+        this.pairs.push(pair);
+    }
+
+    checkConditions() {
+        this.pairs = this.pairs.filter((pair) => {
+            if (pair.condition()) {
+                pair.codeBlock();
+                return false; // Remove the pair from the list
+            }
+            return true; // Keep the pair in the list
+        });
+      }
+
+    startCheckingRegularly(interval: number) {
+        setInterval(() => {
+        this.checkConditions();
+        }, interval);
+    }
+}
+
+export class Scope {
+    parent?: Scope
+    variables: Map<any, VarState>
+
+    constructor(parent=undefined) {
+        this.variables = new Map<any, VarState>;        
+        this.parent = parent
+    }
+    assign(name, value, allow_reassign, priority, lifetime=-1) {
+        const varState = this.variables.get(name);
+
+        if (varState !== undefined) {
+          // Update the existing object properties
+          varState.assign(value, priority);
+        }
+        else if (this.parent && this.parent.has_var(name)) {
+            // Only run if variable already exists
+            // RECUSRION RECUSRION RECUSRION RECUSRION RECUSRION RECUSRION RECUSRION RECUSRION RECUSRION 
+            this.parent.assign(name, value, allow_reassign, priority, lifetime)
+        } else {            
+            // Create a new object and store it in the map
+            this.variables.set(name, new VarState(name, value, allow_reassign, priority, lifetime));
+        }
+    }
+
+    has_var(name) {
+        if (this.variables.get(name) !== undefined) {
+            return true
+        }
+        else {
+            return this.parent && this.parent.has_var(name)
+        }
+    }
+
+    get_var(name) {
+        if (this.variables.get(name) !== undefined) {
+            return this.variables.get(name)!.get()
+        }        
+        else if (this.parent) {
+            return this.parent.get_var(name)
+        }
+        else { // Will only go here if this scope is an orphan
+            // Check for infinite lifetime variables
+            let local_var = localStorage.getItem(name)
+            if (local_var != null) {
+                return local_var;
+            }
+
+            // TODO: 3const server
+
+
+            // Return literal value only if all other possibilities are ruled out
+            return name
+        }
+    }
+}

pyproject.toml

@@ -0,0 +1,70 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "DreamBerd"
+version = "0.9.9.9.9.9.9.9.9d"
+description = "DreamBerd Compiler"
+readme = {file = "README.md", content-type = "text/markdown"}
+license = {file = "LICENSE"}
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 5 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Topic :: Utilities",
+    "Typing :: Typed",
+]
+keywords = ["dream", "berd", "dreamberd", "compiler"]
+dependencies = [
+    "requests~=2.31.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "mypy~=1.3.0",              # must match .pre-commit-config.yaml
+    "pre-commit",
+    "pre-commit-hooks~=4.4.0",  # must match .pre-commit-config.yaml
+    "black~=23.3.0",            # must match .pre-commit-config.yaml
+    "isort~=5.12.0",            # must match .pre-commit-config.yaml
+    "pycln~=2.1.3",             # must match .pre-commit-config.yaml
+]
+
+[project.urls]
+"Homepage" = "https://github.com/TodePond/DreamBerd"
+"Source" = "https://github.com/TodePond/DreamBerd"
+"Bug Tracker" = "https://github.com/TodePond/DreamBerd/issues"
+
+[tool.mypy]
+mypy_path = "src"
+check_untyped_defs = true
+disallow_any_generics = true
+disallow_untyped_calls = true
+disallow_untyped_defs = true
+ignore_missing_imports = true
+no_implicit_optional = true
+no_implicit_reexport = true
+show_column_numbers = true
+show_error_codes = true
+strict = true
+strict_equality = true
+warn_redundant_casts = true
+warn_return_any = true
+warn_unreachable = true
+warn_unused_configs = true
+warn_unused_ignores = true
+
+[tool.black]
+target-version = ['py311']
+
+[tool.isort]
+profile = "black"
+combine_as_imports = true
+line_length = 79
+skip = [".git", ".github", ".venv"]
+
+[tool.pycln]
+all = true
+disable_all_dunder_policy = true

src/README.md

@@ -0,0 +1,8 @@
+**Note:** This code is __under development__ and is not yet functional, let alone efficient.
+# Comp-Trans-Piler
+Running a perfect programming language requires a perfect compiler to run it. As such, the DreamBerd foundation has devised the next innovation in the field of compiling. The **Comp-Trans-Piler**.
+
+The Comp-Trans-Piler works by independently compiling DreamBerd while at the same time transpiling it to JavaScript, maximizing efficiency while staying true to DreamBerd.
+
+While the JavaScript compiler is extensive, it forgives barbaric practices such as loops, while at the same time lacking modern features such as Exact Equalities. As such DreamBerd first ensures that the code abides by the DreamBerd standard before passing it to lesser compilers.
+