"7.4.1.1 Session history entries" doesn't mention whether focus is saved, only scroll has dedicated "attributes" in a history entry, but what this paragraph seems to allude to is that focus can be saved too (and indeed it can).

(See pushState.)

QUESTION

map can be defined using bind and switch,

let map f = bind (switch f)

but how to do this with >=>?...

ANSWER

Found a solution, but this is quite stupid:

let map' f result = match result with // The value of `o` is irrelevant, it is only needed // because `>=>` returns a function, but we need // a value and both operands of the input `f` are // provided by the closures | Ok o -> ((fun _ -> result) >=> (switch f)) o | Error e -> Error e

NOTE<br /> Call them as: map ((+) 2) ((Ok 27) : Result<int,string>);; map' ((+) 2) ((Ok 27) : Result<int,string>);;

Q: How does HttpHandler composition work then?

I guess that all the composition should be done inside the HttpHandler passed to the EndPointRouting functions.

edit: It does state below that

The choose handler is replaced by composing an Endpoint list.

BUG: This will never match foo///: routef "/foo/%s/%s/%s" (fun (s1, s2, s3) -> text (sprintf "%s%s%s" s1 s2 s3)) In fact, if the routex pipeline is removed, the routef one will be skipped as it does not match foo///. Perhaps it did in past versions?

SUGGESTION: If the routef pipeline is replaced with a real conflicting pipeline, such as route "/foo >=> text "Foo" then there the order of the pipelines will decide. Even the Giraffe docs say this about choose:

The choose combinator function iterates through a list of HttpHandler functions and invokes each individual handler until the first HttpHandler returns a positive result:

The phrasing is a bit misleading, because it is absolutely clear which of the two handlers will be invoked.

This is the pinning solution.

great channels vs pinning summary

Wonder what the consensus on channels nowadays?

Again, the entire comment is great.

Another good one.

This entire comment is gold

what

Is this still the case?

mull this over

test

QUESTION: What exactly does nix-shell execute from the Nix expression (i.e., shell.nix, default.nix, etc.)?

ANSWER: Based on my current understanding, the answer is everything. It calls $stdenv/setup (see annotation below) to set up the most basic environment variables (TODO: expand on this), and "injects" the most common tools (e.g., gcc, sed) into it.

It also defines the phases (TODO: verify this) and builder functions, such as genericBuilder. For example, the default builder is just two lines:

source $stdenv/setup
genericBuild

TODO: pkgs/stdenv/generic/builder.sh is a mystery though.

QUESTION: Once dropping into nix-shell, how do I know what phases to execute by looking at a default.nix? (E.g., [..]freeswitch/default.nix)

ANSWER: As far as I can tell, one can override the phases in their Nix build expression (to build the derivation, see at the bottom), but they won't get executed as only the $stdenv/setup (see above) will get sourced, and no builders are called that, in return, invoke the phases (again, see above).

So if one is using nix-shell

• to create/hack on a package, the person has to manually invoke the builder or phases (TODO: still fuzzy on this subject)

• to set up an environment, then one doesn't even have to worry about builders/phases because we just use nix-shell to clear the environment and to inject tools that we need for a given task

QUESTION: When dropping into nix-shell, is this Nix expression (i.e., freeswitch/default.nix) executed? Or just parts of it?

ANSWER: As stated above, all of the input Nix expression is evaluated, but no builders and build phases are called; although, nothing prevents one to override the phases, in case they are creating/hacking on a package.

QUESTION:

The command nix-shell will build the dependencies of the specified derivation, but not the derivation itself.

What is the "derivation" here exactly? I know that it is a build expression, but does that mean the default.nix (or other Nix expression) nix-shell is invoked with?

^{This statement also seems like a contradiction with how `nix-shell` works (i.e., if one issues `nix-shell -p curl`, then `curl` will be available in that sub-shell), but `-p` acts like a shortcut to as if `curl` had been listed in `buildInputs` so this is not the case.}

ANSWER: I have the feeling my confusion comes from the fact that the term "derivation" is used ambiguously in the manuals, sometimes to mean multiple things (see list below).

TODO: Substantiate this claim, and make sure that it not coming from my misunderstanding certain topics.

