Rework Nix example project & add Nix template

Changes the Nix infrastructure inside of simple-nix to use Nix flakes.
Adds some more explanation how to include dependencies using Nix and
includes a Nix template. All of this was done to make it more user
friendly (...for Nix users) to get started with Clash without having to
have very deep knowledge of Nix or how Cabal works to make Nix and Cabal
work together happily.

People who have Nix installed can now use immediately start using Clash
with the simple-nix directory by running three commands:

```
mkdir my-project
cd my-project
nix flake init -t github:clash-lang/clash-starters
```

After this nix command is executed, it will display a 'welcome' message
which gives a plain overview of what the Nix related commands do and
instructs the user to read the README.md for more information.

The original PR is: clash-lang/clash-starters#6
Which I have closed after realizing that repository is essentially just
a mirror

Author: jaschutte

flake.nix

@@ -0,0 +1,36 @@
+{
+  description = "A flake for clash-starter templates. For an actual flake containing the project, check the `simple-nix` subdirectory.";
+
+  outputs = { self }: {
+    defaultTemplate = {
+      path = ./projects/simple-nix;
+      description = "A template containing a simple Clash project with a Nix flake for development";
+      welcomeText = ''
+        # Nix development
+        To use Nix to develop your Clash project, simply run `nix develop` in your current directory.
+        This will put you into an environment with all the tools you will need to build the starter
+        project.
+
+        To compile the project and generate HDL, simply run `nix run` and the output Verilog will be
+        under the `verilog` directory. If you changed the HDL language to VHDL, it will be under the
+        `vhdl` directory.
+
+        You can also run `nix build` to build the project using Nix. Although this isn't very
+        useful in the starter project, it is very useful when developing libraries!
+
+        # Cabal & Nix clashes
+        Cabal and Nix work happily together, most of the time. One important thing of note is that
+        you should **not** define sources using `cabal.project` files. This will overwrite Nix's
+        package source and *will* cause problems. To add dependencies, add them via `flake.nix`.
+
+        # TLDR
+        1. run `nix develop` to immediately jump into development
+        2. run `nix run` to build the package and generate HDL with Nix
+        3. run `nix build` to build the package as a library with Nix
+
+        Read the README.md for more information!
+        Happy hacking!
+      '';
+    };
+  };
+}

projects/simple-nix/default.nix

@@ -0,0 +1,80 @@
+{
+  description = "A flake for the Clash starter project";
+  inputs = {
+    nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
+    clash-compiler.url = "github:clash-lang/clash-compiler?rev=v1.8.4";
+  };
+  outputs = { self, nixpkgs, flake-utils, clash-compiler }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        # A list of regular packages you want to use with your project
+        pkgs = (import nixpkgs {
+          inherit system;
+        });
+
+        # What version of GHC you want to use
+        # The version must be in the list of supported versions of the clash-compiler!
+        ghc-version = "ghc9101";
+
+        # A list of HASKELL packages clash-compiler uses, we use this set packages to prevent version
+        # conflicts with the regular nixpkgs when using Clash
+        clash-pkgs = ((import clash-compiler.inputs.nixpkgs {
+          inherit system;
+        }).extend clash-compiler.overlays.${ghc-version})."clashPackages-${ghc-version}";
+
+        package-overlay = final: prev: {
+          # Here you define the project you want to build
+          simple-nix = prev.developPackage {
+            root = ./.;
+            overrides = _: _: final;
+          };
+        };
+
+        # Create a set of Haskell packages including ours!
+        hs-pkgs = clash-pkgs.extend package-overlay;
+
+        # Options for `nix run`
+        # Select the toplevel module
+        top-module = "Example.Project";
+        # Output VHDL or Verilog
+        hdl = "verilog";
+      in
+        {
+          # Develop the project using `nix develop`
+          devShells.default = hs-pkgs.shellFor {
+            # Under `packages` we list out all Haskell packages we want to develop *for*
+            # This will then grab all the dependencies for those packages
+            # Note that this does *not* build the package itself! Only the dependencies of the package
+            packages = p: [
+              p.simple-nix
+            ];
+
+            nativeBuildInputs = [
+              # Standard
+              hs-pkgs.cabal-install
+              hs-pkgs.cabal-plan
+              hs-pkgs.fourmolu
+              # HLS is commented out as it takes long to compile, but if you want it, here it is:
+              # hs-pkgs.haskell-language-server
+
+              # Regular dependencies you may want to use in your project
+              pkgs.hello
+            ];
+          };
+
+          # Build the project with Clash and generate HDL
+          # This can be ran using `nix run` and will output Verilog files under the `verilog` subdirectory
+          # The top-module and hdl are variables defined above in the let statement
+          apps.default = {
+            type = "app";
+            program = (pkgs.writeShellScript "compile" ''
+              cabal build
+              cabal run clash ${top-module} -- --${hdl}
+            '').outPath;
+          };
+
+          # Build the project using `nix build`
+          packages.default = hs-pkgs.simple-nix;
+        }
+    );
+}