is there a nice way to set up a somewhat "ad hoc" haskell environment with nix? I'd like to do some tinkering around with some data and I'm not quite sure what I'm looking for yet. I want to have access to packages from the package set but I just want to use runhaskell or maybe `cabal repl`, but don't really want to write a cabal file and do a native build before being able to run code.

I believe you might be interested in she-bangs:

#! /usr/bin/env nix-shell
#! nix-shell -p "haskellPackages.ghcWithPackages (pkgs: with pkgs; [])" -i runhaskell

main :: IO ()
main = do
  putStrLn "Hello World!"

Or, my personal favorite (requires nix >= 2.19), which actually compiles and caches the binary:

#!/usr/bin/env nix
#!nix shell nixpkgs#cached-nix-shell --command sh -c ``nix store add "$(readlink -f "$1")" | xargs -I % cached-nix-shell -p 'runCommand "cached-nix-script" {} "mkdir -p $out/bin; ${(haskellPackages.ghcWithPackages (pkgs: with pkgs; []))}/bin/ghc -O2 -o $out/bin/cached-nix-script ${builtins.storePath %}"' --exec cached-nix-script "${@:2}"`` sh

main :: IO ()
main = do
  putStrLn "Hello World!"

I believe you might be interested in she-bangs:

#! /usr/bin/env nix-shell
#! nix-shell -p "haskellPackages.ghcWithPackages (pkgs: with pkgs; [])" -i runhaskell

main :: IO ()
main = do
  putStrLn "Hello World!"

Or, my personal favorite (requires nix >= 2.19), which actually compiles and caches both nix evaluation and the binary:

#!/usr/bin/env nix
#!nix shell nixpkgs#cached-nix-shell --command sh -c ``nix store add "$(readlink -f "$1")" | xargs -I % cached-nix-shell -p 'runCommand "cached-nix-script" {} "mkdir -p $out/bin; ${(haskellPackages.ghcWithPackages (pkgs: with pkgs; []))}/bin/ghc -O2 -o $out/bin/cached-nix-script ${builtins.storePath %}"' --exec cached-nix-script "${@:2}"`` sh

main :: IO ()
main = do
  putStrLn "Hello World!"

Then just run the file as normal executable.

I believe you might be interested in she-bangs:

#! /usr/bin/env nix-shell
#! nix-shell -p "haskellPackages.ghcWithPackages (pkgs: with pkgs; [])" -i runhaskell

main :: IO ()
main = do
  putStrLn "Hello World!"

Or, my personal favorite (requires nix >= 2.19), which actually compiles and caches both nix evaluation and the binary (i.e. ~0 start up cost + maximum performance):

#!/usr/bin/env nix
#!nix shell nixpkgs#cached-nix-shell --command sh -c ``nix store add "$(readlink -f "$1")" | xargs -I % cached-nix-shell -p 'runCommand "cached-nix-script" {} "mkdir -p $out/bin; ${(haskellPackages.ghcWithPackages (pkgs: with pkgs; []))}/bin/ghc -O2 -o $out/bin/cached-nix-script ${builtins.storePath %}"' --exec cached-nix-script "${@:2}"`` sh

main :: IO ()
main = do
  putStrLn "Hello World!"

Then just run the file as normal executable.

Last message kind of reminded me of this "cool" nix she-bang that gives instant-startup + portable + performant haskell scripting I managed to slap together, so I guess I'll leave it outside of the reply thread for more visibility in case it helps anybody.

#!/usr/bin/env nix
#!nix shell nixpkgs#cached-nix-shell --command sh -c ``nix store add "$(readlink -f "$1")" | xargs -I % cached-nix-shell -p 'runCommand "cached-nix-script" {} "mkdir -p $out/bin; ${(haskellPackages.ghcWithPackages (pkgs: with pkgs; []))}/bin/ghc -O2 -o $out/bin/cached-nix-script ${builtins.storePath %}"' --exec cached-nix-script "${@:2}"`` sh

main :: IO ()
main = do
  putStrLn "Hello World!"

1. nix shell nixpkgs#cached-nix-shell uses flakes eval-cache to instantly bring cached-nix-shell from cache if it's already in store, or store it if it isn't
2. nix store add "$(readlink -f "$1")" adds the script to the nix store
3. cached-nix-shell runs a wrapper around nix-shell that caches it's evaluation
4. runCommand actually compiles the script instead of simply interpreting it like runhaskell/runghc
5. haskellPackages.ghcWithPackages (pkgs: with pkgs; [ ]) is where you put your haskell dependencies

At first run it compiles and runs the script, after that it merely runs an already compiled executable.

The reason it's so complicated is because in v3 nix shell --expr "..." you can't reference neither flake nor channel nixpkgs without running it with --impure which disables eval-cache. Old nix-shell doesn't have eval-cache at all, so even if we use it to bring up cached-nix-shell we waste time even if cached-nix-shell is already in store.

Last message kind of reminded me of this "cool" nix she-bang that gives instant-startup + portable + performant haskell scripting I managed to slap together, so I guess I'll leave it outside of the reply thread for more visibility in case it helps anybody.