• Nix build expression (such as default.nix) whose output is going to become the store derivation itself (see last item at the bottom about the Nix manual's glossary definition)

• store derivation.

Had multiple cracks at unambiguously define what a derivation is, and here's a list of these:

• What is the purpose of nix-instantiate? What is a store-derivation? (probably the best try yet)

• What is a Nix expression in regard to Nix package management? (feels sloppier, but commenter mentions ATerm, adding the possibility of making it very specific)

• Closure vs derivation in the Nix package manager (very short, and will have to be re-written, but adds closures to the mix)

• There is now a glossary definition of a derivation in the Nix manual; see this annotation why I find it problematic

QUESTION: What is the difference between nix-shell -p and nix-shell invoked with a Nix expression of mkShell (or other that achieves the similar effect)?

QUESTION: nix-shell does not create a sub-shell, so what does it do? (clarification: so nix-shell indeed does it; I confused it with nix shell)

Come up with an ultimate definition for what a "derivation" is.

So round up all the places where it is mentioned across Nix* manuals, and check out these:

• https://stackoverflow.com/questions/58243554/what-is-a-nix-expression-in-regard-to-nix-package-management (this also needs to be edited)

• https://stackoverflow.com/questions/31490262/what-is-the-purpose-of-nix-instantiate-what-is-a-store-derivation

• https://nixos.org/manual/nix/unstable/expressions/derivations.html

• https://github.com/justinwoo/nix-shorts/blob/master/posts/your-first-derivation.md

• look for more online

From Nix Pills section 6.1. The derivation function (see annotation):

A derivation from a Nix language view point is simply a set, with some attributes. Therefore you can pass the derivation around with variables like anything else.

So there is clearly an ambiguity between what derivations are perceived to be and what is stated in the Eelco Dolstra's PhD thesis. Or maybe I'm having issues with reading comprehension again...

QUESTION: So when I see $out in a builder script, it refers to the default output path because the output attribute in the Nix expression has never been explicitly set, right?

That is, if an input attribute is a reference to a derivation in the Nix store, then

1. that derivation is built first (after a binary substitute is not found, I presume), and
2. the path to the built package (for a better word) is handed to the shell build script.

Organically related to the annotation regarding my nix-shell confusion.

The dissection of this definition to show why I find it lacking:

A description of a build action.

The first (couple) time(s) I read the manuals, this description popped up in many places, and I identified it with Nix expression every time, thinking that a derivation is a synonym for Nix expression.

Maybe it is, because it clearly tries to disambiguate between store derivations and derivation in the last sentence.

The result of a derivation is a store object.

Is this store object the same as a store derivation?

Derivations are typically specified in Nix expressions using the `derivation primitive. These are translated into low-level store derivations (implicitly by nix-env and nix-build, or explicitly by nix-instantiate).

QUESTION: So, the part of the Nix build expression (such as default.nix) where the derivation primitive is called (explicitly or implicitly, as in mkDerivation) is the derivation, that will be ultimately be translated into store derivations?

ANSWER: Start at section 15.4 Derivation.

QUESTION: Also, why is typically used here? Can one define derivations outside of Nix expressions?

ANSWER(?): One could I guess, because store derivations are ATerms (see annotation at the top), and the Nix expression language is just a tool to translate parameterized build actions into concrete terms to build a software package. The store derivations could be achieved using different means; e.g., the way Guix uses Guile scheme to get the same result))

I believe, that originally, derivation was simply a synonym to store derivation. Maybe it still is, and I'm just having difficulties with reading comprehension but I think the following would be less misleading (to me and apart from re-writing the very first sentence):

Derivations are typically the result of Nix expressions calling the derivation primitive explicitly, or implicitly usingmkDerivation`. These are translated into low-level store derivations (implicitly by nix-env and nix-build, or explicitly by nix-instantiate).

QUESTION: Does this refer to pkgs/stdenv/generic/setup.sh? According to 6.5 Phases in the Nixpkgs manual?

ANSWER: I'm pretty sure it does. It sets up the environment (not sure how yet; I see the env vars, but not the basic commands - sed, awk, etc. - that are listed below) and defines a bunch of functions (such as genericBuilder) but it doesn't call these functions!

"Documented" in the Nixpkgs manual under 6.1 Using stdenv.

Used the double-quotes above because I don't consider it well documted. Will give it a try too; worst case scenario is that I'll fail as well.

See annotations with the build-phases tag.

Why are the build phases not enumerated in the Nix manual? If the instructions on how to create a derivation (and thus, a package) then why not go all in instead of spreading out information in different manuals, making the subject harder to grasp?...

(By the way, it is documented in the Nixpkgs manual under 6.5 Phases; not sure why it is not called build phases when every page refers to them like that.)

This such a stupid move to go through a derivation example before introducing the language.

In addition to this rant, step 3. should be more generic, instead of tying it to Nixpkgs; at least, either show how to build your own Nix expression repo, or don't add this step, but it is not at all necessary to write a derivation. There is a Nixpkgs manual for a reason.

So a substitute is a built binary for a given derivation, and a substituter is a server (or binary cache) that serves pre-built binaries, right?

Update: in the next line it says that "it will fall back to using the binary cache substituter", so I guess that answers it.

this is another key topic. Also:

• substitute vs. substituter => this (I think)

See annotations with the substitute tag

binary caches tie in with substitutes somehow; get to the bottom of it. See annotations with the substitute tag.

Maybe this?

Another gem: who knows what a "closure" is.

[This highlight] (a couple lines below) implicitly explains it though:

The command nix-copy-closure copies a Nix store path along with all its dependencies to or from another machine via the SSH protocol. It doesn’t copy store paths that are already present on the target machine.

or this, also just a couple lines below:

the closure of a store path (that is, the path and all its dependencies)

That is a misleading statement. The latest version is where the master branch points, isn't it?

So a channel points to a Nixpkgs commit (on a branch named after the channel) where all packages inside are deemed stable, and all packages are built to have available binary substitutes by a (hydra) build farm.

Definitely avoid this, when a term is used but only introduced formally way later. (There is also a reference to "garbage collector roots" almost at the beginning as well.)

learn more about profiles; creating new profiles was new info

Explain the shit out of this one with tons of examples.

• https://hyp.is/ZHWETHDAEeuNGXcYXST5Ig/toraritte.github.io/saves/Nix-Package-Manager-Guide-Version-2.3.10.html

... and it takes AGES to complete

There is a lot of place in this manual (and probably in the others as well) where the prefix is referred to (usually with italics, such as "prefix/store"), so in the book

• this should be linked to this section (or the one in the book), and

• establish a clear and well-communicated notation to convey this

Why?

Answer is below in the manual: https://hyp.is/qRSFdnCJEeueY8NWtMIeHw/toraritte.github.io/saves/Nix-Package-Manager-Guide-Version-2.3.10.html

Would have been nice to link these to the install chapter where single- and multi-user modes were mentioned.

How would this look in a topic-based documentation? I would think that his chapter would be listed in the pre-requisites, and it could be used to buld different reading paths (or assemblies in DocBook, I believe) such as practical, depth-first (if there are people like me who want to understand everything first), etc.

https://en.wikipedia.org/wiki/Reentrancy_(computing)

Yeah, I there are several tickets and posts about how this is not entirely true.

• https://github.com/NixOS/nix/issues/1623
• https://github.com/NixOS/nix/issues/1402
• https://github.com/NixOS/nix/issues/458
• https://stackoverflow.com/questions/51929461/how-to-uninstall-nix
• https://stackoverflow.com/questions/443699/how-do-you-uninstall-in-nix
• https://apple.stackexchange.com/questions/170000/how-to-completely-remove-nix-package-manager

Traditionally, when a command should be invoked with sudo, it is either included in the example, or the shell indicator is # instead of $.

It should be noted in this section also that since nix 2.1.0, single user install is the default.

What is happening here exactly?

nix-shell's syntax synopsis always bugged because it looks like this

SYNOPSIS
nix-shell [--arg name value] [--argstr name value] [{--attr | -A} attrPath] [--command cmd] [--run cmd] [--exclude regexp] [--pure] [--keep name] {{--packages | -p} packages...  | [path]}

and the canonical example is nix-shell '<nixpkgs>' -A pan; what tripped me up is that path is usually the first in examples, and I thought that the position of arguments are strict. As it turns out, nix-shell -A pan '<nixpkgs> is just as valid.

Side note<br> Apparently there is no standard for man pages. See 1, 2.

'<nixpkgs>' path is the one specified in the NIX_PATH environment variable, and -A pan looks up the pan attribute in pkgs/top-level/all-packages.nix in the Nixpkgs repo.

Wouldn't hurt to tell folks that this is a convenience layer, and one could also just use the old package from the /nix/store, even though that path would be long and obscure; one could use symlinks of course.

Or, onc could just use nix-shell -p that specifies a specific version (that's already in the store), but, of course, it's not that simple...

https://github.com/NixOS/nixpkgs/issues/9682

See main annotation for the derivation topic

This is the gist of how Nixpkgs works (and how it is organized).

QUESTION: What is a fixed-point of a function?

ANSWER: See this video) at least, and the Fixed-point (mathematics)) wikipedia article:

