Nix 语言深度：函数、惰性求值与模块化抽象

# 表面上的「二元函数」
add = a: b: a + b;

# 实际求值过程：先返回闭包，再应用
# add 1     -> b: 1 + b   （一个待应用的函数）
# add 1 2   -> 3

# 部分应用（partial application）是柯里化的直接红利
inc = add 1;         # b: 1 + b
inc 10               # => 11

# callPackage 的实质就是依次传入两个参数
# pkgs.callPackage drv { extra = 1; }
#   -> import drv 得到的函数，先注入 derivation 依赖，再注入覆盖参数

greet = { name, greeting ? "Hello" }: "${greeting}, ${name}!";

greet { name = "Alice"; }          # => "Hello, Alice!"
greet { name = "Bob"; greeting = "Hi"; }  # => "Hi, Bob!"

# ? 表示默认值；不给默认值且调用时缺少该属性会直接报错
# greet {}                         # error: 'name' argument not passed

# 只声明关心的字段，多余字段被静默忽略
f = { a, ... }: a;
f { a = 1; b = 2; c = 3; }     # => 1

# @ 语法同时绑定整个 attrset
g = args @ { a, ... }: a + args.b;
g { a = 1; b = 2; }            # => 3

# 多参数函数同样遵循柯里化 + 模式拆包
h = { a, ... }: { b, ... }: a + b;
h { a = 1; } { b = 2; }        # => 3

pkgs = import <nixpkgs> {};

# map 本身只接收一个函数 + 一个列表
map (x: x * 2) [ 1 2 3 ];      # => [ 2 4 6 ]

# 柯里化让组合更自然
map (pkg: pkg.name) [ pkgs.hello pkgs.git ];

# 下面的表达式完全合法，虽然 /nonexistent 不存在
{
  a = builtins.readFile /nonexistent;   # 只有访问 a 才会报错
  b = 1;
}

# 访问 b 不会触发 readFile
# 访问 a 才会：error: path '/nonexistent' does not exist

# 无限列表：除非访问足够深，否则不会死循环
evens = let go = n: [ n ] ++ go (n + 2); in go 0;
builtins.head evens            # => 0

# attrset 自引用：rec 的底层就是惰性
lib = rec {
  x = y + 1;
  y = 10;
};
lib.x                        # => 11

# 错误示范：试图用 builtins.trace 观察「顺序」
# 输出顺序不一定是书写顺序，因为父表达式决定子表达式何时求值
x = builtins.trace "eval x" 1;
y = builtins.trace "eval y" 2;
[ x y ]                     # 取决于访问顺序

# --strict 强制完全求值，暴露深处的错误
nix-instantiate --eval -E --strict '{ a = builtins.readFile /missing; b = 1; }'

# 合并
builtins.unionOf
  { a = 1; b = 2; }
  { b = 3; c = 4; }            # => { a = 1; b = 3; c = 4; }  （后合并覆盖前）

# 更新单个属性（返回新集合，原集合不变——纯函数式）
builtins.update { a = 1; b = 2; } { a = 9; }   # => { a = 9; b = 2; }

# 属性存在性检查
builtins.hasAttr "a" { a = 1; }            # => true
{ a = 1; } ? a                            # 等价语法糖

# 取属性（? 防止报错）
lib.attrByPath [ "a" "b" ] "default" { a = { b = 2; }; }   # => 2

lib.mapAttrs (name: value: "${name}-${value}")
  { x = "a"; y = "b"; }          # => { x = "a-x"; y = "b-y"; }

# 递归展开嵌套 attrset 的关键是自引用闭包
lib.mapAttrsRecursive
  (path: value: "PATH:${lib.concatStringsSep "." path}:${toString value}")
  { a = { b = 1; }; c = 2; }
  # => { a = { b = "PATH:a.b:1"; }; c = "PATH:c:2"; }

a = { x = 1; y = 2; };
b = a // { y = 3; z = 4; };
# b => { x = 1; y = 3; z = 4; }
# a 不变 => { x = 1; y = 2; }

let
  a = b + 1;    # 引用后面才定义的 b —— 惰性求值下合法
  b = 2;
in a            # => 3

let
  name = "nix";
  version = "2.18";
in {
  inherit name version;          # => { name = "nix"; version = "2.18"; }
  name = "overridden";           # 之后可以再覆盖
}

