flake.nix 파일
  |------------- 외부 모듈 flake 파일
  |                     |------------- 외부 모듈 flake 파일 ...
  |                     |------------- 외부 모듈 flake 파일 ...
  |                     ...
  |------------- 외부 모듈 flake 파일
  |                     |------------- 외부 모듈 flake 파일 ...
  ...                   ...

{
  description = ...;
  inputs = ...;
  outputs =
    {
      lib =                  ;# 공통 유틸리티들이 들어 있는, 스탠다드 라이브러리 같은 것
      overlays =             ;# Nixpkgs를 수정, 확장하기 위한 오버레이 정의
      packages =             ;# 특정 환경(default, x86_64-linux, aarch64-darwin 같은 것)에 맞는 패키지 정의
                             ;# nix run 실행할 때 참조
      apps =                 ;# nix run 으로 애플리케이션을 실행
      checks =               ;# 테스트 정의
      defaultPacakage =      ;# Flake가 실행될 때 기본적으로 사용할 패키지
                             ;# nix build 에서 참조
      defaultApp =           ;# Flake가 실행될 때 기본적으로 실행할 애플리케이션
                             ;# nix run 와 연동
      devShells =            ;# 개발 환경을 정의
                             ;# nix develop 이 호출
      nixosConfigurations =  ;# NixOS 시스템 설정 정의
      darwinConfigurations = ;# macOS 시스템 설정 정의
      templates =            ;# 프로젝트를 생성할 수 있는 템플릿
                             ;# nix flake init에서 씁니다.
    };
}

{
  lib,
  config,
  options,
  pkgs,
  # 위의 것들이 자주 보이는데, 아래도 표준이라 합니다.
  modulePath, 
  configDir, 
  system, 
  parentConfig, 
  optionsPath, 
  specialArgs,
  ...
}: 
# 위 매개 변수로 들어오는 인자들을 닉스OS 모듈 시스템의 표준 인자라 합니다.
# 특별히 넘겨 주는 코드를 쓰지 않아도 자동으로 넘어 옵니다.
# 표준 인자만 받는 모듈일 경우 위는 통채로 생략하고, 파일 시작을 아래부터 할 수도 있습니다. 
{
  # 다른 모듈에서 불러 오기
  imports = [
    # ...
    ./xxx.nix # 파일 경로만(절대, 상대 모두 가능) 써주면 됩니다.
  ];

  options = {
    # ...
  };

  config = {
    # ...
  };

  foo.bar.enable = true;
  # 다른 옵션 선언
  # ...
}

# flake.nix 예시
{
  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.11";

    # helix의 데이터 소스를 추가한다. helix의 마스터 브랜치 
    helix.url = "github:helix-editor/helix/master";
  };

  outputs = inputs@{ self, nixpkgs, ... }: {
    nixosConfigurations.my-nixos = nixpkgs.lib.nixosSystem {
      system = "x86_64-linux";
      specialArgs = { inherit inputs; }; # (가)
      modules = [
        ./configuration.nix
        # { _module.args = { inherit inputs; };} (나)
        # (가)와 (나)가 하는 일은 같다. 원하는 걸로 골라 쓰면 됩니다.
      ];
    };
  };
}

# configuration.nix
{ config, pkgs, inputs, ... }:
{
  # ...
  environment.systemPackages = with pkgs; [
    git
    vim
    wget
    # 여기서, helix input 소스에서 가져와 helix 패키지를 설치합니다.
    inputs.helix.packages."${pkgs.system}".helix
  ];
  # ...
}

# packages.nix
{
  config, # 최소 두 개의 매개 변수를 가집니다.
  pkgs,   # 닉스 모듈 시스템이 값을 넣어 줍니다.
  ...
}: {
  imports = [ # 외부 모듈을 불러올 때
    (import ./special-fonts-1.nix {inherit config pkgs;}) # (1)
    ./special-fonts-2.nix # (2)
  ];

  fontconfig.enable = true;
}

