reformat script-writers with nixfmt

pkgs/builders/script-writers.nix

@@ -27,107 +27,127 @@ rec {
   # Examples:
   #   writeBash = makeScriptWriter { interpreter = "${pkgs.bash}/bin/bash"; }
   #   makeScriptWriter { interpreter = "${pkgs.dash}/bin/dash"; } "hello" "echo hello world"
-  makeScriptWriter = { interpreter, check ? "", makeWrapperArgs ? [], }: nameOrPath: content:
+  makeScriptWriter =
-    assert lib.or (types.path.check nameOrPath) (builtins.match "([0-9A-Za-z._])[0-9A-Za-z._-]*" nameOrPath != null);
+    {
+      interpreter,
+      check ? "",
+      makeWrapperArgs ? [ ],
+    }:
+    nameOrPath: content:
+    assert lib.or (types.path.check nameOrPath) (
+      builtins.match "([0-9A-Za-z._])[0-9A-Za-z._-]*" nameOrPath != null
+    );
     assert lib.or (types.path.check content) (types.str.check content);
     let
       name = last (builtins.split "/" nameOrPath);
     in
 
-    pkgs.runCommandLocal name (
+    pkgs.runCommandLocal name
-      {
+      (
-        inherit makeWrapperArgs;
+        {
-        nativeBuildInputs = [
+          inherit makeWrapperArgs;
-          makeWrapper
+          nativeBuildInputs = [ makeWrapper ];
-        ];
-      }
-      // lib.optionalAttrs (nameOrPath == "/bin/${name}") {
-        meta.mainProgram = name;
-      }
-      // (
-        if (types.str.check content) then {
-          inherit content interpreter;
-          passAsFile = [ "content" ];
-        } else {
-          inherit interpreter;
-          contentPath = content;
         }
+        // lib.optionalAttrs (nameOrPath == "/bin/${name}") { meta.mainProgram = name; }
+        // (
+          if (types.str.check content) then
+            {
+              inherit content interpreter;
+              passAsFile = [ "content" ];
+            }
+          else
+            {
+              inherit interpreter;
+              contentPath = content;
+            }
+        )
       )
-    )
+      ''
-    ''
+        # On darwin a script cannot be used as an interpreter in a shebang but
-      # On darwin a script cannot be used as an interpreter in a shebang but
+        # there doesn't seem to be a limit to the size of shebang and multiple
-      # there doesn't seem to be a limit to the size of shebang and multiple
+        # arguments to the interpreter are allowed.
-      # arguments to the interpreter are allowed.
+        if [[ -n "${toString pkgs.stdenvNoCC.isDarwin}" ]] && isScript $interpreter
-      if [[ -n "${toString pkgs.stdenvNoCC.isDarwin}" ]] && isScript $interpreter
-      then
-        wrapperInterpreterLine=$(head -1 "$interpreter" | tail -c+3)
-        # Get first word from the line (note: xargs echo remove leading spaces)
-        wrapperInterpreter=$(echo "$wrapperInterpreterLine" | xargs echo | cut -d " " -f1)
-
-        if isScript $wrapperInterpreter
         then
-          echo "error: passed interpreter ($interpreter) is a script which has another script ($wrapperInterpreter) as an interpreter, which is not supported."
+          wrapperInterpreterLine=$(head -1 "$interpreter" | tail -c+3)
-          exit 1
+          # Get first word from the line (note: xargs echo remove leading spaces)
+          wrapperInterpreter=$(echo "$wrapperInterpreterLine" | xargs echo | cut -d " " -f1)
+
+          if isScript $wrapperInterpreter
+          then
+            echo "error: passed interpreter ($interpreter) is a script which has another script ($wrapperInterpreter) as an interpreter, which is not supported."
+            exit 1
+          fi
+
+          # This should work as long as wrapperInterpreter is a shell, which is
+          # the case for programs wrapped with makeWrapper, like
+          # python3.withPackages etc.
+          interpreterLine="$wrapperInterpreterLine $interpreter"
+        else
+          interpreterLine=$interpreter
         fi
 
