nixir

# Large benchmark for comprehensive stress testing

let

  range = start: end:

    if start >= end

    then []

    else [start] ++ range (start + 1) end;

  concat = a: b: a ++ b;

  factorial = n:

    if n <= 1

    then 1

    else n * factorial (n - 1);

  # Ackermann function (highly recursive)

  ackermann = m: n:

    if m == 0

    then n + 1

    else if n == 0

    then ackermann (m - 1) 1

    else ackermann (m - 1) (ackermann m (n - 1));

  # Greatest common divisor

  gcd = a: b:

    if b == 0

    then a

    else gcd b (a - (a / b) * b);

  # Power function

  pow = base: exp:

    if exp == 0

    then 1

    else if exp == 1

    then base

    else base * pow base (exp - 1);

  compose = f: g: x: f (g x);

  double = x: x * 2;

  addTen = x: x + 10;

  square = x: x * x;

  pipeline = compose square (compose double addTen);

  list_100 = range 1 101;

  list_50 = range 1 51;

  list_25 = range 1 26;

  largeAttrs = {

    a1 = 1;

    a2 = 2;

    a3 = 3;

    a4 = 4;

    a5 = 5;

    a6 = 6;

    a7 = 7;

    a8 = 8;

    a9 = 9;

    a10 = 10;

    b1 = 11;

    b2 = 12;

    b3 = 13;

    b4 = 14;

    b5 = 15;

    b6 = 16;

    b7 = 17;

    b8 = 18;

    b9 = 19;

    b10 = 20;

    c1 = 21;

    c2 = 22;

    c3 = 23;

    c4 = 24;

    c5 = 25;

    c6 = 26;

    c7 = 27;

    c8 = 28;

    c9 = 29;

    c10 = 30;

    d1 = 31;

    d2 = 32;

    d3 = 33;

    d4 = 34;

    d5 = 35;

    d6 = 36;

    d7 = 37;

    d8 = 38;

    d9 = 39;

    d10 = 40;

    e1 = 41;

    e2 = 42;

    e3 = 43;

    e4 = 44;

    e5 = 45;

    e6 = 46;

    e7 = 47;

    e8 = 48;

    e9 = 49;

    e10 = 50;

  };

  # Very deep nesting (10 levels)

  deepNest = {

    level1 = {

      level2 = {

        level3 = {

          level4 = {

            level5 = {

              level6 = {

                level7 = {

                  level8 = {

                    level9 = {

                      level10 = {

                        treasure = "found";

                        value = 12345;

                      };

                    };

                  };

                };

              };

            };

          };

        };

      };

    };

  };

  recursiveComplex = rec {

    base = 10;

    doubled = base * 2;

    tripled = base * 3;

    sum = doubled + tripled;

    product = doubled * tripled;

    x = base * 4;

    y = x + doubled;

    z = y * tripled;

    total = sum + product + z;

    final = total * base;

  };

  config1 = rec {

    multiplier = 5;

    base = 100;

    result = base * multiplier;

  };

  config2 = rec {

    offset = 50;

    scaled = config1.result + offset;

    doubled = scaled * 2;

  };

  config3 = rec {

    factor = 3;

    combined = config2.doubled * factor;

    final = combined + config1.multiplier;

  };

  baseConfig = {

    system = {

      arch = "x86_64";

      os = "linux";

    };

    settings = {

      enabled = true;

      level = 5;

    };

  };

  overrides = {

    system = {

      kernel = "6.1";

    };

    settings = {

      level = 10;

      extra = "custom";

    };

    newSection = {

      value = 42;

    };

  };

  merged =

    baseConfig

    // overrides

    // {

      system = baseConfig.system // overrides.system;

      settings =

        baseConfig.settings

        // overrides.settings

        // {

          combined = baseConfig.settings.level + overrides.settings.level;

        };

    };

  fact10 = factorial 10;

  fact7 = factorial 7;

  ack_3_3 = ackermann 3 3;

  gcd_48_18 = gcd 48 18;

  gcd_100_35 = gcd 100 35;

  pow_2_10 = pow 2 10;

  pow_3_5 = pow 3 5;

  pipelineResult = pipeline 5; # ((5 + 10) * 2)^2 = 900

  # List operations

  concatenated = concat [1 2 3] [4 5 6];

  multilevel = concat (concat [1] [2 3]) [4 5];

in {

  # Lists

  inherit list_100 list_50 list_25 concatenated multilevel;

  # Math results

  inherit fact10 fact7 ack_3_3 gcd_48_18 gcd_100_35 pow_2_10 pow_3_5 pipelineResult;

  # Data structures

  inherit largeAttrs merged;

  deepValue = deepNest.level1.level2.level3.level4.level5.level6.level7.level8.level9.level10.value;

  deepTreasure = deepNest.level1.level2.level3.level4.level5.level6.level7.level8.level9.level10.treasure;

  # Recursive attrsets

  recursiveTotal = recursiveComplex.total;

  recursiveFinal = recursiveComplex.final;

  computedZ = recursiveComplex.z;

  # Config chain

  config1Result = config1.result;

  config2Doubled = config2.doubled;

  config3Final = config3.final;

  # Merged config

  mergedCombined = merged.settings.combined;

  mergedArch = merged.system.arch;

  mergedKernel = merged.system.kernel;

}