# inherit 还可以带括号改变取值来源：
# inherit (pkgs) git hello;   从 pkgs 中取 git、hello 属性
lib = { inherit (pkgs) jq jdk; };   # => { jq = <derivation>; jdk = <derivation>; }

rec {
  a = b;
  b = 1;
}
# => { a = 1; b = 1; }

# 危险：真正的循环，会无限递归
# rec { x = x; }   —— 访问 x 会死循环

pkgs = import <nixpkgs> {};

with pkgs; [ git curl jq ]
# 等价于 [ pkgs.git pkgs.curl pkgs.jq ]

# 坑：with 会遮蔽外层同名变量
let x = 1; in with { x = 2; }; x     # => 2

# 坑：with 是「部分惰性」的——若属性不存在不会立刻报错，访问才报
with { a = 1; }; b                     # error: attribute 'b' missing

fix = f: let x = f x; in x;

# 用法：f = 最终结果: { ... }
lib.fix (self: { a = 1; b = self.a + 1; })
# => { a = 1; b = 2; }   —— self 就是「求值中的自己」

# pkgs 定义简化示意
pkgs = lib.fix (self: {
  hello = import ./hello { inherit self; };
  git = import ./git { inherit self; };
  # hello 内部可以引用 self.git
});

# overlay 实质：在 fix 的每一步生成后套一层 final: prev
pkgs = lib.fix (self:
  lib.extends oldOverlay (prev: { ... })
);

extends = overlay: baseFunc: final: prev:
  let prev' = baseFunc final prev;
      in prev' // overlay final prev';

# ① override：替换传给「包函数」的顶层命名参数（通常即依赖项）
pkgs.postgresql_15.override {
  openssl = pkgs.openssl_3;          # 换依赖
  enableICU = false;                 # 换布尔选项
}

# ② overrideAttrs：直接修改 mkDerivation 的参数
pkgs.nginx.overrideAttrs (final: prev: {
  configureFlags = prev.configureFlags ++ [ "--with-http_v2_module" ];
  buildInputs = prev.buildInputs ++ [ pkgs.libpcre ];
})

# pkgs/development/.../foo.nix 的典型结构
{ lib, stdenv, fetchFromGitHub, cmake, openssl }:

stdenv.mkDerivation {
  pname = "foo";
  version = "1.0";
  buildInputs = [ cmake openssl ];
  src = fetchFromGitHub { ... };
}

pkgs.lib.callPackageWith (pkgs // { newDep = pkgs.hello; }) ./mypkg.nix {}

# 一个参数化构建函数的推荐写法
# config.nix
{ lib, stdenv, fetchurl, python3, extraBuildInputs ? [] }:

let
  configure = { withPython, withTests, additionalFlags ? [] }:
    stdenv.mkDerivation {
      pname = "myapp";
      version = "1.2.0";
      src = fetchurl { url = "..."; sha256 = "..."; };
      buildInputs = lib.optionals withPython [ python3 ] ++ extraBuildInputs;
      configureFlags = lib.optionals withTests [ "--enable-tests" ] ++ additionalFlags;
      passthru = { inherit configure; };   # 暴露可继续覆盖的入口
    };
in
configure   # 默认配置

# 配置层的叠加：后层覆盖前层
layers = [
  (self: super: { version = "1.2.0"; })
  (self: super: { enableFeatureX = true; })
  (self: super: super // { finalMark = "layered"; })  # 显式合并
];

final = lib.fix (self:
  lib.foldl' lib.extends (prev: {}) layers self);

# final.version => "1.2.0"; final.enableFeatureX => true

# 只有真正被需要的包才会被求值（触发构建）
packagesForSystem = system: {
  default = lib.attrByPath [ system ] (throw "unsupported system")
    { x86_64-linux = pkgs.buildx86; aarch64-linux = pkgs.buildArm; };
};

# 在 aarch64 机器上，pkgs.buildx86 永远不会被强制求值

# 计算并打印表达式
nix-instantiate --eval -E '1 + 2'

# 强制完整求值（暴露惰性隐藏的错误）
nix-instantiate --eval --strict -E 'let x = builtins.readFile /missing; y = 1; in y'

# 查看推导式结构
nix derivation show .#default

# 交互式探索（repl）
nix repl