-        # This should work as long as wrapperInterpreter is a shell, which is
+        echo "#! $interpreterLine" > $out
-        # the case for programs wrapped with makeWrapper, like
+        cat "$contentPath" >> $out
-        # python3.withPackages etc.
+        ${optionalString (check != "") ''
-        interpreterLine="$wrapperInterpreterLine $interpreter"
+          ${check} $out
-      else
+        ''}
-        interpreterLine=$interpreter
+        chmod +x $out
-      fi
 
-      echo "#! $interpreterLine" > $out
+        # Relocate executable if path was specified instead of name.
-      cat "$contentPath" >> $out
+        # Only in this case wrapProgram is applied, as it wouldn't work with a
-      ${optionalString (check != "") ''
+        #   single executable file under $out.
-        ${check} $out
+        ${optionalString (types.path.check nameOrPath) ''
-      ''}
+          mv $out tmp
-      chmod +x $out
+          mkdir -p $out/$(dirname "${nameOrPath}")
-
+          mv tmp $out/${nameOrPath}
-      # Relocate executable if path was specified instead of name.
+          wrapProgram $out/${nameOrPath} ''${makeWrapperArgs[@]}
-      # Only in this case wrapProgram is applied, as it wouldn't work with a
+        ''}
-      #   single executable file under $out.
+      '';
-      ${optionalString (types.path.check nameOrPath) ''
-        mv $out tmp
-        mkdir -p $out/$(dirname "${nameOrPath}")
-        mv tmp $out/${nameOrPath}
-        wrapProgram $out/${nameOrPath} ''${makeWrapperArgs[@]}
-      ''}
-    '';
 
   # Base implementation for compiled executables.
   # Takes a compile script, which in turn takes the name as an argument.
   #
   # Examples:
   #   writeSimpleC = makeBinWriter { compileScript = name: "gcc -o $out $contentPath"; }
-  makeBinWriter = { compileScript, strip ? true }: nameOrPath: content:
+  makeBinWriter =
-    assert lib.or (types.path.check nameOrPath) (builtins.match "([0-9A-Za-z._])[0-9A-Za-z._-]*" nameOrPath != null);
+    {
+      compileScript,
+      strip ? true,
+    }:
+    nameOrPath: content:
+    assert lib.or (types.path.check nameOrPath) (
+      builtins.match "([0-9A-Za-z._])[0-9A-Za-z._-]*" nameOrPath != null
+    );
     assert lib.or (types.path.check content) (types.str.check content);
     let
       name = last (builtins.split "/" nameOrPath);
     in
-    pkgs.runCommand name ((if (types.str.check content) then {
+    pkgs.runCommand name
-      inherit content;
+      (
-      passAsFile = [ "content" ];
+        (
-    } else {
+          if (types.str.check content) then
-      contentPath = content;
+            {
-    }) // lib.optionalAttrs (nameOrPath == "/bin/${name}") {
+              inherit content;
-      meta.mainProgram = name;
+              passAsFile = [ "content" ];
-    }) ''
+            }
-      ${compileScript}
+          else
-      ${lib.optionalString strip
+            { contentPath = content; }
-          "${lib.getBin buildPackages.bintools-unwrapped}/bin/${buildPackages.bintools-unwrapped.targetPrefix}strip -S $out"}
+        )
-      # Sometimes binaries produced for darwin (e. g. by GHC) won't be valid
+        // lib.optionalAttrs (nameOrPath == "/bin/${name}") { meta.mainProgram = name; }
-      # mach-o executables from the get-go, but need to be corrected somehow
+      )
-      # which is done by fixupPhase.
+      ''
-      ${lib.optionalString pkgs.stdenvNoCC.hostPlatform.isDarwin "fixupPhase"}
+        ${compileScript}
-      ${optionalString (types.path.check nameOrPath) ''
+        ${lib.optionalString strip "${lib.getBin buildPackages.bintools-unwrapped}/bin/${buildPackages.bintools-unwrapped.targetPrefix}strip -S $out"}
-        mv $out tmp
+        # Sometimes binaries produced for darwin (e. g. by GHC) won't be valid
-        mkdir -p $out/$(dirname "${nameOrPath}")
+        # mach-o executables from the get-go, but need to be corrected somehow
-        mv tmp $out/${nameOrPath}
+        # which is done by fixupPhase.
-      ''}
+        ${lib.optionalString pkgs.stdenvNoCC.hostPlatform.isDarwin "fixupPhase"}
-    '';
+        ${optionalString (types.path.check nameOrPath) ''
+          mv $out tmp
+          mkdir -p $out/$(dirname "${nameOrPath}")
+          mv tmp $out/${nameOrPath}
+        ''}
+      '';
 
   # Like writeScript but the first line is a shebang to bash
   #