{ config, pkgs, ...}: {
    # Configuration stuff ...
}

    nixosConfigurations.mySystem = nixpkgs.lib.nixosSystem {
      system = "x86_64-linux";
      modules = [
        ./packages.nix
      ];

{
  boot.kernelModules = mkBefore ["kvm-intel"]
}

{
  services.httpd.adminAddr = pkgs.lib.mkForce "bob@example.org";
}

pkgs.fcitx5-rime.override { rimeDataPkgs = [ ./rime-data-flypy ]; }

{ callPackage
, lib
, stdenv
, fetchurl
, nixos
, testers
, hello
}:
# 위에 있는 것들은 override로 덮어 씌우고
stdenv.mkDerivation (finalAttrs: {
  # 아래 있는 항목들은 overrideAttrs로 덮어 씌웁니다.
  pname = "hello";
  version = "2.12.1";

  src = fetchurl {
    url = "mirror://gnu/hello/hello-${finalAttrs.version}.tar.gz";
    sha256 = "sha256-jZkUKv2SV28wsM18tCqNxoCZmLxdYH2Idh9RLibH2yA=";
  };

  doCheck = true;
  ...
})

hellowWithDebug = pkgs.hello.overrideAttrs (finalAttrs: previousAttrs: {
#                                             인자1         인자2
  doCheck = false;
})

hellowWithDebug = pkgs.hello.overrideAttrs (finalAttrs: previousAttrs: {
  separateDebugInfo = true;
})

# ./overlays/default.nix
{ config, pkgs, lib, ... }:

{
  nixpkgs.overlays = [
    # Overlay 1: 상속 관계를 표현하기 위해 `self`와 `super`를 씁니다.
    (self: super: {
      google-chrome = super.google-chrome.override {
        commandLineArgs =
          "--proxy-server='https=127.0.0.1:3128;http=127.0.0.1:3128'";
      };
    })

    # Overlay 2: 새로운 것과 오래된 것을 나타내는 의미로 `final`과 `prev`를 씁니다.
    (final: prev: {
      steam = prev.steam.override {
        extraPkgs = pkgs: with pkgs; [
          keyutils
          libkrb5
          libpng
          libpulseaudio
          libvorbis
          stdenv.cc.cc.lib
          xorg.libXcursor
          xorg.libXi
          xorg.libXinerama
          xorg.libXScrnSaver
        ];
        extraProfile = "export GDK_SCALE=2";
      };
    })

    # Overlay 3: 다른 파일에 overlays를 정의합니다.
    # ./overlays/overlay3/default.nix 의 내용은 위와 같습니다.
    # `(final: prev: { xxx = prev.xxx.override { ... }; })`
    (import ./overlay3)
  ];
}

# ./flake.nix
{
  inputs = {
    # ...
  };

  outputs = inputs@{ nixpkgs, ... }: {
    nixosConfigurations = {
      my-nixos = nixpkgs.lib.nixosSystem {
        system = "x86_64-linux";
        modules = [
          ./configuration.nix

          (import ./overlays) # 이렇게 폴더만 써주면, default.nix를 찾는다.
        ];
      };
    };
  };
}

{ pkgs, lib, ... }:
let
  overlays = builtins.attrValues (builtins.readDir ./overlays);
in
{ overlays = overlays; }

nixosConfigurations = {
  my-nixos = nixpkgs.lib.nixosSystem rec {
    system = ...
    specialArgs = s1 # <-- 자동으로 modules에 넘어 갑니다.
    modules = [m1 m2]
  }
}

{
  description = ''
    Pure and reproducible overlay for binary distributed rust toolchains.
    A compatible but better replacement for rust overlay of github:mozilla/nixpkgs-mozilla.
  ''; # ''로 여러 줄 텍스트를 넣어 줄 수 있다.

  inputs = { # flake의 입력
    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
  };

  outputs = { self, nixpkgs }@inputs: let
    inherit (nixpkgs) lib; # lib = nixpkgs.lib 보통 유틸리티 함수를 쓸 때 필요한 것 같다.
    inherit (lib) filterAttrs mapAttrs' replaceStrings;  
    # filterAttrs = lib.filterAttrs 속성 필터
    # mapAttrs' = lib.mapAttrs' 속성 매핑
    # replaceStrings = lib.replaceStrings 문자열 치환

    forEachSystem = lib.genAttrs lib.systems.flakeExposed; # 함수 정의
    #                            지원되는 시스템 목록 제공
    #                            x86_64-linux, aarch64-linux, x86_64-darwin 같은 것들

    overlay = import ./.; # 현재 디렉토리에서 오버레이 가져 오기. 아마도 default.nix?

    defaultDistRoot = import ./lib/dist-root.nix;
    mkManifests = distRoot: import ./lib/manifests.nix { inherit lib distRoot; };
    #                                                    distRoot = lib.distRoot

    # Rust 도구 체인 인터페이스 빌더
    # Builder to construct `rust-bin` interface on an existing `pkgs`.
    # This would be immutable, non-intrusive and (hopefully) can benefit from
    # flake eval-cache.
    #
    # Note that this does not contain compatible attrs for mozilla-overlay.

    # Rust 바이너리 인터페이스
    mkRustBin =
      { distRoot ? defaultDistRoot }: # 값이 들어 오지 않으면, defaultDistRoot를 사용
                                      # 매개 변수의 기본값을 정의하는 구문
      pkgs:
      lib.fix (rust-bin: import ./lib/rust-bin.nix {
        inherit lib pkgs; # pkgs = lib.pkgs
        inherit (pkgs.rust) toRustTarget; # toRustTarget = pkgs.rust.toRustTarget
        inherit (rust-bin) nightly; # nightly = rust-bin.nightly
        manifests = mkManifests distRoot; # manifest: 파일 메타 정보 목록
                                          # 아마도 버전 목록?
                                          # {이름, 버전, 의존성, ...}을 받아 메니페스트 생성
      });

  in {
    lib = { 
      _internal = { # 내부에서만 사용할 라이브러리
        defaultManifests = mkManifests defaultDistRoot;
      };

      inherit mkRustBin; # 외부에서 접근 가능한 Rust 도구 체인 빌더
    };

    overlays = { # 패키지에서 특정 부분만 바뀌 치기 위한 오버레이
      default = overlay; # 현재 폴더에서 가져온 오버레이(위에서 정의된 변수)
      rust-overlay = overlay;
    };

    # TODO: Flake outputs except `overlay[s]` are not stabilized yet.

    packages = # 다양한 Rust 버전을 정의
      let
        select = version: comps: # 함수
          if comps ? default then
            comps.default // {
              minimal = comps.minimal or (throw "missing profile 'minimal' for ${version}");
            }
          else
            null;
        result = rust-bin: # 함수
          mapAttrs' (version: comps: {
            name = if version == "latest"
              then "rust" # latest면 그냥 rust
              else "rust_${replaceStrings ["."] ["_"] version}";
                  # ex) rust_1_81_0
            value = select version comps;
          }) rust-bin.stable //
          mapAttrs' (version: comps: { # 고차 함수를 인자로 넘기고 있다.
            name = if version == "latest"
              then "rust-nightly"
              else "rust-nightly_${version}";
            value = select version comps;
          }) rust-bin.nightly //
          mapAttrs' (version: comps: {
            name = if version == "latest"
              then "rust-beta"
              else "rust-beta_${version}";
            value = select version comps;
          }) rust-bin.beta;
        result' = rust-bin: filterAttrs (name: drv: drv != null) (result rust-bin);
      in
      forEachSystem (system:
        result' (mkRustBin {} nixpkgs.legacyPackages.${system})
        // { default = self.packages.${system}.rust; }
      );
      # todo: legacyPackage가 구버전 패키지를 뜻한다는데,
      # 신버전은 뭐고, 구버전은 뭐지?
    checks = forEachSystem (import ./tests inputs);
  };
}

lib.genAttrs [ "x86_64-linux" "aarch64-darwin" ] (system: "Hello, ${system}!")
#                                                           함수 
# 아래와 같습니다. 
{
  "x86_64-linux" = "Hello, x86_64-linux!";
  "aarch64-darwin" = "Hello, aarch64-darwin!";
}