How does nix maintain itself to be lazy?

[Animeshz]

Follow up from Nix Hour #19 at 7m51s

How does this work?

let
  x = y;
  y = { v = x; };
in
  x # or y

# { v = { v = «repeated»; }; }

Or a bit more complicated example,

let
  x = { v = x; w = y; };
  y = { p = x; q = y; };
in
  x

# { v = { v = «repeated»; w = { p = «repeated»; q = «repeated»; }; }; w = «repeated»; }

It does however, fails when its not referenced yet it refers to some undefined value:

let
  x = { v = y; };
in
  7

# error: undefined variable 'y'

Note: All ran in nix repl with/without :p in front.

Follow up questions after this,

• How infinite recursion is detected by nix?
• Evaluation order, does it matter, is there a catch in let ... in ...?
• Any (interesting) high-level details about the evaluation order that makes nix do this.

This maybe goes a bit into nix internals, so I'm not sure if its a good fit for a Nix Hour talk, but its really interesting to see how lazy language evolve into this while still being written in a procedural language.

Thanks!

[Animeshz]

Some related information (I recently found): https://nixos.wiki/wiki/Nix_Evaluation_Performance