:sparkles: (Janet) initial chapters

Janet/.envrc

···
+use flake

Janet/chapter2/example.janet

···
+(def skadi @{:name "Skadi" :type "German Shepherd"})
+(def odin @{:name "Odin" :type "German Shepherd"})
+
+(def people
+    [{:name "ian" :dogs [skadi odin]}
+        {:name "kelsey" :dogs [skadi odin]}
+        {:name "jeffrey" :dogs []}])
+
+(pp people)
+
+(defn main[&]
+    (set (odin :type)
+        "Well mostly German Shepherd but he's mixed with some")
+    (pp people))

Janet/chapter2/shader-example.janet

···
+(def gamma-shader (slurp "gamma.fs"))
+
+(defn main[&]
+    (print gamma-shader))

Janet/chapter3/macro-example.janet

···
+(use ./set-x-verbose)
+
+(defn main [&]
+    (set-x
+        (var sum 0)
+        (for i 0 10
+            (+= sum i))
+        (print sum)))
+
+(print)
+(print "and this is what main looks like:")
+(print)
+(pp (disasm main))

Janet/chapter3/meta.janet

···
+(defn sequence [& fs]
+    (fn [&]
+        (each f fs
+            (f))))
+
+(defn first-word []
+    (prin "hello"))
+
+(defn space []
+    (prin " "))
+
+(defn second-word []
+    (prin "world"))
+
+(defn newline []
+    (print))
+
+(def main
+    (sequence first-word space second-word newline))

Janet/chapter3/querify.janet

···
+(import sqlite3)
+
+(defmacro querify [schema-file]
+    ~(defn ,(symbol table-name) [conn]
+        (sqlite3/eval conn ,(string/format "select * from %s;" table-name)))
+
+    (def conn (sqlite3/open ":memory:"))
+    (sqlite3/eval conn (string (slurp schema-file)))
+    (def tables
+        (->> (sqlite3/eval conn "select name from sqlite_schema where type = 'table';")
+            (map |($ :name))
+            (filter |(not (string/has-prefix? "sqlite_" $)))))
+    (sqlite3/close conn)
+
+    ~(upscope
+        ,;(map table-definition tables)))
+
+(querify "schema.sql")
+
+(defn main [&]
+    (def conn (sqlite3/open "db.sqlite"))
+    (pp (people conn))
+    (pp (grudges conn)))

Janet/chapter3/schema.sql

···
+create table people (id integer primary key, name text not null);
+
+create table grudges (
+    id integer primary key,
+    holder integer not null,
+    against integer not null,
+    reason text not null,
+    foreign key (holder) references people (id),
+    foreign key (against) references people (id)
+);

Janet/chapter3/set-x-macro.janet

···
+(defmacro set-x [& expressions]
+    ~(upscope
+        ,;(mapcat (fn [expression]
+            [~(print ,(string/format "about to execute %q" expression))
+                expression])
+        expressions)))

Janet/chapter3/set-x-verbose.janet

···
+(defmacro set-x [& expressions]
+    (print "expanding the set-x macro")
+    (printf "  here are my arguments: %q" expressions)
+    (def result ~(upscope
+        ,;(mapcat (fn [expression]
+            [~(print ,(string/format "about to execute %q" expression))
+                expression])
+        expressions)))
+    (printf "   and i'm going to return: %q" result)
+    result)

Janet/chapter3/set-x.janet

···
+(defn set-x [& expressions]
+    ~(upscope
+        ,;(mapcat (fn [expression]
+            [~(print ,(string/format "about to execute %q" expression))
+                expression])
+        expressions)))

Janet/flake.lock

···
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1747790854,
+        "narHash": "sha256-8TpwOtr0T016HNlVuDcDNq4q+GMKfLStOSwdabrz+rk=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "f0d925b947cca0bbe7f2d25115cbaf021844aba7",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

Janet/flake.nix

···
+{
+  description = "A Nix-flake-based Janet development environment";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
+
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { self, nixpkgs, flake-utils }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        inherit (pkgs.lib) optional optionals;
+
+        pkgs = import nixpkgs { inherit system; };
+      in
+        {
+          devShells.default = pkgs.mkShell {
+            buildInputs = with pkgs; [
+              janet
+              sqlite
+            ];
+          };
+        }
+    );
+}