Adrian Cochrane @alcinnz@floss.social

Don't get me wrong, computers can absolutely help us regain our environmental efficiency. They just *aren't*.

Not as long as we're:
* constantly syncing everything to the cloud,
* expecting same-hour delivery,
* funding our clickbait via surveillance advertising,
* buying a new phone every year,
* using AIs because they're cool rather than useful,
* running bloated software & webpages,
* buying into "big data"
* etc

Computing is environmentally cheap, but it rapidly adds up!

Maybe it's just because this is where my interest lies, but reading a few takes on how to Fix The Web yesterday I really think a major issue are the discovery hueristics we use. Their incomprehensibility and shallowness promotes the bad and buries the good.

There's PLENTY of good links! Otherwise I'd be wanting to tear The Web down rather than just JS...

I created Odysseus to explore some partial solutions, but I'm keen to see others address the problem from a different angle! Links? Advice?

Now I've published the last section to https://adrian.geek.nz/docs/haskell-libs.html

After a break I think I'll discuss Haskell development tools, namely HSpec, file-embed, Cabal, Haddock Hackage, & Hoogle.

And then GHC itself!

More writings about how software works at https://adrian.geek.nz/docs

Upon the Parser Combinators implemented upon those Get/Look operators (where branches may be merged) it implements a rudimentary Haskell pull-based lexer.

The Prelude uses that parser combinators framework and lexer to implement the Read typeclass allowing you to parse them with a call to `read(s)Prec`. Don't worry, GHC will offer to generate an implementation for you, and you can stick to the simpler `String -> [(a,String)]` API.

`read`/`readMaybe`/`readEither`/etc calls `readPrec`.

6/6 Fin!

The Prelude provides a `read :: Read a => String -> a` function making it trivial to parse any of it's types. It's not trivial for the Prelude though, it defines it's own parsing framework behind the scenes to implement this.

At it's simplest it defines a synonym for `String -> [(a,String)]` returning all possible parses. Or it may hide the character iterator from the parsing code by having it yield Get, Look, or possible Results before it's ultimate Fail or Final.

5/6

While GHC is bundled with `containers` implementing a size-balanced Binary Search Tree, the Prelude just uses a linked-list of key-value pairs (Eq k => [(k,v)]) by providing the function:

lookup _key [] = Nothing
lookup key ((x,y):xys) | key == x = Just y
| otherwise = lookup key xys

(P.S. "otherwise" is part of the Prelude, not the parser)

I've previously mentioned arbitrary precision Integers implemented using LibGMP or pure Haskell. These are imported into the Prelude.

4/5?

The Prelude defines linked lists which it uses for everything, via the code: data [] a = [] | a : [a]
GHC is *really good* at optimizing the processing of these, but not always the storage. That's what Text & Bytestring's for!

A Haskell String is a linked list of unicode codepoints (`[Char]`) with hardly any APIs of it's own. Char is defined amongst the other numeric types.

Text encodings are stripped away in the I/O APIs, providing bufferring, typeclasses, etc around C's <stdio.h>.

3/?

I'll start with numbers, because it's the most seperate!

They could *in theory* be implemented in pure Haskell using "Church Numerals", but that would be incredibly wasteful! So instead it uses "primitive" functions & types GHC's backend will compile into specific opcodes.

Around these primitives boxed types are defined to allow for laziness. The Prelude declares math operators, & typeclasses for operator overloading. GHC's frontend has hardly no concept of numbers, it's all in the prelude!
2/

Over the past week(s?) I've been describing the Haskell dependencies I pulled in to write Rhapsode. (Though my C dependencies are the more distinctive aspect, see https://adrian.geek.nz/docs/espeak.html )

So now let me ask: How does this compare to the standard Prelude? A.k.a. the code I don't need to import? A.k.a. the naive (mostly) pure-Haskell approach?

Specifically I've discussed:
* Mappings
* Networking
* Numeric lists
* Text
* Parsing
* & parsing numbers

1/?

What's in a Parser Combinator? https://remusao.github.io/posts/whats-in-a-parser-combinator.html

A topic I've been describing a lot recently... And I might do so once more today!