In mathematics, a fixed point (sometimes shortened to fixpoint, also known as an invariant point) of a function is an element of the function's domain that is mapped to itself by the function. That is to say, c is a fixed point of the function f if f(c) = c. This means

f(f(...f(c)...)) = f n(c) = c

an important terminating consideration when recursively computing f. A set of fixed points is sometimes called a fixed set.

For example, if f is defined on the real numbers by f(x)=x^{2}-3x+4,}, then 2 is a fixed point of f, because f(2) = 2.

There is also the wiki article fixed-point combinator that actually plays a role here, but read through the articles in this order.

Then dissect the Stackoverflow thread What is a Y combinator?, and pay attention to the comments! For example:

According to Mike Vanier's description, your definition for Y is actually not a combinator because it's recursive. Under "Eliminating (most) explicit recursion (lazy version)" he has the lazy scheme equivalent of your C# code but explains in point 2: "It is not a combinator, because the Y in the body of the definition is a free variable which is only bound once the definition is complete..." I think the cool thing about Y-combinators is that they produce recursion by evaluating the fixed-point of a function. In this way, they don't need explicit recursion. – GrantJ Jul 18 '11 at 0:02

(wut?)

Other resources in no particular order:

• google search for "fixpoint evaluation fixed point combinator explained"
• Cornell's CS 6110 S17 Lecture 5
• google search for "fixed-point of a function"
• Fixed-point theorem (wikipedia)
• How can I find the fixed points of a function? (math stackexchange)
• The Y Combinator (Slight Return) (see the "Fixpoint of functions" section)
• Clear, intuitive derivation of the fixed-point combinator (Y combinator)? (computer science stackexchange)
• Fixed-Point Combinators (stackoverflow)
• Fixed-point combinator (HandWiki)

QUESTION: How the hell did they come up with the idea of using this with Nix and package management? (..and who? I remember a video saved somewhere, but maybe that was about overlays)

QUESTION: ... and how does it work in this context?

ANSWER: Well, not an answer yet, but this may be something in the right direction:

