Discussion
Continuing where I left off yesterday, I've got some dependency reworking to do, then a bunch of Fennel.
The great thing about that is that I can do most of it in a REPL, without embedding it first. I'll make (package) emit a table, rather than a derivation, and then it needs nothing from the rust side.
Well, it would need hash calculation, but that's the easy part, and I can ignore it while I figure out the rest.
Like, with tulisp, my Rust-side functions can have access to the interpreter context, and that'd make my life so much easier in some cases!
So, next steps:
Not necessarily in that order.
Also, another insight that came to me during a dream: (package) can yield a list of derivations, not just one. It can yield all the derivations it uses.
That way, I can have any number of packages in a file, and only those will be evaluated that the running action needs.
Regarding tulisp, I can have plist arguments at the end of a function call, so I can't have stuff like (package :name 'dinit :version '0.22.1 ...), unless I make it a macro or something, and walk the args myself. Which I might need to do anyway.
Also, I can't seem to be able to (defun) plist-accepting functions from the tulisp side, only from the Rust side. In this case, that's fine.
What if...?
(define-package
(package :name "dinit" :version "0.22.1")
(source :url (github :owner "davmac314")
:hash (blake3 "0e50739814471c6fbad61ee8a03ecc75c6e674825f9f83ac0683df015f9bd440"))
(builder
(configure :syscontrolsocket "/run/dinitctrl"
:enable-shutdown true)))
(define-package) would be a macro here, that threads a derivation builder through the functions. Essentially, (-> (derivation-builder-default) ,@rest) or something along those lines.
(define-package
(package :name "dinit" :version "0.22.1")
(source :url (github :owner "davmac314")
:hash (blake3 "0e50739814471c6fbad61ee8a03ecc75c6e674825f9f83ac0683df015f9bd440"))
(builder
(configure :syscontrolsocket "/run/dinitctrl"
:enable-shutdown true)))
->
cargo run -q --bin tulisp -- tmp/fuck.lisp
(:name "dinit" :version "0.22.1" :source "https://github.com/davmac314/dinit/archive/refs/tags/v0.22.1.tar.gz")
Progress.
Well, it's not quite ok, as in, the state is currently a plist, and a plist can have the same key multiple times, and plist-get will return the first... but I can fix that.
And if I provide a proper derivation builder, it gets easier.
Oooh. I don't even need that! There's (make-hash-table)! The state don't have to be a plist!
I can also make the (package ...), (source ...), etc forms only valid within (define-package), but... not sure I want to. I might, but not sure yet.
Break time, gotta do some math with the twins, then it's more lisp.
❯ cargo run -q --bin tulisp -- tmp/pkg.lisp
(:name "dinit" :version "0.22.1" :source (:fetcher ("/sickos/support/fuck-support" "fetch" "http") :url "https://github.com/davmac314/dinit/archive/refs/tags/v0.22.1.tar.gz" :hash (:algo "blake3" :hash "0e50739814471c6fbad61ee8a03ecc75c6e674825f9f83ac0683df015f9bd440")))
Getting there. The code is rather ugly, though, because I'm messing with hash tables. If I had a DerivationBuilder or similar, that'd help a ton.
So maybe I'll do that next.
Now, this is a part where Fennel would be superior, because that's a much more complete language, with tables and stuff.
So... lets do an experiment! Lets see if I can make the same syntax work with Fennel, producing an output the Rust side can then work with.
fml, macros are hard.
(let [pkg (define-package
(package {:name "dinit" :version "0.22.1"})
(source {:url (github {:owner "davmac314"})
:hash (blake3 "0e50739814471c6fbad61ee8a03ecc75c6e674825f9f83ac0683df015f9bd440")})
)]
(print (fennel.view pkg)))
->
{:name
"dinit"
:source
{:fetcher
["/sickos/support/fuck-support" "fetch" "http"]
:hash
{:algo "blake3"
:hash "0e50739814471c6fbad61ee8a03ecc75c6e674825f9f83ac0683df015f9bd440"}
:url
"https://github.com/davmac314/dinit/archive/refs/tags/v0.22.1"}
:version
"0.22.1"}
Nice, nice. Looks like I will be going with Fennel, because this code is much nicer. Not perfect yet, but... we're getting there.
(let [pkg (define-package
(package {:name "dinit" :version "0.22.1"})
(source {:url (github {:owner "davmac314"})
:hash (blake3 "0e50739814471c6fbad61ee8a03ecc75c6e674825f9f83ac0683df015f9bd440")})
(builder
(configure {:syscontrolsocket "/run/dinitctrl"
:enable-shutdown true})))]
(print (fennel.view pkg)))
->
{:builder
{:command ["/sickos/support/fuck-support" "builder" "autotools"]
:configure {:enable-shutdown true :syscontrolsocket "/run/dinitctrl"}}
:name
"dinit"
:source
{:fetcher
["/sickos/support/fuck-support" "fetch" "http"]
:hash
{:algo "blake3"
:hash "0e50739814471c6fbad61ee8a03ecc75c6e674825f9f83ac0683df015f9bd440"}
:url
"https://github.com/davmac314/dinit/archive/refs/tags/v0.22.1.tar.gz"}
:version
"0.22.1"}
Not bad. I will probably remove the defaults, and have another function fill those in at the end. That'll also do the validation, and turning it into a Derivation.
Oompf. So Lua tables can't have nil values, which is a problem, because if I wish to merge two tables, and want to remove a value from the old one, how do I express that?
I can't use false either, because that's a valid value.
In the specific context I'm in, :nil would work, I guess...
(let [pkg (define-package
(package {:name "dinit" :version "0.22.1"})
(source {:url (github {:owner "davmac314"})
:hash (blake3 "0e50739814471c6fbad61ee8a03ecc75c6e674825f9f83ac0683df015f9bd440")})
(builder
(configure {:syscontrolsocket "/run/dinitctrl"
:enable-shutdown true})
(make)
(make :install)))]
(print (fennel.view pkg)))
->
{:builder
{:steps
{:configure {:enable-shutdown true :syscontrolsocket "/run/dinitctrl"}
:make [["make"] ["make" "install"]]}}
:name
"dinit"
:source
{:hash
{:algo "blake3"
:hash "0e50739814471c6fbad61ee8a03ecc75c6e674825f9f83ac0683df015f9bd440"}
:url
"https://github.com/davmac314/dinit/archive/refs/tags/v0.22.1.tar.gz"}
:version
"0.22.1"}
Install bonfire.cafe
Get the full app experience
...or I could use
tulisp, because it is Rust-native, less dependencies, less compile-this-thing-to-lua, less lua, and a - for me - more convenient Rust-side API.And it still provides a fine Lisp-y environment.