everett 0.1.1

A clean, zero-dependency statevector quantum simulator.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

{
  description = "everett - a zero-dependency statevector quantum simulator";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
    crane.url = "github:ipetkov/crane";
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    flake-utils.url = "github:numtide/flake-utils";
    treefmt-nix = {
      url = "github:numtide/treefmt-nix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs =
    {
      self,
      nixpkgs,
      crane,
      fenix,
      flake-utils,
      treefmt-nix,
    }:
    flake-utils.lib.eachDefaultSystem (
      system:
      let
        pkgs = nixpkgs.legacyPackages.${system};
        fenixPkgs = fenix.packages.${system};

        # stable toolchain pinned via rust-toolchain.toml, used by crane for
        # all production builds and checks.
        stableToolchain = fenixPkgs.fromToolchainFile {
          file = ./rust-toolchain.toml;
          # hash of the pinned toolchain from rust-toolchain.toml. if the pin
          # changes, `nix build` prints the new expected hash to paste here.
          sha256 = "sha256-gh/xTkxKHL4eiRXzWv8KP7vfjSk61Iq48x47BEDFgfk=";
        };
        craneLib = (crane.mkLib pkgs).overrideToolchain stableToolchain;

        src = craneLib.cleanCargoSource ./.;
        commonArgs = {
          inherit src;
          strictDeps = true;
        };
        cargoArtifacts = craneLib.buildDepsOnly commonArgs;

        everett = craneLib.buildPackage (commonArgs // { inherit cargoArtifacts; });

        # nightly toolchain carrying miri + rust-src (cargo-miri builds its own
        # sysroot from rust-src). lives only in the `.#miri` devShell, separate
        # from the stable build toolchain above.
        miriToolchain = fenixPkgs.complete.withComponents [
          "cargo"
          "rustc"
          "rust-src"
          "miri"
          "clippy"
          "rustfmt"
        ];

        treefmtEval = treefmt-nix.lib.evalModule pkgs ./treefmt.nix;
      in
      {
        packages.default = everett;

        checks = {
          inherit everett;

          clippy = craneLib.cargoClippy (
            commonArgs
            // {
              inherit cargoArtifacts;
              cargoClippyExtraArgs = "--all-features --all-targets -- --deny warnings";
            }
          );

          nextest = craneLib.cargoNextest (
            commonArgs
            // {
              inherit cargoArtifacts;
              partitions = 1;
              partitionType = "count";
            }
          );

          doctest = craneLib.cargoDocTest (commonArgs // { inherit cargoArtifacts; });

          doc = craneLib.cargoDoc (
            commonArgs
            // {
              inherit cargoArtifacts;
              env.RUSTDOCFLAGS = "--deny warnings";
            }
          );

          formatting = treefmtEval.config.build.check self;
        };

        # `nix develop` - stable toolchain for normal work.
        devShells.default = craneLib.devShell {
          checks = self.checks.${system};
          packages = [
            pkgs.cargo-nextest
            pkgs.cargo-llvm-cov
          ];
        };

        # `nix develop .#miri` - nightly + miri for undefined-behavior checking.
        devShells.miri = pkgs.mkShell {
          buildInputs = [ miriToolchain ];
          shellHook = ''
            echo "everett miri shell (nightly + miri)"
            echo "  MIRIFLAGS=\"-Zmiri-strict-provenance -Zmiri-tree-borrows\" cargo miri test miri_"
          '';
        };

        # `nix develop .#kani` - kani bounded model checker for the index math.
        devShells.kani = pkgs.mkShell {
          buildInputs = [
            stableToolchain
            pkgs.python3
          ];
          shellHook = ''
            echo "everett kani shell"
            if ! command -v cargo-kani &> /dev/null; then
              echo "  install once with: cargo install --locked kani-verifier && cargo kani setup"
            fi
            echo "  then: cargo kani"
          '';
        };

        formatter = treefmtEval.config.build.wrapper;
      }
    );
}