@@ -135,13 +155,10 @@ rec {
   #   writeBash "example" ''
   #     echo hello world
   #   ''
-  writeBash = makeScriptWriter {
+  writeBash = makeScriptWriter { interpreter = "${lib.getExe pkgs.bash}"; };
-    interpreter = "${lib.getExe pkgs.bash}";
-  };
 
   # Like writeScriptBin but the first line is a shebang to bash
-  writeBashBin = name:
+  writeBashBin = name: writeBash "/bin/${name}";
-    writeBash "/bin/${name}";
 
   # Like writeScript but the first line is a shebang to dash
   #
@@ -149,13 +166,10 @@ rec {
   #   writeDash "example" ''
   #     echo hello world
   #   ''
-  writeDash = makeScriptWriter {
+  writeDash = makeScriptWriter { interpreter = "${lib.getExe pkgs.dash}"; };
-    interpreter = "${lib.getExe pkgs.dash}";
-  };
 
   # Like writeScriptBin but the first line is a shebang to dash
-  writeDashBin = name:
+  writeDashBin = name: writeDash "/bin/${name}";
-    writeDash "/bin/${name}";
 
   # Like writeScript but the first line is a shebang to fish
   #
@@ -165,12 +179,11 @@ rec {
   #   ''
   writeFish = makeScriptWriter {
     interpreter = "${lib.getExe pkgs.fish} --no-config";
-    check = "${lib.getExe pkgs.fish} --no-config --no-execute";  # syntax check only
+    check = "${lib.getExe pkgs.fish} --no-config --no-execute"; # syntax check only
   };
 
   # Like writeScriptBin but the first line is a shebang to fish
-  writeFishBin = name:
+  writeFishBin = name: writeFish "/bin/${name}";
-    writeFish "/bin/${name}";
 
   # writeHaskell takes a name, an attrset with libraries and haskell version (both optional)
   # and some haskell source code and returns an executable.
@@ -181,29 +194,31 @@ rec {
   #
   #     main = launchMissiles
   #   '';
-  writeHaskell = name: {
+  writeHaskell =
-    libraries ? [],
+    name:
-    ghc ? pkgs.ghc,
+    {
-    ghcArgs ? [],
+      libraries ? [ ],
-    threadedRuntime ? true,
+      ghc ? pkgs.ghc,
-    strip ? true
+      ghcArgs ? [ ],
-  }:
+      threadedRuntime ? true,
+      strip ? true,
+    }:
     let
       appendIfNotSet = el: list: if elem el list then list else list ++ [ el ];
       ghcArgs' = if threadedRuntime then appendIfNotSet "-threaded" ghcArgs else ghcArgs;
 
-    in makeBinWriter {
+    in
+    makeBinWriter {
       compileScript = ''
         cp $contentPath tmp.hs
-        ${(ghc.withPackages (_: libraries ))}/bin/ghc ${lib.escapeShellArgs ghcArgs'} tmp.hs
+        ${(ghc.withPackages (_: libraries))}/bin/ghc ${lib.escapeShellArgs ghcArgs'} tmp.hs
         mv tmp $out
       '';
       inherit strip;
     } name;
 
   # writeHaskellBin takes the same arguments as writeHaskell but outputs a directory (like writeScriptBin)
-  writeHaskellBin = name:
+  writeHaskellBin = name: writeHaskell "/bin/${name}";
-    writeHaskell "/bin/${name}";
 
   # Like writeScript but the first line is a shebang to nu
   #
@@ -211,30 +226,30 @@ rec {
   #   writeNu "example" ''
   #     echo hello world
   #   ''
-  writeNu = makeScriptWriter {
+  writeNu = makeScriptWriter { interpreter = "${lib.getExe pkgs.nushell} --no-config-file"; };
-    interpreter = "${lib.getExe pkgs.nushell} --no-config-file";
-  };
 
   # Like writeScriptBin but the first line is a shebang to nu
-  writeNuBin = name:
+  writeNuBin = name: writeNu "/bin/${name}";
-    writeNu "/bin/${name}";
 
   # makeRubyWriter takes ruby and compatible rubyPackages and produces ruby script writer,
   # If any libraries are specified, ruby.withPackages is used as interpreter, otherwise the "bare" ruby is used.
-  makeRubyWriter = ruby: rubyPackages: buildRubyPackages: name: { libraries ? [], ... } @ args:
+  makeRubyWriter =
-  makeScriptWriter (
+    ruby: _rubyPackages: _buildRubyPackages: name:
-    (builtins.removeAttrs args ["libraries"])
+    {
-    // {
+      libraries ? [ ],
-      interpreter =
+      ...
-        if libraries == []
+    }@args:
-        then "${ruby}/bin/ruby"
+    makeScriptWriter (
-        else "${(ruby.withPackages (ps: libraries))}/bin/ruby";
+      (builtins.removeAttrs args [ "libraries" ])
-      # Rubocop doesnt seem to like running in this fashion.
+      // {
-      #check = (writeDash "rubocop.sh" ''
+        interpreter =
-      #  exec ${lib.getExe buildRubyPackages.rubocop} "$1"
+          if libraries == [ ] then "${ruby}/bin/ruby" else "${(ruby.withPackages (_ps: libraries))}/bin/ruby";
-      #'');
+        # Rubocop doesnt seem to like running in this fashion.
-    }
+        #check = (writeDash "rubocop.sh" ''
-  ) name;
+        #  exec ${lib.getExe buildRubyPackages.rubocop} "$1"
+        #'');
+      }
+    ) name;
 
   # Like writeScript but the first line is a shebang to ruby
   #
@@ -244,26 +259,29 @@ rec {
   #   ''
   writeRuby = makeRubyWriter pkgs.ruby pkgs.rubyPackages buildPackages.rubyPackages;
 
-  writeRubyBin = name:
+  writeRubyBin = name: writeRuby "/bin/${name}";
-    writeRuby "/bin/${name}";
 
   # makeLuaWriter takes lua and compatible luaPackages and produces lua script writer,
   # which validates the script with luacheck at build time. If any libraries are specified,
   # lua.withPackages is used as interpreter, otherwise the "bare" lua is used.
-  makeLuaWriter = lua: luaPackages: buildLuaPackages: name: { libraries ? [], ... } @ args:
+  makeLuaWriter =
-  makeScriptWriter (
+    lua: _luaPackages: buildLuaPackages: name:
-    (builtins.removeAttrs args ["libraries"])
+    { ... }@args:
-    // {
+    makeScriptWriter (
-      interpreter = lua.interpreter;
+      (builtins.removeAttrs args [ "libraries" ])
+      // {
+        interpreter = lua.interpreter;
         # if libraries == []
         # then lua.interpreter
         # else (lua.withPackages (ps: libraries)).interpreter
         # This should support packages! I just cant figure out why some dependency collision happens whenever I try to run this.
-      check = (writeDash "luacheck.sh" ''
+        check = (
-        exec ${buildLuaPackages.luacheck}/bin/luacheck "$1"
+          writeDash "luacheck.sh" ''
-      '');
+            exec ${buildLuaPackages.luacheck}/bin/luacheck "$1"
-    }
+          ''
-   ) name;
+        );
+      }
+    ) name;
 
   # writeLua takes a name an attributeset with libraries and some lua source code and
   # returns an executable (should also work with luajit)
@@ -287,27 +305,27 @@ rec {
   # ''
   writeLua = makeLuaWriter pkgs.lua pkgs.luaPackages buildPackages.luaPackages;
 
-  writeLuaBin = name:
+  writeLuaBin = name: writeLua "/bin/${name}";
-    writeLua "/bin/${name}";
 
-  writeRust = name: {
+  writeRust =
+    name:
+    {
       rustc ? pkgs.rustc,
-      rustcArgs ? [],
+      rustcArgs ? [ ],
-      strip ? true
+      strip ? true,
-  }:
+    }:
-  let
+    let
-    darwinArgs = lib.optionals stdenv.isDarwin [ "-L${lib.getLib libiconv}/lib" ];
+      darwinArgs = lib.optionals stdenv.isDarwin [ "-L${lib.getLib libiconv}/lib" ];
-  in
+    in
     makeBinWriter {
       compileScript = ''
         cp "$contentPath" tmp.rs
-        PATH=${lib.makeBinPath [pkgs.gcc]} ${rustc}/bin/rustc ${lib.escapeShellArgs rustcArgs} ${lib.escapeShellArgs darwinArgs} -o "$out" tmp.rs
+        PATH=${lib.makeBinPath [ pkgs.gcc ]} ${rustc}/bin/rustc ${lib.escapeShellArgs rustcArgs} ${lib.escapeShellArgs darwinArgs} -o "$out" tmp.rs
       '';
       inherit strip;
     } name;
 
-  writeRustBin = name:
+  writeRustBin = name: writeRust "/bin/${name}";
-    writeRust "/bin/${name}";
 
   # writeJS takes a name an attributeset with libraries and some JavaScript sourcecode and
   # returns an executable
@@ -319,23 +337,26 @@ rec {
   #     var result = UglifyJS.minify(code);
   #     console.log(result.code);
   #   ''
-  writeJS = name: { libraries ? [] }: content:
+  writeJS =
-  let
+    name:
-    node-env = pkgs.buildEnv {
+    {
-      name = "node";
+      libraries ? [ ],
-      paths = libraries;
+    }:
-      pathsToLink = [
+    content:
-        "/lib/node_modules"
+    let
-      ];
+      node-env = pkgs.buildEnv {
-    };
+        name = "node";
-  in writeDash name ''
+        paths = libraries;
-    export NODE_PATH=${node-env}/lib/node_modules
+        pathsToLink = [ "/lib/node_modules" ];
-    exec ${lib.getExe pkgs.nodejs} ${pkgs.writeText "js" content} "$@"
+      };
-  '';
+    in
+    writeDash name ''
+      export NODE_PATH=${node-env}/lib/node_modules
+      exec ${lib.getExe pkgs.nodejs} ${pkgs.writeText "js" content} "$@"
+    '';
 
   # writeJSBin takes the same arguments as writeJS but outputs a directory (like writeScriptBin)
-  writeJSBin = name:
+  writeJSBin = name: writeJS "/bin/${name}";
-    writeJS "/bin/${name}";
 
   awkFormatNginx = builtins.toFile "awkFormat-nginx.awk" ''
     awk -f
@@ -343,18 +364,22 @@ rec {
     /\{/{ctx++;idx=1}
     /\}/{ctx--}
     {id="";for(i=idx;i<ctx;i++)id=sprintf("%s%s", id, "\t");printf "%s%s\n", id, $0}
-   '';
-
-  writeNginxConfig = name: text: pkgs.runCommandLocal name {
-    inherit text;
-    passAsFile = [ "text" ];
-    nativeBuildInputs = [ gixy ];
-  } /* sh */ ''
-    # nginx-config-formatter has an error - https://github.com/1connect/nginx-config-formatter/issues/16
-    awk -f ${awkFormatNginx} "$textPath" | sed '/^\s*$/d' > $out
-    gixy $out
   '';
 
+  writeNginxConfig =
+    name: text:
+    pkgs.runCommandLocal name
+      {
+        inherit text;
+        passAsFile = [ "text" ];
+        nativeBuildInputs = [ gixy ];
+      } # sh
+      ''
+        # nginx-config-formatter has an error - https://github.com/1connect/nginx-config-formatter/issues/16
+        awk -f ${awkFormatNginx} "$textPath" | sed '/^\s*$/d' > $out
+        gixy $out
+      '';
+
   # writePerl takes a name an attributeset with libraries and some perl sourcecode and
   # returns an executable
   #
@@ -363,42 +388,55 @@ rec {
   #     use boolean;
   #     print "Howdy!\n" if true;
   #   ''
-  writePerl = name: { libraries ? [], ... } @ args:
+  writePerl =
+    name:
+    {
+      libraries ? [ ],
+      ...
+    }@args:
     makeScriptWriter (
-      (builtins.removeAttrs args ["libraries"])
+      (builtins.removeAttrs args [ "libraries" ])
       // {
-        interpreter = "${lib.getExe (pkgs.perl.withPackages (p: libraries))}";
+        interpreter = "${lib.getExe (pkgs.perl.withPackages (_p: libraries))}";
       }
     ) name;
 
   # writePerlBin takes the same arguments as writePerl but outputs a directory (like writeScriptBin)
-  writePerlBin = name:
+  writePerlBin = name: writePerl "/bin/${name}";
-    writePerl "/bin/${name}";
 
   # makePythonWriter takes python and compatible pythonPackages and produces python script writer,
   # which validates the script with flake8 at build time. If any libraries are specified,
   # python.withPackages is used as interpreter, otherwise the "bare" python is used.
-  makePythonWriter = python: pythonPackages: buildPythonPackages: name: { libraries ? [], flakeIgnore ? [], ... } @ args:
+  makePythonWriter =
-  let
+    python: pythonPackages: buildPythonPackages: name:
-    ignoreAttribute = optionalString (flakeIgnore != []) "--ignore ${concatMapStringsSep "," escapeShellArg flakeIgnore}";
+    {
-  in
+      libraries ? [ ],
-  makeScriptWriter
+      flakeIgnore ? [ ],
-    (
+      ...
-      (builtins.removeAttrs args ["libraries" "flakeIgnore"])
+    }@args:
+    let
+      ignoreAttribute =
+        optionalString (flakeIgnore != [ ])
+          "--ignore ${concatMapStringsSep "," escapeShellArg flakeIgnore}";
+    in
+    makeScriptWriter (
+      (builtins.removeAttrs args [
+        "libraries"
+        "flakeIgnore"
+      ])
       // {
         interpreter =
           if pythonPackages != pkgs.pypy2Packages || pythonPackages != pkgs.pypy3Packages then
-            if libraries == []
+            if libraries == [ ] then python.interpreter else (python.withPackages (_ps: libraries)).interpreter
-            then python.interpreter
+          else
-            else (python.withPackages (ps: libraries)).interpreter
+            python.interpreter;
-          else python.interpreter
+        check = optionalString python.isPy3k (
-        ;
+          writeDash "pythoncheck.sh" ''
-        check = optionalString python.isPy3k (writeDash "pythoncheck.sh" ''
+            exec ${buildPythonPackages.flake8}/bin/flake8 --show-source ${ignoreAttribute} "$1"
-          exec ${buildPythonPackages.flake8}/bin/flake8 --show-source ${ignoreAttribute} "$1"
+          ''
-        '');
+        );
       }
-    )
+    ) name;
-    name;
 
   # writePyPy2 takes a name an attributeset with libraries and some pypy2 sourcecode and
   # returns an executable
@@ -415,8 +453,7 @@ rec {
   writePyPy2 = makePythonWriter pkgs.pypy2 pkgs.pypy2Packages buildPackages.pypy2Packages;
 
   # writePyPy2Bin takes the same arguments as writePyPy2 but outputs a directory (like writeScriptBin)
-  writePyPy2Bin = name:
+  writePyPy2Bin = name: writePyPy2 "/bin/${name}";
-    writePyPy2 "/bin/${name}";
 
   # writePython3 takes a name an attributeset with libraries and some python3 sourcecode and
   # returns an executable
@@ -433,8 +470,7 @@ rec {
   writePython3 = makePythonWriter pkgs.python3 pkgs.python3Packages buildPackages.python3Packages;
 
   # writePython3Bin takes the same arguments as writePython3 but outputs a directory (like writeScriptBin)
-  writePython3Bin = name:
+  writePython3Bin = name: writePython3 "/bin/${name}";
-    writePython3 "/bin/${name}";
 
   # writePyPy3 takes a name an attributeset with libraries and some pypy3 sourcecode and
   # returns an executable
@@ -451,47 +487,61 @@ rec {
   writePyPy3 = makePythonWriter pkgs.pypy3 pkgs.pypy3Packages buildPackages.pypy3Packages;
 
   # writePyPy3Bin takes the same arguments as writePyPy3 but outputs a directory (like writeScriptBin)
-  writePyPy3Bin = name:
+  writePyPy3Bin = name: writePyPy3 "/bin/${name}";
-    writePyPy3 "/bin/${name}";
 
+  makeFSharpWriter =
+    {
+      dotnet-sdk ? pkgs.dotnet-sdk,
+      fsi-flags ? "",
+      libraries ? _: [ ],
+      ...
+    }@args:
+    nameOrPath:
+    let
+      fname = last (builtins.split "/" nameOrPath);
+      path = if strings.hasSuffix ".fsx" nameOrPath then nameOrPath else "${nameOrPath}.fsx";
+      _nugetDeps = mkNugetDeps {
+        name = "${fname}-nuget-deps";
+        nugetDeps = libraries;
+      };
 
-  makeFSharpWriter = { dotnet-sdk ? pkgs.dotnet-sdk, fsi-flags ? "", libraries ? _: [], ... } @ args: nameOrPath:
+      nuget-source = mkNugetSource {
-  let
+        name = "${fname}-nuget-source";
-    fname = last (builtins.split "/" nameOrPath);
+        description = "A Nuget source with the dependencies for ${fname}";
-    path = if strings.hasSuffix ".fsx" nameOrPath then nameOrPath else "${nameOrPath}.fsx";
+        deps = [ _nugetDeps ];
-    _nugetDeps = mkNugetDeps { name = "${fname}-nuget-deps"; nugetDeps = libraries; };
+      };
 
-    nuget-source = mkNugetSource {
+      fsi = writeBash "fsi" ''
-      name = "${fname}-nuget-source";
+        export HOME=$NIX_BUILD_TOP/.home
-      description = "A Nuget source with the dependencies for ${fname}";
+        export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1
-      deps = [ _nugetDeps ];
+        export DOTNET_CLI_TELEMETRY_OPTOUT=1
-    };
+        export DOTNET_NOLOGO=1
+        script="$1"; shift
+        ${lib.getExe dotnet-sdk} fsi --quiet --nologo --readline- ${fsi-flags} "$@" < "$script"
+      '';
 
-    fsi = writeBash "fsi" ''
+    in
-      export HOME=$NIX_BUILD_TOP/.home
+    content:
-      export DOTNET_SKIP_FIRST_TIME_EXPERIENCE=1
+    makeScriptWriter
-      export DOTNET_CLI_TELEMETRY_OPTOUT=1
+      (
-      export DOTNET_NOLOGO=1
+        (builtins.removeAttrs args [
-      script="$1"; shift
+          "dotnet-sdk"
-      ${lib.getExe dotnet-sdk} fsi --quiet --nologo --readline- ${fsi-flags} "$@" < "$script"
+          "fsi-flags"
-    '';
+          "libraries"
+        ])
+        // {
+          interpreter = fsi;
+        }
+      )
+      path
+      ''
+        #i "nuget: ${nuget-source}/lib"
+        ${content}
+        exit 0
+      '';
 
-  in content: makeScriptWriter (
+  writeFSharp = makeFSharpWriter { };
-    (builtins.removeAttrs args ["dotnet-sdk" "fsi-flags" "libraries"])
-    // {
-      interpreter = fsi;
-    }
-  ) path
-  ''
-    #i "nuget: ${nuget-source}/lib"
-    ${ content }
-    exit 0
-  '';
 
-  writeFSharp =
+  writeFSharpBin = name: writeFSharp "/bin/${name}";
-    makeFSharpWriter {};
-
-  writeFSharpBin = name:
-    writeFSharp "/bin/${name}";
 
 }