| Age | Commit message (Collapse) | Author |
|---|
|
Moving away from the DNS-driven namespacing toward more condensed names,
mostly because I don't like typing so much.
|
|
A bunch of formatting changes got in there too. Oops.
I will probably eventually de-namespace everything, mostly because I'm
tired of typing "Com.Whatever.Thing" all the time. A better namespacing
strategy might be to use normal Haskell namespacing (Data, Control,
Network, etc) for code that is not specific to biz activities (i.e. if I
could open-source it at any time), and use simply "Biz" for stuff that I
would never want to open-source.
|
|
|
|
Idk what I was thinking, I dodn't need any of that stuff.
|
|
This also includes some drive-by formatting changes and config changes
needed to get it up and running.
|
|
I wanted to even further simplify the build tooling overhead. My general
goal is to not have to think about declaring packages, or dependencies,
or really anything that you might find in a cabal file. Not all of these
goals are possible, but we can get pretty close. With this commit all I
need for the 'buildGhc/buildGhcjs' functions is the path to the
entrypoint file; everything else is either inferred by the Nix code or
declared in the Haskell code comments.
The strategy is to map a Haskell module to an executable artifact, and
pass just that module to 'ghc --make'. Then we can rely on ghc to handle
walking the local filesystem for imports. The only thing ghc really
needs to know is a name for the output executable; it is hard to
automatically infer this, so we have a simple comment syntax to declare
this in the file. The comment syntax is inspired by existing Haskell
'LANGUAGE' pragmas; having this in the same file keeps the configuration
as close to the real code as possible. The Nix code then extracts this
info from the code comments, and sets the required ghc flags.
Second, we need to declare the set of 3rd-party packages that our
program relies on. For this we can re-use the same comment syntax and
just list the dependencies, then extract them in Nix and construct a
package set as we were before.
This reduces the amount of "package declaration" code we have to write
in default.nix, and reduces the amount of time we have to spend
switching between the Haskell code and the Nix code (I find such context
switching super annoying). I also think having the configuration in with
the Haskell code encourages us to write smaller, simpler modules and
only write code that we need.
Additionally, I refactored the bild and ghci (now called 'repl') scripts
to work in any directory. The .envrc uses direnv to set the path so that
you can run these scripts anywhere. That means the following works:
$ cd Run/Que
$ bild Website
$ repl Server
λ> :l Run.Que.Server
I find this to be a rather nice workflow.
|
|
|
|
It's easier to remember what operators do, and thus easier to write and
read condens code, if they follow some symbolic pattern or visually
represent the concept to which they map. This is in part inspired by
hoon, in part by OCaml's operators.
I'm not married to these operators specifically, but I think they are
good so far.
|
|
Two functions makes it simpler to reason about what is being built and
when, even if it is a bit more explicit. I also removed the dumb
Apex/Aero naming thing because Server/Client is just easier to remember.
|
|
|
|
|