#!/usr/bin/env nix
#!nix shell nixpkgs#cached-nix-shell --command sh -c ``nix store add "$(readlink -f "$1")" | xargs -I % cached-nix-shell -p 'runCommand "cached-nix-script" {} "mkdir -p $out/bin; ${(haskellPackages.ghcWithPackages (pkgs: with pkgs; []))}/bin/ghc -O2 -o $out/bin/cached-nix-script ${builtins.storePath %}"' --exec cached-nix-script "${@:2}"`` sh

main :: IO ()
main = do
  putStrLn "Hello World!"

1. nix shell nixpkgs#cached-nix-shell uses flakes eval-cache to instantly bring cached-nix-shell from cache if it's already in store, or store it if it isn't
2. nix store add "$(readlink -f "$1")" adds the script to the nix store
3. cached-nix-shell runs a wrapper around nix-shell that caches it's evaluation
4. runCommand actually compiles the script instead of simply interpreting it like runhaskell/runghc
5. haskellPackages.ghcWithPackages (pkgs: with pkgs; [ ]) is where you put your haskell dependencies

At first run it compiles and runs the script, after that it merely runs an already compiled executable.

The reason it's so complicated is because in new nix shell --expr "..." you can't reference neither flake nor channel nixpkgs without running it with --impure which disables eval-cache. Old nix-shell doesn't have eval-cache at all, so even if we use it to bring up cached-nix-shell we waste time even if cached-nix-shell is already in store.

Last message kind of reminded me of this "cool" nix she-bang (requires nix >= 2.19) that gives instant-startup + portable + performant haskell scripting I managed to slap together, so I guess I'll leave it outside of the reply thread for more visibility in case it helps anybody.

#!/usr/bin/env nix
#!nix shell nixpkgs#cached-nix-shell --command sh -c ``nix store add "$(readlink -f "$1")" | xargs -I % cached-nix-shell -p 'runCommand "cached-nix-script" {} "mkdir -p $out/bin; ${(haskellPackages.ghcWithPackages (pkgs: with pkgs; []))}/bin/ghc -O2 -o $out/bin/cached-nix-script ${builtins.storePath %}"' --exec cached-nix-script "${@:2}"`` sh

main :: IO ()
main = do
  putStrLn "Hello World!"

1. nix shell nixpkgs#cached-nix-shell uses flakes eval-cache to instantly bring cached-nix-shell from cache if it's already in store, or store it if it isn't
2. nix store add "$(readlink -f "$1")" adds the script to the nix store
3. cached-nix-shell runs a wrapper around nix-shell that caches it's evaluation
4. runCommand actually compiles the script instead of simply interpreting it like runhaskell/runghc
5. haskellPackages.ghcWithPackages (pkgs: with pkgs; [ ]) is where you put your haskell dependencies

At first run it compiles and runs the script, after that it merely runs an already compiled executable.

The reason it's so complicated is because in new nix shell --expr "..." you can't reference neither flake nor channel nixpkgs without running it with --impure which disables eval-cache. Old nix-shell doesn't have eval-cache at all, so even if we use it to bring up cached-nix-shell we waste time even if cached-nix-shell is already in store.

In reply to ymeister

I believe you might be interested in she-bangs:

#! /usr/bin/env nix-shell
#! nix-shell -p "haskellPackages.ghcWithPackages (pkgs: with pkgs; [])" -i runhaskell

main :: IO ()
main = do
  putStrLn "Hello World!"

Or, my personal favorite (requires nix >= 2.19), which actually compiles and caches the binary:

#!/usr/bin/env nix
#!nix shell nixpkgs#cached-nix-shell --command sh -c ``nix store add "$(readlink -f "$1")" | xargs -I % cached-nix-shell -p 'runCommand "cached-nix-script" {} "mkdir -p $out/bin; ${(haskellPackages.ghcWithPackages (pkgs: with pkgs; []))}/bin/ghc -O2 -o $out/bin/cached-nix-script ${builtins.storePath %}"' --exec cached-nix-script "${@:2}"`` sh

main :: IO ()
main = do
  putStrLn "Hello World!"

ah, neat, going to try that, thank you

In reply to @b:chreekat.net
What I thought you should do is specify your package and its modified dependencies in the same haskellPackages override, but that results in "This package indirectly depends on multiple versions of the same package."

I am a bit confused

• how is it possible that cabal fails to build with non-matching unix constraint on pkgsStatic while it doesn’t on normal pkgs?
• why is semaphore-compat set to null on ghc 9.10 when it’s needed to e.g. build cabal-install?

In reply to @maralorn:maralorn.de
Re the second: We generally set packages to null, when they are distributed with ghc. semaphore-compat sounds definitely like a package to which this applies.

In reply to @mangoiv.:matrix.org
Static ghc 9.10 is not cached 🥲

In reply to @cdepillabout:matrix.org
Did you try the haskell-updates branch? That's what Hydra builds for us, and I think it should still contain the pkgsStatic ghc.

In reply to @mangoiv.:matrix.org
Nah, I’m good with unstable for now, don’t wanna spend time fiddling around to get HLS building. I just use ghc910 haskell packages for the static build

In reply to @cdepillabout:matrix.org
Ah, I mean if you want to get ghc for pkgsStatic from the cache, you should use a commit from haskell-updates. Not the current haskell-updates, since like you say stuff may be broken, but one of the last commits from the previous haskell-updates. That way you can get everything from the cache, and almost nothing should be broken.