http://blog.tpleyer.de/posts/2020-01-29-Nix-overlay-evaluation-example.html

QUESTION: What is ldconfig cache?

QUESTION: What is libc and why does Bash need it?

QUESTION: So the Nix store houses derivations and not the built packages?

QUESTION: Are the hashes in the Nix store not unique?

Doesn't really say anything but thought it important to highlight this first mention of derivations in the Nix Pills.

This is a very good pointer; I guess it refers to systemd services when it mentions "simple services".

Didn't they mean what mkDerivation requires?

I have been jumping around in this manual, so not sure about what arguments does derivation require.

The error messages are not helpful when one messes up the input attribute set ofmkDerivation (i.e., either name, or pname and version attributes have to be present); see Nixpkgs issue #113520.

... and from Chapter 11:

fetchpatch works very similarly to fetchurl with the same arguments expected. It expects patch files as a source and and performs normalization on them before computing the checksum. For example it will remove comments or other unstable parts that are sometimes added by version control systems and can change over time.

... and also adding highlight of 19.3. Submitting security fixes

because these are the only places I've seen fetchpatch mentioned.

From the wild in freeswitch/default.nix in Nixpkgs:

stdenv.mkDerivation rec {
  pname = "freeswitch";
  version = "1.10.5";
  src = fetchFromGitHub {
    owner = "signalwire";
    repo = pname;
    rev = "v${version}";
    sha256 = "18dhyb19k28dcm1i8mhqvvgm2phsrmrwyjmfn79glk8pdlalvcha";
  };

  patches = [
    # https://github.com/signalwire/freeswitch/pull/812 fix mod_spandsp, mod_gsmopen build, drop when updating from 1.10.5
    (fetchpatch {
      url = "https://github.com/signalwire/freeswitch/commit/51fba83ed3ed2d9753d8e6b13e13001aca50b493.patch";
      sha256 = "0h2bmifsyyasxjka3pczbmqym1chvz91fmb589njrdbwpkjyvqh3";
    })
  ];
  postPatch = ''
    patchShebangs     libs/libvpx/build/make/rtcd.pl
    substituteInPlace libs/libvpx/build/make/configure.sh \
      --replace AS=\''${AS} AS=yasm

    # Disable advertisement banners
    for f in src/include/cc.h libs/esl/src/include/cc.h; do
      {
        echo 'const char *cc = "";'
        echo 'const char *cc_s = "";'
      } > $f
    done
  '';

Not sure why this isn't called build phases... See also.

Instead of #<output> it should have said channel-name instead at the top nix-channel example to keep it consistent.

TODO: Find other sources about this topic. I remember this mentioned already (and it makes) sense, but need to learn more.

TODO: What is a better alternative? An own repo? Flakes? Can cachix help?

It says right below that pinning can help but keep looking.

When package reproducibility become a major concern, as it is the case in this tutorial, it is preferable to refer to a pinned version of the nixpkgs repository instead — i.e, a specific commit of the repository or an immutable archived tarball. The ability to pin the version of nixpkgs is powerful, it will ensure that a package is always constructed from the same Nix source. As we go deeper in the tutorial we avoid using channels in favor of pinned environments.

And symlinks

nix-build <path> --run-env has been superseded by nix-shell. From Nix manual section C.12. Release 1.6 (2013-09-10):

The command nix-build --run-env has been renamed to nix-shell.

i should remember this to only get last commit, which basically means to only care about the data, and discard commit history.

How?

It would be helpful to

1. formally describe the formats for NIXPATH, and
2. note the allowed angle bracket syntax accordingly

<path> will work with the prefixless format, but not with the prefixed one, and it may be helpful to spell this out explicitly.

0 [14:16:19] nix repl
Welcome to Nix version 2.3.10. Type :? for help.

nix-repl> :l <nixpkgs/doc>  
Added 40 variables.

nix-repl> :l <doc>
error: file 'doc' was not found in the Nix search path (add it using $NIX_PATH or -I)

I always saw a NIXPATH used with the prefix syntax so far:

$ echo $NIX_PATH
nixpkgs=/nix/var/nix/profiles/per-user/root/channels/nixos:nixos-config=/etc/nixos/configuration.nix:/nix/var/nix/profiles/per-user/root

but NIX_PATH documentation shows that the prefixless format is also valid.

$ export NIX_PATH=/home/toraritte:/nix/var/nix/profiles/per-user/root/channels/nixos

$ printenv NIX_PATH
/home/toraritte:/nix/var/nix/profiles/per-user/root/channels/nixos

$ nix repl
Welcome to Nix version 2.3.10. Type :? for help.

nix-repl> :l <nixpkgs>
Added 12439 variables.

That is, they don't accept options, only data arguments. E.g., DATA's argument is the RFC 822 message format with headers and message body.

!

The SMTP envelope is sent as a series of SMTP protocol units (described in Section 3). It consists of

• an originator address (to which error reports should be directed),

MAIL FROM that refers to the originator (a.k.a., reverse path, backward-pointing address) of the request

• one or more recipient addresses,

Multiple RCPT TO for each "to:" rfc822 message header in the mail data (see annotation)

• and optional protocol extension material.

DATA (see below)

(See also envelope-vs-mail tags.)

Third part of the envelope: DATA.

This just answered my question regarding the quote from "Postfix: The Definitive Guide":

ENVELOPE ADDRESSES AND MESSAGE HEADERS A common source of confusion for email users is the fact that the To: address in email message headers has nothing to do with where a message is actually delivered. The envelope address controls message delivery. In practice, when you compose a message and provide your MUA with a To: address, your MUA uses that same address as the envelope destination address, but this is not required nor is it always the case. From the MTA’s point of view, message headers are part of the content of an email message. The delivery of a message is determined by the addresses specified during the SMTP conversation. These addresses are the envelope addresses , and they are the only thing that determine where messages go. See Section 2.2.8 later in the chapter for an explanation of the SMTP protocol.

Mailing lists and spam are common examples of when the envelope destination address differs from the To: address of the message headers.

Also an answer to this question.

Another section that serves well to understand the difference between email data and SMTP envelope.

This annotation explains what this paragraph means and dispels my confusion regarding how 3mails with multiple recipients will get processed (also, SMTP envelope vs mail data).

MS Outlook's "distribution list" is the same as an rfc5321 alias.

1. This the only difference between an SMTP alias and list; expanding recipients to RCPT commands is the same.

1. Another great example to highlight the difference between SMTP envelope and mail data: the envelope's MAIL FROM (see annotation) is different from to the mail data's rfc822 From:.

Will the entire transaction be canceled? "Transaction" in the name of this a section implies yes, but what if all the recipients are valid?

See replies below but the answer is no; an RCPT command is specified for each recipient in the mail data, these RCPT commands will be evaluated in sequence,, and any SMTP (error) notifications will be sent to the address in the MAIL FROM command (which is not necessarily the same as the mail data's From: header).

I guess Mailman would qualify (e.g., Reply-to header munging)

Sometimes "reverse path" or "originator" address is also referred to "backward-pointing" address (and those instances also refer to the MAIL command mostly).

This step of the procedure can be repeated any number of times. !

So the section

3.9.1. Alias

To expand an alias, the recipient mailer simply replaces the pseudo-mailbox address in the envelope with each of the expanded addresses in turn; the rest of the envelope and the message body are left unchanged. The message is then delivered or forwarded to each expanded address.

means that for each "to:" rfc822 message header in the mail data (i.e., SMTP envelope's DATA) a RCPT TO command will be added.

So this section describes how distribution list addresses or mailing list addresses are expanded into individual email addresses of the members of those lists, and not how emails are delivered to multiple addresses when more than one recipient is specified in a MUA.

https://hyp.is/WpKfxkbOEeucNAerBMma0A/tools.ietf.org/html/rfc5321

Seems relevant for the question above.

How could this specific scenario be even possible? It just said in the previous paragraph that

If there was no MAIL, or no RCPT, command, or all such commands were rejected, the server MAY return a "command out of sequence" (503) or "no valid recipients" (554) reply in response to the DATA command.

This was unexpected; why wasn't the canonical format (i.e., 5xx) used instead?

!

For a personal mail server, this sounds like a reasonable advice to follow.

Is SMTP stateless or stateful? See thread above.

What does this mean? Then what is the point of preserving the case if one can't act on it?

The local-part of a mailbox MUST BE treated as case sensitive.

Meaning that email addresses are case sensitive (the part before @, that is).

The terms "message content" and "mail are used interchangeably

To-do: look at the mentioned RFCs.

SMTP is stateless but SMTP sessions (just as HTTP/HTTPS sessions) are stateful.

RR - resource record

What does "SMTP client" refer to in this context? A MUA?

Important?

The second sentence ruins understanding this definition for me. Does this mean that CNAME is basically an alias, but it is the highest priority one (hence the designation "primary")?

What is the difference between provisioning and deployment?

Typo? Missing -> spinning

inets:start() will automatically start the httpc service also!

https://stackoverflow.com/a/64212985/1498178

This should be profile() = default | atom() because the httpc service is automatically started with the default profile (called default) when inets is started.

See also How to get more information about error when starting Inets httpd?

https://stackoverflow.com/a/64212985/1498178

That is, to request token if the app is not running in the Azure cloud with a managed identity:

• Acquire a token from Azure AD for authorizing requests from a client application

• Request an access token in Azure Active Directory B2C (and the other chapters in the Authorization protocols section)

Original post is here.

This explanation should be combined with 24 Days of GHC Extensions: Rank N Types (see related hypothes.is note).

This is such a nice description of forall. It should be combined with forall is the type-level "lambda" (also saved it here).

This was very neatly put, and forall above is also spot on.

If this would be the first time I came across parametricity, I wouldn't understand what it means.

https://en.wikipedia.org/wiki/Parametricity

In programming language theory, parametricity is an abstract uniformity property enjoyed by parametrically polymorphic functions, which captures the intuition that all instances of a polymorphic function act the same way.

That is, a function with the type signature a -> a has only one implementation: it can only return its input. In a similar fashion, a -> b -> a will only return the first argument and ignore the second. And so on.

What does this mean?

From Turning a map of data constructors into a row type (purescript discourse):

rows don’t have corresponding values, they only exist at the type level. If you do only purely want a row and not something like a Variant result you could return a proxy though.

My main issue with this book is that the difficulty is exponentially increasing, and by "keeping it simple" (i.e., trying to use simple terms) it is even harder to do a proper research.

For example:

1. The name of this chapter

This chapter should have been called Explicitly quantified type or Explicit universal quantification as it is too general as is, and doing a search to get to know more when someone has no formal/previous functional programming background, makes very hard.

Most importantly though, even if Haskell not mentioned, the word "explicit" would have been important.

It is also more about generic parameters than about quantification itself, and forall is kind of introduced but it is totally misleading.

2. forall

The post “forall” is the type-level “lambda” (saved) is the best, most succinct explanation of forall that I ever found. Unfortunately not before going down the rabbit hole.. (See links below.) One still needs to know about

• typeclasses
• generic parameters
• constraints
• what pragmas are but after that, it is straightforward.

(Jordan's Reference section on forall also doesn't help much.)

forall is also mandatory in PureScript (which is also not mentioned when introducing it), and I believe a comparison (the way the above post did) with Haskell is important, but at the right time. At least Jordan's Reference tries to put it off until later, but still before explaining concepts required to understand it.

3. The "rabbit hole" links

These are all good resources, but not for uninitiated mortals, and at a lower level (such as where I am now) they raise more questions than answers.

• Explicit forall (r/purescript reddit)]

  (Started here initially, but the single sentence there prompted a search for scoped type variables and rank-n types (or Rank N types).)

These are the spago equivalents for pulp browserify I guess.

Is this the same as pscid?

TODO: Is this the same as lib.attrsets.attrValues in nixpkgs?

equalElem or eqElem would have been more fortunate. In this form I would believe that it does what builtins.elemAt does.

works both on strings and paths

Path concatenation as well: https://gist.github.com/CMCDragonkai/de84aece83f8521d087416fa21e34df4

Bonus: https://stackoverflow.com/questions/43850371/when-does-a-nix-path-type-make-it-into-the-nix-store-and-when-not

TODO Is this an alias to builtins.attrValues?

This is vague to the point of being useless, given the Nix expression language is untyped.

A snippet from freeswitch.nix:

      configTemplate = mkOption {
        type = types.path;
        # omitted
      };
      configDir = mkOption {
        type = with types; attrsOf path;
        # omitted
      };

• Where does types come from?

  See NixOS manual at "Option types".

• What is the difference between the path types? (I guess, the second one is attribute set consisting only of paths.)

TODO: document lib.mkIf

Found a description in the NixOS manual:

The special function mkIf causes the evaluation of the conditional to be “pushed down” into the individual definitions, as if you had written:

config = {
  environment.systemPackages = if
config.services.httpd.enable then [ ... ] else [];
  ...
};

TODO: document lib.mkDefault

Not mentioned in any of the manuals (i.e., nix, nixpkgs, NixOS), only the NixOS options page has 1 mention:

Some promising search result (in the order of relevance):

• https://releases.nixos.org/nix-dev/2015-June/017549.html
• https://releases.nixos.org/nix-dev/2015-June/017549.html

From source:

  mkOverride = priority: content:
    { _type = "override";
      inherit priority content;
    };

  mkDefault = mkOverride 1000; # used in config sections of non-user modules to set a default

It seems that all the mkOverride calls set up a priority for certain actions.

What is an option?

From the link below to the source, it's just an attribute set with all the function parameters (see below) plus a _type attribute name to allow for type level operations (because Nix is untyped).

  mkOption =
    {
    # Default value used when no definition is given in the configuration.
    default ? null,
    # Textual representation of the default, for the manual.
    defaultText ? null,
    # Example value used in the manual.
    example ? null,
    # String describing the option.
    description ? null,
    # Related packages used in the manual (see `genRelatedPackages` in ../nixos/lib/make-options-doc/default.nix).
    relatedPackages ? null,
    # Option type, providing type-checking and value merging.
    type ? null,
    # Function that converts the option value to something else.
    apply ? null,
    # Whether the option is for NixOS developers only.
    internal ? null,
    # Whether the option shows up in the manual.
    visible ? null,
    # Whether the option can be set only once
    readOnly ? null,
    # Deprecated, used by types.optionSet.
    options ? null
    } @ attrs:
    attrs // { _type = "option"; };

How does it fit in a big scheme of things?

?

If there is recursiveUpdateUntil (i.e., mergeUntil) then mergeWith would also be welcome.

Would be nice to have an alias called merge.

Fix: add semicolon after last Any. (same above in the main type signature)

So the type signature

(String -> Any -> Any) -> AttrSet -> Any
                                     ^^^

should be

(String -> Any -> Any) -> AttrSet -> List
                                     ^^^^

instead, right?

See comment above.

Then why not call it collectVals?... (Following the distinctive naming convention between lib.attrsets.attrVals and lib.attrsets.attrValues.)

Especially because there is lib.attrsets.collect:

catAttrs :: String -> [AttrSet] -> [Any]
collect :: (Any -> Bool) -> AttrSet -> [Any]

(Call it filterVals? There are filterAttrs* functions but those return an attribute set, so no collision.)

This should read "Attribute Set Functions". Nowhere else is attribute sets spelled as "attribute-set".

edit: Alright, "attribute-set" is used in total of 4 times, whereas "attribute set" is used 112 times.

This can be written up in many other forms, plus the possibility of currying deserves to be pointed out:

$ nix repl
nix-repl> (sq: (x: y: sq y + sq x) 2 7) (x: x*x)
53

nix-repl> (sq: (x: y: sq y + sq x)) (x: x*x)     
«lambda @ (string):1:11»

nix-repl> (sq: (x: y: sq y + sq x)) (x: x*x) 2
«lambda @ (string):1:14»

nix-repl> (sq: (x: y: sq y + sq x)) (x: x*x) 2 7
53

nix-repl> (sq: x: y: sq y + sq x) (x: x*x) 2 7   
53

What does this mean?

This sentence is straightforward but I only understood it just now.

rebar.config can specify the dependencies of all the applications in the umbrella project, but they are not necessarily run-time dependencies. Also, the relx example from the rebar.config above shows how to include an app/lib (in this case, recon) in the final production release, even if it is not a run-time dependency.

This guide also expands on it a paragraph below:

The Rebar3 maintainers therefore just decided to keep a clear distinction between the applications that need fetching for the project to build or run (in rebar.config), and the run-time dependencies of each OTP application (in the .app file) which may be part of the default OTP install, and would therefore not be included in rebar.config. Other build tools in the ecosystem let you achieve similar results, but they default to including everything at run-time whereas Rebar3 asks of developers to always be specific in their intent.

restart defines when a terminated child process must be restarted.

• A permanent child process is always restarted.
• A temporary child process is never restarted (even when the supervisor's restart strategy is rest_for_one or one_for_all and a sibling's death causes the temporary process to be terminated).
• A transient child process is restarted only if it terminates abnormally, that is, with another exit reason than normal, shutdown, or {shutdown,Term}. https://erlang.org/doc/man/supervisor.html

Or use the Nix package manager's nix-shell.

• https://toraritte.github.io/posts/2020-07-15-nix-shell-with-specific-path.html
• https://stackoverflow.com/a/62923700/1498178

So the signature can be used by another entity to create the digital signature if authorized beforehand.

So if there is a statement that "I authorize [organization] to create a cryptographic key-pair on my behalf, and create the digital signature."

Not only is there no fetchgit (the right one is fetchGit), but there is also no sha256 argument.

Backtracking: Got to IRC log https://logs.nix.samueldr.com/nixos/2018-08-14 (save on archive.org), search for Unsupported argument 'sha256' to 'fetchGit' (or part of it), and an answer will point to:<br> https://github.com/NixOS/nix/blob/master/src/libexpr/primops/fetchGit.cc#L198-L215

We are again back to trying things out on hearsay.

In the home-manager NixOS wiki it also shows a ref argument to fetchGit but it is not documented anywhere. Yay. Anyway, it works without it too.

There is hnix that is still actively developed (as of 2020/06/21).

It is kind of an anti-pattern using the angle bracket notation and the linked post also makes a suggestion:

{ pkgs ? import (fetchTarball https://github.com/NixOS/nixpkgs/archive/3590f02e7d5760e52072c1a729ee2250b5560746.tar.gz) {};
}:
# ...

It is kind of an anti-pattern using the angle bracket notation and the linked post also makes a suggestion:

{ pkgs ? import (fetchTarball https://github.com/NixOS/nixpkgs/archive/3590f02e7d5760e52072c1a729ee2250b5560746.tar.gz) {};
}:
# ...

It is kind of an anti-pattern using the angle bracket notation and the linked post also makes a suggestion:

{ pkgs ? import (fetchTarball https://github.com/NixOS/nixpkgs/archive/3590f02e7d5760e52072c1a729ee2250b5560746.tar.gz) {};
}:
# ...

What is the difference between the vim and vim_configurable packages?

I believe the source for the latter is here.

If I understood it correctly, take the hardware-configration.nix from the target machine, and put it into the NixOps config.

Also relevant: Minimal NixOS config for Nixops deployment (discourse)

Here's why it's important to revoke access (rom Upload a VHD to Azure or copy a managed disk to another region - Azure PowerShell):

After the upload is complete, and you no longer need to write any more data to the disk, revoke the SAS. Revoking the SAS will change the state of the managed disk and allow you to attach the disk to a VM.

... or list it in environment.systemPackages in /etc/nixos/configuration.nix, and nixos-rebuild switch.

One way (are there others?) to pin Nixpkgs, and ditch channels.

extraUsers have been renamed to users. See related commits.

This will still work on 20.03 but will show a warning as name = "root"; is deprecated, and luksroot should be used instead (see boot.initrd.luks.devices NixOS option) .

boot.initd.luks.devices = {
  luksroot = {
    device = "/nev/sda2";
    preLVM = true;
  };
};

Got a warning here but it seems to be safe to ignore.

WARNING: Locking directory /run/cryptsetup is missing!

This didn't work out of the box, therefore worth looking at the Arch linux wpa_supplicant docs.

wpa_cli also wouldn't work, and needed to make sure that I had the right SSID so this link is also helpful to list available wifi networks.

On 20.03 install drops users to a non-privileged terminal so sudo su has to be entered to become root. (Otherwise the first steps in "Networking" will fail immediately.)

Saving this here for posterity: https://stackoverflow.com/questions/55191125/cant-seem-to-get-sudo-working-under-nixos

Q1: So inet and socket are competing socket implementations then?

Q2: inets is higher level abstraction layer on top of inet? (Just as HTTP is higher level than transport protocols.)

Q3 (corollary of Q1 and Q2): inets could be then rewritten to use socket instead? (And used just like gen_tcp with the inet_backend option?)

Hypertext is text which contains links to other texts. The term was coined by Ted Nelson around 1965 (see History ).

HyperMedia is a term used for hypertext which is not constrained to be text: it can include graphics, video and sound , for example. Apparently Ted Nelson was the first to use this term too. https://www.w3.org/WhatIs.html

Most Web navigation is done by clicking text-based links that open new pages in a Web browser. These links, which are often blue and underlined, are referred to as hypertext, since they allow the user to jump from page to page. Hypermedia is an extension of hypertext that allows images, movies, and Flash animations to be linked to other content.

The most common type of hypermedia is an image link. Photos or graphics on the Web are often linked to other pages. For example, clicking a small "thumbnail" image may open a larger version of the picture in a new window. Clicking a promotional graphic may direct you to an advertiser's website. Flash animations and videos can also be turned into hyperlinks by embedding one or more links that appear during playback. https://techterms.com/definition/hypermedia

See also hypermedia tags in hypothes.is

We start out with the TL;DR treatise: The mnesia database is not CP, nor AP. And it cannot be CA, because CA doesn’t make any meaningful sense. In short, it is broken with respect to the CAP theorem. https://medium.com/@jlouis666/mnesia-and-cap-d2673a92850

The Nixpkgs pull request template has a checkbox "Determined the impact on package closure size (by running nix path-info -S before and after)" but there is only 4 instances of path-info in the Nix manual (and none in the Nixpkgs manual).

nix --help says

path-info        query information about store paths

so the command works at the bottom but what switches are available for example? From the examples, -r and -S is valid but where are they documented?

nix path-info -rS $(readlink -f $(which vim))

Applicative-order and normal-order evaluation sound like synonyms to eager/strict versus _lazy_evaluation strategies respectively, but there are differences:

• Eager evaluation/applicative order and lazy evaluation/normal order (Stackoverflow)
• Normal, Applicative, and Lazy evaluation

The bottom line seems to be that

• strict/eager = normal order
• lazy ~= applicative BUT all terms are evaluated at most once

Does this refer to recurrence relations?

Not much found for recursion equations, and those seem to suggest the two terms are interchangeable. However: Recurrence vs Recursive

See wikipedia on recurrence relation also.

"Fold" should be replaced with "combine" to make this paragraph consistent with the HTTP/1 specs (RFC 2616, RFC 7230).

https://www.rfc-editor.org/errata/eid6093 https://stackoverflow.com/questions/3241326/

Couldn't find where the exhaustive list of API versions are listed, but found this on the Azure Instance Metadata Service (aka IMDS) page:

2017-04-02, 2017-08-01, 2017-12-01, 2018-02-01, 2018-04-02, 2018-10-01, 2019-02-01, 2019-03-11, 2019-04-30, 2019-06-01, 2019-06-04, 2019-08-01, 2019-08-15

Also:

The version 2019-11-01 is currently getting deployed and may not be available in all regions.

Content-Length

Not mentioned anywhere (not even in the inets User's Guide), but Content-Length is calculated automatically if it is not provided.

See httpc_request.erl#213.

This is by far the best explanation I found.

How does one find what vim packages are available? (That nix vim-derivations/attributes, such as vimHugeX)

Why is rec needed here, and not in the example under 2.6.1?

Based on what I saw with other examples, rec is usually included when a_package.override is used inside packageOverrides. But why?

Nix ecosystem introduction ("Talk at my company")

Declarative package management for normal users

What is the relationship between Disnix and NixOps?

any real reason you should use zeromq over rabbitmq?

NIX + BAZEL = FULLY REPRODUCIBLE, INCREMENTAL BUILDS

Membrane Framework - Reliable & scalable multimedia streaming

Web Hosting with IPFS and Nix

How we use Nix at IOHK?

What technical details should a programmer of a web application consider before making the site public?

The entire chapter 3 is worth reading. Great resource on what a package (or more broadly, a component) is in regards to Nix.

Specifically "3.1 What is a component?"

There is no officially prescribed reading order of the Nix manuals, but it's safe to say that one should start this, the Nix manual. Then it would be prudent to briefly describe what a package is in the context of Nix and/or (at east) link to the definition.

I like how Dolstra's thesis has an entire section on the topic (that is, on the more general concept of components).

It is clear now that there can be multiple versions of the same package in the store, but how does one call them (e.g., if is an executable application)? Simply by using the full Nix store path (and create and manage one's own symlinks, with stow or manually)??