Fix

Co-authored-by: tomjaguarpaw <tom-github.com@jaguarpaw.co.uk>

.cirrus.yml

@@ -0,0 +1,25 @@
+freebsd_instance:
+  image_family: freebsd-13-1
+
+task:
+  env:
+    GHC_VER: 9.2.4
+    CABAL_VER: 3.6.2.0
+    ARTIFACT: "x86_64-portbld-freebsd-ghcup"
+    ARCH: 64
+    RUNNER_OS: FreeBSD
+    DISTRO: na
+    GITHUB_WORKSPACE: ${CIRRUS_WORKING_DIR}
+    JSON_VERSION: "0.0.7"
+    CIRRUS_CLONE_SUBMODULES: true
+    AWS_ACCESS_KEY_ID: ENCRYPTED[3e99c4ac040871f213abd616ec66952d954dc289cdd97772f88e58a74d08a2250133437780fe98b7aedf7ef1fb32f5eb]
+    AWS_SECRET_ACCESS_KEY: ENCRYPTED[5910cfd77a922ff7fc06eeb6a6b9f79d4867863e541f06eb2c4cfecae0613650e3e0588373fa8d9249d295d76cf9cb3b]
+    S3_HOST: ENCRYPTED[ce961780a33159f7d1d8046956b5ac6ebc3bfc8149428e5f538576cda51d9f3d0c35b79cdd1e325793639ff6e31f889d]
+  install_script: pkg install -y ghc hs-cabal-install git bash misc/compat10x misc/compat11x misc/compat12x gmake
+  script:
+    - tzsetup Etc/GMT
+    - adjkerntz -a
+    - bash .github/scripts/build.sh
+    - bash .github/scripts/test.sh
+  binaries_artifacts:
+    path: "out/*"

.github/ghcup-run.files

@@ -0,0 +1,37 @@
+.
+./cabal
+./ghc
+./ghc-8.10.7
+./ghc-pkg
+./ghc-pkg-8.10.7
+./ghci
+./ghci-8.10.7
+./haddock
+./haddock-8.10.7
+./haskell-language-server-8.10.6
+./haskell-language-server-8.10.6~1.6.1.0
+./haskell-language-server-8.10.7
+./haskell-language-server-8.10.7~1.6.1.0
+./haskell-language-server-8.6.5
+./haskell-language-server-8.6.5~1.6.1.0
+./haskell-language-server-8.8.4
+./haskell-language-server-8.8.4~1.6.1.0
+./haskell-language-server-9.0.1
+./haskell-language-server-9.0.1~1.6.1.0
+./haskell-language-server-9.0.2
+./haskell-language-server-9.0.2~1.6.1.0
+./haskell-language-server-9.2.1
+./haskell-language-server-9.2.1~1.6.1.0
+./haskell-language-server-wrapper
+./haskell-language-server-wrapper-1.6.1.0
+./hp2ps
+./hp2ps-8.10.7
+./hpc
+./hpc-8.10.7
+./hsc2hs
+./hsc2hs-8.10.7
+./runghc
+./runghc-8.10.7
+./runhaskell
+./runhaskell-8.10.7
+./stack

.github/ghcup-run.files.alpine

@@ -0,0 +1,31 @@
+.
+./cabal
+./ghc
+./ghc-8.10.7
+./ghc-pkg
+./ghc-pkg-8.10.7
+./ghci
+./ghci-8.10.7
+./haddock
+./haddock-8.10.7
+./haskell-language-server-8.10.7
+./haskell-language-server-8.10.7~1.6.1.0
+./haskell-language-server-8.8.4
+./haskell-language-server-8.8.4~1.6.1.0
+./haskell-language-server-9.0.2
+./haskell-language-server-9.0.2~1.6.1.0
+./haskell-language-server-9.2.1
+./haskell-language-server-9.2.1~1.6.1.0
+./haskell-language-server-wrapper
+./haskell-language-server-wrapper-1.6.1.0
+./hp2ps
+./hp2ps-8.10.7
+./hpc
+./hpc-8.10.7
+./hsc2hs
+./hsc2hs-8.10.7
+./runghc
+./runghc-8.10.7
+./runhaskell
+./runhaskell-8.10.7
+./stack

.github/ghcup-run.files.windows

@@ -0,0 +1,81 @@
+.
+./cabal.exe
+./cabal.shim
+./ghc-8.10.7.exe
+./ghc-8.10.7.shim
+./ghc-pkg-8.10.7.exe
+./ghc-pkg-8.10.7.shim
+./ghc-pkg.exe
+./ghc-pkg.shim
+./ghc.exe
+./ghc.shim
+./ghci-8.10.7.exe
+./ghci-8.10.7.shim
+./ghci.exe
+./ghci.shim
+./ghcii-8.10.7.sh-8.10.7.exe
+./ghcii-8.10.7.sh-8.10.7.shim
+./ghcii-8.10.7.sh.exe
+./ghcii-8.10.7.sh.shim
+./ghcii.sh-8.10.7.exe
+./ghcii.sh-8.10.7.shim
+./ghcii.sh.exe
+./ghcii.sh.shim
+./haddock-8.10.7.exe
+./haddock-8.10.7.shim
+./haddock.exe
+./haddock.shim
+./haskell-language-server-8.10.6.exe
+./haskell-language-server-8.10.6.shim
+./haskell-language-server-8.10.6~1.6.1.0.exe
+./haskell-language-server-8.10.6~1.6.1.0.shim
+./haskell-language-server-8.10.7.exe
+./haskell-language-server-8.10.7.shim
+./haskell-language-server-8.10.7~1.6.1.0.exe
+./haskell-language-server-8.10.7~1.6.1.0.shim
+./haskell-language-server-8.6.5.exe
+./haskell-language-server-8.6.5.shim
+./haskell-language-server-8.6.5~1.6.1.0.exe
+./haskell-language-server-8.6.5~1.6.1.0.shim
+./haskell-language-server-8.8.4.exe
+./haskell-language-server-8.8.4.shim
+./haskell-language-server-8.8.4~1.6.1.0.exe
+./haskell-language-server-8.8.4~1.6.1.0.shim
+./haskell-language-server-9.0.1.exe
+./haskell-language-server-9.0.1.shim
+./haskell-language-server-9.0.1~1.6.1.0.exe
+./haskell-language-server-9.0.1~1.6.1.0.shim
+./haskell-language-server-9.0.2.exe
+./haskell-language-server-9.0.2.shim
+./haskell-language-server-9.0.2~1.6.1.0.exe
+./haskell-language-server-9.0.2~1.6.1.0.shim
+./haskell-language-server-9.2.1.exe
+./haskell-language-server-9.2.1.shim
+./haskell-language-server-9.2.1~1.6.1.0.exe
+./haskell-language-server-9.2.1~1.6.1.0.shim
+./haskell-language-server-wrapper-1.6.1.0.exe
+./haskell-language-server-wrapper-1.6.1.0.shim
+./haskell-language-server-wrapper.exe
+./haskell-language-server-wrapper.shim
+./hp2ps-8.10.7.exe
+./hp2ps-8.10.7.shim
+./hp2ps.exe
+./hp2ps.shim
+./hpc-8.10.7.exe
+./hpc-8.10.7.shim
+./hpc.exe
+./hpc.shim
+./hsc2hs-8.10.7.exe
+./hsc2hs-8.10.7.shim
+./hsc2hs.exe
+./hsc2hs.shim
+./runghc-8.10.7.exe
+./runghc-8.10.7.shim
+./runghc.exe
+./runghc.shim
+./runhaskell-8.10.7.exe
+./runhaskell-8.10.7.shim
+./runhaskell.exe
+./runhaskell.shim
+./stack.exe
+./stack.shim

.github/release.yaml

@@ -0,0 +1,109 @@
+name: Create Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  draft_release:
+    name: Create Release
+    runs-on: ubuntu-latest
+    outputs:
+      upload_url: ${{ steps.create_release.outputs.upload_url }}
+
+    steps:
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: Release ${{ github.ref }}
+          body: |
+            Changes in this Release
+            - First Change
+            - Second Change
+          draft: true
+          prerelease: false
+
+  release-mac:
+    name: Create Release for macOS
+    needs: draft_release
+    runs-on: ${{ matrix.os }}
+    env:
+      MACOSX_DEPLOYMENT_TARGET: 10.13
+    strategy:
+      matrix:
+        os:
+          - macOS-10.15
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+
+      - uses: haskell/actions/setup@v1.2
+        with:
+          ghc-version: 8.10.4
+          cabal-version: 3.4.0.0
+
+      - name: create ~/.local/bin
+        run: mkdir -p "$HOME/.local/bin"
+        shell: bash
+
+      - name: Add ~/.local/bin to PATH
+        run: echo "$HOME/.local/bin" >> $GITHUB_PATH
+        shell: bash
+
+      - name: Update cabal cache
+        run: cabal update
+        shell: bash
+
+      - name: Install cabal dependencies
+        run: cabal build --only-dependencies
+        shell: bash
+
+      - name: Build
+        run: cabal build -w ghc-${GHC_VERSION} --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" -ftui
+        shell: bash
+
+      - name: Install
+        run: cp "$(cabal list-bin exe:ghcup)" ~/.local/bin/ghcup
+        shell: bash
+
+      - name: Strip
+        run: strip ~/.local/bin/ghcup
+        shell: bash
+
+      - name: Run tests
+        run: cabal test --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" all
+        shell: bash
+
+      - name: Install git
+        run: brew install git
+
+      - name: set HOME
+        run: echo "HOME=$HOME" >> $GITHUB_ENV
+        shell: bash
+
+      - name: Set ASSET_PATH
+        run: echo "ASSET_PATH=$HOME/.local/bin/ghcup" >> $GITHUB_ENV
+        shell: bash
+
+      - name: Upload Release Asset
+        id: upload-release-asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.draft_release.outputs.upload_url }}
+          asset_path: ${{ env.ASSET_PATH }}
+          asset_name: ghcup-${{ matrix.os }}
+          asset_content_type: application/octet-stream
+
+      - if: always()
+        uses: actions/upload-artifact@v2
+        with:
+          name: plan.json
+          path: ./dist-newstyle/cache/plan.json
+

.github/scripts/bootstrap.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+set -eux
+
+. .github/scripts/prereq.sh
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+git describe --always
+
+### build
+
+./scripts/bootstrap/bootstrap-haskell
+
+[ "$(ghc --numeric-version)" = "${BOOTSTRAP_HASKELL_GHC_VERSION}" ]
+

.github/scripts/build.sh

@@ -0,0 +1,76 @@
+#!/bin/sh
+
+set -eux
+
+. .github/scripts/prereq.sh
+. .github/scripts/common.sh
+
+
+# ensure ghcup
+if ! command -v ghcup ; then
+	install_ghcup
+fi
+
+# ensure cabal-cache
+if ! cabal-cache version ; then
+	download_cabal_cache "$HOME/.local/bin/cabal-cache"
+fi
+
+# ensure ghc
+if [ "${RUNNER_OS}" != "FreeBSD" ] ; then
+	if [ "${DISTRO}" != "Debian" ] ; then # ! armv7 or aarch64 linux
+		if ! "ghc-${GHC_VER}" --numeric-version ; then
+			ghcup -v install ghc --set --force "$GHC_VER"
+		fi
+		if [ "$(cabal --numeric-version || true)" != "${CABAL_VER}" ] ; then
+			ghcup -v install cabal --force "$CABAL_VER"
+		fi
+		ghc --version
+		cabal --version
+		GHC="ghc-${GHC_VER}"
+	else
+		if [ "$(cabal --numeric-version || true)" != "${CABAL_VER}" ] ; then
+			ghcup -v install cabal --force "$CABAL_VER"
+		fi
+		cabal --version
+		GHC="ghc"
+	fi
+else
+	ghc --version
+	cabal --version
+	GHC="ghc"
+fi
+
+git_describe
+
+
+# build
+ecabal update
+
+if [ "${RUNNER_OS}" = "Linux" ] ; then
+	if [ "${ARCH}" = "32" ] ; then
+		build_with_cache -w "${GHC}" --ghc-options='-split-sections -optl-static' -ftui --enable-tests
+	elif [ "${ARCH}" = "64" ] ; then
+		build_with_cache -w "${GHC}" --ghc-options='-split-sections -optl-static' -ftui --enable-tests
+	else
+		build_with_cache -w "${GHC}" -ftui --enable-tests
+	fi
+elif [ "${RUNNER_OS}" = "FreeBSD" ] ; then
+	build_with_cache -w "${GHC}" --ghc-options='-split-sections' --constraint="zlib +bundled-c-zlib" --constraint="zip +disable-zstd" -ftui --enable-tests
+elif [ "${RUNNER_OS}" = "Windows" ] ; then
+	build_with_cache -w "${GHC}" --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" --enable-tests
+else
+	build_with_cache -w "${GHC}" --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" -ftui --enable-tests
+fi
+
+
+# set up artifacts
+mkdir -p out
+binary=$(cabal list-bin ghcup)
+binary_test=$(cabal list-bin ghcup-test)
+ver=$("${binary}" --numeric-version)
+strip_binary "${binary}"
+cp "${binary}" "out/${ARTIFACT}-${ver}"
+cp "${binary_test}" "out/test-${ARTIFACT}-${ver}"
+cp ./dist-newstyle/cache/plan.json "out/${ARTIFACT}.plan.json"
+

.github/scripts/common.sh

@@ -0,0 +1,172 @@
+#!/bin/sh
+
+if [ "${RUNNER_OS}" = "Windows" ] ; then
+	ext=".exe"
+else
+	ext=''
+fi
+
+ecabal() {
+	cabal "$@"
+}
+
+sync_from_retry() {
+	if [ "${RUNNER_OS}" != "Windows" ] ; then
+		cabal_store_path="$(dirname "$(cabal help user-config | tail -n 1 | xargs)")/store"
+	else
+		cabal_store_path="${CABAL_DIR}/store"
+	fi
+
+    sync_from || { sleep 9 ; rm -rf "${cabal_store_path:?}"/* ; sync_from || { sleep 20 ; rm -rf "${cabal_store_path:?}"/* ; sync_from ; } }
+}
+
+sync_from() {
+	if [ "${RUNNER_OS}" != "Windows" ] ; then
+		cabal_store_path="$(dirname "$(cabal help user-config | tail -n 1 | xargs)")/store"
+	fi
+
+	cabal-cache sync-from-archive \
+		--host-name-override=${S3_HOST} \
+		--host-port-override=443 \
+		--host-ssl-override=True \
+		--region us-west-2 \
+		$([ "${RUNNER_OS}" != "Windows" ] && echo --store-path="$cabal_store_path") \
+		--archive-uri "s3://ghcup-hs/${RUNNER_OS}-${ARCH}-${DISTRO}"
+}
+
+sync_to_retry() {
+    sync_to || { sleep 9 ; sync_to || { sleep 20 ; sync_to ; } }
+}
+
+sync_to() {
+	if [ "${RUNNER_OS}" != "Windows" ] ; then
+		cabal_store_path="$(dirname "$(cabal help user-config | tail -n 1 | xargs)")/store"
+	fi
+
+	cabal-cache sync-to-archive \
+		--host-name-override=${S3_HOST} \
+		--host-port-override=443 \
+		--host-ssl-override=True \
+		--region us-west-2 \
+		$([ "${RUNNER_OS}" != "Windows" ] && echo --store-path="$cabal_store_path") \
+		--archive-uri "s3://ghcup-hs/${RUNNER_OS}-${ARCH}-${DISTRO}"
+}
+
+raw_eghcup() {
+	"$GHCUP_BIN/ghcup${ext}" -v -c "$@"
+}
+
+eghcup() {
+	if [ "${OS}" = "Windows" ] ; then
+		"$GHCUP_BIN/ghcup${ext}" -c -s "file:/$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml" "$@"
+	else
+		"$GHCUP_BIN/ghcup${ext}" -c -s "file://$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml" "$@"
+	fi
+}
+
+sha_sum() {
+	if [ "${OS}" = "FreeBSD" ] ; then
+		sha256 "$@"
+	else
+		sha256sum "$@"
+	fi
+
+}
+
+git_describe() {
+	git config --global --get-all safe.directory | grep '^\*$' || git config --global --add safe.directory "*"
+	git describe --always
+}
+
+download_cabal_cache() {
+	(
+	set -e
+	dest="$HOME/.local/bin/cabal-cache"
+    url=""
+	exe=""
+	cd /tmp
+	case "${RUNNER_OS}" in
+		"Linux")
+			case "${ARCH}" in
+				"32") url=https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal-cache/experimental5/i386-linux-cabal-cache
+					;;
+				"64") url=https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal-cache/experimental5/x86_64-linux-cabal-cache
+					;;
+				"ARM64") url=https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal-cache/experimental5/aarch64-linux-cabal-cache
+					;;
+				"ARM") url=https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal-cache/experimental5/armv7-linux-cabal-cache
+					;;
+			esac
+			;;
+		"FreeBSD")
+			url=https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal-cache/experimental5/x86_64-portbld-freebsd-cabal-cache
+			;;
+		"Windows")
+			exe=".exe"
+			url=https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal-cache/experimental5/x86_64-mingw64-cabal-cache
+			;;
+		"macOS")
+			case "${ARCH}" in
+				"ARM64") url=https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal-cache/experimental5/aarch64-apple-darwin-cabal-cache
+					;;
+				"64") url=https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal-cache/experimental5/x86_64-apple-darwin-cabal-cache
+					;;
+			esac
+			;;
+	esac
+
+	if [ -n "${url}" ] ; then
+		case "${url##*.}" in
+			"gz")
+				curl -L -o - "${url}" | gunzip > cabal-cache${exe}
+				;;
+			*)
+				curl -o cabal-cache${exe} -L "${url}"
+				;;
+		esac
+		sha_sum cabal-cache${exe}
+		mv "cabal-cache${exe}" "${dest}${exe}"
+		chmod +x "${dest}${exe}"
+	fi
+    )
+}
+
+build_with_cache() {
+	ecabal configure "$@"
+	ecabal build --dependencies-only "$@" --dry-run
+	sync_from_retry
+	ecabal build --dependencies-only "$@" || sync_to_retry
+	sync_to_retry
+	ecabal build "$@"
+	sync_to_retry
+}
+
+install_ghcup() {
+	find "$GHCUP_INSTALL_BASE_PREFIX"
+	mkdir -p "$GHCUP_BIN"
+	mkdir -p "$GHCUP_BIN"/../cache
+
+	if [ "${RUNNER_OS}" = "FreeBSD" ] ; then
+		curl -o ghcup https://downloads.haskell.org/ghcup/tmp/x86_64-portbld-freebsd-ghcup-0.1.18.1
+		chmod +x ghcup
+		mv ghcup "$HOME/.local/bin/ghcup"
+	else
+		curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_NONINTERACTIVE=1 BOOTSTRAP_HASKELL_MINIMAL=1 BOOTSTRAP_HASKELL_INSTALL_NO_STACK=yes sh
+	fi
+}
+
+strip_binary() {
+	(
+	set -e
+	local binary=$1
+	case "$(uname -s)" in
+		"Darwin"|"darwin")
+			;;
+		MSYS_*|MINGW*)
+			;;
+		*)
+			strip -s "${binary}"
+		   ;;
+   esac
+	)
+}

.github/scripts/hls.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+
+set -eux
+
+. .github/scripts/prereq.sh
+. .github/scripts/common.sh
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+### build
+
+
+
+if [ "${OS}" = "Windows" ] ; then
+	GHCUP_DIR="${GHCUP_INSTALL_BASE_PREFIX}"/ghcup
+else
+	GHCUP_DIR="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
+fi
+
+rm -rf "${GHCUP_DIR}"
+mkdir -p "${GHCUP_BIN}"
+
+ls -lah out
+find out
+cp "out/${ARTIFACT}"-* "$GHCUP_BIN/ghcup${ext}"
+chmod +x "$GHCUP_BIN/ghcup${ext}"
+echo "$PATH"
+
+"$GHCUP_BIN/ghcup${ext}" --version
+eghcup --version
+sha_sum "$GHCUP_BIN/ghcup${ext}"
+sha_sum "$(raw_eghcup --offline whereis ghcup)"
+
+git_describe
+
+eghcup install ghc "${GHC_VERSION}"
+eghcup install cabal
+
+ecabal update
+
+if ! command -v cabal-cache ; then
+	download_cabal_cache "$HOME/.local/bin/cabal-cache"
+fi
+
+if ! cabal-cache version ; then
+	build_cabal_cache "$HOME/.local/bin"
+fi
+
+
+eghcup debug-info
+
+(
+	cd /tmp
+	git clone --depth 1 --branch "${HLS_TARGET_VERSION}" \
+		https://github.com/haskell/haskell-language-server.git \
+		"haskell-language-server-${HLS_TARGET_VERSION}"
+	cd "haskell-language-server-${HLS_TARGET_VERSION}/"
+	ecabal configure -w "ghc-${GHC_VERSION}" --disable-profiling --disable-tests --jobs="$(nproc)"
+	ecabal build --dependencies-only -w "ghc-${GHC_VERSION}" --disable-profiling --disable-tests --jobs="$(nproc)" --dry-run
+	sync_from_retry
+	ecabal build --dependencies-only -w "ghc-${GHC_VERSION}" --disable-profiling --disable-tests --jobs="$(nproc)" || sync_to
+	sync_to_retry
+)
+
+eghcup -v compile hls -j "$(nproc)" -g "${HLS_TARGET_VERSION}" --ghc "${GHC_VERSION}"
+
+[ "$($(eghcup whereis hls "${HLS_TARGET_VERSION}") --numeric-version)" = "${HLS_TARGET_VERSION}" ] ||
+	[ "$($(eghcup whereis hls "${HLS_TARGET_VERSION}") --numeric-version | sed 's/.0$//')" = "${HLS_TARGET_VERSION}" ]
+
+# nuke
+eghcup nuke
+[ ! -e "${GHCUP_DIR}" ]
+

.github/scripts/prereq.sh

@@ -0,0 +1,66 @@
+#!/bin/sh
+
+mkdir -p "$HOME"/.local/bin
+
+export OS="$RUNNER_OS"
+export PATH="$HOME/.local/bin:$PATH"
+: "${APT_GET:=apt-get}"
+
+if [ "${RUNNER_OS}" = "Windows" ] ; then
+	# on windows use pwd to get unix style path
+	CI_PROJECT_DIR="$(pwd)"
+	export CI_PROJECT_DIR
+    export GHCUP_INSTALL_BASE_PREFIX="/c"
+    export GHCUP_BIN="$GHCUP_INSTALL_BASE_PREFIX/ghcup/bin"
+    export PATH="$GHCUP_BIN:$PATH"
+	export CABAL_DIR="C:\\Users\\runneradmin\\AppData\\Roaming\\cabal"
+else
+	export CI_PROJECT_DIR="${GITHUB_WORKSPACE}"
+    export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
+    export GHCUP_BIN="$GHCUP_INSTALL_BASE_PREFIX/.ghcup/bin"
+    export PATH="$GHCUP_BIN:$PATH"
+    export CABAL_DIR="$CI_PROJECT_DIR/cabal"
+    export CABAL_CACHE="$CI_PROJECT_DIR/cabal-cache"
+fi
+
+if [ "${RUNNER_OS}" = "Linux" ] ; then
+	if [ "${DISTRO}" = "Alpine" ] ; then
+		:
+	elif [ "${DISTRO}" = "Ubuntu" ] ; then
+		export DEBIAN_FRONTEND=noninteractive
+		export TZ=Asia/Singapore
+		if [ "${ARCH}" = "ARM64" ] || [ "${ARCH}" = "ARM" ] ; then
+			:
+		else
+			${APT_GET} install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev libbz2-dev git wget lsb-release software-properties-common gnupg2 apt-transport-https gcc autoconf automake build-essential curl gzip
+		fi
+	elif [ "${DISTRO}" = "Debian" ] ; then
+		export DEBIAN_FRONTEND=noninteractive
+		export TZ=Asia/Singapore
+		${APT_GET} install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev libbz2-dev git wget lsb-release software-properties-common gnupg2 apt-transport-https gcc autoconf automake build-essential curl ghc gzip
+	fi
+elif [ "${RUNNER_OS}" = "macOS" ] ; then
+	if ! command -v brew ; then
+		[ -e "$HOME/.brew" ] ||
+			git clone --depth=1 https://github.com/Homebrew/brew "$HOME/.brew"
+		export PATH="$HOME/.brew/bin:$HOME/.brew/sbin:$PATH"
+		brew update
+	fi
+	if ! command -v git ; then
+		brew install git
+	fi
+	if ! command -v realpath ; then
+		brew install coreutils
+	fi
+
+    if [ "${ARCH}" = "ARM64" ] ; then
+		brew install llvm@11 autoconf automake
+		export PATH="$HOME/.brew/opt/llvm@11/bin:$PATH"
+		export CC="$HOME/.brew/opt/llvm@11/bin/clang"
+		export CXX="$HOME/.brew/opt/llvm@11/bin/clang++"
+		export LD=ld
+		export AR="$HOME/.brew/opt/llvm@11/bin/llvm-ar"
+		export RANLIB="$HOME/.brew/opt/llvm@11/bin/llvm-ranlib"
+	fi
+fi
+

.github/scripts/test.sh

@@ -0,0 +1,263 @@
+#!/usr/bin/env bash
+
+set -eux
+
+. .github/scripts/prereq.sh
+. .github/scripts/common.sh
+
+
+if [ "${OS}" = "Windows" ] ; then
+	GHCUP_DIR="${GHCUP_INSTALL_BASE_PREFIX}"/ghcup
+else
+	GHCUP_DIR="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
+fi
+
+git_describe
+
+rm -rf "${GHCUP_DIR}"
+mkdir -p "${GHCUP_BIN}"
+
+cp "out/${ARTIFACT}"-* "$GHCUP_BIN/ghcup${ext}"
+cp "out/test-${ARTIFACT}"-* "ghcup-test${ext}"
+chmod +x "$GHCUP_BIN/ghcup${ext}"
+chmod +x "ghcup-test${ext}"
+
+"$GHCUP_BIN/ghcup${ext}" --version
+eghcup --version
+sha_sum "$GHCUP_BIN/ghcup${ext}"
+sha_sum "$(raw_eghcup --offline whereis ghcup)"
+
+### Haskell test suite
+
+./ghcup-test${ext}
+rm ghcup-test${ext}
+
+### manual cli based testing
+
+eghcup --numeric-version
+
+eghcup install ghc ${GHC_VER}
+eghcup unset ghc ${GHC_VER}
+ls -lah "$(eghcup whereis -d ghc ${GHC_VER})"
+[ "`$(eghcup whereis ghc ${GHC_VER}) --numeric-version`" = "${GHC_VER}" ]
+[ "`eghcup run --ghc ${GHC_VER} -- ghc --numeric-version`" = "${GHC_VER}" ]
+[ "`ghcup run --ghc ${GHC_VER} -- ghc -e 'Control.Monad.join (Control.Monad.fmap System.IO.putStr System.Environment.getExecutablePath)'`" = "`$(ghcup whereis ghc ${GHC_VER}) -e 'Control.Monad.join (Control.Monad.fmap System.IO.putStr System.Environment.getExecutablePath)'`" ]
+eghcup set ghc ${GHC_VER}
+eghcup install cabal ${CABAL_VER}
+[ "`$(eghcup whereis cabal ${CABAL_VER}) --numeric-version`" = "${CABAL_VER}" ]
+eghcup unset cabal
+"$GHCUP_BIN"/cabal --version && exit 1 || echo yes
+
+# make sure no cabal is set when running 'ghcup run' to check that PATH propagages properly
+# https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/375
+[ "`eghcup run --cabal ${CABAL_VER} -- cabal --numeric-version`" = "${CABAL_VER}" ]
+eghcup set cabal ${CABAL_VER}
+
+[ "`$(eghcup whereis cabal ${CABAL_VER}) --numeric-version`" = "${CABAL_VER}" ]
+
+if [ "${OS}" != "FreeBSD" ] ; then
+	if [ "${ARCH}" = "64" ] && [ "${DISTRO}" != "Alpine" ] ; then
+		eghcup run --ghc 8.10.7 --cabal 3.4.1.0 --hls 1.6.1.0 --stack 2.7.3 --install --bindir "$(pwd)/.bin"
+		if [ "${OS}" = "Windows" ] ; then
+			cat "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup-run.files.windows" | sort > expected.txt
+		elif [ "${DISTRO}" = "Alpine" ] ; then
+			cat "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup-run.files.alpine" | sort > expected.txt
+		else
+			cat "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup-run.files" | sort > expected.txt
+		fi
+		(cd ".bin" && find . | sort) > actual.txt
+		diff --strip-trailing-cr -w -u actual.txt expected.txt
+		rm actual.txt expected.txt
+		rm -rf .bin
+	fi
+fi
+
+cabal --version
+
+eghcup debug-info
+
+# also test etags
+eghcup list
+eghcup list -t ghc
+eghcup list -t cabal
+
+ghc_ver=$(ghc --numeric-version)
+ghc --version
+ghc-${ghc_ver} --version
+if [ "${OS}" != "Windows" ] ; then
+		ghci --version
+		ghci-${ghc_ver} --version
+fi
+
+
+if [ "${OS}" = "macOS" ] && [ "${ARCH}" = "ARM64" ] ; then
+	# missing bindists
+	echo
+elif [ "${OS}" = "FreeBSD" ] ; then
+	# not enough space
+	echo
+else
+	# test installing new ghc doesn't mess with currently set GHC
+	# https://gitlab.haskell.org/haskell/ghcup-hs/issues/7
+	if [ "${OS}" = "Linux" ] ; then
+		eghcup --downloader=wget prefetch ghc 8.10.3
+		eghcup --offline install ghc 8.10.3
+		if [ "${ARCH}" = "64" ] ; then
+		    if [ "${DISTRO}" = "Alpine" ] ; then
+				(cat "$( cd "$(dirname "$0")" ; pwd -P )/../ghc-8.10.3-linux.alpine.files" | sort) > expected.txt
+			else
+				(cat "$( cd "$(dirname "$0")" ; pwd -P )/../ghc-8.10.3-linux.files" | sort) > expected.txt
+			fi
+			(cd "${GHCUP_DIR}/ghc/8.10.3/" && find . | sort) > actual.txt
+			# ignore docs
+		    sed -i '/share\/doc/d' actual.txt
+		    sed -i '/share\/doc/d' expected.txt
+			diff --strip-trailing-cr -w -u actual.txt expected.txt
+			rm actual.txt expected.txt
+		fi
+	elif [ "${OS}" = "Windows" ] ; then
+		eghcup prefetch ghc 8.10.3
+		eghcup --offline install ghc 8.10.3
+		(cat "$( cd "$(dirname "$0")" ; pwd -P )/../ghc-8.10.3-windows.files" | sort) > expected.txt
+		(cd "${GHCUP_DIR}/ghc/8.10.3/" && find . | sort) > actual.txt
+		diff --strip-trailing-cr -w -u actual.txt expected.txt
+		rm actual.txt expected.txt
+	else
+		eghcup prefetch ghc 8.10.3
+		eghcup --offline install ghc 8.10.3
+	fi
+	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
+	eghcup --offline set 8.10.3
+	eghcup set 8.10.3
+	[ "$(ghc --numeric-version)" = "8.10.3" ]
+	eghcup set ${GHC_VER}
+	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
+	eghcup unset ghc
+    "$GHCUP_BIN"/ghc --numeric-version && exit 1 || echo yes
+	eghcup set ${GHC_VER}
+	eghcup --offline rm 8.10.3
+	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
+
+
+	ls -lah "$GHCUP_BIN"
+
+	if [ "${OS}" = "macOS" ] ; then
+		eghcup install hls
+		$(eghcup whereis hls) --version
+
+		eghcup install stack
+		$(eghcup whereis stack) --version
+	elif [ "${OS}" = "Linux" ] ; then
+		if [ "${ARCH}" = "64" ] && [ "${DISTRO}" != "Alpine" ] ; then
+			eghcup install hls
+			haskell-language-server-wrapper --version
+			eghcup unset hls
+			"$GHCUP_BIN"/haskell-language-server-wrapper --version && exit 1 || echo yes
+
+			eghcup install stack
+			stack --version
+			eghcup unset stack
+			"$GHCUP_BIN"/stack --version && exit 1 || echo yes
+		fi
+	fi
+fi
+
+
+
+# check that lazy loading works for 'whereis'
+cp "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml" "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml.bak"
+echo '**' > "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml"
+eghcup whereis ghc $(ghc --numeric-version)
+mv -f "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml.bak" "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml"
+
+eghcup rm $(ghc --numeric-version)
+
+# https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/116
+if [ "${OS}" = "Linux" ] ; then
+	if [ "${ARCH}" = "64" ] ; then
+		eghcup install cabal -u https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal/3.7.0.0-pre20220407/cabal-install-3.7-x86_64-linux-alpine.tar.xz 3.4.0.0-rc4
+		eghcup rm cabal 3.4.0.0-rc4
+	fi
+fi
+
+eghcup gc -c
+
+# test etags
+rm -f "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml"
+raw_eghcup -s https://www.haskell.org/ghcup/data/ghcup-${JSON_VERSION}.yaml list
+# snapshot yaml and etags file
+etag=$(cat "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml.etags")
+sha=$(sha_sum "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml")
+# invalidate access time timer, which is 5minutes, so we re-download
+touch -a -m -t '199901010101' "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml"
+# redownload same file with some newlines added
+raw_eghcup -s https://www.haskell.org/ghcup/exp/ghcup-${JSON_VERSION}.yaml list
+# snapshot new yaml and etags file
+etag2=$(cat "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml.etags")
+sha2=$(sha_sum "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml")
+# compare
+[ "${etag}" != "${etag2}" ]
+[ "${sha}" != "${sha2}" ]
+# invalidate access time timer, which is 5minutes, but don't expect a re-download
+touch -a -m -t '199901010101' "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml"
+# this time, we expect the same hash and etag
+raw_eghcup -s https://www.haskell.org/ghcup/exp/ghcup-${JSON_VERSION}.yaml list
+etag3=$(cat "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml.etags")
+sha3=$(sha_sum "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml")
+[ "${etag2}" = "${etag3}" ]
+[ "${sha2}" = "${sha3}" ]
+
+# test isolated installs
+if [ "${DISTRO}" != "Alpine" ] ; then
+	eghcup install ghc -i "$(pwd)/isolated" 8.10.5
+	[ "$(isolated/bin/ghc --numeric-version)" = "8.10.5" ]
+	! eghcup install ghc -i "$(pwd)/isolated" 8.10.5
+	if [ "${ARCH}" = "64" ] ; then
+		if [ "${OS}" = "Linux" ] || [ "${OS}" = "Windows" ] ; then
+			eghcup install cabal -i "$(pwd)/isolated" 3.4.0.0
+			[ "$(isolated/cabal --numeric-version)" = "3.4.0.0" ]
+			eghcup install stack -i "$(pwd)/isolated" 2.7.3
+			[ "$(isolated/stack --numeric-version)" = "2.7.3" ]
+			eghcup install hls -i "$(pwd)/isolated" 1.3.0
+			[ "$(isolated/haskell-language-server-wrapper --numeric-version)" = "1.3.0" ] ||
+				[ "$(isolated/haskell-language-server-wrapper --numeric-version)" = "1.3.0.0" ]
+
+			# test that isolated installs don't clean up target directory
+			cat <<EOF > "${GHCUP_BIN}/gmake"
+#!/bin/bash
+exit 1
+EOF
+			chmod +x "${GHCUP_BIN}/gmake"
+			mkdir isolated_tainted/
+			touch isolated_tainted/lol
+
+			! eghcup install ghc -i "$(pwd)/isolated_tainted" 8.10.5 --force
+			[ -e "$(pwd)/isolated_tainted/lol" ]
+			rm "${GHCUP_BIN}/gmake"
+		fi
+	fi
+fi
+
+eghcup upgrade
+eghcup upgrade -f
+
+# restore old ghcup, because we want to test nuke
+cp "out/${ARTIFACT}"-* "$GHCUP_BIN/ghcup${ext}"
+chmod +x "$GHCUP_BIN/ghcup${ext}"
+
+# test that doing fishy symlinks into GHCup dir doesn't cause weird stuff on 'ghcup nuke'
+mkdir no_nuke/
+mkdir no_nuke/bar
+echo 'foo' > no_nuke/file
+echo 'bar' > no_nuke/bar/file
+ln -s "$CI_PROJECT_DIR"/no_nuke/ "${GHCUP_DIR}"/cache/no_nuke
+ln -s "$CI_PROJECT_DIR"/no_nuke/ "${GHCUP_DIR}"/logs/no_nuke
+
+# nuke
+eghcup nuke
+[ ! -e "${GHCUP_DIR}" ]
+
+# make sure nuke doesn't resolve symlinks
+[ -e "$CI_PROJECT_DIR"/no_nuke/file ]
+[ -e "$CI_PROJECT_DIR"/no_nuke/bar/file ]
+

.github/workflows/bootstrap.yaml

@@ -0,0 +1,48 @@
+name: Bootstrap tests
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - 'v*'
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  bootstrap:
+    name: bootstrap
+    runs-on: ${{ matrix.os }}
+    env:
+      BOOTSTRAP_HASKELL_CABAL_VERSION: 3.6.2.0
+      BOOTSTRAP_HASKELL_GHC_VERSION: 8.10.7
+      BOOTSTRAP_HASKELL_NONINTERACTIVE: yes
+      ARCH: 64
+      JSON_VERSION: "0.0.7"
+      APT_GET: "sudo apt-get"
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            DISTRO: Ubuntu
+          - os: macOS-10.15
+            DISTRO: na
+          - os: windows-latest
+            DISTRO: na
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          submodules: 'true'
+
+      - if: runner.os != 'Windows'
+        name: Run bootstrap
+        run: sh ./.github/scripts/bootstrap.sh
+        env:
+          DISTRO: ${{ matrix.DISTRO }}
+
+      - if: runner.os == 'Windows'
+        name: Run bootstrap
+        run: ./scripts/bootstrap/bootstrap-haskell.ps1 -InstallDir ${GITHUB_WORKSPACE} -BootstrapUrl ${GITHUB_WORKSPACE}/bootstrap-haskell -InBash
+        shell: pwsh

.github/workflows/cache.yaml

@@ -0,0 +1,37 @@
+name: Cache eviction
+
+on:
+  workflow_dispatch:
+    inputs:
+      key:
+        description: Which cache to evict
+        required: true
+        default: '/'
+        type: choice
+        options:
+        - FreeBSD-64-na
+        - Linux-32-Alpine
+        - Linux-64-Alpine
+        - Linux-64-Ubuntu
+        - Linux-ARM-Ubuntu
+        - Linux-ARM64-Ubuntu
+        - Windows-64-na
+        - macOS-64-na
+        - macOS-ARM64-na
+        - /
+jobs:
+  evict:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Remove from S3
+      uses: vitorsgomes/s3-rm-action@master
+      with:
+        args: --recursive
+      env:
+        AWS_S3_ENDPOINT: ${{ secrets.S3_HOST }}
+        AWS_S3_BUCKET: ghcup-hs
+        AWS_REGION: us-west-2
+        AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+        AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+        PATH_TO_DELETE: ${{ github.event.inputs.key }}

.github/workflows/docker.yaml

@@ -0,0 +1,68 @@
+name: Docker image builds
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 0 * * *'
+
+jobs:
+  docker-alpine:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Build and push (alpine 32bit)
+        uses: docker/build-push-action@v3
+        with:
+          context: ./docker/alpine32
+          push: true
+          tags: hasufell/i386-alpine-haskell:3.12
+          platforms: linux/i386
+      - name: Build and push (alpine 64bit)
+        uses: docker/build-push-action@v3
+        with:
+          context: ./docker/alpine64
+          push: true
+          tags: hasufell/alpine-haskell:3.12
+          platforms: linux/amd64
+
+  docker-arm:
+    runs-on: [self-hosted, Linux, aarch64]
+    steps:
+      - uses: docker://arm64v8/ubuntu:focal
+        name: Cleanup
+        with:
+          args: rm -rf .ghcup/ cabal/ dist-newstyle/ out/
+
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Build and push (arm64v8)
+        uses: docker/build-push-action@v3
+        with:
+          context: ./docker/arm64v8/
+          push: true
+          tags: hasufell/arm64v8-ubuntu-haskell:focal
+          platforms: linux/arm64
+      - name: Build and push (arm32v7)
+        uses: docker/build-push-action@v3
+        with:
+          context: ./docker/arm32v7
+          push: true
+          tags: hasufell/arm32v7-ubuntu-haskell:focal
+          platforms: linux/arm

.github/workflows/hlint.yaml

@@ -0,0 +1,26 @@
+name: Hlint
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - 'v*'
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  hlint:
+    name: hlint
+    runs-on: ubuntu-latest
+    env:
+      JSON_VERSION: "0.0.7"
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          submodules: 'true'
+
+      - name: Run hlint
+        run: curl -sSL https://raw.github.com/ndmitchell/hlint/master/misc/run.sh | sh -s -- -r lib/ test/

.github/workflows/mkdocs.yaml

@@ -0,0 +1,33 @@
+name: MkDocs
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - 'v*'
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  mkdocs:
+    name: mkdocs
+    runs-on: ubuntu-latest
+    env:
+      JSON_VERSION: "0.0.7"
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          submodules: 'true'
+
+      - name: Install mkdocs deps
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y python3-pip
+          sudo pip3 install mkdocs
+
+      - name: Run mkdocs
+        run: |
+          mkdocs build

.github/workflows/release.yaml

@@ -0,0 +1,460 @@
+name: Build and release
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - 'v*'
+  pull_request:
+    branches:
+      - master
+  schedule:
+    - cron: '0 2 * * *'
+
+jobs:
+  build-linux:
+    name: Build linux binary
+    runs-on: ${{ matrix.os }}
+    env:
+      CABAL_VER: 3.6.2.0
+      JSON_VERSION: "0.0.7"
+      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+      S3_HOST: ${{ secrets.S3_HOST }}
+    strategy:
+      fail-fast: true
+      matrix:
+        include:
+          - os: ubuntu-latest
+            ARTIFACT: "i386-linux-ghcup"
+            GHC_VER: 8.10.7
+            ARCH: 32
+          - os: ubuntu-latest
+            ARTIFACT: "x86_64-linux-ghcup"
+            GHC_VER: 8.10.7
+            ARCH: 64
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          submodules: 'true'
+
+      - if: matrix.ARCH == '32'
+        name: Run build (32 bit linux)
+        uses: docker://hasufell/i386-alpine-haskell:3.12
+        with:
+          args: sh .github/scripts/build.sh
+        env:
+          ARTIFACT: ${{ matrix.ARTIFACT }}
+          ARCH: ${{ matrix.ARCH }}
+          GHC_VER: ${{ matrix.GHC_VER }}
+          DISTRO: Alpine
+          AWS_SECRET_ACCESS_KEY: ${{ env.AWS_SECRET_ACCESS_KEY }}
+          AWS_ACCESS_KEY_ID: ${{ env.AWS_ACCESS_KEY_ID }}
+          S3_HOST: ${{ env.S3_HOST }}
+
+      - if: matrix.ARCH == '64'
+        name: Run build (64 bit linux)
+        uses: docker://hasufell/alpine-haskell:3.12
+        with:
+          args: sh .github/scripts/build.sh
+        env:
+          ARTIFACT: ${{ matrix.ARTIFACT }}
+          ARCH: ${{ matrix.ARCH }}
+          GHC_VER: ${{ matrix.GHC_VER }}
+          DISTRO: Alpine
+          AWS_SECRET_ACCESS_KEY: ${{ env.AWS_SECRET_ACCESS_KEY }}
+          AWS_ACCESS_KEY_ID: ${{ env.AWS_ACCESS_KEY_ID }}
+          S3_HOST: ${{ env.S3_HOST }}
+
+      - if: always()
+        name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: artifacts
+          path: |
+            ./out/*
+
+
+  build-arm:
+    name: Build ARM binary
+    runs-on: ${{ matrix.os }}
+    env:
+      CABAL_VER: 3.6.2.0
+      JSON_VERSION: "0.0.7"
+      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+      S3_HOST: ${{ secrets.S3_HOST }}
+    strategy:
+      fail-fast: true
+      matrix:
+        include:
+          - os: [self-hosted, Linux, aarch64]
+            ARTIFACT: "armv7-linux-ghcup"
+            GHC_VER: 8.10.7
+            ARCH: ARM
+          - os: [self-hosted, Linux, aarch64]
+            ARTIFACT: "aarch64-linux-ghcup"
+            GHC_VER: 8.10.7
+            ARCH: ARM64
+    steps:
+      - uses: docker://arm64v8/ubuntu:focal
+        name: Cleanup (aarch64 linux)
+        with:
+          args: "find . -mindepth 1 -maxdepth 1 -exec rm -rf -- {} +"
+
+      - name: git config
+        run: |
+          git config --global --get-all safe.directory | grep '^\*$' || git config --global --add safe.directory "*"
+        shell: bash
+
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          submodules: 'true'
+
+      - if: matrix.ARCH == 'ARM'
+        uses: docker://hasufell/arm32v7-ubuntu-haskell:focal
+        name: Run build (armv7 linux)
+        with:
+          args: sh .github/scripts/build.sh
+        env:
+          ARTIFACT: ${{ matrix.ARTIFACT }}
+          ARCH: ${{ matrix.ARCH }}
+          GHC_VER: ${{ matrix.GHC_VER }}
+          DISTRO: Ubuntu
+          AWS_SECRET_ACCESS_KEY: ${{ env.AWS_SECRET_ACCESS_KEY }}
+          AWS_ACCESS_KEY_ID: ${{ env.AWS_ACCESS_KEY_ID }}
+          S3_HOST: ${{ env.S3_HOST }}
+
+      - if: matrix.ARCH == 'ARM64'
+        uses: docker://hasufell/arm64v8-ubuntu-haskell:focal
+        name: Run build (aarch64 linux)
+        with:
+          args: sh .github/scripts/build.sh
+        env:
+          ARTIFACT: ${{ matrix.ARTIFACT }}
+          ARCH: ${{ matrix.ARCH }}
+          GHC_VER: ${{ matrix.GHC_VER }}
+          DISTRO: Ubuntu
+          AWS_SECRET_ACCESS_KEY: ${{ env.AWS_SECRET_ACCESS_KEY }}
+          AWS_ACCESS_KEY_ID: ${{ env.AWS_ACCESS_KEY_ID }}
+          S3_HOST: ${{ env.S3_HOST }}
+
+      - if: always()
+        name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: artifacts
+          path: |
+            ./out/*
+
+  build-macwin:
+    name: Build binary (Mac/Win)
+    runs-on: ${{ matrix.os }}
+    env:
+      CABAL_VER: 3.6.2.0
+      MACOSX_DEPLOYMENT_TARGET: 10.13
+      JSON_VERSION: "0.0.7"
+      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+      S3_HOST: ${{ secrets.S3_HOST }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: [self-hosted, macOS, aarch64]
+            ARTIFACT: "aarch64-apple-darwin-ghcup"
+            GHC_VER: 9.2.5
+            ARCH: ARM64
+          - os: macOS-10.15
+            ARTIFACT: "x86_64-apple-darwin-ghcup"
+            GHC_VER: 9.2.5
+            ARCH: 64
+          - os: windows-latest
+            ARTIFACT: "x86_64-mingw64-ghcup"
+            GHC_VER: 8.10.7
+            ARCH: 64
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          submodules: 'true'
+
+      - name: Run build (windows/mac)
+        run: bash .github/scripts/build.sh
+        env:
+          ARTIFACT: ${{ matrix.ARTIFACT }}
+          ARCH: ${{ matrix.ARCH }}
+          GHC_VER: ${{ matrix.GHC_VER }}
+          DISTRO: na
+          AWS_SECRET_ACCESS_KEY: ${{ env.AWS_SECRET_ACCESS_KEY }}
+          AWS_ACCESS_KEY_ID: ${{ env.AWS_ACCESS_KEY_ID }}
+          S3_HOST: ${{ env.S3_HOST }}
+          HOMEBREW_CHANGE_ARCH_TO_ARM: 1
+
+      - if: always()
+        name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: artifacts
+          path: |
+            ./out/*
+
+
+  test-linux:
+    name: Test linux
+    needs: "build-linux"
+    runs-on: ${{ matrix.os }}
+    env:
+      CABAL_VER: 3.6.2.0
+      JSON_VERSION: "0.0.7"
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            ARTIFACT: "i386-linux-ghcup"
+            GHC_VER: 8.10.7
+            ARCH: 32
+            DISTRO: Alpine
+          - os: ubuntu-latest
+            ARTIFACT: "x86_64-linux-ghcup"
+            GHC_VER: 8.10.7
+            ARCH: 64
+            DISTRO: Alpine
+          - os: ubuntu-latest
+            ARTIFACT: "x86_64-linux-ghcup"
+            GHC_VER: 8.10.7
+            ARCH: 64
+            DISTRO: Ubuntu
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          submodules: 'true'
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: artifacts
+          path: ./out
+
+      - if: matrix.ARCH == '32' && matrix.DISTRO == 'Alpine'
+        name: Run test (32 bit linux Alpine)
+        uses: docker://hasufell/i386-alpine-haskell:3.12
+        with:
+          args: sh .github/scripts/test.sh
+        env:
+          ARTIFACT: ${{ matrix.ARTIFACT }}
+          ARCH: ${{ matrix.ARCH }}
+          GHC_VER: ${{ matrix.GHC_VER }}
+          DISTRO: ${{ matrix.DISTRO }}
+
+      - if: matrix.ARCH == '64' && matrix.DISTRO == 'Alpine'
+        name: Run test (64 bit linux Alpine)
+        uses: docker://hasufell/alpine-haskell:3.12
+        with:
+          args: sh .github/scripts/test.sh
+        env:
+          ARTIFACT: ${{ matrix.ARTIFACT }}
+          ARCH: ${{ matrix.ARCH }}
+          GHC_VER: ${{ matrix.GHC_VER }}
+          DISTRO: ${{ matrix.DISTRO }}
+
+      - if: matrix.DISTRO != 'Alpine'
+        name: Run test (64 bit linux)
+        run: sh .github/scripts/test.sh
+        env:
+          ARTIFACT: ${{ matrix.ARTIFACT }}
+          ARCH: ${{ matrix.ARCH }}
+          GHC_VER: ${{ matrix.GHC_VER }}
+          DISTRO: ${{ matrix.DISTRO }}
+          APT_GET: "sudo apt-get"
+
+      - if: failure()
+        name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: testfiles
+          path: |
+            ./test/golden/unix/GHCupInfo*json
+
+  test-arm:
+    name: Test ARM
+    needs: "build-arm"
+    runs-on: ${{ matrix.os }}
+    env:
+      CABAL_VER: 3.6.2.0
+      JSON_VERSION: "0.0.7"
+    strategy:
+      matrix:
+        include:
+          - os: [self-hosted, Linux, aarch64]
+            ARTIFACT: "armv7-linux-ghcup"
+            GHC_VER: 8.10.7
+            ARCH: ARM
+            DISTRO: Ubuntu
+          - os: [self-hosted, Linux, aarch64]
+            ARTIFACT: "aarch64-linux-ghcup"
+            GHC_VER: 8.10.7
+            ARCH: ARM64
+            DISTRO: Ubuntu
+
+    steps:
+      - uses: docker://arm64v8/ubuntu:focal
+        name: Cleanup (aarch64 linux)
+        with:
+          args: "find . -mindepth 1 -maxdepth 1 -exec rm -rf -- {} +"
+
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          submodules: 'true'
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: artifacts
+          path: ./out
+
+      - if: matrix.ARCH == 'ARM'
+        uses: docker://hasufell/arm32v7-ubuntu-haskell:focal
+        name: Run test (armv7 linux)
+        with:
+          args: sh .github/scripts/test.sh
+        env:
+          ARTIFACT: ${{ matrix.ARTIFACT }}
+          ARCH: ${{ matrix.ARCH }}
+          GHC_VER: ${{ matrix.GHC_VER }}
+          DISTRO: Ubuntu
+
+      - if: matrix.ARCH == 'ARM64'
+        uses: docker://hasufell/arm64v8-ubuntu-haskell:focal
+        name: Run test (aarch64 linux)
+        with:
+          args: sh .github/scripts/test.sh
+        env:
+          ARTIFACT: ${{ matrix.ARTIFACT }}
+          ARCH: ${{ matrix.ARCH }}
+          GHC_VER: ${{ matrix.GHC_VER }}
+          DISTRO: Ubuntu
+
+      - if: failure()
+        name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: testfiles
+          path: |
+            ./test/golden/unix/GHCupInfo*json
+
+  test-macwin:
+    name: Test Mac/Win
+    needs: "build-macwin"
+    runs-on: ${{ matrix.os }}
+    env:
+      CABAL_VER: 3.6.2.0
+      MACOSX_DEPLOYMENT_TARGET: 10.13
+      JSON_VERSION: "0.0.7"
+    strategy:
+      matrix:
+        include:
+          - os: [self-hosted, macOS, aarch64]
+            ARTIFACT: "aarch64-apple-darwin-ghcup"
+            GHC_VER: 9.2.5
+            ARCH: ARM64
+            DISTRO: na
+          - os: macOS-10.15
+            ARTIFACT: "x86_64-apple-darwin-ghcup"
+            GHC_VER: 9.2.5
+            ARCH: 64
+            DISTRO: na
+          - os: windows-latest
+            ARTIFACT: "x86_64-mingw64-ghcup"
+            GHC_VER: 8.10.7
+            ARCH: 64
+            DISTRO: na
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          submodules: 'true'
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: artifacts
+          path: ./out
+
+      - name: Run test (windows/mac)
+        run: bash .github/scripts/test.sh
+        env:
+          ARTIFACT: ${{ matrix.ARTIFACT }}
+          ARCH: ${{ matrix.ARCH }}
+          GHC_VER: ${{ matrix.GHC_VER }}
+          DISTRO: ${{ matrix.DISTRO }}
+          HOMEBREW_CHANGE_ARCH_TO_ARM: 1
+
+      - if: failure() && runner.os == 'Windows'
+        name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: testfiles
+          path: |
+            ./test/golden/windows/GHCupInfo*json
+
+      - if: failure() && runner.os != 'Windows'
+        name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: testfiles
+          path: |
+            ./test/golden/unix/GHCupInfo*json
+  hls:
+    name: hls
+    needs: build-linux
+    runs-on: ubuntu-latest
+    env:
+      GHC_VERSION: "8.10.7"
+      HLS_TARGET_VERSION: "1.8.0.0"
+      CABAL_VERSION: "3.6.2.0"
+      JSON_VERSION: "0.0.7"
+      ARTIFACT: "x86_64-linux-ghcup"
+      DISTRO: Ubuntu
+      ARCH: 64
+      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+      S3_HOST: ${{ secrets.S3_HOST }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          submodules: 'true'
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: artifacts
+          path: ./out
+
+      - name: Run hls build
+        run: sh .github/scripts/hls.sh
+        env:
+          APT_GET: "sudo apt-get"
+
+  release:
+    name: release
+    needs: ["test-linux", "test-arm", "test-macwin", "hls"]
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/v')
+    steps:
+      - name: Download artifacts
+        uses: actions/download-artifact@v3
+        with:
+          name: artifacts
+          path: ./out
+
+      - name: Release
+        uses: softprops/action-gh-release@v1
+        with:
+          draft: true
+          files: |
+            ./out/*

.github/workflows/shellcheck.yaml

@@ -0,0 +1,28 @@
+name: Shellcheck
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - 'v*'
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  shellcheck:
+    name: shellcheck
+    runs-on: ubuntu-latest
+    env:
+      JSON_VERSION: "0.0.7"
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          submodules: 'true'
+
+      - name: Run shellcheck
+        uses: docker://koalaman/shellcheck-alpine
+        with:
+          args: shellcheck scripts/bootstrap/bootstrap-haskell

.github/workflows/shimgen.yaml

@@ -0,0 +1,29 @@
+name: Shimgen CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build-shimgen:
+
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows-latest]
+
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ilammy/msvc-dev-cmd@v1
+
+    - name: compile
+      run: cl /O1 scoop-better-shimexe/shim.c
+
+    - uses: actions/upload-artifact@v2
+      with:
+        name: shim.exe
+        path: shim.exe
+

.gitignore

@@ -1,2 +1,17 @@
+.ghci
+.vim
+codex.tags
 dist-newstyle/
+cabal.project.local
 .stack-work/
+bin/
+/*.prof
+/*.ps
+/*.hp
+tags
+TAGS
+/tmp/
+.entangled
+release/
+releases/
+site/

.gitlab-ci.yml

@@ -0,0 +1,689 @@
+stages:
+  - checks
+  - quick-test
+  - test
+  - expensive-test
+  - release
+
+variables:
+  GIT_SSL_NO_VERIFY: "1"
+
+  # Commit of ghc/ci-images repository from which to pull Docker images
+  DOCKER_REV: 8d0224e6b2a08157649651e69302380b2bd24e11
+
+  # Sequential version number of all cached things.
+  # Bump to invalidate GitLab CI cache.
+  CACHE_REV: 1
+
+  GIT_SUBMODULE_STRATEGY: recursive
+
+
+############################################################
+# CI Step
+############################################################
+
+.debian:
+  image: "registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb10:$DOCKER_REV"
+  tags:
+    - x86_64-linux
+  variables:
+    OS: "LINUX"
+    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+    CROSS: ""
+
+.alpine:64bit:
+  image: "alpine:3.12"
+  tags:
+    - x86_64-linux
+  variables:
+    OS: "LINUX"
+    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.alpine:32bit:
+  image: "i386/alpine:3.12"
+  tags:
+    - x86_64-linux
+  variables:
+    OS: "LINUX"
+    ARCH: "32"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.linux:armv7:
+  image: "registry.gitlab.haskell.org/ghc/ci-images/armv7-linux-deb10:$DOCKER_REV"
+  tags:
+    - armv7-linux
+  variables:
+    OS: "LINUX"
+    ARCH: "ARM"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+  retry: 2
+
+.linux:aarch64:
+  image: "registry.gitlab.haskell.org/ghc/ci-images/aarch64-linux-deb10:$DOCKER_REV"
+  tags:
+    - aarch64-linux
+  variables:
+    OS: "LINUX"
+    ARCH: "ARM64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.darwin:
+  tags:
+    - x86_64-darwin
+  variables:
+    OS: "DARWIN"
+    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.darwin:aarch64:
+  tags:
+    - aarch64-darwin-m1
+  variables:
+    OS: "DARWIN"
+    ARCH: "ARM64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.freebsd13:
+  tags:
+    - x86_64-freebsd13
+  variables:
+    OS: "FREEBSD"
+    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.freebsd12:
+  tags:
+    - x86_64-freebsd12
+  variables:
+    OS: "FREEBSD"
+    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+
+.windows:
+  tags:
+    - new-x86_64-windows
+  variables:
+    OS: "WINDOWS"
+    ARCH: "64"
+    CABAL_DIR: "$CI_PROJECT_DIR/cabal"
+  retry: 2
+
+.root_cleanup:
+  after_script:
+    - bash ./.gitlab/after_script.sh
+
+.test_ghcup_version:
+  script:
+    - bash ./.gitlab/script/ghcup_version.sh
+  variables:
+    JSON_VERSION: "0.0.7"
+  artifacts:
+    expire_in: 2 week
+    paths:
+      - test/golden
+      - dist-newstyle/cache/
+    when: on_failure
+  cache:
+    key: ghcup-test-$CACHE_REV
+    paths:
+      - cabal-cache
+
+# .test_ghcup_scoop:
+  # script:
+    # - cl /O1 scoop-better-shimexe/shim.c
+
+.test_ghcup_version:linux:
+  extends:
+    - .test_ghcup_version
+    - .debian
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps.sh
+    - ./.gitlab/script/ci.sh extract_cabal_cache
+  after_script:
+    - ./.gitlab/script/ci.sh save_cabal_cache
+    - bash ./.gitlab/after_script.sh
+
+.test_ghcup_version:linux32:
+  extends:
+    - .test_ghcup_version
+    - .alpine:32bit
+  before_script:
+    - ./.gitlab/before_script/linux/alpine/install_deps.sh
+    - ./.gitlab/script/ci.sh extract_cabal_cache
+  after_script:
+    - ./.gitlab/script/ci.sh save_cabal_cache
+    - bash ./.gitlab/after_script.sh
+
+.test_ghcup_version:armv7:
+  extends:
+    - .test_ghcup_version
+    - .linux:armv7
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps.sh
+    - ./.gitlab/script/ci.sh extract_cabal_cache
+  after_script:
+    - ./.gitlab/script/ci.sh save_cabal_cache
+    - bash ./.gitlab/after_script.sh
+
+.test_ghcup_version:aarch64:
+  extends:
+    - .test_ghcup_version
+    - .linux:aarch64
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps.sh
+    - ./.gitlab/script/ci.sh extract_cabal_cache
+  after_script:
+    - ./.gitlab/script/ci.sh save_cabal_cache
+    - bash ./.gitlab/after_script.sh
+
+.test_ghcup_version:darwin:
+  extends:
+    - .test_ghcup_version
+    - .darwin
+  before_script:
+    - ./.gitlab/before_script/darwin/install_deps.sh
+    - ./.gitlab/script/ci.sh extract_cabal_cache
+  after_script:
+    - ./.gitlab/script/ci.sh save_cabal_cache
+    - bash ./.gitlab/after_script.sh
+
+.test_ghcup_version:darwin:aarch64:
+  extends:
+    - .test_ghcup_version
+    - .darwin:aarch64
+  cache:
+    key: darwin-brew-$CACHE_REV
+    paths:
+      - brew_cache
+    key: ghcup-test-$CACHE_REV
+    paths:
+      - cabal-cache
+  before_script:
+    # extract brew cache
+    - ./.gitlab/script/ci.sh extract_brew_cache
+    # otherwise we seem to get intel binaries
+    - export HOMEBREW_CHANGE_ARCH_TO_ARM=1
+    # update and install packages
+    - /bin/bash ./.gitlab/script/brew.sh llvm autoconf automake coreutils
+    # extract cabal cache
+    - ./.gitlab/script/ci.sh extract_cabal_cache
+  script: |
+    export PATH="$CI_PROJECT_DIR/.brew/opt/llvm/bin:$CI_PROJECT_DIR/.brew/bin:$CI_PROJECT_DIR/.brew/sbin:$PATH"
+    export CC=$CI_PROJECT_DIR/.brew/opt/llvm/bin/clang
+    export CXX=$CI_PROJECT_DIR/.brew/opt/llvm/bin/clang++
+    export LD=ld
+    export AR=$CI_PROJECT_DIR/.brew/opt/llvm/bin/llvm-ar
+    export RANLIB=$CI_PROJECT_DIR/.brew/opt/llvm/bin/llvm-ranlib
+    ./.gitlab/before_script/darwin/install_deps.sh
+    ./.gitlab/script/ghcup_version.sh
+  after_script:
+    - ./.gitlab/script/ci.sh save_cabal_cache
+    - ./.gitlab/script/ci.sh save_brew_cache
+    - bash ./.gitlab/after_script.sh
+
+.test_ghcup_version:freebsd12:
+  extends:
+    - .test_ghcup_version
+    - .freebsd12
+  before_script:
+    - ./.gitlab/before_script/freebsd/install_deps.sh
+    - ./.gitlab/script/ci.sh extract_cabal_cache
+  after_script:
+    - ./.gitlab/script/ci.sh save_cabal_cache
+    - bash ./.gitlab/after_script.sh
+
+.test_ghcup_version:freebsd13:
+  extends:
+    - .test_ghcup_version
+    - .freebsd13
+  before_script:
+    - sudo pkg update
+    - sudo pkg install --yes compat12x-amd64
+    - sudo ln -s libncurses.so.6 /usr/local/lib/libncurses.so.6.2
+    - ./.gitlab/before_script/freebsd/install_deps.sh
+    - ./.gitlab/script/ci.sh extract_cabal_cache
+  after_script:
+    - ./.gitlab/script/ci.sh save_cabal_cache
+    - bash ./.gitlab/after_script.sh
+
+.test_ghcup_version:windows:
+  extends:
+    - .test_ghcup_version
+    - .windows
+  before_script:
+    - bash ./.gitlab/before_script/windows/install_deps.sh
+    - bash ./.gitlab/script/ci.sh extract_cabal_cache
+  after_script:
+    - bash ./.gitlab/script/ci.sh save_cabal_cache
+    - bash ./.gitlab/after_script.sh
+
+# .test_ghcup_scoop:windows:
+  # extends:
+    # - .windows
+    # - .test_ghcup_scoop
+
+.release_ghcup:
+  script:
+    - bash ./.gitlab/script/ghcup_release.sh
+  artifacts:
+    expire_in: 2 week
+    paths:
+      - out
+      - dist-newstyle/cache/
+  only:
+    - tags
+  variables:
+    JSON_VERSION: "0.0.7"
+
+######## stack test ########
+
+test:linux:stack:
+  stage: test
+  before_script:
+    - ./.gitlab/script/ci.sh extract_stack_cache
+    - ./.gitlab/before_script/linux/install_deps_minimal.sh
+  script:
+    - ./.gitlab/script/ghcup_stack.sh
+  after_script:
+    - ./.gitlab/script/ci.sh save_stack_cache
+  extends:
+    - .debian
+  needs: []
+
+######## bootstrap test ########
+
+test:linux:bootstrap_script:
+  stage: quick-test
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_minimal.sh
+  script:
+    - ./.gitlab/script/ghcup_bootstrap.sh
+  variables:
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+  extends:
+    - .debian
+    - .root_cleanup
+  needs: []
+
+test:windows:bootstrap_powershell_script:
+  stage: quick-test
+  script:
+    - ./scripts/bootstrap/bootstrap-haskell.ps1 -InstallDir $CI_PROJECT_DIR -BootstrapUrl $CI_PROJECT_DIR/bootstrap-haskell -InBash
+  after_script:
+    - "[Environment]::SetEnvironmentVariable('GHCUP_INSTALL_BASE_PREFIX', $null, [System.EnvironmentVariableTarget]::User)"
+    - "[Environment]::SetEnvironmentVariable('GHCUP_MSYS2', $null, [System.EnvironmentVariableTarget]::User)"
+    - "[Environment]::SetEnvironmentVariable('CABAL_DIR', $null, [System.EnvironmentVariableTarget]::User)"
+    - bash ./.gitlab/after_script.sh
+    - bash ./.gitlab/script/ci.sh save_cabal_cache
+  variables:
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+  extends:
+    - .windows
+  needs: []
+
+######## linux test ########
+
+test:linux:
+  stage: test
+  extends: .test_ghcup_version:linux
+  variables:
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+  needs: []
+
+test:linux:hls:
+  stage: expensive-test
+  extends:
+    - .test_ghcup_version
+    - .debian
+  variables:
+    GHC_VERSION: "8.10.7"
+    HLS_TARGET_VERSION: "1.4.0"
+    CABAL_VERSION: "3.6.2.0"
+  needs: []
+  when: manual
+  allow_failure: true
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps.sh
+  script:
+    - ./.gitlab/script/ghcup_hls.sh
+
+test:linux:cross-armv7:
+  stage: expensive-test
+  extends:
+    - .test_ghcup_version
+    - .debian
+  variables:
+    GHC_VERSION: "8.10.6"
+    GHC_TARGET_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+    CROSS: "arm-linux-gnueabihf"
+  needs: []
+  when: manual
+  allow_failure: true
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps.sh
+  script:
+    - ./.gitlab/script/ghcup_cross.sh
+
+test:linux:git:hadrian:
+  stage: expensive-test
+  extends:
+    - .test_ghcup_version
+    - .debian
+  variables:
+    GHC_VERSION: "8.10.7"
+    GHC_GIT_TAG: "ghc-9.0.1-release"
+    GHC_GIT_VERSION: "9.0.1"
+    CABAL_VERSION: "3.6.2.0"
+    CROSS: ""
+  needs: []
+  when: manual
+  allow_failure: true
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps.sh
+  script:
+    - ./.gitlab/script/ghcup_git.sh
+
+
+######## linux 32bit test ########
+
+test:linux:32bit:
+  stage: test
+  extends: .test_ghcup_version:linux32
+  variables:
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+  needs: []
+
+######## arm tests ########
+
+test:linux:armv7:
+  stage: test
+  extends: .test_ghcup_version:armv7
+  variables:
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+    CROSS: ""
+  when: manual
+  needs: []
+
+test:linux:aarch64:
+  stage: test
+  extends: .test_ghcup_version:aarch64
+  variables:
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+    CROSS: ""
+  when: manual
+  needs: []
+
+######## darwin test ########
+
+test:mac:
+  stage: test
+  extends: .test_ghcup_version:darwin
+  variables:
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+  needs: []
+
+test:mac:aarch64:
+  stage: test
+  extends: .test_ghcup_version:darwin:aarch64
+  variables:
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+  needs: []
+  allow_failure: true
+  when: manual
+
+
+######## freebsd test ########
+
+test:freebsd12:
+  stage: test
+  extends: .test_ghcup_version:freebsd12
+  variables:
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+  allow_failure: true # freebsd runners are unreliable
+  when: manual
+  needs: []
+
+test:freebsd13:
+  stage: test
+  extends: .test_ghcup_version:freebsd13
+  variables:
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+  allow_failure: true # freebsd runners are unreliable
+  when: manual
+  needs: []
+
+######## windows test ########
+
+test:windows:
+  stage: test
+  extends: .test_ghcup_version:windows
+  variables:
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+  needs: []
+
+# test:windows:scoop:
+  # stage: test
+  # extends: .test_ghcup_scoop:windows
+  # needs: []
+
+######## linux release ########
+
+release:linux:64bit:
+  stage: release
+  needs: ["test:linux"]
+  extends:
+    - .alpine:64bit
+    - .release_ghcup
+  before_script:
+    - ./.gitlab/before_script/linux/alpine/install_deps.sh
+  variables:
+    ARTIFACT: "x86_64-linux-ghcup"
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+
+
+release:linux:32bit:
+  stage: release
+  needs: ["test:linux:32bit"]
+  extends:
+    - .alpine:32bit
+    - .release_ghcup
+  before_script:
+    - ./.gitlab/before_script/linux/alpine/install_deps.sh
+  variables:
+    ARTIFACT: "i386-linux-ghcup"
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+
+release:linux:armv7:
+  stage: release
+  needs: ["test:linux:armv7"]
+  extends:
+    - .linux:armv7
+    - .release_ghcup
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps.sh
+  variables:
+    ARTIFACT: "armv7-linux-ghcup"
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+    CROSS: ""
+
+release:linux:aarch64:
+  stage: release
+  needs: ["test:linux:aarch64"]
+  extends:
+    - .linux:aarch64
+    - .release_ghcup
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps.sh
+  variables:
+    ARTIFACT: "aarch64-linux-ghcup"
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+    CROSS: ""
+
+######## darwin release ########
+
+release:darwin:
+  stage: release
+  needs: ["test:mac"]
+  extends:
+    - .darwin
+    - .release_ghcup
+    - .root_cleanup
+  before_script:
+    - ./.gitlab/before_script/darwin/install_deps.sh
+  variables:
+    ARTIFACT: "x86_64-apple-darwin-ghcup"
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+    MACOSX_DEPLOYMENT_TARGET: "10.7"
+
+release:darwin:aarch64:
+  stage: release
+  needs: ["test:mac:aarch64"]
+  extends:
+    - .darwin:aarch64
+    - .release_ghcup
+    - .root_cleanup
+  cache:
+    key: darwin-brew-$CACHE_REV
+    paths:
+      - brew_cache
+    key: ghcup-test-$CACHE_REV
+    paths:
+      - cabal-cache
+  before_script:
+    - ./.gitlab/script/ci.sh extract_brew_cache
+    - ./.gitlab/script/ci.sh extract_cabal_cache
+    # otherwise we seem to get intel binaries
+    - export HOMEBREW_CHANGE_ARCH_TO_ARM=1
+    # update and install packages
+    - /bin/bash ./.gitlab/script/brew.sh llvm autoconf automake coreutils
+  script: |
+    export PATH="$CI_PROJECT_DIR/.brew/opt/llvm/bin:$CI_PROJECT_DIR/.brew/bin:$CI_PROJECT_DIR/.brew/sbin:$PATH"
+    export CC=$CI_PROJECT_DIR/.brew/opt/llvm/bin/clang
+    export CXX=$CI_PROJECT_DIR/.brew/opt/llvm/bin/clang++
+    export LD=ld
+    export AR=$CI_PROJECT_DIR/.brew/opt/llvm/bin/llvm-ar
+    export RANLIB=$CI_PROJECT_DIR/.brew/opt/llvm/bin/llvm-ranlib
+    ./.gitlab/before_script/darwin/install_deps.sh
+    ./.gitlab/script/ghcup_release.sh
+  after_script:
+    - ./.gitlab/script/ci.sh save_cabal_cache
+    - ./.gitlab/script/ci.sh save_brew_cache
+  variables:
+    ARTIFACT: "aarch64-apple-darwin-ghcup"
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+    MACOSX_DEPLOYMENT_TARGET: "10.7"
+  allow_failure: true
+  when: manual
+
+
+######## freebsd release ########
+
+release:freebsd12:
+  stage: release
+  needs: ["test:freebsd12"]
+  extends:
+    - .freebsd12
+    - .release_ghcup
+    - .root_cleanup
+  before_script:
+    - ./.gitlab/before_script/freebsd/install_deps.sh
+  variables:
+    ARTIFACT: "x86_64-portbld-freebsd-ghcup"
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+  allow_failure: true
+
+release:freebsd13:
+  stage: release
+  needs: ["test:freebsd13"]
+  extends:
+    - .freebsd13
+    - .release_ghcup
+    - .root_cleanup
+  before_script:
+    - sudo pkg update
+    - sudo pkg install --yes compat12x-amd64
+    - sudo ln -s libncurses.so.6 /usr/local/lib/libncurses.so.6.2
+    - ./.gitlab/before_script/freebsd/install_deps.sh
+  variables:
+    ARTIFACT: "x86_64-portbld-freebsd-ghcup"
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+  allow_failure: true
+
+######## windows release ########
+
+release:windows:
+  stage: release
+  needs: ["test:windows"]
+  extends:
+    - .windows
+    - .release_ghcup
+    - .root_cleanup
+  before_script:
+    - bash ./.gitlab/before_script/windows/install_deps.sh
+  variables:
+    ARTIFACT: "x86_64-mingw64-ghcup"
+    GHC_VERSION: "8.10.7"
+    CABAL_VERSION: "3.6.2.0"
+
+######## hlint ########
+
+hlint:
+  stage: checks
+  extends:
+    - .debian
+  script:
+    - curl -sSL https://raw.github.com/ndmitchell/hlint/master/misc/run.sh | sh -s -- -r lib/ test/
+  allow_failure: true
+  artifacts:
+    expire_in: 2 week
+    paths:
+      - report.html
+    when: on_failure
+
+######## mkdocs ########
+
+mkdocs:
+  stage: checks
+  extends:
+    - .debian
+  before_script:
+    - sudo apt-get update -y
+    - sudo apt-get install -y python3-pip
+    - pip3 install mkdocs
+  script:
+    - ~/.local/bin/mkdocs build
+  allow_failure: true
+
+######## shellcheck ########
+
+shellcheck:
+  image: "koalaman/shellcheck-alpine"
+  tags:
+    - x86_64-linux
+  stage: checks
+  script:
+    - shellcheck scripts/bootstrap/bootstrap-haskell
+  allow_failure: true
+

.gitlab/after_script.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+set -eux
+
+BUILD_DIR=$CI_PROJECT_DIR
+echo "Cleaning $BUILD_DIR"
+cd $HOME
+test -n "$BUILD_DIR"
+shopt -s extglob
+rm -Rf "$BUILD_DIR"/!(out)
+if [ "${OS}" = "WINDOWS" ] ; then
+	rm -Rf /c/ghcup
+fi
+
+if [ "${OS}" = "DARWIN" ] ; then
+	rm -Rf /private/tmp/.brew_tmp
+fi
+
+exit 0

.gitlab/before_script/darwin/install_deps.sh

@@ -0,0 +1,32 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}"
+
+if [ $ARCH = 'ARM64' ] ; then
+	curl -sSfL https://downloads.haskell.org/~ghcup/aarch64-apple-darwin-ghcup > ./ghcup-bin
+	chmod +x ghcup-bin
+else
+	curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-apple-darwin-ghcup > ./ghcup-bin
+	chmod +x ghcup-bin
+	./ghcup-bin upgrade -i -f
+fi
+
+./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin install-cabal ${CABAL_VERSION}
+
+if [ $ARCH = 'ARM64' ] ; then
+	cabal update
+	mkdir vendored
+	cd vendored
+	cabal unpack network-3.1.2.1
+	cd network*
+	autoreconf -fi
+	cd ../..
+fi
+
+exit 0

.gitlab/before_script/freebsd/install_deps.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+
+set -eux
+
+# pkg install --force --yes --no-repo-update curl gcc gmp gmake ncurses perl5 libffi libiconv
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}"
+
+if freebsd-version | grep -E '^12.*' ; then
+	freebsd_ver=12
+elif freebsd-version | grep -E '^13.*' ; then
+	freebsd_ver=13
+else
+	(>&2 echo "Unsupported FreeBSD version! Please report a bug at https://gitlab.haskell.org/haskell/ghcup-hs/-/issues")
+	exit 1
+fi
+curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-freebsd${freebsd_ver}-ghcup > ./ghcup-bin
+chmod +x ghcup-bin
+
+./ghcup-bin -v upgrade -i -f
+./ghcup-bin -v install ${GHC_VERSION}
+./ghcup-bin -v set ${GHC_VERSION}
+./ghcup-bin -v install-cabal ${CABAL_VERSION}
+
+exit 0

.gitlab/before_script/linux/alpine/install_deps.sh

@@ -0,0 +1,58 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../../ghcup_env"
+
+mkdir -p "${TMPDIR}"
+
+apk add --no-cache \
+	curl \
+	gcc \
+	g++ \
+	binutils \
+	binutils-gold \
+	bsd-compat-headers \
+	gmp-dev \
+	ncurses-dev \
+	libffi-dev \
+	make \
+	xz \
+	tar \
+	perl
+
+if [ "${ARCH}" = "32" ] ; then
+	curl -sSfL https://downloads.haskell.org/ghcup/i386-linux-ghcup > ./ghcup-bin
+else
+	curl -sSfL https://downloads.haskell.org/ghcup/x86_64-linux-ghcup > ./ghcup-bin
+fi
+chmod +x ghcup-bin
+./ghcup-bin upgrade -i -f
+./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin install-cabal ${CABAL_VERSION}
+
+# utils
+apk add --no-cache \
+	bash \
+	git
+
+## Package specific
+apk add --no-cache \
+	zlib \
+	zlib-dev \
+	zlib-static \
+	bzip2 \
+	bzip2-dev \
+	bzip2-static \
+	gmp \
+	gmp-dev \
+	openssl-dev \
+	openssl-libs-static \
+	xz \
+	xz-dev \
+	ncurses-static
+
+if [ "${ARCH}" = "32" ] ; then
+	apk add --no-cache \
+		bsd-compat-headers
+fi

.gitlab/before_script/linux/install_deps.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}"
+
+sudo apt-get update -y
+sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev libbz2-dev git wget lsb-release software-properties-common gnupg2 apt-transport-https gcc autoconf automake build-essential
+
+if [ "${CROSS}" = "arm-linux-gnueabihf" ] ; then
+	sudo apt-get install -y gcc-arm-linux-gnueabihf
+	sudo dpkg --add-architecture armhf
+	sudo apt-get update -y
+	sudo apt-get install -y libncurses-dev:armhf
+fi
+
+export BOOTSTRAP_HASKELL_NONINTERACTIVE=1
+export BOOTSTRAP_HASKELL_GHC_VERSION=$GHC_VERSION
+export BOOTSTRAP_HASKELL_CABAL_VERSION=$CABAL_VERSION
+export BOOTSTRAP_HASKELL_VERBOSE=1
+
+curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh
+
+rm "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/ghcup
+

.gitlab/before_script/linux/install_deps_minimal.sh

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}"
+
+sudo apt-get update -y
+sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev libbz2-dev git wget

.gitlab/before_script/windows/install_deps.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}" "${CABAL_DIR}"
+
+mkdir -p "$GHCUP_INSTALL_BASE_PREFIX/ghcup/bin"
+
+CI_PROJECT_DIR=$(pwd)
+curl -o ghcup.exe https://downloads.haskell.org/~ghcup/x86_64-mingw64-ghcup.exe
+chmod +x ghcup.exe
+
+./ghcup.exe install ${GHC_VERSION}
+./ghcup.exe set ${GHC_VERSION}
+./ghcup.exe install-cabal ${CABAL_VERSION}
+
+rm ./ghcup.exe
+
+exit 0

.gitlab/ghcup-run.files

@@ -0,0 +1,37 @@
+.
+./cabal
+./ghc
+./ghc-8.10.7
+./ghc-pkg
+./ghc-pkg-8.10.7
+./ghci
+./ghci-8.10.7
+./haddock
+./haddock-8.10.7
+./haskell-language-server-8.10.6
+./haskell-language-server-8.10.6~1.6.1.0
+./haskell-language-server-8.10.7
+./haskell-language-server-8.10.7~1.6.1.0
+./haskell-language-server-8.6.5
+./haskell-language-server-8.6.5~1.6.1.0
+./haskell-language-server-8.8.4
+./haskell-language-server-8.8.4~1.6.1.0
+./haskell-language-server-9.0.1
+./haskell-language-server-9.0.1~1.6.1.0
+./haskell-language-server-9.0.2
+./haskell-language-server-9.0.2~1.6.1.0
+./haskell-language-server-9.2.1
+./haskell-language-server-9.2.1~1.6.1.0
+./haskell-language-server-wrapper
+./haskell-language-server-wrapper-1.6.1.0
+./hp2ps
+./hp2ps-8.10.7
+./hpc
+./hpc-8.10.7
+./hsc2hs
+./hsc2hs-8.10.7
+./runghc
+./runghc-8.10.7
+./runhaskell
+./runhaskell-8.10.7
+./stack

.gitlab/ghcup-run.files.windows

@@ -0,0 +1,81 @@
+.
+./cabal.exe
+./cabal.shim
+./ghc-8.10.7.exe
+./ghc-8.10.7.shim
+./ghc-pkg-8.10.7.exe
+./ghc-pkg-8.10.7.shim
+./ghc-pkg.exe
+./ghc-pkg.shim
+./ghc.exe
+./ghc.shim
+./ghci-8.10.7.exe
+./ghci-8.10.7.shim
+./ghci.exe
+./ghci.shim
+./ghcii-8.10.7.sh-8.10.7.exe
+./ghcii-8.10.7.sh-8.10.7.shim
+./ghcii-8.10.7.sh.exe
+./ghcii-8.10.7.sh.shim
+./ghcii.sh-8.10.7.exe
+./ghcii.sh-8.10.7.shim
+./ghcii.sh.exe
+./ghcii.sh.shim
+./haddock-8.10.7.exe
+./haddock-8.10.7.shim
+./haddock.exe
+./haddock.shim
+./haskell-language-server-8.10.6.exe
+./haskell-language-server-8.10.6.shim
+./haskell-language-server-8.10.6~1.6.1.0.exe
+./haskell-language-server-8.10.6~1.6.1.0.shim
+./haskell-language-server-8.10.7.exe
+./haskell-language-server-8.10.7.shim
+./haskell-language-server-8.10.7~1.6.1.0.exe
+./haskell-language-server-8.10.7~1.6.1.0.shim
+./haskell-language-server-8.6.5.exe
+./haskell-language-server-8.6.5.shim
+./haskell-language-server-8.6.5~1.6.1.0.exe
+./haskell-language-server-8.6.5~1.6.1.0.shim
+./haskell-language-server-8.8.4.exe
+./haskell-language-server-8.8.4.shim
+./haskell-language-server-8.8.4~1.6.1.0.exe
+./haskell-language-server-8.8.4~1.6.1.0.shim
+./haskell-language-server-9.0.1.exe
+./haskell-language-server-9.0.1.shim
+./haskell-language-server-9.0.1~1.6.1.0.exe
+./haskell-language-server-9.0.1~1.6.1.0.shim
+./haskell-language-server-9.0.2.exe
+./haskell-language-server-9.0.2.shim
+./haskell-language-server-9.0.2~1.6.1.0.exe
+./haskell-language-server-9.0.2~1.6.1.0.shim
+./haskell-language-server-9.2.1.exe
+./haskell-language-server-9.2.1.shim
+./haskell-language-server-9.2.1~1.6.1.0.exe
+./haskell-language-server-9.2.1~1.6.1.0.shim
+./haskell-language-server-wrapper-1.6.1.0.exe
+./haskell-language-server-wrapper-1.6.1.0.shim
+./haskell-language-server-wrapper.exe
+./haskell-language-server-wrapper.shim
+./hp2ps-8.10.7.exe
+./hp2ps-8.10.7.shim
+./hp2ps.exe
+./hp2ps.shim
+./hpc-8.10.7.exe
+./hpc-8.10.7.shim
+./hpc.exe
+./hpc.shim
+./hsc2hs-8.10.7.exe
+./hsc2hs-8.10.7.shim
+./hsc2hs.exe
+./hsc2hs.shim
+./runghc-8.10.7.exe
+./runghc-8.10.7.shim
+./runghc.exe
+./runghc.shim
+./runhaskell-8.10.7.exe
+./runhaskell-8.10.7.shim
+./runhaskell.exe
+./runhaskell.shim
+./stack.exe
+./stack.shim

.gitlab/ghcup_env

@@ -0,0 +1,23 @@
+if [ "${OS}" = "WINDOWS" ] ; then
+    export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
+    export GHCUP_BIN="$CI_PROJECT_DIR/ghcup/bin"
+    export PATH="$GHCUP_BIN:$CI_PROJECT_DIR/.local/bin:$PATH"
+    export TMPDIR="$CI_PROJECT_DIR/tmp"
+    export CABAL_DIR="$CI_PROJECT_DIR/cabal"
+    export CABAL_CACHE="$CI_PROJECT_DIR/cabal-cache"
+    export STACK_ROOT="$CI_PROJECT_DIR/stack"
+    export STACK_CACHE="$CI_PROJECT_DIR/stack-cache"
+    export BREW_DIR="$CI_PROJECT_DIR/.brew_cache"
+    export BREW_CACHE="$CI_PROJECT_DIR/brew-cache"
+else
+    export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
+    export GHCUP_BIN="$CI_PROJECT_DIR/.ghcup/bin"
+    export PATH="$GHCUP_BIN:$CI_PROJECT_DIR/.local/bin:$PATH"
+    export TMPDIR="$CI_PROJECT_DIR/tmp"
+    export CABAL_DIR="$CI_PROJECT_DIR/cabal"
+    export CABAL_CACHE="$CI_PROJECT_DIR/cabal-cache"
+    export STACK_ROOT="$CI_PROJECT_DIR/stack"
+    export STACK_CACHE="$CI_PROJECT_DIR/stack-cache"
+    export BREW_DIR="$CI_PROJECT_DIR/.brew_cache"
+    export BREW_CACHE="$CI_PROJECT_DIR/brew-cache"
+fi

.gitlab/script/brew.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+set -Eeuxo pipefail
+
+# Install brew locally in the project dir. Packages will also be installed here.
+[ -e "$CI_PROJECT_DIR/.brew" ] || git clone --depth=1 https://github.com/Homebrew/brew $CI_PROJECT_DIR/.brew
+export PATH="$CI_PROJECT_DIR/.brew/bin:$CI_PROJECT_DIR/.brew/sbin:$PATH"
+
+# make sure to not pollute the machine with temp files etc
+mkdir -p $CI_PROJECT_DIR/.brew_cache
+export HOMEBREW_CACHE=$CI_PROJECT_DIR/.brew_cache
+mkdir -p $CI_PROJECT_DIR/.brew_logs
+export HOMEBREW_LOGS=$CI_PROJECT_DIR/.brew_logs
+mkdir -p /private/tmp/.brew_tmp
+export HOMEBREW_TEMP=/private/tmp/.brew_tmp
+
+# update and install packages
+brew update
+brew install ${1+"$@"}

.gitlab/script/ci.sh

@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+
+set -Eeuo pipefail
+
+TOP="$( cd "$(dirname "$0")" ; pwd -P )"
+. "${TOP}/../ghcup_env"
+
+function save_cabal_cache () {
+  echo "Storing cabal cache from $CABAL_DIR to $CABAL_CACHE..."
+  rm -Rf "$CABAL_CACHE"
+  mkdir -p "$CABAL_CACHE"
+  if [ -d "$CABAL_DIR" ]; then
+	  cp -Rf "$CABAL_DIR" "$CABAL_CACHE/"
+  fi
+}
+
+
+function extract_cabal_cache () {
+  if [ -d "$CABAL_CACHE" ]; then
+      echo "Extracting cabal cache from $CABAL_CACHE to $CABAL_DIR..."
+      mkdir -p "$CABAL_DIR"
+      cp -Rf "$CABAL_CACHE"/* "$CABAL_DIR"
+  fi
+}
+
+function save_stack_cache () {
+  echo "Storing stack cache from $STACK_ROOT to $STACK_CACHE..."
+  rm -Rf "$STACK_CACHE"
+  mkdir -p "$STACK_CACHE"
+  if [ -d "$STACK_ROOT" ]; then
+	  cp -Rf "$STACK_DIR" "$STACK_CACHE"
+  fi
+}
+
+
+function extract_stack_cache () {
+  if [ -d "$STACK_CACHE" ]; then
+      echo "Extracting stack cache from $STACK_CACHE to $STACK_ROOT..."
+      mkdir -p "$STACK_ROOT"
+      cp -Rf "$STACK_CACHE"/* "$STACK_ROOT"
+  fi
+}
+
+function save_brew_cache () {
+  echo "Storing brew cache from $BREW_DIR to $BREW_CACHE..."
+  rm -Rf "$BREW_CACHE"
+  mkdir -p "$BREW_CACHE"
+  if [ -d "$BREW_DIR" ]; then
+	  cp -Rf "$BREW_DIR" "$BREW_CACHE"
+  fi
+}
+
+
+function extract_brew_cache () {
+  if [ -d "$BREW_CACHE" ]; then
+      echo "Extracting stack cache from $BREW_CACHE to $BREW_DIR..."
+      mkdir -p "$BREW_DIR"
+      cp -Rf "$BREW_CACHE"/* "$BREW_DIR"
+  fi
+}
+
+case $1 in
+  extract_cabal_cache) extract_cabal_cache ;;
+  save_cabal_cache) save_cabal_cache ;;
+  extract_stack_cache) extract_stack_cache ;;
+  save_stack_cache) save_stack_cache ;;
+  extract_brew_cache) extract_brew_cache ;;
+  save_brew_cache) save_brew_cache ;;
+  *) echo "unknown mode $1" ; exit 11 ;;
+esac

.gitlab/script/ghcup_bootstrap.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+git describe --always
+
+### build
+
+export BOOTSTRAP_HASKELL_NONINTERACTIVE=yes
+export BOOTSTRAP_HASKELL_GHC_VERSION=$GHC_VERSION
+export BOOTSTRAP_HASKELL_CABAL_VERSION=$CABAL_VERSION
+
+./scripts/bootstrap/bootstrap-haskell
+
+[ "$(ghc --numeric-version)" = "${GHC_VERSION}" ]
+

.gitlab/script/ghcup_cross.sh

@@ -0,0 +1,52 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+CI_PROJECT_DIR=$(pwd)
+
+ecabal() {
+	cabal "$@"
+}
+
+eghcup() {
+	ghcup -v -c -s file://$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml "$@"
+}
+
+git describe --always
+
+### build
+
+ecabal update
+
+ecabal build -w ghc-${GHC_VERSION}
+cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" "$CI_PROJECT_DIR"/.local/bin/ghcup
+
+### cleanup
+
+rm -rf "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
+
+### manual cli based testing
+
+eghcup --numeric-version
+
+eghcup install ghc ${GHC_VERSION}
+eghcup set ghc ${GHC_VERSION}
+eghcup install cabal ${CABAL_VERSION}
+
+cabal --version
+
+eghcup debug-info
+
+eghcup compile ghc -j $(nproc) -v ${GHC_TARGET_VERSION} -b ${GHC_VERSION} -x ${CROSS} -- --enable-unregisterised
+eghcup set ghc ${CROSS}-${GHC_TARGET_VERSION}
+
+[ `$(eghcup whereis ghc ${CROSS}-${GHC_TARGET_VERSION}) --numeric-version` = "${GHC_TARGET_VERSION}" ]
+
+# nuke
+eghcup nuke
+[ ! -e "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup" ]
+

.gitlab/script/ghcup_git.sh

@@ -0,0 +1,52 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+CI_PROJECT_DIR=$(pwd)
+
+ecabal() {
+	cabal "$@"
+}
+
+eghcup() {
+	ghcup -v -c -s file://$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml "$@"
+}
+
+git describe --always
+
+### build
+
+ecabal update
+
+ecabal build -w ghc-${GHC_VERSION}
+cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" "$CI_PROJECT_DIR"/.local/bin/ghcup
+
+### cleanup
+
+rm -rf "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
+
+### manual cli based testing
+
+eghcup --numeric-version
+
+eghcup install ghc ${GHC_VERSION}
+eghcup set ghc ${GHC_VERSION}
+eghcup install cabal ${CABAL_VERSION}
+
+cabal --version
+
+eghcup debug-info
+
+eghcup compile ghc -j $(nproc) -g ${GHC_GIT_TAG} -b ${GHC_VERSION} -- --enable-unregisterised
+eghcup set ghc ${GHC_GIT_VERSION}
+
+[ `$(eghcup whereis ghc ${GHC_GIT_VERSION}) --numeric-version` = "${GHC_GIT_VERSION}" ]
+
+# nuke
+eghcup nuke
+[ ! -e "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup" ]
+

.gitlab/script/ghcup_hls.sh

@@ -0,0 +1,51 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+CI_PROJECT_DIR=$(pwd)
+
+ecabal() {
+	cabal "$@"
+}
+
+eghcup() {
+	ghcup -v -c -s file://$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml "$@"
+}
+
+git describe --always
+
+### build
+
+ecabal update
+
+ecabal build -w ghc-${GHC_VERSION}
+cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" "$CI_PROJECT_DIR"/.local/bin/ghcup
+
+### cleanup
+
+rm -rf "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
+
+### manual cli based testing
+
+eghcup --numeric-version
+
+eghcup install ghc ${GHC_VERSION}
+eghcup set ghc ${GHC_VERSION}
+eghcup install cabal ${CABAL_VERSION}
+
+cabal --version
+
+eghcup debug-info
+
+eghcup compile hls -j $(nproc) -v ${HLS_TARGET_VERSION} --ghc ${GHC_VERSION}
+
+[ `$(eghcup whereis hls ${HLS_TARGET_VERSION}) --numeric-version` = "${HLS_TARGET_VERSION}" ] || [ `$(eghcup whereis hls ${HLS_TARGET_VERSION}) --numeric-version | sed 's/.0$//'` = "${HLS_TARGET_VERSION}" ]
+
+# nuke
+eghcup nuke
+[ ! -e "${GHCUP_INSTALL_BASE_PREFIX}/.ghcup" ]
+

.gitlab/script/ghcup_release.sh

@@ -0,0 +1,44 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+ecabal() {
+	cabal "$@"
+}
+
+git describe
+
+# build
+ecabal update
+
+
+if [ "${OS}" = "LINUX" ] ; then
+	if [ "${ARCH}" = "32" ] ; then
+		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui
+	elif [ "${ARCH}" = "64" ] ; then
+		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui
+	else
+		ecabal build -w ghc-${GHC_VERSION} -ftui
+	fi
+elif [ "${OS}" = "FREEBSD" ] ; then
+	ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections' --constraint="zlib +bundled-c-zlib" --constraint="zip +disable-zstd" -ftui
+elif [ "${OS}" = "WINDOWS" ] ; then
+	ecabal build -w ghc-${GHC_VERSION} --constraint="zlib +bundled-c-zlib" --constraint="lzma +static"
+else
+	ecabal build -w ghc-${GHC_VERSION} --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" -ftui
+fi
+
+mkdir out
+binary=$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')
+ver=$("${binary}" --numeric-version)
+if [ "${OS}" = "DARWIN" ] ; then
+	strip "${binary}"
+else
+	strip -s "${binary}"
+fi
+cp "${binary}" out/${ARTIFACT}-${ver}
+

.gitlab/script/ghcup_stack.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+git describe --always
+
+### build
+
+curl -L -O https://get.haskellstack.org/stable/linux-x86_64.tar.gz
+tar xf linux-x86_64.tar.gz
+cp stack-*-linux-*/stack "$CI_PROJECT_DIR"/.local/bin/stack
+chmod +x "$CI_PROJECT_DIR"/.local/bin/stack
+
+mkdir -p "$CI_PROJECT_DIR"/.stack_root
+export TAR_OPTIONS=--no-same-owner
+stack --allow-different-user --stack-root "$CI_PROJECT_DIR"/.stack_root build
+stack --allow-different-user --stack-root "$CI_PROJECT_DIR"/.stack_root test

.gitlab/script/ghcup_version.sh

@@ -0,0 +1,314 @@
+#!/usr/bin/env bash
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+CI_PROJECT_DIR=$(pwd)
+
+
+ecabal() {
+	cabal "$@"
+}
+
+raw_eghcup() {
+	ghcup -v -c "$@"
+}
+
+eghcup() {
+	if [ "${OS}" = "WINDOWS" ] ; then
+		ghcup -v -c -s file:/$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml "$@"
+	else
+		ghcup -v -c -s file://$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml "$@"
+	fi
+}
+
+if [ "${OS}" = "WINDOWS" ] ; then
+	GHCUP_DIR="${GHCUP_INSTALL_BASE_PREFIX}"/ghcup
+else
+	GHCUP_DIR="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
+fi
+
+git describe --always
+
+### build
+
+rm -rf "${GHCUP_DIR}"/share
+
+ecabal update
+
+if [ "${OS}" = "DARWIN" ] ; then
+	ecabal build -w ghc-${GHC_VERSION} -ftui
+	ecabal test -w ghc-${GHC_VERSION} -ftui ghcup-test
+	ecabal haddock -w ghc-${GHC_VERSION} -ftui
+elif [ "${OS}" = "LINUX" ] ; then
+	if [ "${ARCH}" = "32" ] ; then
+		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
+		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui ghcup-test
+		ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui
+	else
+		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
+		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui ghcup-test
+		ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui
+
+		if [ "${ARCH}" = "64" ] ; then
+			# doctest
+			curl -sL https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal-docspec/cabal-docspec-0.0.0.20210228_p1.tar.bz2 > cabal-docspec.tar.bz2
+			echo '3a10f6fec16dbd18efdd331b1cef5d2d342082da42f5b520726d1fa6a3990d12  cabal-docspec.tar.bz2' | sha256sum -c -
+			tar -xjf cabal-docspec.tar.bz2 cabal-docspec
+			mv cabal-docspec "$CI_PROJECT_DIR"/.local/bin/cabal-docspec
+			rm -f cabal-docspec.tar.bz2
+			chmod a+x "$CI_PROJECT_DIR"/.local/bin/cabal-docspec
+
+			cabal-docspec -XCPP -XTypeSynonymInstances -XOverloadedStrings -XPackageImports --check-properties
+		fi
+	fi
+elif [ "${OS}" = "FREEBSD" ] ; then
+	ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui --constraint="zip +disable-zstd"
+	ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui --constraint="zip +disable-zstd" ghcup-test
+	ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui --constraint="zip +disable-zstd"
+elif [ "${OS}" = "WINDOWS" ] ; then
+	ecabal build -w ghc-${GHC_VERSION}
+	ecabal test -w ghc-${GHC_VERSION} ghcup-test
+	ecabal haddock -w ghc-${GHC_VERSION}
+else
+	ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
+	ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui ghcup-test
+	ecabal haddock -w ghc-${GHC_VERSION} -finternal-downloader -ftui
+fi
+
+
+if [ "${OS}" = "WINDOWS" ] ; then
+	ext=".exe"
+else
+	ext=''
+fi
+	cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" "$CI_PROJECT_DIR"/.local/bin/ghcup${ext}
+
+### cleanup
+
+rm -rf "${GHCUP_DIR}"
+
+### manual cli based testing
+
+
+eghcup --numeric-version
+
+eghcup install ghc ${GHC_VERSION}
+eghcup unset ghc ${GHC_VERSION}
+ls -lah "$(eghcup whereis -d ghc ${GHC_VERSION})"
+[ "`$(eghcup whereis ghc ${GHC_VERSION}) --numeric-version`" = "${GHC_VERSION}" ]
+[ "`eghcup run --ghc ${GHC_VERSION} -- ghc --numeric-version`" = "${GHC_VERSION}" ]
+[ "`ghcup run --ghc ${GHC_VERSION} -- ghc -e 'Control.Monad.join (Control.Monad.fmap System.IO.putStr System.Environment.getExecutablePath)'`" = "`$(ghcup whereis ghc ${GHC_VERSION}) -e 'Control.Monad.join (Control.Monad.fmap System.IO.putStr System.Environment.getExecutablePath)'`" ]
+eghcup set ghc ${GHC_VERSION}
+eghcup install cabal ${CABAL_VERSION}
+[ "`$(eghcup whereis cabal ${CABAL_VERSION}) --numeric-version`" = "${CABAL_VERSION}" ]
+eghcup unset cabal
+"$GHCUP_BIN"/cabal --version && exit 1 || echo yes
+
+# make sure no cabal is set when running 'ghcup run' to check that PATH propagages properly
+# https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/375
+[ "`eghcup run --cabal ${CABAL_VERSION} -- cabal --numeric-version`" = "${CABAL_VERSION}" ]
+eghcup set cabal ${CABAL_VERSION}
+
+[ "`$(eghcup whereis cabal ${CABAL_VERSION}) --numeric-version`" = "${CABAL_VERSION}" ]
+
+if [ "${OS}" != "FREEBSD" ] ; then
+	if [ "${ARCH}" = "64" ] ; then
+		eghcup run --ghc 8.10.7 --cabal 3.4.1.0 --hls 1.6.1.0 --stack 2.7.3 --install --bindir "$(pwd)/.bin"
+		if [ "${OS}" == "WINDOWS" ] ; then
+			expected=$(cat "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup-run.files.windows" | sort)
+		else
+			expected=$(cat "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup-run.files" | sort)
+		fi
+		actual=$(cd ".bin" && find . | sort)
+		[ "${actual}" = "${expected}" ]
+		unset actual expected
+		rm -rf .bin
+	fi
+fi
+
+cabal --version
+
+eghcup debug-info
+
+# also test etags
+eghcup list
+eghcup list -t ghc
+eghcup list -t cabal
+
+ghc_ver=$(ghc --numeric-version)
+ghc --version
+ghc-${ghc_ver} --version
+if [ "${OS}" != "WINDOWS" ] ; then
+		ghci --version
+		ghci-${ghc_ver} --version
+fi
+
+
+if [ "${OS}" = "DARWIN" ] && [ "${ARCH}" = "ARM64" ] ; then
+	echo
+else
+	# test installing new ghc doesn't mess with currently set GHC
+	# https://gitlab.haskell.org/haskell/ghcup-hs/issues/7
+	if [ "${OS}" = "LINUX" ] ; then
+		eghcup --downloader=wget prefetch ghc 8.10.3
+		eghcup --offline install ghc 8.10.3
+		if [ "${ARCH}" = "64" ] ; then
+			expected=$(cat "$( cd "$(dirname "$0")" ; pwd -P )/../ghc-8.10.3-linux.files" | sort)
+			actual=$(cd "${GHCUP_DIR}/ghc/8.10.3/" && find . | sort)
+			[ "${actual}" = "${expected}" ]
+			unset actual expected
+		fi
+	elif [ "${OS}" = "WINDOWS" ] ; then
+		eghcup prefetch ghc 8.10.3
+		eghcup --offline install ghc 8.10.3
+		expected=$(cat "$( cd "$(dirname "$0")" ; pwd -P )/../ghc-8.10.3-windows.files" | sort)
+		actual=$(cd "${GHCUP_DIR}/ghc/8.10.3/" && find . | sort)
+		[ "${actual}" = "${expected}" ]
+		unset actual expected
+	else
+		eghcup prefetch ghc 8.10.3
+		eghcup --offline install ghc 8.10.3
+	fi
+	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
+	eghcup --offline set 8.10.3
+	eghcup set 8.10.3
+	[ "$(ghc --numeric-version)" = "8.10.3" ]
+	eghcup set ${GHC_VERSION}
+	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
+	eghcup unset ghc
+    "$GHCUP_BIN"/ghc --numeric-version && exit 1 || echo yes
+	eghcup set ${GHC_VERSION}
+	eghcup --offline rm 8.10.3
+	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
+
+
+	ls -lah "$GHCUP_BIN"
+
+	if [ "${OS}" = "DARWIN" ] ; then
+		eghcup install hls
+		$(eghcup whereis hls) --version
+
+		eghcup install stack
+		$(eghcup whereis stack) --version
+	elif [ "${OS}" = "LINUX" ] ; then
+		if [ "${ARCH}" = "64" ] ; then
+			eghcup install hls
+			haskell-language-server-wrapper --version
+			eghcup unset hls
+			"$GHCUP_BIN"/haskell-language-server-wrapper --version && exit 1 || echo yes
+
+			eghcup install stack
+			stack --version
+			eghcup unset stack
+			"$GHCUP_BIN"/stack --version && exit 1 || echo yes
+		fi
+	fi
+fi
+
+
+
+# check that lazy loading works for 'whereis'
+cp "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml" "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml.bak"
+echo '**' > "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml"
+eghcup whereis ghc $(ghc --numeric-version)
+mv -f "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml.bak" "$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml"
+
+eghcup rm $(ghc --numeric-version)
+
+# https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/116
+if [ "${OS}" = "LINUX" ] ; then
+	if [ "${ARCH}" = "64" ] ; then
+		eghcup install cabal -u https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal/3.7.0.0-pre20220407/cabal-install-3.7-x86_64-linux-alpine.tar.xz 3.4.0.0-rc4
+		eghcup rm cabal 3.4.0.0-rc4
+	fi
+fi
+
+eghcup gc -c
+
+sha_sum() {
+	if [ "${OS}" = "FREEBSD" ] ; then
+		sha256 "$@"
+	else
+		sha256sum "$@"
+	fi
+
+}
+
+# test etags
+rm -f "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml"
+raw_eghcup -s https://www.haskell.org/ghcup/data/ghcup-${JSON_VERSION}.yaml list
+# snapshot yaml and etags file
+etag=$(cat "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml.etags")
+sha=$(sha_sum "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml")
+# invalidate access time timer, which is 5minutes, so we re-download
+touch -a -m -t '199901010101' "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml"
+# redownload same file with some newlines added
+raw_eghcup -s https://www.haskell.org/ghcup/exp/ghcup-${JSON_VERSION}.yaml list
+# snapshot new yaml and etags file
+etag2=$(cat "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml.etags")
+sha2=$(sha_sum "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml")
+# compare
+[ "${etag}" != "${etag2}" ]
+[ "${sha}" != "${sha2}" ]
+# invalidate access time timer, which is 5minutes, but don't expect a re-download
+touch -a -m -t '199901010101' "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml"
+# this time, we expect the same hash and etag
+raw_eghcup -s https://www.haskell.org/ghcup/exp/ghcup-${JSON_VERSION}.yaml list
+etag3=$(cat "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml.etags")
+sha3=$(sha_sum "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml")
+[ "${etag2}" = "${etag3}" ]
+[ "${sha2}" = "${sha3}" ]
+
+# test isolated installs
+eghcup install ghc -i "$(pwd)/isolated" 8.10.5
+[ "$(isolated/bin/ghc --numeric-version)" = "8.10.5" ]
+! eghcup install ghc -i "$(pwd)/isolated" 8.10.5
+if [ "${ARCH}" = "64" ] ; then
+	if [ "${OS}" = "LINUX" ] || [ "${OS}" = "WINDOWS" ] ; then
+		eghcup install cabal -i "$(pwd)/isolated" 3.4.0.0
+		[ "$(isolated/cabal --numeric-version)" = "3.4.0.0" ]
+		eghcup install stack -i "$(pwd)/isolated" 2.7.3
+		[ "$(isolated/stack --numeric-version)" = "2.7.3" ]
+		eghcup install hls -i "$(pwd)/isolated" 1.3.0
+		[ "$(isolated/haskell-language-server-wrapper --numeric-version)" = "1.3.0" ] ||
+			[ "$(isolated/haskell-language-server-wrapper --numeric-version)" = "1.3.0.0" ]
+
+		# test that isolated installs don't clean up target directory
+		cat <<EOF > "${GHCUP_BIN}/gmake"
+#!/bin/bash
+exit 1
+EOF
+		chmod +x "${GHCUP_BIN}/gmake"
+		mkdir isolated_tainted/
+		touch isolated_tainted/lol
+
+		! eghcup install ghc -i "$(pwd)/isolated_tainted" 8.10.5 --force
+		[ -e "$(pwd)/isolated_tainted/lol" ]
+		rm "${GHCUP_BIN}/gmake"
+	fi
+fi
+
+eghcup upgrade
+eghcup upgrade -f
+
+# test that doing fishy symlinks into GHCup dir doesn't cause weird stuff on 'ghcup nuke'
+mkdir no_nuke/
+mkdir no_nuke/bar
+echo 'foo' > no_nuke/file
+echo 'bar' > no_nuke/bar/file
+ln -s "$CI_PROJECT_DIR"/no_nuke/ "${GHCUP_DIR}"/cache/no_nuke
+ln -s "$CI_PROJECT_DIR"/no_nuke/ "${GHCUP_DIR}"/logs/no_nuke
+
+# nuke
+eghcup nuke
+[ ! -e "${GHCUP_DIR}" ]
+
+# make sure nuke doesn't resolve symlinks
+[ -e "$CI_PROJECT_DIR"/no_nuke/file ]
+[ -e "$CI_PROJECT_DIR"/no_nuke/bar/file ]
+
+

.gitlab/script/hlint.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+ecabal() {
+	cabal --store-dir="$(pwd)"/.store "$@"
+}
+
+git describe
+
+ecabal update
+ecabal install -w ghc-${GHC_VERSION} --installdir="$CI_PROJECT_DIR"/.local/bin hlint
+
+hlint -r app/ lib/ test/ 
+

.gitmodules

@@ -0,0 +1,4 @@
+[submodule "data/metadata"]
+	path = data/metadata
+	url = https://github.com/haskell/ghcup-metadata.git
+	branch = master

.hlint.yaml

@@ -0,0 +1,84 @@
+# HLint configuration file
+# https://github.com/ndmitchell/hlint
+##########################
+
+# This file contains a template configuration file, which is typically
+# placed as .hlint.yaml in the root of your project
+
+
+# Warnings currently triggered by your code
+- ignore: {name: "Redundant bang pattern"}
+- ignore: {name: "Use camelCase"}
+- ignore: {name: "Use if"}
+- ignore: {name: "Use newtype instead of data"}
+- ignore: {name: "Use <$>"}
+- ignore: {name: "Use mapMaybe"}
+- ignore: {name: "Use const"}
+- ignore: {name: "Use list comprehension"}
+- ignore: {name: "Redundant multi-way if"}
+- ignore: {name: "Redundant lambda"}
+- ignore: {name: "Avoid lambda"}
+- ignore: {name: "Use uncurry"}
+- ignore: {name: "Use replicateM"}
+- ignore: {name: "Use unless"}
+- ignore: {name: "Redundant irrefutable pattern"}
+
+
+# Specify additional command line arguments
+#
+# - arguments: [--color, --cpp-simple, -XQuasiQuotes]
+
+
+# Control which extensions/flags/modules/functions can be used
+#
+# - extensions:
+#   - default: false # all extension are banned by default
+#   - name: [PatternGuards, ViewPatterns] # only these listed extensions can be used
+#   - {name: CPP, within: CrossPlatform} # CPP can only be used in a given module
+#
+# - flags:
+#   - {name: -w, within: []} # -w is allowed nowhere
+#
+# - modules:
+#   - {name: [Data.Set, Data.HashSet], as: Set} # if you import Data.Set qualified, it must be as 'Set'
+#   - {name: Control.Arrow, within: []} # Certain modules are banned entirely
+#
+# - functions:
+#   - {name: unsafePerformIO, within: []} # unsafePerformIO can only appear in no modules
+
+
+# Add custom hints for this project
+#
+# Will suggest replacing "wibbleMany [myvar]" with "wibbleOne myvar"
+# - error: {lhs: "wibbleMany [x]", rhs: wibbleOne x}
+
+# The hints are named by the string they display in warning messages.
+# For example, if you see a warning starting like
+#
+# Main.hs:116:51: Warning: Redundant ==
+#
+# You can refer to that hint with `{name: Redundant ==}` (see below).
+
+# Turn on hints that are off by default
+#
+# Ban "module X(module X) where", to require a real export list
+# - warn: {name: Use explicit module export list}
+#
+# Replace a $ b $ c with a . b $ c
+# - group: {name: dollar, enabled: true}
+#
+# Generalise map to fmap, ++ to <>
+# - group: {name: generalise, enabled: true}
+
+
+# Ignore some builtin hints
+# - ignore: {name: Use let}
+# - ignore: {name: Use const, within: SpecialModule} # Only within certain modules
+
+
+# Define some custom infix operators
+# - fixity: infixr 3 ~^#^~
+
+
+# To generate a suitable file for HLint do:
+# $ hlint --default > .hlint.yaml

.travis.yml

@@ -10,12 +10,13 @@ jobs:
       language: generic
       env: ARTIFACT=x86_64-apple-darwin-10.14-ghcup
 
+
 script: ".travis/build.sh"
 
 deploy:
   provider: releases
   api_key:
-    secure: GEQR+HIwMUql+tFU0LoKCCzG+IG1s5XVA4yp8xMFk0IPsNjHEMh6djYgNqsS6MnujzRulinZe69RyJMZHW3UbtVKWd1D5nsCKmAVfnU8VRbubaL55Bz7C2WI9UCYtKY0isVIQu3KkY+0a6LhdjSkbatO2hl9v0nFmN28q/RpEzsJTI4kyVhmCBflH4fL/QvXzfLuyOae7qsiZBVQXEhmySYktKifNMANSI1aU+kyZ3JgykqZogMK+g/fmcxxTe9MPYMsRQxae/xqdf87IQpmK8v9BRShvF0wq1gO8NY+/fEemAVIHi5CYhPgiLntUD/HFr6AT04LcHnaGryDn/PhkvHuDuZ4INYgBrdNMeGVTjT93N7OtXyh7c+AP3/51E8nM0SkSWCeP4P2fMMksdeOnKtPbhzlqgEM9tbRMILOj1LcjcqurU5ku+WEwZ7d1osTyNug7FVCO5Vb0q3NYnDF4UPXc/d5/2SB+SjJSMxRc52+BiKskHmOa96TXirL3eo6KVNaokQRKvbLw1fEjZvqYJuhPWBRDMalyYjc77poj4kzfVL9CYjtP7h6N5wFR7AtPsMz2n2fQf7J3N4+oqHK+83fOPGyy4FYPZojKNw+L2X/XYrfVscsY/1KbBjULgGIrdr4euYz+rRrTHixUYIvGclKOx+g3SHAOXFWhXlldvI=
+    secure: "hT2od8Iy04tdFVuonPSWv0NX5hZDmv4al8Q0GbIWmviUetROuM7c6/MCHUcgyiw6H2L3pmH4F24GBYWpKBT3ZMbxrKXhZOZ3KPLXzlnuRlm1qymKqqwsJs3466bMftaiBr16rx1VpAuditN4A32oSmTFcQAJc84Bxn2WZ4t8hk9muS8YPyLhqg3/NxT6ob8dzNp9eS2cA0WODMb/fMzaMruRtepSK8JvuXb/SnTvaDcl9plmPzEa+eW54jwVsDps8ZpQMQlTtGIjYHIwTQ36/iLH4LoAvD7OEnB7qf753LOzmI/bvlB75xYGsLxe1qgpzPMjuG3AK0jb2KGSZCzyAyrbBFSQMIyC1gNKMtab3CohnA9WdQqAT1xrzPzA9zNw516G5Fn/z+t9Ek1f6L2OYO2hJfweNhWh+ChAIsOags2QBpqc0qjkwUS4wqxCWBdyVfgPTUoGelvjCfjQgypgIyLEHFvXt9rlj+kd97FY7nG3vxZrsvWTKKKT551OqUYX5zWTyvGR71jKyNst/p93Pg3DkRy31gHrGnG9zfNgN5tWxJqDd/suR/BAFTp0VtkFb8fR3ct7WMVeJXtE2+bKqxO5Fnocs1VjEm8pKPk7glnp0muu08kaO0h54wiSOCbk1RvO1KZtHue4wKWrHcI18dwW2WtzoBQ4P1lOSkS81UY="
   file: $ARTIFACT
   on:
     repo: hasufell/ghcup-hs

.travis/build.sh

@@ -1,22 +1,28 @@
-#/bin/sh
+#!/bin/sh
 
 set -ex
 
-## install ghc via old ghcup
-
 mkdir -p ~/.ghcup/bin
-curl https://gitlab.haskell.org/haskell/ghcup/raw/master/ghcup > ~/.ghcup/bin/ghcup
+curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-apple-darwin-ghcup > ~/.ghcup/bin/ghcup
 chmod +x ~/.ghcup/bin/ghcup
 
 export PATH="$HOME/.ghcup/bin:$PATH"
 
-ghcup install 8.8.3
-ghcup install-cabal 3.2.0.0
-ghcup set 8.8.3
+ghcup install 8.10.4
+ghcup install-cabal 3.4.0.0
+ghcup set 8.10.4
 
 
 ## install ghcup
 
 cabal update
-cabal build -fcurl
-cp "$(cabal new-exec --verbose=0 --offline sh -- -c 'command -v ghcup')" "./${ARTIFACT}"
+
+(
+       cd /tmp
+       cabal install --installdir="$HOME"/.ghcup/bin hspec-discover
+)
+
+cabal build --constraint="zlib +static" --constraint="lzma +static" -ftui
+cp "$(cabal new-exec --verbose=0 --offline sh -- -c 'command -v ghcup')" .
+strip ./ghcup
+cp ghcup "./${ARTIFACT}"

CHANGELOG.md

@@ -1,5 +1,299 @@
 # Revision history for ghcup
 
+## 0.1.18.1 -- 2022-08-06
+
+* fix sdist and unbreak hackage, wrt [#399](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/399)
+
+## 0.1.18.0 -- 2022-07-30
+
+* Fix tui set wrt [#266](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/266) by Arjun Kathuria
+    - Ask the user to install the tool via prompt when setting an non-installed version
+* improvements to safe (un-)installations
+    - bindists that don't support `make DESTDIR=/some/tmp/dir install` are now unsupported
+    - installed GHC files are now recorded to avoid use of `removePathForcibly`
+    - internally uses a newtype wrapper for user-input paths and restrict destructive operations to validated paths
+* Add `--disable-ld-override` for darwin bindists wrt #391
+* Allow passing bindist configure args wrt #377
+* use of `TMPDIR` is dropped... now uses an internal tmp dir `~/.ghcup/tmp`
+* improvements to error handling and warnings
+* Require --isolate to have an absolute directory, fixes #367
+* Fix mingw PATH handling wrt #371
+* Add --mingw-path switch to `ghcup run`
+* Fix `ghcup run` on windows, fixes #375
+* Improve `ghcup compile <hls|ghc>`
+    - short hashes now work
+    - print the long hash in addition to the detected version
+* Improve `ghcup compile hls`
+    - add `--git-describe-version` switch as an alternative to `--overwrite-version`
+    - Allow to build HLS from hackage (now is the default)
+	- Allow to run 'cabal update' automatically before the HLS build
+	- Fix parser and completer for 'ghcup compile hls --version'
+* Improve `ghcup compile ghc`
+    - Allow to build from arbitrary GHC source dists
+
+## 0.1.17.10 -- 2022-05-12
+
+* windows hotfix (hackage-only release)
+
+## 0.1.17.9 -- 2022-05-12
+
+* broken sdist (hackage-only release)
+
+## 0.1.17.8 -- 2022-05-11
+
+* Fix a serious (but hard to trigger) bug when combining `--isolate <DIR>` with `--force`, please make sure to upgrade or avoid `--force`
+* Fix HLS build not cleaning up properly on failed installations, fixes [#361](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/361)
+* Fix parsing of symlinks with multiple slashes, wrt [#353](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/353)
+* Re-enable upgrade functionality for all configurations wrt [MR #250](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/250) and [VSCode haskell issue #601](https://github.com/haskell/vscode-haskell/issues/601)
+* Fix `ghcup run --ghc 8.10` (for short versions) wrt [#360](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/360)
+    - this also introduces a `--quick` switch for `ghcup run`
+
+## 0.1.17.7 -- 2022-04-21
+
+* Fix `ghcup run` on windows wrt [#345](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/345)
+
+## 0.1.17.6 -- 2022-03-18
+
+* Vastly improve shell completions wrt [#242](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/242)
+* Fix 'ghcup install cabal/hls/stack --set' wrt [#324](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/324)
+* Fix bad error message wrt [#323](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/323)
+* Use predictable /tmp names for `ghcup run`, fixes [#329](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/329)
+* Fix bug with isolated installation of not previously installed versions
+* Add `--no-set` to install commands, fixes [#330](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/330)
+* Fix serious bug in `ghcup list --raw-format -t <tool> -c installed`
+* Overhaul metadata merging and add `ghcup config add-release-channel URI` wrt [#328](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/328)
+* Fix max path issues on windows with `ghcup run`
+
+## 0.1.17.5 -- 2022-02-26
+
+* Implement `ghcup run` subcommand wrt [#137](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/137)
+* Support installation of dynamic HLS bindists wrt [HLS #2675](https://github.com/haskell/haskell-language-server/pull/2675) and [#237](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/237)
+* Fix XDG support when `~/.local/bin` is a symlink wrt [#311](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/311)
+* Add support for quilt-style patches wrt [#230](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/230), by James Hobson
+* Fix redundant upgrade warnings in `ghcup upgrade`
+* Fix `ghcup whereis ghc` for non-standard versions wrt [#289](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/289)
+* Don't print logs to stdout, but stderr
+* Allow unpacking legacy lzma archives wrt [#307](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/307)
+* Allow to disable self-upgrade functionality wrt [#305](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/305)
+* Fix `ghcup install ghc --set` when ghc is already installed wrt [#291](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/291)
+
+## 0.1.17.4 -- 2021-11-13
+
+* add `--metadata-caching` option, allowing to also disable yaml metadata caching wrt [#278](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/278)
+* make upgrading ghcup in TUI more pleasant wrt [#276](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/276)
+* fix parsing of atypical GHC versions (e.g. `8.10.5-patch1`)
+* fix compiling HLS dynamically linked, also see [#245](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/245)
+* redo (and break) some of the `ghcup compile <tool>` interface, improving patch options and setting custom cabal.project files
+* avoid redundant update warnings wrt [#283](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/283)
+
+## 0.1.17.3 -- 2021-10-27
+
+* clean up during unpack failures as well
+* migrate te aeson-2.0.1.0
+* switch to yaml-streamly to fix performance regression wrt [#270](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/270)
+* use [github.com/haskell/ghcup-metadata](https://github.com/haskell/ghcup-metadata) for metadata file download (better caching)
+
+## 0.1.17.2 -- 2021-09-30
+
+* Honour GHC bootstrap compiler during git clone stages wrt [#250](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/250)
+* Speed up `unset` command
+* Fix `--overwrite-version` for `ghcup compile ghc` wrt [#253](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/253)
+* Apply patches before bootstrap
+
+## 0.1.17.1 -- 2021-09-26
+
+* Fix `NO_COLOR`
+* Fix `ghcup list -t` for hls/stack, wrt [#244](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/244)
+* Get rid of concurrent-output
+* Improve cli interface with partial versions (e.g. `ghcup install ghc 8`)
+* Fix HLS compilation builds
+* Implement `ghcup gc` (garbage collection) command
+
+## 0.1.17 -- 2021-09-20
+
+* Add `--force` option to install/compile wrt [#210](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/210) by Arjun Kathuria
+* Implement compiling HLS from source wrt [#201](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/201)
+* Implement experimental GPG verification of the metadata file (see README) wrt [#263](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/236)
+* Add `ghcup unset` command wrt [#145](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/145)
+* Add `ghcup whereis bindir` etc wrt [#221](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/221)
+* Greatly reduce dependency footprint wrt [#212](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/212)
+* Add `ghcup --plan-json`
+* Improve `--patchdir` option for GHC compilation wrt [#226](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/226)
+* Try to improve logging and failure modes, especially during downloads
+* Add descriptive warnings when HLS and GHC versions are incompatible
+* Improve curl header parsing wrt [#213](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/213)
+
+## 0.1.16.2 -- 2021-08-12
+
+* Add isolated installations wrt [#141](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/141) by Arjun Kathuria
+* Implement config cli MVP wrt [#134](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/134) by Oleksii Dorozhkin
+* Fix `ghcup compile ghc --flavor`
+* Fix minor installation bug causing increased disk space wrt [#139](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/139)
+* Improved error handling wrt [#136](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/136)
+* Various improvements to metadata download when using `file://` and `--offline` wrt [#137](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/137)
+
+## 0.1.16.1 -- 2021-07-29
+
+* Add 'nuke' subcommand wrt [#135](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/135), implemented by Arjun Kathuria
+* Add uninstallation powershell script on windows wrt [#150](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/150)
+* Improve logging
+* Fix building GHC cross compiler wrt [#180](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/180)
+* Allow to use hadrian as build system (for git based versions only) wrt [#35](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/35)
+* Allow passing `--flavor` to `ghcup compile ghc`
+* Support new GHC `bin/` directory format wrt [ghc/ghc#20074](https://gitlab.haskell.org/ghc/ghc/-/issues/20074#note_363720)
+* Implement `whereis` subcommand wrt [#173](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/173)
+* Add `--offline` switch and `prefetch` subcommand wrt [#186](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/186)
+* Implement ETAGs hashing for metadata downloads to speed up `ghcup list` wrt [#193](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/193)
+* Avoid unnecessary fetching of ghcup metadata in some commands
+* Avoid unnecessary update checks for some commands
+* Preserve mtimes on unpacked GHC tarballs on windows wrt [#187](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/187), fixing issues with `ghc-pkg`
+* Fix lesser bug in `ghcup list` for stray stack versions wrt [#183](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/183)
+* Major redo on how file removal on windows works, avoiding partial removals etc, wrt [#165](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/165)
+* Improve ghcup tui for screen readers wrt [github/#4](https://github.com/haskell/ghcup-hs/pull/4), thanks to Mario Lang
+
+## 0.1.15.2 -- 2021-06-13
+
+* Remove legacy handling of cabal binary and be more graceful about binaries not installed by ghcup (e.g. stack)
+* Fix GHC compilation from git
+* Fix 'ghcup upgrade' on windows
+* Allow to skip update checks via `GHCUP_SKIP_UPDATE_CHECK`
+* Use libarchive on windows as well, fixing unpack errors wrt [#147](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/147)
+
+## 0.1.15.1 -- 2021-06-11
+
+* Add Apple Silicon support
+* Add windows support wrt [#130](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/130)
+* Add stack support
+* Warn when /tmp doesn't have 5GB or more of disk space
+* Allow to compile GHC from git repo wrt [#126](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/126)
+* Allow to set custom ghc version when running 'ghcup compile ghc' wrt [#136](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/136)
+* Add date to GHC bindist names created by ghcup
+
+## 0.1.14.2 -- 2021-05-12
+
+* Remove dead dependency on ascii-string
+
+## 0.1.14.1 -- 2021-04-11
+
+* Make internal symlink target parser more lax, fixes [#119](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/119)
+* Prepare for hackage release
+
+## 0.1.14 -- 2021-03-07
+
+* Major bugfix: fix handling of stray versions wrt [#116](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/116)
+* Fix error messages and overhaul pretty printing wrt [#115](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/115)
+
+## 0.1.13 -- 2021-02-26
+
+* Support ARMv7/AARCH64
+* Add command line completions for installed and available versions wrt [MR #70](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/70)
+* Allow to cycle through set tools wrt [#114](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/114)
+* Fix item selection with unavailable versions wrt [#107](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/107)
+* Allow for dynamic post-install, post-remove and pre-compile msgs wrt [MR #68](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/68)
+* Alert user if upgraded ghcup is shadowed by old ghcup wrt [#111](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/111)
+* Fix to `ghcup` directory creation and placement for the XDG install mode ([MR #49](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/49))
+* Do 755 permissions on executables, wrt #97
+* Add [NO_COLOR](https://no-color.org/) support wrt [MR #47](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/47)
+
+## 0.1.12 -- 2020-11-21
+
+* Fix disappearing HLS symlinks wrt #91
+* improve TUI:
+  - separators between tools sections
+  - reverse list order so latest is on top
+  - expand the blues selected bar
+  - show new latest versions in bright white
+* allow configuration file and setting TUI hotkeys wrt #41
+  - see https://gitlab.haskell.org/haskell/ghcup-hs#configuration for a more in-depth explanation
+* add a `--set` switch to `ghcup install ghc` to automatically set as default after install
+* emit warnings when CC/LD is set wrt #82
+* add support for version ranges in distro specifiers wrt #84
+  - e.g. `"(>= 19 && <= 20) || ==0.2.2"` is a valid version key for distro
+
+## 0.1.11 -- 2020-09-23
+
+* Add support for installing haskell-language-server, wrt #65
+* When compiling GHC from source create a bindist first, store that bindist in `~/.ghcup/cache` and install it, wrt #51
+* Allow to compile over existing version (`ghcup compile ghc -v 8.6.5 -b 8.6.5`) and replace it wrt #59
+* simplify installing from custom bindist wrt #60
+  - `ghcup install ghc -u <url> <version>`
+* fix bug when cabal isn't marked executable in bindist
+* fix bug when `~/.ghcup` is a valid symlink wrt #49
+* Drop support for compiling cabal from source (the old bootstrap script is discontinued)
+
+## 0.1.10 -- 2020-08-14
+
+* Show stray Cabals (useful for pre-releases or compiled ones)
+
+## 0.1.9 -- 2020-08-14
+
+* Fix bug when uninstalling all cabal versions
+* Fix bug when setting a non-installed ghc version as current default
+* Use yaml instead of generated json for download info for ease of adding new GHC versions #44
+* Allow pre-release versions of GHC/cabal
+* Add XDG dirs support (set `GHCUP_USE_XDG_DIRS`) wrt #39
+* Allow to specify regex for tarball subdir (e.g. `ghc-.*`)
+* Allow installing arbitrary bindists more seamlessly:
+  - e.g. installing GHC HEAD: `ghcup -n install ghc -u '{"dlHash": "", "dlSubdir": { "RegexDir": "ghc-.*"}, "dlUri": "https://gitlab.haskell.org/api/v4/projects/1/jobs/artifacts/master/raw/ghc-x86_64-fedora27-linux.tar.xz?job=validate-x86_64-linux-fedora27" }' head`
+* Avoid duplicate edits to .bashrc/.zshrc wrt #43
+
+## 0.1.8 -- 2020-07-21
+
+* Fix bug in logging thread dying on newlines
+* Allow to install from arbitrary bindists: `ghcup -n install ghc -u '{"dlHash": "", "dlSubdir": "ghc-8.10.1", "dlUri": "https://github.com/commercialhaskell/ghc/releases/download/ghc-8.10.1-release/ghc-8.10.1-x86_64-deb9-linux.tar.xz"}' 8.10.1`
+
+## 0.1.7 -- 2020-07-20
+
+* Fix a bug in libarchive not unpacking some uncleanly packed bindists
+* Improved fish support in bootstrap-haskell
+* Only check for upgrades when not upgrading
+* Fix platform detection for i386 docker images
+* Improve alpine support
+  - more/proper bindists
+  - don't fall back to glibc based bindists
+  - install bindists with `--disable-ld-override` to avoid ld.gold bugs
+
+## 0.1.6 -- 2020-07-13
+
+* Create a new curses (brick) based TUI, accessible via `ghcup tui` #24
+* Support multiple installed versions of cabal #23
+* Improvements to `ghcup list` (show unavailable bindists for platform)
+* Fix redhat downloads #29
+* Support for hadrian bindists (fixes alpine-8.10.1) #31
+* Add FreeBSD bindists 8.6.5 and 8.8.3
+* Fix memory leak during unpack
+
+## 0.1.5 -- 2020-04-30
+
+* Fix errors when PATH variable contains path components that are actually files
+* Add `--version` and `--numeric-version` options
+* Add `changelog` command
+* Also check for available GHC and Cabal updates on start
+* Add base versions as tags for every GHC version (these are "installable" tags and the latest GHC version matching the tag will be picked)
+* Added `--format-raw` to list subcommand
+* Allow to install X.Y versions (e.g.: ghcup install 8.8)
+* Implement `--keep=<always|errors|never>` to control temporary build directories cleanup
+* Add proper shell completions to the repo
+* Fix building of documentation
+* Allow to work in offline mode and use cached files if possible
+* Allow to set the downloader via `--downloader=<curl|wget>`
+* Support for compiling and installing a cross GHC (see README). This is experimental.
+
+## 0.1.4 -- 2020-04-16
+
+* build on all platforms with curl (as a binary), wrt https://gitlab.haskell.org/haskell/ghcup-hs/issues/6
+* Fix unlinking of ghc symlinks after new installation, wrt https://gitlab.haskell.org/haskell/ghcup-hs/issues/7
+
+## 0.1.3 -- 2020-04-15
+
+* Fix lesser bug when skipping ghcup update
+
+## 0.1.2 -- 2020-04-15
+
+* Fix bug when removing the set GHC version
+* Fix use of undocumented `GHCUP_INSTALL_BASE_PREFIX` variable
+* skip upgrade if ghcup is already latest version
+
 ## 0.1.1 -- 2020-04-15
 
 * fix awful fdopendir bug on mac bug by updating hpath-posix

Dockerfile

@@ -1,42 +0,0 @@
-FROM alpine:edge
-
-# ghc and cabal
-RUN apk add --no-cache \
-	curl \
-	gcc \
-	g++ \
-	gmp-dev \
-	ncurses-dev \
-	libffi-dev \
-	make \
-	xz \
-	tar \
-	perl \
-	\
-	cabal \
-	ghc
-
-# utils
-RUN apk add --no-cache \
-	bash
-
-## Package specific
-RUN apk add --no-cache \
-	zlib \
-	zlib-dev \
-	zlib-static \
-	gmp \
-	gmp-dev \
-	openssl-dev \
-	openssl-libs-static \
-	xz \
-	xz-dev
-
-RUN cabal v2-update
-
-COPY . /app
-
-WORKDIR /app
-
-RUN chmod +x /app/docker/build.sh
-

HACKING.md

@@ -1,45 +0,0 @@
-# HACKING
-
-## Design decisions
-
-### Using [Excepts](https://hackage.haskell.org/package/haskus-utils-variant-3.0/docs/Haskus-Utils-Variant-Excepts.html) as a beefed up ExceptT
-
-This is an open variant, similar to [plucky](https://hackage.haskell.org/package/plucky) or [oops](https://github.com/i-am-tom/oops) and allows us to combine different error types. Maybe it is too much and it's a little bit [unergonomic](https://github.com/haskus/packages/issues/32) at times. If it really hurts maintenance, it will be removed. It was more of an experiment.
-
-### No use of filepath or directory
-
-Filepath and directory have two fundamental problems: 1. they use String as filepath (see [AFPP](https://gitlab.haskell.org/ghc/ghc/-/wikis/proposal/abstract-file-path) as to why this is wrong) and 2. they try very hard to be cross-platform at the expense of low-level correctness. Instead, we use the [hpath](https://github.com/hasufell/hpath) libraries for file and filepath related stuff, which also gives us stronger filepath types.
-
-### No use of haskell-TLS
-
-I consider haskell-TLS an interesting experiment, but not a battle-tested and peer-reviewed crypto implementation. There is little to no research about what the intricacies of using haskell for low-level crypto are and how vulnerable such binaries are. Instead, we use either curl the binary (for FreeBSD and mac) or http-io-streams, which works with OpenSSL bindings.
-
-### Optics instead of lens
-
-They're a little safer (less Monoid weirdness with view) and have better error messages. Consider the following wit lens
-
-```
-> view (_Just . to (++ "abc")) Nothing
-""
-```
-
-vs optics
-
-```
-> view (_Just % to (++ "abc")) Nothing
-
-<interactive>:2:1: error:
-    • An_AffineFold cannot be used as A_Getter
-    • In the expression: view (_Just % to (++ "abc")) Nothing
-      In an equation for ‘it’: it = view (_Just % to (++ "abc")) Nothing
-```
-
-### Strict and StrictData on by default
-
-Kazu Yamamoto [explained it in his PR](https://github.com/yesodweb/wai/pull/752#issuecomment-501531386) very well. I like to agree with him. The instances where we need non-strict behavior, we annotate it.
-
-## Code style and formatting
-
-1. Brittany
-2. mtl-style preferred
-3. no overly pointfree style

README.md

@@ -1,144 +1,13 @@
-`ghcup` makes it easy to install specific versions of `ghc` on GNU/Linux,
-macOS (aka Darwin) and FreeBSD and can also bootstrap a fresh Haskell developer environment from scratch.
-It follows the unix UNIX philosophy of [do one thing and do it well](https://en.wikipedia.org/wiki/Unix_philosophy#Do_One_Thing_and_Do_It_Well).
+## The GHCup Haskell installer
 
-Similar in scope to [rustup](https://github.com/rust-lang-nursery/rustup.rs), [pyenv](https://github.com/pyenv/pyenv) and [jenv](http://www.jenv.be).
+[![Join the chat at Libera.chat](https://img.shields.io/badge/chat-on%20libera%20IRC-brightgreen.svg)](https://kiwiirc.com/nextclient/irc.libera.chat/?nick=Guest%7C?#haskell,#haskell-ghcup)
+[![Join the chat at Matrix.org](https://img.shields.io/matrix/haskell-tooling:matrix.org?label=chat%20on%20matrix.org)](https://app.element.io/#/room/#haskell-tooling:matrix.org)
+[![Join the chat at Discord](https://img.shields.io/discord/280033776820813825?label=chat%20on%20discord)](https://discord.gg/pKYf3zDQU7)
+[![Join the chat at https://gitter.im/haskell/ghcup](https://badges.gitter.im/haskell/ghcup.svg)](https://gitter.im/haskell/ghcup?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+<a href="https://opencollective.com/ghcup#category-CONTRIBUTE"><img src="https://opencollective.com/webpack/donate/button@2x.png?color=blue" alt="Donate" width="150"></a>
 
-*Ubuntu users may prefer [hvr's ppa](https://launchpad.net/~hvr/+archive/ubuntu/ghc).*
+GHCup is the main installer for the general purpose language [Haskell](https://www.haskell.org/).
 
-## Table of Contents
-
-   * [Installation](#installation)
-   * [Usage](#usage)
-     * [Manpages](#manpages)
-   * [Design goals](#design-goals)
-   * [How](#how)
-   * [Known users](#known-users)
-   * [Known problems](#known-problems)
-   * [FAQ](#faq)
-
-## Installation
-
-### Simple bootstrap
-
-Follow the instructions at [https://www.haskell.org/ghcup/](https://www.haskell.org/ghcup/)
-
-### Manual install
-
-Download the binary for your platform at [https://downloads.haskell.org/~ghcup/](https://downloads.haskell.org/~ghcup/)
-and place it into your `PATH` anywhere.
-
-Then adjust your `PATH` in `~/.bashrc` (or similar, depending on your shell) like so:
-
-```sh
-export PATH="$HOME/.cabal/bin:$HOME/.ghcup/bin:$PATH"
-```
-
-## Usage
-
-See `ghcup --help`.
-
-Common use cases are:
-
-```sh
-# list available ghc/cabal versions
-ghcup list
-
-# install the recommended GHC version
-ghcup install
-
-# install a specific GHC version
-ghcup install 8.2.2
-
-# set the currently "active" GHC version
-ghcup set 8.4.4
-
-# install cabal-install
-ghcup install-cabal
-
-# update ghcup itself
-ghcup upgrade
-```
-
-Generally this is meant to be used with [`cabal-install`](https://hackage.haskell.org/package/cabal-install), which
-handles your haskell packages and can demand that [a specific version](https://cabal.readthedocs.io/en/latest/nix-local-build.html#cfg-flag---with-compiler)  of `ghc` is available, which `ghcup` can do.
-
-### Manpages
-
-For man pages to work you need [man-db](http://man-db.nongnu.org/) as your `man` provider, then issue `man ghc`. Manpages only work for the currently set ghc.
-`MANPATH` may be required to be unset.
-
-## Design goals
-
-1. simplicity
-2. non-interactive
-3. portable (eh)
-4. do one thing and do it well (UNIX philosophy)
-
-### Non-goals
-
-1. invoking `sudo`, `apt-get` or *any* package manager
-2. handling system packages
-3. handling cabal projects
-4. being a stack alternative
-
-## How
-
-Installs a specified GHC version into `~/.ghcup/ghc/<ver>`, and places `ghc-<ver>` symlinks in `~/.ghcup/bin/`.
-
-Optionally, an unversioned `ghc` link can point to a default version of your choice.
-
-This uses precompiled GHC binaries that have been compiled on fedora/debian by [upstream GHC](https://www.haskell.org/ghc/download_ghc_8_6_1.html#binaries).
-
-Alternatively, you can also tell it to compile from source (note that this might fail due to missing requirements).
-
-In addition this script can also install `cabal-install`.
-
-## Known users
-
-* [vabal](https://github.com/Franciman/vabal)
-
-## Known problems
-
-### Limited distributions supported
-
-Currently only GNU/Linux distributions compatible with the [upstream GHC](https://www.haskell.org/ghc/download_ghc_8_6_1.html#binaries) binaries are supported.
-
-### Precompiled binaries
-
-Since this uses precompiled binaries you may run into
-several problems.
-
-#### Missing libtinfo (ncurses)
-
-You may run into problems with *ncurses* and **missing libtinfo**, in case
-your distribution doesn't use the legacy way of building
-ncurses and has no compatibility symlinks in place.
-
-Ask your distributor on how to solve this or
-try to compile from source via `ghcup compile <version>`.
-
-#### Libnuma required
-
-This was a [bug](https://ghc.haskell.org/trac/ghc/ticket/15688) in the build system of some GHC versions that lead to
-unconditionally enabled libnuma support. To mitigate this you might have to install the libnuma
-package of your distribution. See [here](https://gitlab.haskell.org/haskell/ghcup/issues/58) for a discussion.
-
-### Compilation
-
-Although this script can compile GHC for you, it's just a very thin
-wrapper around the build system. It makes no effort in trying
-to figure out whether you have the correct toolchain and
-the correct dependencies. Refer to [the official docs](https://ghc.haskell.org/trac/ghc/wiki/Building/Preparation/Linux)
-on how to prepare your environment for building GHC.
-
-## FAQ
-
-1. Why reimplement stack?
-
-ghcup is not a reimplementation of stack. The only common part is automatic installation of GHC, but even that differs in scope and design.
-
-2. Why not support windows?
-
-Consider using [Chocolatey](https://chocolatey.org/search?q=ghc) or [ghcups](https://github.com/kakkun61/ghcups).
+Visit the [documentation](https://www.haskell.org/ghcup/) for installation instructions.
 
+If you're looking for the metadata YAML files, see here: [https://github.com/haskell/ghcup-metadata](https://github.com/haskell/ghcup-metadata)

RELEASING.md

@@ -1,11 +0,0 @@
-# RELEASING
-
-1. update `GHCup.Version` module. `ghcupURL` must only be updated if we change the `_toolRequirements` type or the JSON representation of it. The version of the json represents the change increments. `ghcUpVer` is the current application version.
-
-2. Add/fix downloads to `GHCupDownloads` module, then run `ghcup-gen gen` to generate the new json and validate it via `ghcup-gen check`.
-
-3. Commit and git push with tag. Wait for tests to succeed.
-
-4. Upload the new `ghcup-<ver>.json` to `webhost.haskell.org/ghcup/data/`.
-
-5. Build ghcup releases for Linux (fully static), mac (with `-fcurl`) and FreeBSD (with `-fcurl`). Upload to `webhost.haskell.org/ghcup/bin/` and update symlinks.

app/ghcup-gen/GHCupInfo.hs

@@ -1,11 +0,0 @@
-module GHCupInfo where
-
-import           GHCupDownloads
-import           ToolRequirements
-import           GHCup.Types
-
-
-ghcupInfo :: GHCupInfo
-ghcupInfo = GHCupInfo { _toolRequirements = toolRequirements
-                      , _ghcupDownloads   = ghcupDownloads
-                      }

app/ghcup-gen/Main.hs

@@ -1,173 +0,0 @@
-{-# LANGUAGE CPP               #-}
-{-# LANGUAGE DataKinds         #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE NamedFieldPuns    #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes       #-}
-{-# LANGUAGE TemplateHaskell   #-}
-{-# LANGUAGE TypeApplications  #-}
-
-
-module Main where
-
-import           GHCup.Types
-import           GHCup.Types.JSON               ( )
-import           GHCup.Utils.Logger
-import           GHCupInfo
-
-import           Data.Aeson                     ( eitherDecode, encode )
-import           Data.Aeson.Encode.Pretty
-#if !MIN_VERSION_base(4,13,0)
-import           Data.Semigroup                 ( (<>) )
-#endif
-import           Options.Applicative     hiding ( style )
-import           System.Console.Pretty
-import           System.Exit
-import           System.IO                      ( stdout )
-import           Validate
-
-import qualified Data.ByteString               as B
-import qualified Data.ByteString.Lazy          as L
-
-
-data Options = Options
-  { optCommand :: Command
-  }
-
-data Command = GenJSON GenJSONOpts
-             | ValidateJSON ValidateJSONOpts
-             | ValidateTarballs ValidateJSONOpts
-
-data Output
-  = FileOutput FilePath -- optsparse-applicative doesn't handle ByteString correctly anyway
-  | StdOutput
-
-fileOutput :: Parser Output
-fileOutput =
-  FileOutput
-    <$> (strOption
-          (long "file" <> short 'f' <> metavar "FILENAME" <> help
-            "Output to a file"
-          )
-        )
-
-stdOutput :: Parser Output
-stdOutput = flag'
-  StdOutput
-  (short 'o' <> long "stdout" <> help "Print to stdout (default)")
-
-outputP :: Parser Output
-outputP = fileOutput <|> stdOutput
-
-
-data GenJSONOpts = GenJSONOpts
-  { output :: Maybe Output
-  , pretty :: Bool
-  }
-
-genJSONOpts :: Parser GenJSONOpts
-genJSONOpts = GenJSONOpts <$> optional outputP <*> switch
-  (short 'p' <> long "pretty" <> help "Make JSON output pretty (human readable)"
-  )
-
-
-data Input
-  = FileInput FilePath -- optsparse-applicative doesn't handle ByteString correctly anyway
-  | StdInput
-
-fileInput :: Parser Input
-fileInput =
-  FileInput
-    <$> (strOption
-          (long "file" <> short 'f' <> metavar "FILENAME" <> help
-            "Input file to validate"
-          )
-        )
-
-stdInput :: Parser Input
-stdInput = flag'
-  StdInput
-  (short 'i' <> long "stdin" <> help "Validate from stdin (default)")
-
-inputP :: Parser Input
-inputP = fileInput <|> stdInput
-
-data ValidateJSONOpts = ValidateJSONOpts
-  { input :: Maybe Input
-  }
-
-validateJSONOpts :: Parser ValidateJSONOpts
-validateJSONOpts = ValidateJSONOpts <$> optional inputP
-
-opts :: Parser Options
-opts = Options <$> com
-
-com :: Parser Command
-com = subparser
-  (  (command
-       "gen"
-       (   GenJSON
-       <$> (info (genJSONOpts <**> helper)
-                 (progDesc "Generate the json downloads file")
-           )
-       )
-     )
-  <> (command
-       "check"
-       (   ValidateJSON
-       <$> (info (validateJSONOpts <**> helper)
-                 (progDesc "Validate the JSON")
-           )
-       )
-     )
-  <> (command
-       "check-tarballs"
-       (   ValidateTarballs
-       <$> (info
-             (validateJSONOpts <**> helper)
-             (progDesc "Validate all tarballs (download and checksum)")
-           )
-       )
-     )
-  )
-
-
-
-main :: IO ()
-main = do
-  customExecParser (prefs showHelpOnError) (info (opts <**> helper) idm)
-    >>= \Options {..} -> case optCommand of
-          GenJSON gopts -> do
-            let bs True =
-                  encodePretty' (defConfig { confIndent = Spaces 2 }) ghcupInfo
-                bs False = encode ghcupInfo
-            case gopts of
-              GenJSONOpts { output = Nothing, pretty } ->
-                L.hPutStr stdout (bs pretty)
-              GenJSONOpts { output = Just StdOutput, pretty } ->
-                L.hPutStr stdout (bs pretty)
-              GenJSONOpts { output = Just (FileOutput file), pretty } ->
-                L.writeFile file (bs pretty)
-          ValidateJSON vopts -> case vopts of
-            ValidateJSONOpts { input = Nothing } ->
-              L.getContents >>= valAndExit validate
-            ValidateJSONOpts { input = Just StdInput } ->
-              L.getContents >>= valAndExit validate
-            ValidateJSONOpts { input = Just (FileInput file) } ->
-              L.readFile file >>= valAndExit validate
-          ValidateTarballs vopts -> case vopts of
-            ValidateJSONOpts { input = Nothing } ->
-              L.getContents >>= valAndExit validateTarballs
-            ValidateJSONOpts { input = Just StdInput } ->
-              L.getContents >>= valAndExit validateTarballs
-            ValidateJSONOpts { input = Just (FileInput file) } ->
-              L.readFile file >>= valAndExit validateTarballs
-  pure ()
-
- where
-  valAndExit f contents = do
-    (GHCupInfo _ av) <- case eitherDecode contents of
-      Right r -> pure r
-      Left  e -> die (color Red $ show e)
-    myLoggerT (LoggerConfig True (B.hPut stdout) (\_ -> pure ())) (f av)
-      >>= exitWith

app/ghcup-gen/ToolRequirements.hs

@@ -1,94 +0,0 @@
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes       #-}
-
-module ToolRequirements where
-
-import           GHCup.Types
-import           GHCup.Utils.String.QQ
-
-import qualified Data.Map                      as M
-
-
-
--- | Currently 'GHC' is used for both GHC and cabal to simplify
--- this, until we need actual separation.
-toolRequirements :: ToolRequirements
-toolRequirements = M.fromList
-  [ ( GHC
-    , M.fromList
-      [ ( Nothing
-        , M.fromList
-          [ ( Linux UnknownLinux
-            , M.fromList
-              [ ( Nothing
-                , Requirements
-                  []
-                  [s|You need the following packages: curl g++ gcc gmp make ncurses realpath xz-utils. Consult your distro documentation on the exact names of those packages.|]
-                )
-              ]
-            )
-          , ( Linux Alpine
-            , M.fromList
-              [ ( Nothing
-                , Requirements
-                  [ "curl"
-                  , "gcc"
-                  , "g++"
-                  , "gmp-dev"
-                  , "ncurses-dev"
-                  , "libffi-dev"
-                  , "make"
-                  , "xz"
-                  , "tar"
-                  , "perl"
-                  ]
-                  ""
-                )
-              ]
-            )
-          , ( Linux Ubuntu
-            , M.fromList
-              [ ( Nothing
-                , Requirements
-                  [ "build-essential"
-                  , "curl"
-                  , "libgmp-dev"
-                  , "libffi-dev"
-                  , "libncurses-dev"
-                  , "libtinfo5"
-                  ]
-                  ""
-                )
-              ]
-            )
-          , ( Darwin
-            , M.fromList
-              [ ( Nothing
-                , Requirements
-                  []
-                  "On OS X, in the course of running ghcup you will be given a dialog box to install the command line tools. Accept and the requirements will be installed for you. You will then need to run the command again."
-                )
-              ]
-            )
-          , ( FreeBSD
-            , M.fromList
-              [ ( Nothing
-                , Requirements
-                  [ "curl"
-                  , "gcc"
-                  , "gmp"
-                  , "gmake"
-                  , "ncurses"
-                  , "perl5"
-                  , "libffi"
-                  , "libiconv"
-                  ]
-                  ""
-                )
-              ]
-            )
-          ]
-        )
-      ]
-    )
-  ]

app/ghcup-gen/Validate.hs

@@ -1,181 +0,0 @@
-{-# LANGUAGE TemplateHaskell  #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE QuasiQuotes      #-}
-
-module Validate where
-
-import           GHCup
-import           GHCup.Download
-import           GHCup.Types
-import           GHCup.Utils.Logger
-
-import           Control.Exception.Safe
-import           Control.Monad
-import           Control.Monad.IO.Class
-import           Control.Monad.Logger
-import           Control.Monad.Reader.Class
-import           Control.Monad.Trans.Class      ( lift )
-import           Control.Monad.Trans.Reader     ( runReaderT )
-import           Control.Monad.Trans.Resource   ( runResourceT
-                                                , MonadUnliftIO
-                                                )
-import           Data.IORef
-import           Data.List
-import           Data.String.Interpolate
-import           Data.Versions
-import           Haskus.Utils.Variant.Excepts
-import           Optics
-import           System.Exit
-import           System.IO
-
-import qualified Data.ByteString               as B
-import qualified Data.Map.Strict               as M
-
-
-data ValidationError = InternalError String
-  deriving Show
-
-instance Exception ValidationError
-
-
-addError :: (MonadReader (IORef Int) m, MonadIO m, Monad m) => m ()
-addError = do
-  ref <- ask
-  liftIO $ modifyIORef ref (+ 1)
-
-
-validate :: (Monad m, MonadLogger m, MonadThrow m, MonadIO m, MonadUnliftIO m)
-         => GHCupDownloads
-         -> m ExitCode
-validate dls = do
-  ref <- liftIO $ newIORef 0
-
-  -- * verify binary downloads * --
-  flip runReaderT ref $ do
-    -- unique tags
-    forM_ (M.toList dls) $ \(t, _) -> checkUniqueTags t
-
-    -- required platforms
-    forM_ (M.toList dls) $ \(t, versions) ->
-      forM_ (M.toList versions) $ \(v, vi) ->
-        forM_ (M.toList $ _viArch vi) $ \(arch, pspecs) -> do
-          checkHasRequiredPlatforms t v arch (M.keys pspecs)
-
-    checkGHCisSemver
-    forM_ (M.toList dls) $ \(t, _) -> checkMandatoryTags t
-
-    -- exit
-    e <- liftIO $ readIORef ref
-    if e > 0
-      then pure $ ExitFailure e
-      else do
-        lift $ $(logInfo) [i|All good|]
-        pure ExitSuccess
- where
-  checkHasRequiredPlatforms t v arch pspecs = do
-    let v' = prettyVer v
-    when (not $ any (== Linux UnknownLinux) pspecs) $ do
-      lift $ $(logError)
-        [i|Linux UnknownLinux missing for for #{t} #{v'} #{arch}|]
-      addError
-    when ((not $ any (== Darwin) pspecs) && arch == A_64) $ do
-      lift $ $(logError) [i|Darwin missing for #{t} #{v'} #{arch}|]
-      addError
-    when ((not $ any (== FreeBSD) pspecs) && arch == A_64) $ lift $ $(logWarn)
-      [i|FreeBSD missing for #{t} #{v'} #{arch}|]
-
-  checkUniqueTags tool = do
-    let allTags = join $ fmap snd $ availableToolVersions dls tool
-    let nonUnique =
-          fmap fst
-            .   filter (\(_, b) -> not b)
-            <$> ( mapM
-                    (\case
-                      [] -> throwM $ InternalError "empty inner list"
-                      (t : ts) ->
-                        pure $ (t, ) $ if isUniqueTag t then ts == [] else True
-                    )
-                . group
-                . sort
-                $ allTags
-                )
-    case join nonUnique of
-      [] -> pure ()
-      xs -> do
-        lift $ $(logError) [i|Tags not unique for #{tool}: #{xs}|]
-        addError
-   where
-    isUniqueTag Latest      = True
-    isUniqueTag Recommended = True
-
-  checkGHCisSemver = do
-    let ghcVers = toListOf (ix GHC % to M.keys % folded) dls
-    forM_ ghcVers $ \v -> case semver (prettyVer v) of
-      Left _ -> do
-        lift $ $(logError) [i|GHC version #{v} is not valid semver|]
-        addError
-      Right _ -> pure ()
-
-  -- a tool must have at least one of each mandatory tags
-  checkMandatoryTags tool = do
-    let allTags = join $ fmap snd $ availableToolVersions dls tool
-    forM_ [Latest, Recommended] $ \t -> case elem t allTags of
-      False -> do
-        lift $ $(logError) [i|Tag #{t} missing from #{tool}|]
-        addError
-      True -> pure ()
-
-
-validateTarballs :: ( Monad m
-                    , MonadLogger m
-                    , MonadThrow m
-                    , MonadIO m
-                    , MonadUnliftIO m
-                    , MonadMask m
-                    )
-                 => GHCupDownloads
-                 -> m ExitCode
-validateTarballs dls = do
-  ref <- liftIO $ newIORef 0
-
-  flip runReaderT ref $ do
-     -- download/verify all binary tarballs
-    let
-      dlbis = nub $ join $ (M.elems dls) <&> \versions ->
-        join $ (M.elems versions) <&> \vi ->
-          join $ (M.elems $ _viArch vi) <&> \pspecs ->
-            join $ (M.elems pspecs) <&> \pverspecs -> (M.elems pverspecs)
-    forM_ dlbis $ downloadAll
-
-    let dlsrc = nub $ join $ (M.elems dls) <&> \versions ->
-          join $ (M.elems versions) <&> maybe [] (: []) . _viSourceDL
-    forM_ dlsrc $ downloadAll
-
-    -- exit
-    e <- liftIO $ readIORef ref
-    if e > 0
-      then pure $ ExitFailure e
-      else do
-        lift $ $(logInfo) [i|All good|]
-        pure ExitSuccess
-
- where
-  downloadAll dli = do
-    let settings = Settings True False
-    let runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
-                                           , colorOutter  = B.hPut stderr
-                                           , rawOutter    = (\_ -> pure ())
-                                           }
-
-    r <-
-      runLogger
-      . flip runReaderT settings
-      . runResourceT
-      . runE
-      $ downloadCached dli Nothing
-    case r of
-      VRight _ -> pure ()
-      VLeft  e -> do
-        lift $ $(logError)
-          [i|Could not download (or verify hash) of #{dli}, Error was: #{e}|]
-        addError

app/ghcup/AnsiMain.hs

@@ -0,0 +1,621 @@
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE RankNTypes        #-}
+{-# LANGUAGE MultiWayIf        #-}
+
+module AnsiMain where
+
+import           GHCup
+import           GHCup.Download
+import           GHCup.Errors
+import           GHCup.Prelude                  ( decUTF8Safe )
+import           GHCup.Prelude.File
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.Process
+import           GHCup.Prompts
+import           GHCup.Types             hiding ( LeanAppState(..) )
+import           GHCup.Types.Optics             ( getDirs )
+import           GHCup.Utils
+
+import           Data.List (sort, intersperse)
+import           Data.Versions (prettyPVP, prettyVer)
+import           Codec.Archive
+import           Control.Monad.IO.Class
+-- import           System.Console.ANSI
+import           System.Console.ANSI
+import           Terminal.Game
+import           Text.PrettyPrint.HughesPJClass ( prettyShow )
+
+import           Control.Exception.Safe
+import           Control.Monad                  ( when, forM_ )
+import           Control.Monad.ST
+import           Control.Monad.Reader           ( ReaderT(runReaderT), MonadReader, ask, lift )
+import           Control.Monad.Trans.Except
+import           Control.Monad.Trans.Resource
+import           Data.Functor
+import           Data.STRef
+import           Data.IORef
+import           Data.Maybe                     ( fromMaybe, catMaybes )
+import qualified Data.Text                     as Tx
+import qualified Data.Tuple                    as T
+import qualified Data.Vector                   as V
+import           GHC.IO                         ( unsafePerformIO )
+import           Haskus.Utils.Variant.Excepts
+import           System.Exit
+import           System.Environment (getExecutablePath)
+import qualified Data.Text                     as T
+import qualified Data.Text.Lazy.Builder        as B
+import qualified Data.Text.Lazy                as L
+import           System.FilePath
+import           URI.ByteString (serializeURIRef')
+
+
+
+data Direction = Up
+               | Down
+  deriving (Show, Eq)
+
+data BrickData = BrickData
+  { lr :: [ListResult]
+  }
+  deriving Show
+
+data BrickSettings = BrickSettings
+  { showAllVersions :: Bool
+  , showAllTools    :: Bool
+  }
+  deriving Show
+
+data BrickInternalState = BrickInternalState
+  { clr :: V.Vector ListResult
+  , ix  :: Int
+  }
+  deriving Show
+
+data BrickState = BrickState
+  { appData      :: BrickData
+  , appSettings  :: BrickSettings
+  , appState     :: BrickInternalState
+  , appKeys      :: KeyBindings
+  , appQuit      :: Bool
+  , appRestart   :: Bool
+  , appMoreInput :: Maybe String
+  }
+  deriving Show
+
+
+startGame :: BrickState -> IO BrickState
+startGame g = do
+  g'@BrickState { appRestart } <- errorPress $ playGameT liftIO (ghcupGame g)
+  if appRestart
+  then do
+    putStrLn "Press enter to continue"
+    _ <- getLine
+    startGame $ g' { appRestart = False }
+  else pure g'
+
+ansiMain :: AppState -> IO ()
+ansiMain s = do
+  writeIORef settings' s
+
+  eAppData <- getAppData (Just $ ghcupInfo s)
+  case eAppData of
+    Right ad -> do
+      let g = BrickState ad
+                         defaultAppSettings
+                         (constructList ad defaultAppSettings Nothing)
+                         (keyBindings (s :: AppState))
+                         False
+                         False
+                         Nothing
+
+
+      sizeCheck
+      void $ startGame g
+      cleanAndExit
+    Left e -> do
+      flip runReaderT s $ logError $ "Error building app state: " <> Tx.pack
+        (show e)
+      exitWith $ ExitFailure 2
+
+
+ where
+  sizeCheck :: IO ()
+  sizeCheck = let (w, h) = T.swap . snd $ boundaries in assertTermDims w h
+
+
+ghcupGame :: BrickState -> Game BrickState
+ghcupGame bs = Game 13
+                    bs                                    -- ticks per second
+                    (\ge s e -> logicFun ge s e)          -- logic function
+                    (\r s -> centerFull r $ drawFun s r)  -- draw function
+                    (\s -> appQuit s || appRestart s)  -- quit function
+
+
+drawFun :: BrickState -> GEnv -> Plane
+drawFun (BrickState {..}) GEnv{..} =
+  let focus pl = maybe pl
+                   (\ix -> V.update pl (V.singleton (ix + 1, fmap invert $ pl V.! (ix + 1))))
+                   mix
+      rows = V.fromList [header, [box (mw - 2) 1 '=']] V.++ renderItems
+      cols = V.foldr (\xs ys -> zipWith (:) xs ys) (repeat []) $ V.filter ((==5) . length) rows
+      padded  = focus $ V.map (\xs -> zipWith padTo xs lengths) rows
+      lengths :: [Int]
+      lengths = fmap (maximum . fmap (fst . planeSize)) cols
+  in blankPlane mw mh
+    & (1, 1)   % box 1        1        'X' -- '┌'
+    & (2, 1)   % box 1        (mh - 3) '|' -- '│'
+    & (1, 2)   % box (mw - 2) 1        '=' -- '─'
+    & (2, mw)  % box 1        (mh - 3) '|' -- '│'
+    & (1, mw)  % box 1        1        'X' -- '┐'
+    & (mh-1, 2)  % box (mw - 2) 1      '=' -- '─'
+    & (mh-1, 1)  % box 1        1      'X' -- '└'
+    & (mh-1, mw) % box 1        1      'X' -- '┘'
+    & (2, 2)   % box (mw - 2) (mh - 3) ' ' -- ' '
+    & (2, 2)   % vcat (hcat <$> V.toList padded)
+    & (mh, 1)  % footer
+    & (1, mw `div` 2 - 2) % stringPlane "GHCup"
+ where
+
+  padTo :: Plane -> Int -> Plane
+  padTo plane x =
+    let lstr = fst $ planeSize plane
+        add' = x - lstr + 1
+    in  if add' < 0 then plane else plane ||| stringPlane (replicate add' ' ')
+  mh :: Height
+  mw :: Width
+  (mh, mw) = T.swap eTermDims
+  footer = hcat
+         . intersperse (stringPlane "  ")
+         . fmap stringPlane
+         $ ["q:Quit", "i:Install", "u:Uninstall", "s:Set", "c:Changelog", "a:all versions", "↑:Up", "↓:Down"]
+  header = fmap stringPlane [" ", "Tool", "Version", "Tags", "Notes"]
+  (renderItems, mix) = drawListElements renderItem appState
+  renderItem _ _ listResult@ListResult{..} =
+    let marks = if
+          | lSet       -> color Green Vivid $ stringPlane "IS"
+          | lInstalled -> color Green Vivid $ stringPlane "I "
+          | otherwise  -> color Red Vivid $ stringPlane "X "
+        ver = case lCross of
+          Nothing -> stringPlane . Tx.unpack . prettyVer $ lVer
+          Just c  -> stringPlane . Tx.unpack $ (c <> "-" <> prettyVer lVer)
+        tool = printTool lTool
+        tag = let l = catMaybes . fmap printTag $ sort lTag
+              in  if null l then blankPlane 1 1 else foldr1 (\x y -> x ||| stringPlane "," ||| y) l
+        notes = let n = printNotes listResult
+                in  if null n
+                      then blankPlane 1 1
+                      else foldr1 (\x y -> x ||| stringPlane "," ||| y) n
+
+    in [marks ||| space, tool, ver, tag, notes]
+
+  printTag Recommended    = Just $ color Green Dull $ stringPlane "recommended"
+  printTag Latest         = Just $ color Yellow Dull $ stringPlane "latest"
+  printTag Prerelease     = Just $ color Red Dull $ stringPlane "prerelease"
+  printTag (Base pvp'')   = Just $ stringPlane ("base-" ++ T.unpack (prettyPVP pvp''))
+  printTag Old            = Nothing
+  printTag (UnknownTag t) = Just $ stringPlane t
+
+  printTool Cabal = stringPlane "cabal"
+  printTool GHC   = stringPlane "GHC"
+  printTool GHCup = stringPlane "GHCup"
+  printTool HLS   = stringPlane "HLS"
+  printTool Stack = stringPlane "Stack"
+
+  printNotes ListResult {..} =
+    (if hlsPowered then [color Green Dull $ stringPlane "hls-powered"] else mempty
+      )
+      ++ (if fromSrc then [color Blue Dull $ stringPlane "compiled"] else mempty)
+      ++ (if lStray then [color Blue Dull $ stringPlane "stray"] else mempty)
+
+  space = stringPlane " "
+
+  -- | Draws the list elements.
+  --
+  -- Evaluates the underlying container up to, and a bit beyond, the
+  -- selected element. The exact amount depends on available height
+  -- for drawing and 'listItemHeight'. At most, it will evaluate up to
+  -- element @(i + h + 1)@ where @i@ is the selected index and @h@ is the
+  -- available height.
+  drawListElements :: (Int -> Bool -> ListResult -> [Plane])
+                   -> BrickInternalState
+                   -> (V.Vector [Plane], Maybe Int)
+  drawListElements drawElem is@(BrickInternalState clr _) =
+      let es = clr
+          listSelected        = fmap fst $ listSelectedElement' is
+
+          (drawnElements, selIx) = runST $ do
+            ref <- newSTRef (Nothing :: Maybe Int)
+            vec <- newSTRef (mempty :: V.Vector [Plane])
+            elem' <- newSTRef 0
+            void $ flip V.imapM es $ \i' e -> do
+              let isSelected  = Just i' == listSelected
+                  elemWidget  = drawElem i' isSelected e
+              case es V.!? (i' - 1) of
+                    Just e' | lTool e' /= lTool e -> do
+                      modifySTRef elem' (+2)
+                      i <- readSTRef elem'
+                      when isSelected $ writeSTRef ref (Just i)
+                      modifySTRef vec (`V.snoc` [hBorder])
+                      modifySTRef vec (`V.snoc` elemWidget)
+                      pure ()
+                    _ -> do
+                      modifySTRef elem' (+1)
+                      i <- readSTRef elem'
+                      when isSelected $ writeSTRef ref (Just i)
+                      modifySTRef vec (`V.snoc` elemWidget)
+                      pure ()
+            i <- readSTRef ref
+            arr <- readSTRef vec
+            pure (arr, i)
+        in (makeVisible drawnElements (mh - 5) selIx, selIx)
+   where
+    makeVisible :: V.Vector [Plane] -> Height -> Maybe Int -> V.Vector [Plane]
+    makeVisible listElements drawableHeight (Just ix) =
+      let listHeight = V.length listElements
+      in if | listHeight <= 0 -> listElements
+            | listHeight > drawableHeight ->
+              if | ix <= drawableHeight -> makeVisible (V.init listElements) drawableHeight (Just ix)
+                 | otherwise            -> makeVisible (V.tail listElements) drawableHeight (Just (ix - 1))
+            | otherwise -> listElements
+    makeVisible listElements _ Nothing = listElements
+
+    hBorder = box (mw - 2) 1 '='
+
+
+logicFun :: GEnv -> BrickState -> Event -> IO BrickState
+logicFun _ gs (KeyPress 'q') = pure gs { appQuit = True }
+logicFun _ gs@BrickState{appMoreInput = Nothing} (KeyPress '\ESC') = pure gs { appMoreInput = Just "\ESC" }
+logicFun _ gs@BrickState{appMoreInput = Just "\ESC"} (KeyPress '[') = pure gs { appMoreInput = Just "\ESC[" }
+logicFun _ gs@BrickState{appMoreInput = Just "\ESC[", appState = s'} (KeyPress 'A')
+ = pure gs { appMoreInput = Nothing, appState = moveCursor 1 s' Up }
+logicFun _ gs@BrickState{appMoreInput = Just "\ESC[", appState = s'} (KeyPress 'B')
+ = pure gs { appMoreInput = Nothing, appState = moveCursor 1 s' Down }
+logicFun _ gs@BrickState{appMoreInput = Just _} _ = pure gs { appMoreInput = Nothing }
+logicFun _ gs (KeyPress 'i') = do
+  bs <- withIOAction install' gs
+  pure bs { appRestart = True }
+logicFun _ gs (KeyPress 'u') = do
+  bs <- withIOAction del' gs
+  pure bs { appRestart = True }
+logicFun _ gs (KeyPress 's') = do
+  bs <- withIOAction set' gs
+  pure bs { appRestart = True }
+logicFun _ gs (KeyPress 'c') = do
+  bs <- withIOAction changelog' gs
+  pure bs { appRestart = True }
+logicFun _ gs (KeyPress 'a') = pure $ hideShowHandler (not . showAllVersions) showAllTools gs
+ where
+  hideShowHandler :: (BrickSettings -> Bool) -> (BrickSettings -> Bool) -> BrickState -> BrickState
+  hideShowHandler f p BrickState{..} =
+    let newAppSettings   = appSettings { showAllVersions = f appSettings , showAllTools = p appSettings }
+        newInternalState = constructList appData newAppSettings (Just appState)
+    in  BrickState appData newAppSettings newInternalState appKeys appQuit appRestart appMoreInput
+
+-- windows powershell
+logicFun _ gs@BrickState{ appState = s' } (KeyPress 'P') = pure gs { appMoreInput = Nothing, appState = moveCursor 1 s' Down }
+logicFun _ gs@BrickState{ appState = s' } (KeyPress 'H') = pure gs { appMoreInput = Nothing, appState = moveCursor 1 s' Up }
+
+logicFun _ gs Tick           = pure gs
+logicFun _ gs (KeyPress _)   = pure gs
+
+withIOAction :: (BrickState
+                 -> (Int, ListResult)
+                 -> ReaderT AppState IO (Either String a))
+             -> BrickState
+             -> IO BrickState
+withIOAction action as = case listSelectedElement' (appState as) of
+  Nothing      -> pure as
+  Just (ix, e) -> do
+    clearScreen
+
+    settings <- readIORef settings'
+    flip runReaderT settings $ action as (ix, e) >>= \case
+      Left  err -> liftIO $ putStrLn ("Error: " <> err)
+      Right _   -> liftIO $ putStrLn "Success"
+    getAppData Nothing >>= \case
+      Right data' -> do
+        pure (updateList data' as)
+      Left err -> throwIO $ userError err
+
+moveCursor :: Int -> BrickInternalState -> Direction -> BrickInternalState
+moveCursor steps ais@BrickInternalState{..} direction =
+  let newIx = if direction == Down then ix + steps else ix - steps
+  in  case clr V.!? newIx of
+        Just _  -> BrickInternalState { ix = newIx, .. }
+        Nothing -> ais
+
+defaultAppSettings :: BrickSettings
+defaultAppSettings =
+  BrickSettings { showAllVersions = False, showAllTools = False }
+
+-- | Update app data and list internal state based on new evidence.
+-- This synchronises @BrickInternalState@ with @BrickData@
+-- and @BrickSettings@.
+updateList :: BrickData -> BrickState -> BrickState
+updateList appD BrickState{..} =
+  let newInternalState = constructList appD appSettings (Just appState)
+  in  BrickState { appState    = newInternalState
+                 , appData     = appD
+                 , appSettings = appSettings
+                 , appKeys     = appKeys
+                 , appQuit     = appQuit
+                 , appRestart  = appRestart
+                 , appMoreInput = appMoreInput
+                 }
+
+constructList
+  :: BrickData
+  -> BrickSettings
+  -> Maybe BrickInternalState
+  -> BrickInternalState
+constructList appD appSettings = replaceLR
+  (filterVisible (showAllVersions appSettings) (showAllTools appSettings))
+  (lr appD)
+
+
+-- | Replace the @appState@ or construct it based on a filter function
+-- and a new @[ListResult]@ evidence.
+-- When passed an existing @appState@, tries to keep the selected element.
+replaceLR
+  :: (ListResult -> Bool)
+  -> [ListResult]
+  -> Maybe BrickInternalState
+  -> BrickInternalState
+replaceLR filterF lr s =
+  let oldElem = s >>= listSelectedElement'
+      newVec  = V.fromList . filter filterF $ lr
+      newSelected =
+        case oldElem >>= \(_, oldE) -> V.findIndex (toolEqual oldE) newVec of
+          Just ix -> ix
+          Nothing -> selectLatest newVec
+  in  BrickInternalState newVec newSelected
+ where
+  toolEqual e1 e2 =
+    lTool e1 == lTool e2 && lVer e1 == lVer e2 && lCross e1 == lCross e2
+
+
+filterVisible :: Bool -> Bool -> ListResult -> Bool
+filterVisible v t e
+  | lInstalled e                   = True
+  | v, not t, lTool e `notElem` hiddenTools = True
+  | not v, t, Old `notElem` lTag e = True
+  | v, t                           = True
+  | otherwise = (Old `notElem` lTag e) && (lTool e `notElem` hiddenTools)
+
+
+hiddenTools :: [Tool]
+hiddenTools = []
+
+
+selectLatest :: V.Vector ListResult -> Int
+selectLatest = fromMaybe 0
+  . V.findIndex (\ListResult {..} -> lTool == GHC && Latest `elem` lTag)
+
+
+listSelectedElement' :: BrickInternalState -> Maybe (Int, ListResult)
+listSelectedElement' BrickInternalState {..} = fmap (ix, ) $ clr V.!? ix
+
+
+boundaries :: (Coords, Coords)
+boundaries = ((1, 1), (24, 80))
+
+install' :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadFail m, MonadMask m, MonadUnliftIO m)
+         => BrickState
+         -> (Int, ListResult)
+         -> m (Either String ())
+install' _ (_, ListResult {..}) = do
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
+
+  let run =
+        runResourceT
+          . runE
+            @'[ AlreadyInstalled
+              , ArchiveResult
+              , UnknownArchive
+              , FileDoesNotExistError
+              , CopyError
+              , NoDownload
+              , NotInstalled
+              , BuildFailed
+              , TagNotFound
+              , DigestError
+              , ContentLengthError
+              , GPGError
+              , DownloadFailed
+              , DirNotEmpty
+              , NoUpdate
+              , TarDirDoesNotExist
+              , FileAlreadyExistsError
+              , ProcessError
+              , ToolShadowed
+              , UninstallFailed
+              , MergeFileTreeError
+              ]
+
+  run (do
+      ce <- liftIO $ fmap (either (const Nothing) Just) $
+        try @_ @SomeException $ getExecutablePath >>= canonicalizePath
+      dirs <- lift getDirs
+      case lTool of
+        GHC   -> do
+          let vi = getVersionInfo lVer GHC dls
+          liftE $ installGHCBin lVer GHCupInternal False [] $> (vi, dirs, ce)
+        Cabal -> do
+          let vi = getVersionInfo lVer Cabal dls
+          liftE $ installCabalBin lVer GHCupInternal False $> (vi, dirs, ce)
+        GHCup -> do
+          let vi = snd <$> getLatest dls GHCup
+          liftE $ upgradeGHCup Nothing False False $> (vi, dirs, ce)
+        HLS   -> do
+          let vi = getVersionInfo lVer HLS dls
+          liftE $ installHLSBin lVer GHCupInternal False $> (vi, dirs, ce)
+        Stack -> do
+          let vi = getVersionInfo lVer Stack dls
+          liftE $ installStackBin lVer GHCupInternal False $> (vi, dirs, ce)
+    )
+    >>= \case
+          VRight (vi, Dirs{..}, Just ce) -> do
+            forM_ (_viPostInstall =<< vi) $ \msg -> logInfo msg
+            case lTool of
+              GHCup -> do
+                up <- liftIO $ fmap (either (const Nothing) Just)
+                  $ try @_ @SomeException $ canonicalizePath (binDir </> "ghcup" <.> exeExt)
+                when ((normalise <$> up) == Just (normalise ce)) $
+                  -- TODO: track cli arguments of previous invocation
+                  void $ liftIO $ exec ce ["tui"] Nothing Nothing
+                logInfo "Please restart 'ghcup' for the changes to take effect"
+              _ -> pure ()
+            pure $ Right ()
+          VRight (vi, _, _) -> do
+            forM_ (_viPostInstall =<< vi) $ \msg -> logInfo msg
+            logInfo "Please restart 'ghcup' for the changes to take effect"
+            pure $ Right ()
+          VLeft  (V (AlreadyInstalled _ _)) -> pure $ Right ()
+          VLeft (V NoUpdate) -> pure $ Right ()
+          VLeft e -> pure $ Left $ prettyShow e <> "\n"
+            <> "Also check the logs in ~/.ghcup/logs"
+
+
+set' :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadFail m, MonadMask m, MonadUnliftIO m)
+     => BrickState
+     -> (Int, ListResult)
+     -> m (Either String ())
+set' bs input@(_, ListResult {..}) = do
+  settings <- liftIO $ readIORef settings'
+
+  let run =
+        flip runReaderT settings
+          . runE @'[FileDoesNotExistError , NotInstalled , TagNotFound]
+
+  run (do
+      case lTool of
+        GHC   -> liftE $ setGHC (GHCTargetVersion lCross lVer) SetGHCOnly Nothing $> ()
+        Cabal -> liftE $ setCabal lVer $> ()
+        HLS   -> liftE $ setHLS lVer SetHLSOnly Nothing $> ()
+        Stack -> liftE $ setStack lVer $> ()
+        GHCup -> pure ()
+    )
+    >>= \case
+          VRight _ -> pure $ Right ()
+          VLeft  e -> case e of
+            (V (NotInstalled tool _)) -> do
+              promptAnswer <- getUserPromptResponse userPrompt
+              case promptAnswer of
+                PromptYes -> do
+                  res <- install' bs input
+                  case res of
+                    (Left err) -> pure $ Left err
+                    (Right _) -> do
+                      logInfo "Setting now..."
+                      set' bs input
+
+                PromptNo -> pure $ Left (prettyShow e)
+              where
+                userPrompt = L.toStrict . B.toLazyText . B.fromString $
+                  "This Version of "
+                  <> show tool
+                  <> " you are trying to set is not installed.\n"
+                  <> "Would you like to install it first? [Y/N]: "
+
+            _ -> pure $ Left (prettyShow e)
+
+
+
+del' :: (MonadReader AppState m, MonadIO m, MonadFail m, MonadMask m, MonadUnliftIO m)
+     => BrickState
+     -> (Int, ListResult)
+     -> m (Either String ())
+del' _ (_, ListResult {..}) = do
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
+
+  let run = runE @'[NotInstalled, UninstallFailed]
+
+  run (do
+      let vi = getVersionInfo lVer lTool dls
+      case lTool of
+        GHC   -> liftE $ rmGHCVer (GHCTargetVersion lCross lVer) $> vi
+        Cabal -> liftE $ rmCabalVer lVer $> vi
+        HLS   -> liftE $ rmHLSVer lVer $> vi
+        Stack -> liftE $ rmStackVer lVer $> vi
+        GHCup -> pure Nothing
+    )
+    >>= \case
+          VRight vi -> do
+            forM_ (_viPostRemove =<< vi) $ \msg ->
+              logInfo msg
+            pure $ Right ()
+          VLeft  e -> pure $ Left (prettyShow e)
+
+
+changelog' :: (MonadReader AppState m, MonadIO m)
+           => BrickState
+           -> (Int, ListResult)
+           -> m (Either String ())
+changelog' _ (_, ListResult {..}) = do
+  AppState { pfreq, ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
+  case getChangeLog dls lTool (Left lVer) of
+    Nothing -> pure $ Left $
+      "Could not find ChangeLog for " <> prettyShow lTool <> ", version " <> T.unpack (prettyVer lVer)
+    Just uri -> do
+      let cmd = case _rPlatform pfreq of
+            Darwin  -> "open"
+            Linux _ -> "xdg-open"
+            FreeBSD -> "xdg-open"
+            Windows -> "start"
+      exec cmd [T.unpack $ decUTF8Safe $ serializeURIRef' uri] Nothing Nothing >>= \case
+        Right _ -> pure $ Right ()
+        Left  e -> pure $ Left $ prettyShow e
+
+
+settings' :: IORef AppState
+{-# NOINLINE settings' #-}
+settings' = unsafePerformIO $ do
+  dirs <- getAllDirs
+  let loggerConfig = LoggerConfig { lcPrintDebug  = False
+                                  , consoleOutter = \_ -> pure ()
+                                  , fileOutter    = \_ -> pure ()
+                                  , fancyColors   = True
+                                  }
+  newIORef $ AppState defaultSettings
+                      dirs
+                      defaultKeyBindings
+                      (GHCupInfo mempty mempty mempty)
+                      (PlatformRequest A_64 Darwin Nothing)
+                      loggerConfig
+
+
+getAppData :: Maybe GHCupInfo -> IO (Either String BrickData)
+getAppData mgi = runExceptT $ do
+  r <- ExceptT $ maybe getGHCupInfo (pure . Right) mgi
+  liftIO $ modifyIORef settings' (\s -> s { ghcupInfo = r })
+  settings <- liftIO $ readIORef settings'
+
+  flip runReaderT settings $ do
+    lV <- listVersions Nothing Nothing
+    pure $ BrickData (reverse lV)
+
+
+getGHCupInfo :: IO (Either String GHCupInfo)
+getGHCupInfo = do
+  settings <- readIORef settings'
+
+  r        <-
+    flip runReaderT settings
+    . runE
+      @'[ DigestError
+        , ContentLengthError
+        , GPGError
+        , JSONError
+        , DownloadFailed
+        , FileDoesNotExistError
+        ]
+    $ liftE getDownloadsF
+
+  case r of
+    VRight a -> pure $ Right a
+    VLeft  e -> pure $ Left (prettyShow e)
+
+

app/ghcup/BrickMain.hs

@@ -0,0 +1,653 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE RankNTypes        #-}
+
+module BrickMain where
+
+import           GHCup
+import           GHCup.Download
+import           GHCup.Errors
+import           GHCup.Types.Optics ( getDirs )
+import           GHCup.Types         hiding ( LeanAppState(..) )
+import           GHCup.Utils
+import           GHCup.OptParse.Common (logGHCPostRm)
+import           GHCup.Prelude ( decUTF8Safe )
+import           GHCup.Prelude.File
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.Process
+import           GHCup.Prompts
+
+import           Brick
+import           Brick.Widgets.Border
+import           Brick.Widgets.Border.Style
+import           Brick.Widgets.Center
+import           Brick.Widgets.List             ( listSelectedFocusedAttr
+                                                , listSelectedAttr
+                                                , listAttr
+                                                )
+import           Codec.Archive
+import           Control.Exception.Safe
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Except
+import           Control.Monad.Trans.Resource
+import           Data.Bool
+import           Data.Functor
+import           Data.List
+import           Data.Maybe
+import           Data.IORef
+import           Data.Vector                    ( Vector
+                                                , (!?)
+                                                )
+import           Data.Versions           hiding ( str )
+import           Haskus.Utils.Variant.Excepts
+import           Prelude                 hiding ( appendFile )
+import           System.FilePath
+import           System.Exit
+import           System.IO.Unsafe
+import           Text.PrettyPrint.HughesPJClass ( prettyShow )
+import           URI.ByteString
+
+import qualified Data.Text                     as T
+import qualified Data.Text.Lazy.Builder        as B
+import qualified Data.Text.Lazy                as L
+import qualified Graphics.Vty                  as Vty
+import qualified Data.Vector                   as V
+import System.Environment (getExecutablePath)
+import qualified System.Posix.Process          as SPP
+
+
+hiddenTools :: [Tool]
+hiddenTools = []
+
+
+data BrickData = BrickData
+  { lr    :: [ListResult]
+  }
+  deriving Show
+
+data BrickSettings = BrickSettings
+  { showAllVersions :: Bool
+  , showAllTools    :: Bool
+  }
+  deriving Show
+
+data BrickInternalState = BrickInternalState
+  { clr :: Vector ListResult
+  , ix  :: Int
+  }
+  deriving Show
+
+data BrickState = BrickState
+  { appData     :: BrickData
+  , appSettings :: BrickSettings
+  , appState    :: BrickInternalState
+  , appKeys     :: KeyBindings
+  }
+  deriving Show
+
+
+keyHandlers :: KeyBindings
+            -> [ ( Vty.Key
+                 , BrickSettings -> String
+                 , BrickState -> EventM n (Next BrickState)
+                 )
+               ]
+keyHandlers KeyBindings {..} =
+  [ (bQuit, const "Quit"     , halt)
+  , (bInstall, const "Install"  , withIOAction install')
+  , (bUninstall, const "Uninstall", withIOAction del')
+  , (bSet, const "Set"      , withIOAction set')
+  , (bChangelog, const "ChangeLog", withIOAction changelog')
+  , ( bShowAllVersions
+    , \BrickSettings {..} ->
+       if showAllVersions then "Don't show all versions" else "Show all versions"
+    , hideShowHandler (not . showAllVersions) showAllTools
+    )
+  , ( bShowAllTools
+    , \BrickSettings {..} ->
+       if showAllTools then "Don't show all tools" else "Show all tools"
+    , hideShowHandler showAllVersions (not . showAllTools)
+    )
+  , (bUp, const "Up", \BrickState {..} -> continue BrickState{ appState = moveCursor 1 appState Up, .. })
+  , (bDown, const "Down", \BrickState {..} -> continue BrickState{ appState = moveCursor 1 appState Down, .. })
+  ]
+ where
+  hideShowHandler f p BrickState{..} =
+    let newAppSettings   = appSettings { showAllVersions = f appSettings , showAllTools = p appSettings }
+        newInternalState = constructList appData newAppSettings (Just appState)
+    in  continue (BrickState appData newAppSettings newInternalState appKeys)
+
+
+showKey :: Vty.Key -> String
+showKey (Vty.KChar c) = [c]
+showKey Vty.KUp = "↑"
+showKey Vty.KDown = "↓"
+showKey key = tail (show key)
+
+
+ui :: AttrMap -> BrickState -> Widget String
+ui dimAttrs BrickState{ appSettings = as@BrickSettings{}, ..}
+  = padBottom Max
+      ( withBorderStyle unicode
+        $ borderWithLabel (str "GHCup")
+          (center (header <=> hBorder <=> renderList' appState))
+      )
+    <=> footer
+
+ where
+  footer =
+    withAttr "help"
+      . txtWrap
+      . T.pack
+      . foldr1 (\x y -> x <> "  " <> y)
+      . fmap (\(key, s, _) -> showKey key <> ":" <> s as)
+      $ keyHandlers appKeys
+  header =
+    minHSize 2 emptyWidget
+      <+> padLeft (Pad 2) (minHSize 6 $ str "Tool")
+      <+> minHSize 15 (str "Version")
+      <+> padLeft (Pad 1) (minHSize 25 $ str "Tags")
+      <+> padLeft (Pad 5) (str "Notes")
+  renderList' = withDefAttr listAttr . drawListElements renderItem True
+  renderItem _ b listResult@ListResult{..} =
+    let marks = if
+          | lSet       -> (withAttr "set" $ str "✔✔")
+          | lInstalled -> (withAttr "installed" $ str "✓ ")
+          | otherwise  -> (withAttr "not-installed" $ str "✗ ")
+        ver = case lCross of
+          Nothing -> T.unpack . prettyVer $ lVer
+          Just c  -> T.unpack (c <> "-" <> prettyVer lVer)
+        dim
+          | lNoBindist && not lInstalled
+            && not b -- TODO: overloading dim and active ignores active
+                       --       so we hack around it here
+          = updateAttrMap (const dimAttrs) . withAttr "no-bindist"
+          | otherwise  = id
+        hooray
+          | elem Latest lTag && not lInstalled =
+              withAttr "hooray"
+          | otherwise = id
+        active = if b then putCursor "GHCup" (Location (0,0)) . forceAttr "active" else id
+    in  hooray $ active $ dim
+          (   marks
+          <+> padLeft (Pad 2)
+               ( minHSize 6
+                 (printTool lTool)
+               )
+          <+> minHSize 15 (str ver)
+          <+> (let l = catMaybes . fmap printTag $ sort lTag
+               in  padLeft (Pad 1) $ minHSize 25 $ if null l
+                     then emptyWidget
+                     else foldr1 (\x y -> x <+> str "," <+> y) l
+              )
+          <+> padLeft (Pad 5)
+              ( let notes = printNotes listResult
+                in  if null notes
+                      then emptyWidget
+                      else foldr1 (\x y -> x <+> str "," <+> y) notes
+              )
+          <+> vLimit 1 (fill ' ')
+          )
+
+  printTag Recommended    = Just $ withAttr "recommended" $ str "recommended"
+  printTag Latest         = Just $ withAttr "latest" $ str "latest"
+  printTag Prerelease     = Just $ withAttr "prerelease" $ str "prerelease"
+  printTag (Base pvp'')   = Just $ str ("base-" ++ T.unpack (prettyPVP pvp''))
+  printTag Old            = Nothing
+  printTag (UnknownTag t) = Just $ str t
+
+  printTool Cabal = str "cabal"
+  printTool GHC = str "GHC"
+  printTool GHCup = str "GHCup"
+  printTool HLS = str "HLS"
+  printTool Stack = str "Stack"
+
+  printNotes ListResult {..} =
+    (if hlsPowered then [withAttr "hls-powered" $ str "hls-powered"] else mempty
+      )
+      ++ (if fromSrc then [withAttr "compiled" $ str "compiled"] else mempty)
+      ++ (if lStray then [withAttr "stray" $ str "stray"] else mempty)
+
+  -- | Draws the list elements.
+  --
+  -- Evaluates the underlying container up to, and a bit beyond, the
+  -- selected element. The exact amount depends on available height
+  -- for drawing and 'listItemHeight'. At most, it will evaluate up to
+  -- element @(i + h + 1)@ where @i@ is the selected index and @h@ is the
+  -- available height.
+  drawListElements :: (Int -> Bool -> ListResult -> Widget String)
+                   -> Bool
+                   -> BrickInternalState
+                   -> Widget String
+  drawListElements drawElem foc is@(BrickInternalState clr _) =
+    Widget Greedy Greedy $
+      let
+        es = clr
+        listSelected        = fmap fst $ listSelectedElement' is
+
+        drawnElements = flip V.imap es $ \i' e ->
+          let addSeparator w = case es !? (i' - 1) of
+                Just e' | lTool e' /= lTool e ->
+                  hBorder <=> w
+                _                             -> w
+
+              isSelected  = Just i' == listSelected
+              elemWidget  = drawElem i' isSelected e
+              selItemAttr = if foc
+                then withDefAttr listSelectedFocusedAttr
+                else withDefAttr listSelectedAttr
+              makeVisible = if isSelected then visible . selItemAttr else id
+          in  addSeparator $ makeVisible elemWidget
+
+      in render
+        $ viewport "GHCup" Vertical
+        $ vBox
+        $ V.toList drawnElements
+
+
+minHSize :: Int -> Widget n -> Widget n
+minHSize s' = hLimit s' . vLimit 1 . (<+> fill ' ')
+
+
+app :: AttrMap -> AttrMap -> App BrickState e String
+app attrs dimAttrs =
+  App { appDraw         = \st -> [ui dimAttrs st]
+  , appHandleEvent  = eventHandler
+  , appStartEvent   = return
+  , appAttrMap      = const attrs
+  , appChooseCursor = showFirstCursor
+  }
+
+defaultAttributes :: Bool -> AttrMap
+defaultAttributes no_color = attrMap
+  Vty.defAttr
+  [ ("active"       , Vty.defAttr `withBackColor` Vty.blue)
+  , ("not-installed", Vty.defAttr `withForeColor` Vty.red)
+  , ("set"          , Vty.defAttr `withForeColor` Vty.green)
+  , ("installed"    , Vty.defAttr `withForeColor` Vty.green)
+  , ("recommended"  , Vty.defAttr `withForeColor` Vty.green)
+  , ("hls-powered"  , Vty.defAttr `withForeColor` Vty.green)
+  , ("latest"       , Vty.defAttr `withForeColor` Vty.yellow)
+  , ("prerelease"   , Vty.defAttr `withForeColor` Vty.red)
+  , ("compiled"     , Vty.defAttr `withForeColor` Vty.blue)
+  , ("stray"        , Vty.defAttr `withForeColor` Vty.blue)
+  , ("help"         , Vty.defAttr `withStyle`     Vty.italic)
+  , ("hooray"       , Vty.defAttr `withForeColor` Vty.brightWhite)
+  ]
+  where
+    withForeColor | no_color  = const
+                  | otherwise = Vty.withForeColor
+
+    withBackColor | no_color  = \attr _ -> attr `Vty.withStyle` Vty.reverseVideo
+                  | otherwise = Vty.withBackColor
+
+    withStyle                 = Vty.withStyle
+
+dimAttributes :: Bool -> AttrMap
+dimAttributes no_color = attrMap
+  (Vty.defAttr `Vty.withStyle` Vty.dim)
+  [ ("active"    , Vty.defAttr `withBackColor` Vty.blue) -- has no effect ??
+  , ("no-bindist", Vty.defAttr `Vty.withStyle` Vty.dim)
+  ]
+  where
+    withBackColor | no_color  = \attr _ -> attr `Vty.withStyle` Vty.reverseVideo
+                  | otherwise = Vty.withBackColor
+
+eventHandler :: BrickState -> BrickEvent n e -> EventM n (Next BrickState)
+eventHandler st@BrickState{..} ev = do
+  AppState { keyBindings = kb } <- liftIO $ readIORef settings'
+  case ev of
+    (MouseDown _ Vty.BScrollUp _ _) ->
+      continue (BrickState { appState = moveCursor 1 appState Up, .. })
+    (MouseDown _ Vty.BScrollDown _ _) ->
+      continue (BrickState { appState = moveCursor 1 appState Down, .. })
+    (VtyEvent (Vty.EvResize _ _)) -> continue st
+    (VtyEvent (Vty.EvKey Vty.KUp _)) ->
+      continue BrickState{ appState = moveCursor 1 appState Up, .. }
+    (VtyEvent (Vty.EvKey Vty.KDown _)) ->
+      continue BrickState{ appState = moveCursor 1 appState Down, .. }
+    (VtyEvent (Vty.EvKey key _)) ->
+      case find (\(key', _, _) -> key' == key) (keyHandlers kb) of
+        Nothing -> continue st
+        Just (_, _, handler) -> handler st
+    _ -> continue st
+
+
+moveCursor :: Int -> BrickInternalState -> Direction -> BrickInternalState
+moveCursor steps ais@BrickInternalState{..} direction =
+  let newIx = if direction == Down then ix + steps else ix - steps
+  in  case clr !? newIx of
+        Just _  -> BrickInternalState { ix = newIx, .. }
+        Nothing -> ais
+
+
+-- | Suspend the current UI and run an IO action in terminal. If the
+-- IO action returns a Left value, then it's thrown as userError.
+withIOAction :: (BrickState
+                 -> (Int, ListResult)
+                 -> ReaderT AppState IO (Either String a))
+             -> BrickState
+             -> EventM n (Next BrickState)
+withIOAction action as = case listSelectedElement' (appState as) of
+  Nothing      -> continue as
+  Just (ix, e) -> do
+    suspendAndResume $ do
+      settings <- readIORef settings'
+      flip runReaderT settings $ action as (ix, e) >>= \case
+        Left  err -> liftIO $ putStrLn ("Error: " <> err)
+        Right _   -> liftIO $ putStrLn "Success"
+      getAppData Nothing >>= \case
+        Right data' -> do
+          putStrLn "Press enter to continue"
+          _ <- getLine
+          pure (updateList data' as)
+        Left err -> throwIO $ userError err
+
+
+-- | Update app data and list internal state based on new evidence.
+-- This synchronises @BrickInternalState@ with @BrickData@
+-- and @BrickSettings@.
+updateList :: BrickData -> BrickState -> BrickState
+updateList appD BrickState{..} =
+  let newInternalState = constructList appD appSettings (Just appState)
+  in  BrickState { appState    = newInternalState
+                 , appData     = appD
+                 , appSettings = appSettings
+                 , appKeys     = appKeys
+                 }
+
+
+constructList :: BrickData
+              -> BrickSettings
+              -> Maybe BrickInternalState
+              -> BrickInternalState
+constructList appD appSettings =
+  replaceLR (filterVisible (showAllVersions appSettings)
+                           (showAllTools appSettings))
+            (lr appD)
+
+listSelectedElement' :: BrickInternalState -> Maybe (Int, ListResult)
+listSelectedElement' BrickInternalState{..} = fmap (ix, ) $ clr !? ix
+
+
+selectLatest :: Vector ListResult -> Int
+selectLatest = fromMaybe 0 . V.findIndex (\ListResult {..} -> lTool == GHC && Latest `elem` lTag)
+
+
+-- | Replace the @appState@ or construct it based on a filter function
+-- and a new @[ListResult]@ evidence.
+-- When passed an existing @appState@, tries to keep the selected element.
+replaceLR :: (ListResult -> Bool)
+          -> [ListResult]
+          -> Maybe BrickInternalState
+          -> BrickInternalState
+replaceLR filterF lr s =
+  let oldElem = s >>= listSelectedElement'
+      newVec  = V.fromList . filter filterF $ lr
+      newSelected =
+        case oldElem >>= \(_, oldE) -> V.findIndex (toolEqual oldE) newVec of
+          Just ix -> ix
+          Nothing -> selectLatest newVec
+  in  BrickInternalState newVec newSelected
+ where
+  toolEqual e1 e2 =
+    lTool e1 == lTool e2 && lVer e1 == lVer e2 && lCross e1 == lCross e2
+
+
+filterVisible :: Bool -> Bool -> ListResult -> Bool
+filterVisible v t e | lInstalled e = True
+                    | v
+                    , not t
+                    , lTool e `notElem` hiddenTools = True
+                    | not v
+                    , t
+                    , Old `notElem` lTag e = True
+                    | v
+                    , t = True
+                    | otherwise = (Old `notElem` lTag e) &&
+                                  (lTool e `notElem` hiddenTools)
+
+
+install' :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadFail m, MonadMask m, MonadUnliftIO m)
+         => BrickState
+         -> (Int, ListResult)
+         -> m (Either String ())
+install' _ (_, ListResult {..}) = do
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
+
+  let run =
+        runResourceT
+          . runE
+            @'[ AlreadyInstalled
+              , ArchiveResult
+              , UnknownArchive
+              , FileDoesNotExistError
+              , CopyError
+              , NoDownload
+              , NotInstalled
+              , BuildFailed
+              , TagNotFound
+              , DigestError
+              , ContentLengthError
+              , GPGError
+              , DownloadFailed
+              , DirNotEmpty
+              , NoUpdate
+              , TarDirDoesNotExist
+              , FileAlreadyExistsError
+              , ProcessError
+              , ToolShadowed
+              , UninstallFailed
+              , MergeFileTreeError
+              ]
+
+  run (do
+      ce <- liftIO $ fmap (either (const Nothing) Just) $
+        try @_ @SomeException $ getExecutablePath >>= canonicalizePath
+      dirs <- lift getDirs
+      case lTool of
+        GHC   -> do
+          let vi = getVersionInfo lVer GHC dls
+          liftE $ installGHCBin lVer GHCupInternal False [] $> (vi, dirs, ce)
+        Cabal -> do
+          let vi = getVersionInfo lVer Cabal dls
+          liftE $ installCabalBin lVer GHCupInternal False $> (vi, dirs, ce)
+        GHCup -> do
+          let vi = snd <$> getLatest dls GHCup
+          liftE $ upgradeGHCup Nothing False False $> (vi, dirs, ce)
+        HLS   -> do
+          let vi = getVersionInfo lVer HLS dls
+          liftE $ installHLSBin lVer GHCupInternal False $> (vi, dirs, ce)
+        Stack -> do
+          let vi = getVersionInfo lVer Stack dls
+          liftE $ installStackBin lVer GHCupInternal False $> (vi, dirs, ce)
+    )
+    >>= \case
+          VRight (vi, Dirs{..}, Just ce) -> do
+            forM_ (_viPostInstall =<< vi) $ \msg -> logInfo msg
+            case lTool of
+              GHCup -> do
+                up <- liftIO $ fmap (either (const Nothing) Just)
+                  $ try @_ @SomeException $ canonicalizePath (binDir </> "ghcup" <.> exeExt)
+                when ((normalise <$> up) == Just (normalise ce)) $
+                  -- TODO: track cli arguments of previous invocation
+                  liftIO $ SPP.executeFile ce False ["tui"] Nothing
+                logInfo "Please restart 'ghcup' for the changes to take effect"
+              _ -> pure ()
+            pure $ Right ()
+          VRight (vi, _, _) -> do
+            forM_ (_viPostInstall =<< vi) $ \msg -> logInfo msg
+            logInfo "Please restart 'ghcup' for the changes to take effect"
+            pure $ Right ()
+          VLeft  (V (AlreadyInstalled _ _)) -> pure $ Right ()
+          VLeft (V NoUpdate) -> pure $ Right ()
+          VLeft e -> pure $ Left $ prettyHFError e <> "\n"
+            <> "Also check the logs in ~/.ghcup/logs"
+
+
+set' :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadFail m, MonadMask m, MonadUnliftIO m)
+     => BrickState
+     -> (Int, ListResult)
+     -> m (Either String ())
+set' bs input@(_, ListResult {..}) = do
+  settings <- liftIO $ readIORef settings'
+
+  let run =
+        flip runReaderT settings
+          . runE @'[FileDoesNotExistError , NotInstalled , TagNotFound]
+
+  run (do
+      case lTool of
+        GHC   -> liftE $ setGHC (GHCTargetVersion lCross lVer) SetGHCOnly Nothing $> ()
+        Cabal -> liftE $ setCabal lVer $> ()
+        HLS   -> liftE $ setHLS lVer SetHLSOnly Nothing $> ()
+        Stack -> liftE $ setStack lVer $> ()
+        GHCup -> pure ()
+    )
+    >>= \case
+          VRight _ -> pure $ Right ()
+          VLeft  e -> case e of
+            (V (NotInstalled tool _)) -> do
+              promptAnswer <- getUserPromptResponse userPrompt
+              case promptAnswer of
+                PromptYes -> do
+                  res <- install' bs input
+                  case res of
+                    (Left err) -> pure $ Left err
+                    (Right _) -> do
+                      logInfo "Setting now..."
+                      set' bs input
+
+                PromptNo -> pure $ Left (prettyHFError e)
+              where
+                userPrompt = L.toStrict . B.toLazyText . B.fromString $
+                  "This Version of "
+                  <> show tool
+                  <> " you are trying to set is not installed.\n"
+                  <> "Would you like to install it first? [Y/N]: "
+
+            _ -> pure $ Left (prettyHFError e)
+
+
+
+del' :: (MonadReader AppState m, MonadIO m, MonadFail m, MonadMask m, MonadUnliftIO m)
+     => BrickState
+     -> (Int, ListResult)
+     -> m (Either String ())
+del' _ (_, ListResult {..}) = do
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
+
+  let run = runE @'[NotInstalled, UninstallFailed]
+
+  run (do
+      let vi = getVersionInfo lVer lTool dls
+      case lTool of
+        GHC   -> liftE $ rmGHCVer (GHCTargetVersion lCross lVer) $> vi
+        Cabal -> liftE $ rmCabalVer lVer $> vi
+        HLS   -> liftE $ rmHLSVer lVer $> vi
+        Stack -> liftE $ rmStackVer lVer $> vi
+        GHCup -> pure Nothing
+    )
+    >>= \case
+          VRight vi -> do
+            logGHCPostRm (mkTVer lVer)
+            forM_ (_viPostRemove =<< vi) $ \msg ->
+              logInfo msg
+            pure $ Right ()
+          VLeft  e -> pure $ Left (prettyHFError e)
+
+
+changelog' :: (MonadReader AppState m, MonadIO m)
+           => BrickState
+           -> (Int, ListResult)
+           -> m (Either String ())
+changelog' _ (_, ListResult {..}) = do
+  AppState { pfreq, ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
+  case getChangeLog dls lTool (Left lVer) of
+    Nothing -> pure $ Left $
+      "Could not find ChangeLog for " <> prettyShow lTool <> ", version " <> T.unpack (prettyVer lVer)
+    Just uri -> do
+      let cmd = case _rPlatform pfreq of
+            Darwin  -> "open"
+            Linux _ -> "xdg-open"
+            FreeBSD -> "xdg-open"
+            Windows -> "start"
+      exec cmd [T.unpack $ decUTF8Safe $ serializeURIRef' uri] Nothing Nothing >>= \case
+        Right _ -> pure $ Right ()
+        Left  e -> pure $ Left $ prettyHFError e
+
+
+settings' :: IORef AppState
+{-# NOINLINE settings' #-}
+settings' = unsafePerformIO $ do
+  dirs <- getAllDirs
+  let loggerConfig = LoggerConfig { lcPrintDebug  = False
+                                  , consoleOutter = \_ -> pure ()
+                                  , fileOutter    = \_ -> pure ()
+                                  , fancyColors   = True
+                                  }
+  newIORef $ AppState defaultSettings
+                      dirs
+                      defaultKeyBindings
+                      (GHCupInfo mempty mempty mempty)
+                      (PlatformRequest A_64 Darwin Nothing)
+                      loggerConfig
+
+
+
+brickMain :: AppState
+          -> IO ()
+brickMain s = do
+  writeIORef settings' s
+
+  eAppData <- getAppData (Just $ ghcupInfo s)
+  case eAppData of
+    Right ad ->
+      defaultMain
+          (app (defaultAttributes (noColor $ settings s)) (dimAttributes (noColor $ settings s)))
+          (BrickState ad
+                    defaultAppSettings
+                    (constructList ad defaultAppSettings Nothing)
+                    (keyBindings (s :: AppState))
+
+          )
+        $> ()
+    Left e -> do
+      flip runReaderT s $ logError $ "Error building app state: " <> T.pack (show e)
+      exitWith $ ExitFailure 2
+
+
+defaultAppSettings :: BrickSettings
+defaultAppSettings = BrickSettings { showAllVersions = False, showAllTools = False }
+
+
+getGHCupInfo :: IO (Either String GHCupInfo)
+getGHCupInfo = do
+  settings <- readIORef settings'
+
+  r <-
+    flip runReaderT settings
+    . runE @'[DigestError, ContentLengthError, GPGError, JSONError , DownloadFailed , FileDoesNotExistError]
+    $ liftE getDownloadsF
+
+  case r of
+    VRight a -> pure $ Right a
+    VLeft  e -> pure $ Left (prettyHFError e)
+
+
+getAppData :: Maybe GHCupInfo
+           -> IO (Either String BrickData)
+getAppData mgi = runExceptT $ do
+  r <- ExceptT $ maybe getGHCupInfo (pure . Right) mgi
+  liftIO $ modifyIORef settings' (\s -> s { ghcupInfo = r })
+  settings <- liftIO $ readIORef settings'
+
+  flip runReaderT settings $ do
+    lV <- listVersions Nothing Nothing
+    pure $ BrickData (reverse lV)

app/ghcup/GHCup/OptParse.hs

@@ -0,0 +1,365 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+
+
+module GHCup.OptParse (
+    module GHCup.OptParse.Common
+  , module GHCup.OptParse.Install
+  , module GHCup.OptParse.Set
+  , module GHCup.OptParse.UnSet
+  , module GHCup.OptParse.Rm
+  , module GHCup.OptParse.Compile
+  , module GHCup.OptParse.Config
+  , module GHCup.OptParse.Whereis
+  , module GHCup.OptParse.List
+#ifndef DISABLE_UPGRADE
+  , module GHCup.OptParse.Upgrade
+#endif
+  , module GHCup.OptParse.ChangeLog
+  , module GHCup.OptParse.Prefetch
+  , module GHCup.OptParse.GC
+  , module GHCup.OptParse.DInfo
+  , module GHCup.OptParse.Nuke
+  , module GHCup.OptParse.ToolRequirements
+  , module GHCup.OptParse.Run
+  , module GHCup.OptParse
+) where
+
+
+import           GHCup.OptParse.Common
+import           GHCup.OptParse.Install
+import           GHCup.OptParse.Set
+import           GHCup.OptParse.UnSet
+import           GHCup.OptParse.Rm
+import           GHCup.OptParse.Run
+import           GHCup.OptParse.Compile
+import           GHCup.OptParse.Config
+import           GHCup.OptParse.Whereis
+import           GHCup.OptParse.List
+#ifndef DISABLE_UPGRADE
+import           GHCup.OptParse.Upgrade
+#endif
+import           GHCup.OptParse.ChangeLog
+import           GHCup.OptParse.Prefetch
+import           GHCup.OptParse.GC
+import           GHCup.OptParse.DInfo
+import           GHCup.OptParse.ToolRequirements
+import           GHCup.OptParse.Nuke
+
+import           GHCup.Types
+
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Data.Bifunctor
+import           Data.Either
+import           Data.Functor
+import           Data.Maybe
+import           Options.Applicative     hiding ( style )
+import           Options.Applicative.Help.Pretty ( text )
+import           Prelude                 hiding ( appendFile )
+import           URI.ByteString
+
+import qualified Data.ByteString.UTF8          as UTF8
+
+
+data Options = Options
+  {
+  -- global options
+    optVerbose     :: Maybe Bool
+  , optCache       :: Maybe Bool
+  , optMetaCache   :: Maybe Integer
+  , optMetaMode    :: Maybe MetaMode
+  , optPlatform    :: Maybe PlatformRequest
+  , optUrlSource   :: Maybe URI
+  , optNoVerify    :: Maybe Bool
+  , optKeepDirs    :: Maybe KeepDirs
+  , optsDownloader :: Maybe Downloader
+  , optNoNetwork   :: Maybe Bool
+  , optGpg         :: Maybe GPGSetting
+  -- commands
+  , optCommand     :: Command
+  }
+
+data Command
+  = Install (Either InstallCommand InstallOptions)
+  | InstallCabalLegacy InstallOptions
+  | Set (Either SetCommand SetOptions)
+  | UnSet UnsetCommand
+  | List ListOptions
+  | Rm (Either RmCommand RmOptions)
+  | DInfo
+  | Compile CompileCommand
+  | Config ConfigCommand
+  | Whereis WhereisOptions WhereisCommand
+#ifndef DISABLE_UPGRADE
+  | Upgrade UpgradeOpts Bool Bool
+#endif
+  | ToolRequirements ToolReqOpts
+  | ChangeLog ChangeLogOptions
+  | Nuke
+#if defined(BRICK)
+  | Interactive
+#endif
+#if defined(ANSI)
+  | InteractiveAnsi
+#endif
+  | Prefetch PrefetchCommand
+  | GC GCOptions
+  | Run RunOptions
+  | PrintAppErrors
+
+
+
+opts :: Parser Options
+opts =
+  Options
+    <$> invertableSwitch "verbose" (Just 'v') False (help "Enable verbosity (default: disabled)")
+    <*> invertableSwitch "cache" (Just 'c') False (help "Cache downloads in ~/.ghcup/cache (default: disabled)")
+    <*> optional (option auto (long "metadata-caching" <> metavar "SEC" <> help "How long the yaml metadata caching interval is (in seconds), 0 to disable"))
+    <*> optional (option auto (long "metadata-fetching-mode" <> metavar "<Strict|Lax>" <> help "Whether to fail on metadata download failure (Strict) or fall back to cached version (Lax (default))"))
+    <*> optional
+      (option
+        (eitherReader platformParser)
+        (  short 'p'
+        <> long "platform"
+        <> metavar "PLATFORM"
+        <> help
+             "Override for platform (triple matching ghc tarball names), e.g. x86_64-fedora27-linux"
+        )
+      )
+    <*> optional
+          (option
+            (eitherReader parseUri)
+            (  short 's'
+            <> long "url-source"
+            <> metavar "URL"
+            <> help "Alternative ghcup download info url"
+            <> internal
+            <> completer fileUri
+            )
+          )
+    <*> (fmap . fmap) not (invertableSwitch "verify" (Just 'n') True (help "Disable tarball checksum verification (default: enabled)"))
+    <*> optional (option
+          (eitherReader keepOnParser)
+          (  long "keep"
+          <> metavar "<always|errors|never>"
+          <> help
+               "Keep build directories? (default: errors)"
+          <> hidden
+          <> completer (listCompleter ["always", "errors", "never"])
+          ))
+    <*> optional (option
+          (eitherReader downloaderParser)
+          (  long "downloader"
+#if defined(INTERNAL_DOWNLOADER)
+          <> metavar "<internal|curl|wget>"
+          <> help
+          "Downloader to use (default: internal)"
+          <> completer (listCompleter ["internal", "curl", "wget"])
+#else
+          <> metavar "<curl|wget>"
+          <> help
+          "Downloader to use (default: curl)"
+          <> completer (listCompleter ["curl", "wget"])
+#endif
+          <> hidden
+          ))
+    <*> invertableSwitch "offline" (Just 'o') False (help "Don't do any network calls, trying cached assets and failing if missing.")
+    <*> optional (option
+          (eitherReader gpgParser)
+          (  long "gpg"
+          <> metavar "<strict|lax|none>"
+          <> help
+          "GPG verification (default: none)"
+          <> completer (listCompleter ["strict", "lax", "none"])
+          ))
+    <*> com
+ where
+  parseUri s' =
+    first show $ parseURI strictURIParserOptions (UTF8.fromString s')
+
+
+com :: Parser Command
+com =
+  subparser
+#if defined(ANSI)
+      (  command
+          "tui-ansi"
+          (   (\_ -> InteractiveAnsi)
+          <$> info
+                helper
+                (  progDesc "Start the interactive GHCup UI (ansi)"
+                )
+          )
+          <>
+#endif
+#if defined(BRICK)
+        command
+          "tui"
+          (   (\_ -> Interactive)
+          <$> info
+                helper
+                (  progDesc "Start the interactive GHCup UI"
+                )
+          )
+      <>  command
+#else
+          command
+#endif
+          "install"
+          (   Install
+          <$> info
+                (installParser <**> helper)
+                (  progDesc "Install or update GHC/cabal/HLS/stack"
+                <> footerDoc (Just $ text installToolFooter)
+                )
+          )
+      <> command
+           "set"
+           (info
+             (Set <$> setParser <**> helper)
+             (  progDesc "Set currently active GHC/cabal version"
+             <> footerDoc (Just $ text setFooter)
+             )
+           )
+      <> command
+           "unset"
+           (info
+             (UnSet <$> unsetParser <**> helper)
+             (  progDesc "Unset currently active GHC/cabal version"
+             <> footerDoc (Just $ text unsetFooter)
+             )
+           )
+      <> command
+           "rm"
+           (info
+             (Rm <$> rmParser <**> helper)
+             (  progDesc "Remove a GHC/cabal/HLS/stack version"
+             <> footerDoc (Just $ text rmFooter)
+             )
+           )
+
+      <> command
+           "list"
+           (info (List <$> listOpts <**> helper)
+                 (progDesc "Show available GHCs and other tools")
+           )
+      <> command
+           "upgrade"
+           (info
+             (    (Upgrade <$> upgradeOptsP <*> switch
+                    (short 'f' <> long "force" <> help "Force update")
+                    <*> switch
+                    (long "fail-if-shadowed" <> help "Fails after upgrading if the upgraded ghcup binary is shadowed by something else in PATH (useful for CI)")
+                  )
+             <**> helper
+             )
+             (progDesc "Upgrade ghcup")
+           )
+      <> command
+           "compile"
+           (   Compile
+           <$> info (compileP <**> helper)
+                    (progDesc "Compile a tool from source")
+           )
+      <> command
+           "whereis"
+            (info
+             (   (Whereis
+                     <$> (WhereisOptions <$> switch (short 'd' <> long "directory" <> help "return directory of the binary instead of the binary location"))
+                     <*> whereisP
+                 ) <**> helper
+             )
+             (progDesc "Find a tools location"
+             <> footerDoc ( Just $ text whereisFooter ))
+           )
+      <> command
+           "prefetch"
+            (info
+             (   (Prefetch
+                     <$> prefetchP
+                 ) <**> helper
+             )
+             (progDesc "Prefetch assets"
+             <> footerDoc ( Just $ text prefetchFooter ))
+           )
+      <> command
+           "gc"
+            (info
+             (   (GC
+                     <$> gcP
+                 ) <**> helper
+             )
+             (progDesc "Garbage collection"
+             <> footerDoc ( Just $ text gcFooter ))
+           )
+      <> command
+              "run"
+               (Run
+               <$>
+                 info
+                   (runOpts <**> helper)
+                   (progDesc "Run a command with the given tool in PATH"
+                   <> footerDoc ( Just $ text runFooter )
+                   )
+               )
+      <> commandGroup "Main commands:"
+      )
+    <|> subparser
+          (  command
+              "debug-info"
+              ((\_ -> DInfo) <$> info helper (progDesc "Show debug info"))
+          <> command
+               "tool-requirements"
+               (   ToolRequirements
+               <$> info (toolReqP <**> helper)
+                        (progDesc "Show the requirements for ghc/cabal")
+               )
+          <> command
+               "changelog"
+               (info
+                  (fmap ChangeLog changelogP <**> helper)
+                  (  progDesc "Find/show changelog"
+                  <> footerDoc (Just $ text changeLogFooter)
+                  )
+               )
+          <> command
+               "config"
+               (   Config
+               <$> info (configP <**> helper)
+                        (progDesc "Show or set config" <> footerDoc (Just $ text configFooter))
+               )
+          <> commandGroup "Other commands:"
+          <> hidden
+          )
+    <|> subparser
+          (  command
+              "install-cabal"
+              (info
+                 ((InstallCabalLegacy <$> installOpts (Just Cabal)) <**> helper)
+                 (  progDesc "Install or update cabal"
+                 <> footerDoc (Just $ text installCabalFooter)
+                 )
+              )
+          <> internal
+          )
+     <|> subparser
+          (command
+              "nuke"
+               (info (pure Nuke <**> helper)
+                     (progDesc "Completely remove ghcup from your system"))
+           <> commandGroup "Nuclear Commands:"
+           <> hidden
+          )
+     <|> subparser
+          (command
+              "print-app-errors"
+               (info (pure PrintAppErrors <**> helper)
+                     (progDesc ""))
+           <> internal
+          )

app/ghcup/GHCup/OptParse/ChangeLog.hs

@@ -0,0 +1,154 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE RankNTypes #-}
+
+module GHCup.OptParse.ChangeLog where
+
+
+import           GHCup.Types
+import           GHCup.Errors
+import           GHCup.OptParse.Common
+import           GHCup.Prelude
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.String.QQ
+import           GHCup.Prelude.Process (exec)
+
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Data.Functor
+import           Data.Maybe
+import           Options.Applicative     hiding ( style )
+import           Prelude                 hiding ( appendFile )
+import           System.Exit
+import           Text.PrettyPrint.HughesPJClass ( prettyShow )
+
+import qualified Data.Text                     as T
+import Control.Exception.Safe (MonadMask)
+import GHCup.Types.Optics
+import GHCup.Utils
+import Data.Versions
+import URI.ByteString (serializeURIRef')
+import Data.Char (toLower)
+
+
+
+    ---------------
+    --[ Options ]--
+    ---------------
+
+
+data ChangeLogOptions = ChangeLogOptions
+  { clOpen    :: Bool
+  , clTool    :: Maybe Tool
+  , clToolVer :: Maybe ToolVersion
+  }
+
+
+
+
+    ---------------
+    --[ Parsers ]--
+    ---------------
+
+
+changelogP :: Parser ChangeLogOptions
+changelogP =
+  (\x y -> ChangeLogOptions x y)
+    <$> switch (short 'o' <> long "open" <> help "xdg-open the changelog url")
+    <*> optional
+          (option
+            (eitherReader
+              (\s' -> case fmap toLower s' of
+                "ghc"   -> Right GHC
+                "cabal" -> Right Cabal
+                "ghcup" -> Right GHCup
+                "stack" -> Right Stack
+                "hls"   -> Right HLS
+                e       -> Left e
+              )
+            )
+            (short 't' <> long "tool" <> metavar "<ghc|cabal|hls|ghcup>" <> help
+              "Open changelog for given tool (default: ghc)"
+              <> completer toolCompleter
+            )
+          )
+    <*> optional (toolVersionTagArgument Nothing Nothing)
+
+
+
+    --------------
+    --[ Footer ]--
+    --------------
+
+
+changeLogFooter :: String
+changeLogFooter = [s|Discussion:
+  By default returns the URI of the ChangeLog of the latest GHC release.
+  Pass '-o' to automatically open via xdg-open.|]
+
+
+
+    ------------------
+    --[ Entrypoint ]--
+    ------------------
+
+
+
+changelog :: ( Monad m
+             , MonadMask m
+             , MonadUnliftIO m
+             , MonadFail m
+             )
+          => ChangeLogOptions
+          -> (forall a . ReaderT AppState m a -> m a)
+          -> (ReaderT LeanAppState m () -> m ())
+          -> m ExitCode
+changelog ChangeLogOptions{..} runAppState runLogger = do
+  GHCupInfo { _ghcupDownloads = dls } <- runAppState getGHCupInfo
+  let tool = fromMaybe GHC clTool
+      ver' = maybe
+        (Right Latest)
+        (\case
+          GHCVersion tv  -> Left (_tvVersion tv)
+          ToolVersion tv -> Left tv
+          ToolTag     t  -> Right t
+        )
+        clToolVer
+      muri = getChangeLog dls tool ver'
+  case muri of
+    Nothing -> do
+      runLogger
+        (logWarn $
+          "Could not find ChangeLog for " <> T.pack (prettyShow tool) <> ", version " <> either prettyVer (T.pack . show) ver'
+        )
+      pure ExitSuccess
+    Just uri -> do
+      pfreq <- runAppState getPlatformReq
+      let uri' = T.unpack . decUTF8Safe . serializeURIRef' $ uri
+          cmd = case _rPlatform pfreq of
+                  Darwin  -> "open"
+                  Linux _ -> "xdg-open"
+                  FreeBSD -> "xdg-open"
+                  Windows -> "start"
+
+      if clOpen
+        then do
+          runAppState $
+            exec cmd
+                 [T.unpack $ decUTF8Safe $ serializeURIRef' uri]
+                 Nothing
+                 Nothing
+              >>= \case
+                    Right _ -> pure ExitSuccess
+                    Left  e -> logError (T.pack $ prettyHFError e)
+                      >> pure (ExitFailure 13)
+        else liftIO $ putStrLn uri' >> pure ExitSuccess

app/ghcup/GHCup/OptParse/Common.hs

@@ -0,0 +1,802 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE NumericUnderscores #-}
+
+module GHCup.OptParse.Common where
+
+
+import           GHCup
+import           GHCup.Download
+import           GHCup.Errors
+import           GHCup.Platform
+import           GHCup.Types
+import           GHCup.Types.Optics
+import           GHCup.Utils
+import           GHCup.Prelude
+import           GHCup.Prelude.Process
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.MegaParsec
+
+import           Control.DeepSeq
+import           Control.Concurrent
+import           Control.Concurrent.Async
+import           Control.Exception.Safe
+import           Control.Monad.Identity (Identity(..))
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Data.Aeson
+#if MIN_VERSION_aeson(2,0,0)
+import qualified Data.Aeson.Key    as KM
+import qualified Data.Aeson.KeyMap as KM
+#else
+import qualified Data.HashMap.Strict as KM
+#endif
+import           Data.ByteString.Lazy           ( ByteString )
+import           Data.Bifunctor
+import           Data.Char
+import           Data.Either
+import           Data.Functor
+import           Data.List                      ( nub, sort, sortBy, isPrefixOf, stripPrefix )
+import           Data.Maybe
+import           Data.Text                      ( Text )
+import           Data.Versions           hiding ( str )
+import           Data.Void
+import qualified Data.Vector      as V
+import           GHC.IO.Exception
+import           Haskus.Utils.Variant.Excepts
+import           Options.Applicative     hiding ( style )
+import           Prelude                 hiding ( appendFile )
+import           Safe
+import           System.Process                  ( readProcess )
+import           System.FilePath
+import           Text.HTML.TagSoup       hiding ( Tag )
+import           URI.ByteString
+
+import qualified Data.ByteString.UTF8          as UTF8
+import qualified Data.Map.Strict               as M
+import qualified Data.Text                     as T
+import qualified Text.Megaparsec               as MP
+import qualified System.FilePath.Posix         as FP
+import GHCup.Version
+import Control.Exception (evaluate)
+import qualified Cabal.Config            as CC
+
+
+    -------------
+    --[ Types ]--
+    -------------
+
+data ToolVersion = GHCVersion GHCTargetVersion
+                 | ToolVersion Version
+                 | ToolTag Tag
+
+-- a superset of ToolVersion
+data SetToolVersion = SetGHCVersion GHCTargetVersion
+                    | SetToolVersion Version
+                    | SetToolTag Tag
+                    | SetRecommended
+                    | SetNext
+
+prettyToolVer :: ToolVersion -> String
+prettyToolVer (GHCVersion v') = T.unpack $ tVerToText v'
+prettyToolVer (ToolVersion v') = T.unpack $ prettyVer v'
+prettyToolVer (ToolTag t) = show t
+
+toSetToolVer :: Maybe ToolVersion -> SetToolVersion
+toSetToolVer (Just (GHCVersion v')) = SetGHCVersion v'
+toSetToolVer (Just (ToolVersion v')) = SetToolVersion v'
+toSetToolVer (Just (ToolTag t')) = SetToolTag t'
+toSetToolVer Nothing = SetRecommended
+
+
+
+
+    --------------
+    --[ Parser ]--
+    --------------
+
+
+toolVersionTagArgument :: Maybe ListCriteria -> Maybe Tool -> Parser ToolVersion
+toolVersionTagArgument criteria tool =
+  argument (eitherReader (parser tool))
+    (metavar (mv tool)
+    <> completer (tagCompleter (fromMaybe GHC tool) [])
+    <> foldMap (completer . versionCompleter criteria) tool)
+ where
+  mv (Just GHC) = "GHC_VERSION|TAG"
+  mv (Just HLS) = "HLS_VERSION|TAG"
+  mv _          = "VERSION|TAG"
+
+  parser (Just GHC) = ghcVersionTagEither
+  parser Nothing    = ghcVersionTagEither
+  parser _          = toolVersionTagEither
+
+
+versionParser' :: Maybe ListCriteria -> Maybe Tool -> Parser Version
+versionParser' criteria tool = argument
+  (eitherReader (first show . version . T.pack))
+  (metavar "VERSION"  <> foldMap (completer . versionCompleter criteria) tool)
+
+ghcVersionArgument :: Maybe ListCriteria -> Maybe Tool -> Parser GHCTargetVersion
+ghcVersionArgument criteria tool = argument (eitherReader ghcVersionEither)
+                                            (metavar "VERSION" <> foldMap (completer . versionCompleter criteria) tool)
+
+
+-- https://github.com/pcapriotti/optparse-applicative/issues/148
+
+-- | A switch that can be enabled using --foo and disabled using --no-foo.
+--
+-- The option modifier is applied to only the option that is *not* enabled
+-- by default. For example:
+--
+-- > invertableSwitch "recursive" True (help "do not recurse into directories")
+--
+-- This example makes --recursive enabled by default, so
+-- the help is shown only for --no-recursive.
+invertableSwitch
+    :: String              -- ^ long option
+    -> Maybe Char          -- ^ short option for the non-default option
+    -> Bool                -- ^ is switch enabled by default?
+    -> Mod FlagFields Bool -- ^ option modifier
+    -> Parser (Maybe Bool)
+invertableSwitch longopt shortopt defv optmod = invertableSwitch' longopt shortopt defv
+    (if defv then mempty else optmod)
+    (if defv then optmod else mempty)
+
+-- | Allows providing option modifiers for both --foo and --no-foo.
+invertableSwitch'
+    :: String              -- ^ long option (eg "foo")
+    -> Maybe Char          -- ^ short option for the non-default option
+    -> Bool                -- ^ is switch enabled by default?
+    -> Mod FlagFields Bool -- ^ option modifier for --foo
+    -> Mod FlagFields Bool -- ^ option modifier for --no-foo
+    -> Parser (Maybe Bool)
+invertableSwitch' longopt shortopt defv enmod dismod = optional
+    ( flag' True ( enmod <> long longopt <> if defv then mempty else maybe mempty short shortopt)
+    <|> flag' False (dismod <> long nolongopt <> if defv then maybe mempty short shortopt else mempty)
+    )
+  where
+    nolongopt = "no-" ++ longopt
+
+
+
+    ---------------------
+    --[ Either Parser ]--
+    ---------------------
+
+
+platformParser :: String -> Either String PlatformRequest
+platformParser s' = case MP.parse (platformP <* MP.eof) "" (T.pack s') of
+  Right r -> pure r
+  Left  e -> Left $ errorBundlePretty e
+ where
+  archP :: MP.Parsec Void Text Architecture
+  archP = MP.try (MP.chunk "x86_64" $> A_64) <|> (MP.chunk "i386" $> A_32)
+  platformP :: MP.Parsec Void Text PlatformRequest
+  platformP = choice'
+    [ (`PlatformRequest` FreeBSD)
+    <$> (archP <* MP.chunk "-")
+    <*> (  MP.chunk "portbld"
+        *> (   MP.try (Just <$> verP (MP.chunk "-freebsd" <* MP.eof))
+           <|> pure Nothing
+           )
+        <* MP.chunk "-freebsd"
+        )
+    , (`PlatformRequest` Darwin)
+    <$> (archP <* MP.chunk "-")
+    <*> (  MP.chunk "apple"
+        *> (   MP.try (Just <$> verP (MP.chunk "-darwin" <* MP.eof))
+           <|> pure Nothing
+           )
+        <* MP.chunk "-darwin"
+        )
+    , (\a d mv -> PlatformRequest a (Linux d) mv)
+    <$> (archP <* MP.chunk "-")
+    <*> distroP
+    <*> ((MP.try (Just <$> verP (MP.chunk "-linux" <* MP.eof)) <|> pure Nothing
+         )
+        <* MP.chunk "-linux"
+        )
+    ]
+  distroP :: MP.Parsec Void Text LinuxDistro
+  distroP = choice'
+    [ MP.chunk "debian" $> Debian
+    , MP.chunk "deb" $> Debian
+    , MP.chunk "ubuntu" $> Ubuntu
+    , MP.chunk "mint" $> Mint
+    , MP.chunk "fedora" $> Fedora
+    , MP.chunk "centos" $> CentOS
+    , MP.chunk "redhat" $> RedHat
+    , MP.chunk "alpine" $> Alpine
+    , MP.chunk "gentoo" $> Gentoo
+    , MP.chunk "exherbo" $> Exherbo
+    , MP.chunk "unknown" $> UnknownLinux
+    ]
+
+
+uriParser :: String -> Either String URI
+uriParser = first show . parseURI strictURIParserOptions . UTF8.fromString
+
+
+absolutePathParser :: FilePath -> Either String FilePath
+absolutePathParser f = case isValid f && isAbsolute f of
+              True -> Right $ normalise f
+              False -> Left "Please enter a valid absolute filepath."
+
+isolateParser :: FilePath -> Either String FilePath
+isolateParser f = case isValid f && isAbsolute f of
+              True -> Right $ normalise f
+              False -> Left "Please enter a valid filepath for isolate dir."
+
+-- this accepts cross prefix
+ghcVersionTagEither :: String -> Either String ToolVersion
+ghcVersionTagEither s' =
+  second ToolTag (tagEither s') <|> second GHCVersion (ghcVersionEither s')
+
+-- this ignores cross prefix
+toolVersionTagEither :: String -> Either String ToolVersion
+toolVersionTagEither s' =
+  second ToolTag (tagEither s') <|> second ToolVersion (toolVersionEither s')
+
+tagEither :: String -> Either String Tag
+tagEither s' = case fmap toLower s' of
+  "recommended" -> Right Recommended
+  "latest"      -> Right Latest
+  ('b':'a':'s':'e':'-':ver') -> case pvp (T.pack ver') of
+                                  Right x -> Right (Base x)
+                                  Left  _ -> Left $ "Invalid PVP version for base " <> ver'
+  other         -> Left $ "Unknown tag " <> other
+
+
+ghcVersionEither :: String -> Either String GHCTargetVersion
+ghcVersionEither =
+  first (const "Not a valid version") . MP.parse ghcTargetVerP "" . T.pack
+
+toolVersionEither :: String -> Either String Version
+toolVersionEither =
+  first (const "Not a valid version") . MP.parse version' "" . T.pack
+
+
+toolParser :: String -> Either String Tool
+toolParser s' | t == T.pack "ghc"   = Right GHC
+              | t == T.pack "cabal" = Right Cabal
+              | t == T.pack "hls"   = Right HLS
+              | t == T.pack "stack" = Right Stack
+              | otherwise           = Left ("Unknown tool: " <> s')
+  where t = T.toLower (T.pack s')
+
+
+criteriaParser :: String -> Either String ListCriteria
+criteriaParser s' | t == T.pack "installed" = Right ListInstalled
+                  | t == T.pack "set"       = Right ListSet
+                  | t == T.pack "available" = Right ListAvailable
+                  | otherwise               = Left ("Unknown criteria: " <> s')
+  where t = T.toLower (T.pack s')
+
+
+
+keepOnParser :: String -> Either String KeepDirs
+keepOnParser s' | t == T.pack "always" = Right Always
+                | t == T.pack "errors" = Right Errors
+                | t == T.pack "never"  = Right Never
+                | otherwise            = Left ("Unknown keep value: " <> s')
+  where t = T.toLower (T.pack s')
+
+
+downloaderParser :: String -> Either String Downloader
+downloaderParser s' | t == T.pack "curl"     = Right Curl
+                    | t == T.pack "wget"     = Right Wget
+#if defined(INTERNAL_DOWNLOADER)
+                    | t == T.pack "internal" = Right Internal
+#endif
+                    | otherwise = Left ("Unknown downloader value: " <> s')
+  where t = T.toLower (T.pack s')
+
+gpgParser :: String -> Either String GPGSetting
+gpgParser s' | t == T.pack "strict" = Right GPGStrict
+             | t == T.pack "lax"    = Right GPGLax
+             | t == T.pack "none"   = Right GPGNone
+             | otherwise = Left ("Unknown gpg setting value: " <> s')
+  where t = T.toLower (T.pack s')
+
+
+
+    ------------------
+    --[ Completers ]--
+    ------------------
+
+
+toolCompleter :: Completer
+toolCompleter = listCompleter ["ghc", "cabal", "hls", "stack"]
+
+gitFileUri :: [String] -> Completer
+gitFileUri add = mkCompleter $ fileUri' (["git://"] <> add)
+
+fileUri :: Completer
+fileUri = mkCompleter $ fileUri' []
+
+fileUri' :: [String] -> String -> IO [String]
+fileUri' add = \case
+  "" -> do
+    pwd <- getCurrentDirectory
+    pure $ ["https://", "http://", "file:///", "file://" <> pwd <> "/"] <> add
+  xs
+   | "file:///" `isPrefixOf` xs -> fmap ("file://" <>) <$>
+      case stripPrefix "file://" xs of
+        Nothing -> pure []
+        Just r ->  do
+          pwd <- getCurrentDirectory
+          dirs  <- compgen "directory" r ["-S", "/"]
+          files <- filter (\f -> (f <> "/") `notElem` dirs) <$> compgen "file" r []
+          pure (dirs <> files <> if r `isPrefixOf` pwd then [pwd <> "/"] else [])
+   | xs `isPrefixOf` "file:///" -> pure ["file:///"]
+   | xs `isPrefixOf` "https://" -> pure ["https://"]
+   | xs `isPrefixOf` "http://"  -> pure ["http://"]
+   | otherwise -> pure []
+ where
+  compgen :: String -> String -> [String] -> IO [String]
+  compgen action' r opts = do
+    let cmd = unwords $ ["compgen", "-A", action'] <> opts <> ["--", requote r]
+    result <- tryIO $ readProcess "bash" ["-c", cmd] ""
+    return . lines . either (const []) id $ result
+
+  -- | Strongly quote the string we pass to compgen.
+  --
+  -- We need to do this so bash doesn't expand out any ~ or other
+  -- chars we want to complete on, or emit an end of line error
+  -- when seeking the close to the quote.
+  -- 
+  -- NOTE: copied from https://hackage.haskell.org/package/optparse-applicative-0.17.0.0/docs/src/Options.Applicative.Builder.Completer.html#requote
+  requote :: String -> String
+  requote s =
+    let
+      -- Bash doesn't appear to allow "mixed" escaping
+      -- in bash completions. So we don't have to really
+      -- worry about people swapping between strong and
+      -- weak quotes.
+      unescaped =
+        case s of
+          -- It's already strongly quoted, so we
+          -- can use it mostly as is, but we must
+          -- ensure it's closed off at the end and
+          -- there's no single quotes in the
+          -- middle which might confuse bash.
+          ('\'': rs) -> unescapeN rs
+
+          -- We're weakly quoted.
+          ('"': rs)  -> unescapeD rs
+
+          -- We're not quoted at all.
+          -- We need to unescape some characters like
+          -- spaces and quotation marks.
+          elsewise   -> unescapeU elsewise
+    in
+      strong unescaped
+
+    where
+      strong ss = '\'' : foldr go "'" ss
+        where
+          -- If there's a single quote inside the
+          -- command: exit from the strong quote and
+          -- emit it the quote escaped, then resume.
+          go '\'' t = "'\\''" ++ t
+          go h t    = h : t
+
+      -- Unescape a strongly quoted string
+      -- We have two recursive functions, as we
+      -- can enter and exit the strong escaping.
+      unescapeN = goX
+        where
+          goX ('\'' : xs) = goN xs
+          goX (x : xs) = x : goX xs
+          goX [] = []
+
+          goN ('\\' : '\'' : xs) = '\'' : goN xs
+          goN ('\'' : xs) = goX xs
+          goN (x : xs) = x : goN xs
+          goN [] = []
+
+      -- Unescape an unquoted string
+      unescapeU = goX
+        where
+          goX [] = []
+          goX ('\\' : x : xs) = x : goX xs
+          goX (x : xs) = x : goX xs
+
+      -- Unescape a weakly quoted string
+      unescapeD = goX
+        where
+          -- Reached an escape character
+          goX ('\\' : x : xs)
+            -- If it's true escapable, strip the
+            -- slashes, as we're going to strong
+            -- escape instead.
+            | x `elem` ("$`\"\\\n" :: String) = x : goX xs
+            | otherwise = '\\' : x : goX xs
+          -- We've ended quoted section, so we
+          -- don't recurse on goX, it's done.
+          goX ('"' : xs)
+            = xs
+          -- Not done, but not a special character
+          -- just continue the fold.
+          goX (x : xs)
+            = x : goX xs
+          goX []
+            = []
+
+
+tagCompleter :: Tool -> [String] -> Completer
+tagCompleter tool add = listIOCompleter $ do
+  dirs' <- liftIO getAllDirs
+  let loggerConfig = LoggerConfig
+        { lcPrintDebug   = False
+        , consoleOutter  = mempty
+        , fileOutter     = mempty
+        , fancyColors    = False
+        }
+  let appState = LeanAppState
+        (defaultSettings { noNetwork = True })
+        dirs'
+        defaultKeyBindings
+        loggerConfig
+
+  mGhcUpInfo <- flip runReaderT appState . runE $ getDownloadsF
+  case mGhcUpInfo of
+    VRight ghcupInfo -> do
+      let allTags = filter (/= Old)
+            $ _viTags =<< M.elems (availableToolVersions (_ghcupDownloads ghcupInfo) tool)
+      pure $ nub $ (add ++) $ fmap tagToString allTags
+    VLeft _ -> pure  (nub $ ["recommended", "latest"] ++ add)
+
+versionCompleter :: Maybe ListCriteria -> Tool -> Completer
+versionCompleter criteria tool = versionCompleter' criteria tool (const True)
+
+versionCompleter' :: Maybe ListCriteria -> Tool -> (Version -> Bool) -> Completer
+versionCompleter' criteria tool filter' = listIOCompleter $ do
+  dirs' <- liftIO getAllDirs
+  let loggerConfig = LoggerConfig
+        { lcPrintDebug   = False
+        , consoleOutter  = mempty
+        , fileOutter     = mempty
+        , fancyColors    = False
+        }
+  let settings = defaultSettings { noNetwork = True }
+  let leanAppState = LeanAppState
+                   settings
+                   dirs'
+                   defaultKeyBindings
+                   loggerConfig
+  mpFreq <- flip runReaderT leanAppState . runE $ platformRequest
+  mGhcUpInfo <- flip runReaderT leanAppState . runE $ getDownloadsF
+  forFold mpFreq $ \pfreq -> do
+    forFold mGhcUpInfo $ \ghcupInfo -> do
+      let appState = AppState
+            settings
+            dirs'
+            defaultKeyBindings
+            ghcupInfo
+            pfreq
+            loggerConfig
+
+          runEnv = flip runReaderT appState
+
+      installedVersions <- runEnv $ listVersions (Just tool) criteria
+      return $ fmap (T.unpack . prettyVer) . filter filter' . fmap lVer $ installedVersions
+
+
+toolDlCompleter :: Tool -> Completer
+toolDlCompleter tool = mkCompleter $ \case
+  "" -> pure (initUrl tool <> ["https://", "http://", "file:///"])
+  word
+    | "file://" `isPrefixOf` word -> fileUri' [] word
+    -- downloads.haskell.org
+    | "https://downloads.haskell.org/" `isPrefixOf` word ->
+        fmap (completePrefix word) . prefixMatch (FP.takeFileName word) <$> fromHRef word
+
+    -- github releases
+    | "https://github.com/haskell/haskell-language-server/releases/download/" `isPrefixOf` word
+    , let xs = splitPath word
+    , (length xs == 6 && last word == '/') || (length xs == 7 && last word /= '/') ->
+        fmap (\x -> completePrefix word x <> "/") . prefixMatch (FP.takeFileName word) <$> getGithubReleases "haskell" "haskell-language-server"
+    | "https://github.com/commercialhaskell/stack/releases/download/" == word
+    , let xs = splitPath word
+    , (length xs == 6 && last word == '/') || (length xs == 7 && last word /= '/') ->
+        fmap (\x -> completePrefix word x <> "/") . prefixMatch (FP.takeFileName word) <$> getGithubReleases "commercialhaskell" "stack"
+
+    -- github release assets
+    | "https://github.com/haskell/haskell-language-server/releases/download/" `isPrefixOf` word
+    , let xs = splitPath word
+    , (length xs == 7 && last word == '/') || length xs == 8
+    , let rel = xs !! 6
+    , length rel > 1 -> do
+        fmap (completePrefix word) . prefixMatch (FP.takeFileName word) <$> getGithubAssets "haskell" "haskell-language-server" (init rel)
+    | "https://github.com/commercialhaskell/stack/releases/download/" `isPrefixOf` word
+    , let xs = splitPath word
+    , (length xs == 7 && last word == '/') || length xs == 8
+    , let rel = xs !! 6
+    , length rel > 1 -> do
+        fmap (completePrefix word) . prefixMatch (FP.takeFileName word) <$> getGithubAssets "commercialhaskell" "stack" (init rel)
+
+    -- github
+    | "https://github.com/c" `isPrefixOf` word -> pure ["https://github.com/commercialhaskell/stack/releases/download/"]
+    | "https://github.com/h" `isPrefixOf` word -> pure ["https://github.com/haskell/haskell-language-server/releases/download/"]
+    | "https://g" `isPrefixOf` word
+    , tool == Stack -> pure ["https://github.com/commercialhaskell/stack/releases/download/"]
+    | "https://g" `isPrefixOf` word
+    , tool == HLS -> pure ["https://github.com/haskell/haskell-language-server/releases/download/"]
+
+    | "https://d" `isPrefixOf` word -> pure $ filter ("https://downloads.haskell.org/" `isPrefixOf`) $ initUrl tool
+
+    | "h" `isPrefixOf` word -> pure $ initUrl tool
+
+    | word `isPrefixOf` "file:///" -> pure ["file:///"]
+    | word `isPrefixOf` "https://" -> pure ["https://"]
+    | word `isPrefixOf` "http://"  -> pure ["http://"]
+
+    | otherwise -> pure []
+ where
+  initUrl :: Tool -> [String]
+  initUrl GHC   = [ "https://downloads.haskell.org/~ghc/"
+                  , "https://downloads.haskell.org/~ghcup/unofficial-bindists/ghc/"
+                  ]
+  initUrl Cabal = [ "https://downloads.haskell.org/~cabal/"
+                  , "https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal/"
+                  ]
+  initUrl GHCup = [ "https://downloads.haskell.org/~ghcup/" ]
+  initUrl HLS   = [ "https://github.com/haskell/haskell-language-server/releases/download/"
+                  , "https://downloads.haskell.org/~ghcup/unofficial-bindists/haskell-language-server/"
+                  ]
+  initUrl Stack = [ "https://github.com/commercialhaskell/stack/releases/download/"
+                  , "https://downloads.haskell.org/~ghcup/unofficial-bindists/stack/"
+                  ]
+
+  completePrefix :: String -- ^ url, e.g.    'https://github.com/haskell/haskell-languag'
+                 -> String -- ^ match, e.g.  'haskell-language-server'
+                 -> String -- ^ result, e.g. 'https://github.com/haskell/haskell-language-server'
+  completePrefix url match =
+    let base = FP.takeDirectory url
+        fn   = FP.takeFileName url
+    in if fn `isPrefixOf` match then base <> "/" <> match else url
+
+  prefixMatch :: String -> [String] -> [String]
+  prefixMatch pref = filter (pref `isPrefixOf`)
+
+  fromHRef :: String -> IO [String]
+  fromHRef url = withCurl (FP.takeDirectory url) 2_000_000 $ \stdout ->
+      pure
+        . fmap (T.unpack . decUTF8Safe' . fromAttrib "href")
+        . filter isTagOpen
+        . filter (~== ("<a href>" :: String))
+        . parseTags
+        $ stdout
+
+  withCurl :: String                      -- ^ url
+           -> Int                         -- ^ delay
+           -> (ByteString -> IO [String]) -- ^ callback
+           -> IO [String]
+  withCurl url delay cb = do
+    let limit = threadDelay delay
+    race limit (executeOut "curl" ["-fL", url] Nothing) >>= \case
+      Right (CapturedProcess {_exitCode, _stdOut}) -> do
+        case _exitCode of
+          ExitSuccess ->
+            (try @_ @SomeException . cb $ _stdOut) >>= \case
+              Left _ ->  pure []
+              Right r' -> do
+                r <- try @_ @SomeException
+                  . evaluate
+                  . force
+                  $ r'
+                either (\_ -> pure []) pure r
+          ExitFailure _ -> pure []
+      Left _ -> pure []
+
+  getGithubReleases :: String
+                    -> String
+                    -> IO [String]
+  getGithubReleases owner repo = withCurl url 3_000_000 $ \stdout -> do
+    Just xs <- pure $ decode' @Array stdout
+    fmap V.toList $ forM xs $ \x -> do
+      (Object r) <- pure x
+      Just (String name) <- pure $ KM.lookup (mkval "tag_name") r
+      pure $ T.unpack name
+   where
+    url = "https://api.github.com/repos/" <> owner <> "/" <> repo <> "/releases"
+
+  getGithubAssets :: String
+                  -> String
+                  -> String
+                  -> IO [String]
+  getGithubAssets owner repo tag = withCurl url 3_000_000 $ \stdout -> do
+    Just xs <- pure $ decode' @Object stdout
+    Just (Array assets) <- pure $ KM.lookup (mkval "assets") xs
+    as <- fmap V.toList $ forM assets $ \val -> do
+      (Object asset) <- pure val
+      Just (String name) <- pure $ KM.lookup (mkval "name") asset
+      pure $ T.unpack name
+    pure as
+   where
+    url = "https://api.github.com/repos/" <> owner <> "/" <> repo <> "/releases/tags/" <> tag
+
+
+#if MIN_VERSION_aeson(2,0,0)
+  mkval = KM.fromString
+#else
+  mkval = id
+#endif
+
+
+
+
+
+
+    -----------------
+    --[ Utilities ]--
+    -----------------
+
+
+fromVersion :: ( HasLog env
+               , MonadFail m
+               , MonadReader env m
+               , HasGHCupInfo env
+               , HasDirs env
+               , MonadThrow m
+               , MonadIO m
+               , MonadCatch m
+               )
+            => Maybe ToolVersion
+            -> Tool
+            -> Excepts
+                 '[ TagNotFound
+                  , NextVerNotFound
+                  , NoToolVersionSet
+                  ] m (GHCTargetVersion, Maybe VersionInfo)
+fromVersion tv = fromVersion' (toSetToolVer tv)
+
+fromVersion' :: ( HasLog env
+                , MonadFail m
+                , MonadReader env m
+                , HasGHCupInfo env
+                , HasDirs env
+                , MonadThrow m
+                , MonadIO m
+                , MonadCatch m
+                )
+             => SetToolVersion
+             -> Tool
+             -> Excepts
+                  '[ TagNotFound
+                   , NextVerNotFound
+                   , NoToolVersionSet
+                   ] m (GHCTargetVersion, Maybe VersionInfo)
+fromVersion' SetRecommended tool = do
+  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  bimap mkTVer Just <$> getRecommended dls tool
+    ?? TagNotFound Recommended tool
+fromVersion' (SetGHCVersion v) tool = do
+  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  let vi = getVersionInfo (_tvVersion v) tool dls
+  case pvp $ prettyVer (_tvVersion v) of -- need to be strict here
+    Left _ -> pure (v, vi)
+    Right pvpIn ->
+      lift (getLatestToolFor tool pvpIn dls) >>= \case
+        Just (pvp_, vi') -> do
+          v' <- lift $ pvpToVersion pvp_ ""
+          when (v' /= _tvVersion v) $ lift $ logWarn ("Assuming you meant version " <> prettyVer v')
+          pure (GHCTargetVersion (_tvTarget v) v', Just vi')
+        Nothing -> pure (v, vi)
+fromVersion' (SetToolVersion v) tool = do
+  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  let vi = getVersionInfo v tool dls
+  case pvp $ prettyVer v of -- need to be strict here
+    Left _ -> pure (mkTVer v, vi)
+    Right pvpIn ->
+      lift (getLatestToolFor tool pvpIn dls) >>= \case
+        Just (pvp_, vi') -> do
+          v' <- lift $ pvpToVersion pvp_ ""
+          when (v' /= v) $ lift $ logWarn ("Assuming you meant version " <> prettyVer v')
+          pure (GHCTargetVersion mempty v', Just vi')
+        Nothing -> pure (mkTVer v, vi)
+fromVersion' (SetToolTag Latest) tool = do
+  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  bimap mkTVer Just <$> getLatest dls tool ?? TagNotFound Latest tool
+fromVersion' (SetToolTag Recommended) tool = do
+  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  bimap mkTVer Just <$> getRecommended dls tool ?? TagNotFound Recommended tool
+fromVersion' (SetToolTag (Base pvp'')) GHC = do
+  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  bimap mkTVer Just <$> getLatestBaseVersion dls pvp'' ?? TagNotFound (Base pvp'') GHC
+fromVersion' SetNext tool = do
+  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  next <- case tool of
+    GHC -> do
+      set <- fmap _tvVersion $ ghcSet Nothing !? NoToolVersionSet tool
+      ghcs <- rights <$> lift getInstalledGHCs
+      (headMay
+        . tail
+        . dropWhile (\GHCTargetVersion {..} -> _tvVersion /= set)
+        . cycle
+        . sortBy (\x y -> compare (_tvVersion x) (_tvVersion y))
+        . filter (\GHCTargetVersion {..} -> isNothing _tvTarget)
+        $ ghcs) ?? NoToolVersionSet tool
+    Cabal -> do
+      set <- cabalSet !? NoToolVersionSet tool
+      cabals <- rights <$> lift getInstalledCabals
+      (fmap (GHCTargetVersion Nothing)
+        . headMay
+        . tail
+        . dropWhile (/= set)
+        . cycle
+        . sort
+        $ cabals) ?? NoToolVersionSet tool
+    HLS -> do
+      set <- hlsSet !? NoToolVersionSet tool
+      hlses <- rights <$> lift getInstalledHLSs
+      (fmap (GHCTargetVersion Nothing)
+        . headMay
+        . tail
+        . dropWhile (/= set)
+        . cycle
+        . sort
+        $ hlses) ?? NoToolVersionSet tool
+    Stack -> do
+      set <- stackSet !? NoToolVersionSet tool
+      stacks <- rights <$> lift getInstalledStacks
+      (fmap (GHCTargetVersion Nothing)
+        . headMay
+        . tail
+        . dropWhile (/= set)
+        . cycle
+        . sort
+        $ stacks) ?? NoToolVersionSet tool
+    GHCup -> fail "GHCup cannot be set"
+  let vi = getVersionInfo (_tvVersion next) tool dls
+  pure (next, vi)
+fromVersion' (SetToolTag t') tool =
+  throwE $ TagNotFound t' tool
+
+
+checkForUpdates :: ( MonadReader env m
+                   , HasGHCupInfo env
+                   , HasDirs env
+                   , HasPlatformReq env
+                   , MonadCatch m
+                   , HasLog env
+                   , MonadThrow m
+                   , MonadIO m
+                   , MonadFail m
+                   )
+                => m [(Tool, Version)]
+checkForUpdates = do
+  GHCupInfo { _ghcupDownloads = dls } <- getGHCupInfo
+  lInstalled <- listVersions Nothing (Just ListInstalled)
+  let latestInstalled tool = (fmap lVer . lastMay . filter (\lr -> lTool lr == tool)) lInstalled
+
+  ghcup <- forMM (getLatest dls GHCup) $ \(l, _) -> do
+    (Right ghcup_ver) <- pure $ version $ prettyPVP ghcUpVer
+    if (l > ghcup_ver) then pure $ Just (GHCup, l) else pure Nothing
+
+  otherTools <- forM [GHC, Cabal, HLS, Stack] $ \t ->
+    forMM (getLatest dls t) $ \(l, _) -> do
+      let mver = latestInstalled t
+      forMM mver $ \ver ->
+        if (l > ver) then pure $ Just (t, l) else pure Nothing
+
+  pure $ catMaybes (ghcup:otherTools)
+ where
+  forMM a f = fmap join $ forM a f
+
+
+logGHCPostRm :: (MonadReader env m, HasLog env, MonadIO m) => GHCTargetVersion -> m ()
+logGHCPostRm ghcVer = do
+  cabalStore <- liftIO $ handleIO (\_ -> if isWindows then pure "C:\\cabal\\store" else pure "~/.cabal/store")
+    (runIdentity . CC.cfgStoreDir <$> CC.readConfig)
+  let storeGhcDir = cabalStore </> ("ghc-" <> T.unpack (prettyVer $ _tvVersion ghcVer))
+  logInfo $ T.pack $ "After removing GHC you might also want to clean up your cabal store at: " <> storeGhcDir
+

app/ghcup/GHCup/OptParse/Compile.hs

@@ -0,0 +1,618 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE RankNTypes #-}
+
+module GHCup.OptParse.Compile where
+
+
+import           GHCup
+import qualified GHCup.GHC as GHC
+import qualified GHCup.HLS as HLS
+import           GHCup.Errors
+import           GHCup.Types
+import           GHCup.Types.Optics
+import           GHCup.Utils
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.String.QQ
+import           GHCup.OptParse.Common
+
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Codec.Archive                  ( ArchiveResult )
+import           Control.Concurrent (threadDelay)
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Data.Bifunctor
+import           Data.Functor
+import           Data.Maybe
+import           Data.Versions                  ( Version, prettyVer, version, pvp )
+import qualified Data.Versions as V
+import           Data.Text                      ( Text )
+import           Haskus.Utils.Variant.Excepts
+import           Options.Applicative     hiding ( style )
+import           Options.Applicative.Help.Pretty ( text )
+import           Prelude                 hiding ( appendFile )
+import           System.Exit
+
+import           URI.ByteString          hiding ( uriParser )
+import qualified Data.Text                     as T
+import Control.Exception.Safe (MonadMask, displayException)
+import System.FilePath (isPathSeparator)
+import Text.Read (readEither)
+
+
+
+
+    ----------------
+    --[ Commands ]--
+    ----------------
+
+
+data CompileCommand = CompileGHC GHCCompileOptions
+                    | CompileHLS HLSCompileOptions
+
+
+
+    ---------------
+    --[ Options ]--
+    ---------------
+
+
+data GHCCompileOptions = GHCCompileOptions
+  { targetGhc    :: GHC.GHCVer Version
+  , bootstrapGhc :: Either Version FilePath
+  , jobs         :: Maybe Int
+  , buildConfig  :: Maybe FilePath
+  , patches      :: Maybe (Either FilePath [URI])
+  , crossTarget  :: Maybe Text
+  , addConfArgs  :: [Text]
+  , setCompile   :: Bool
+  , ovewrwiteVer :: Maybe Version
+  , buildFlavour :: Maybe String
+  , hadrian      :: Bool
+  , isolateDir   :: Maybe FilePath
+  }
+
+
+data HLSCompileOptions = HLSCompileOptions
+  { targetHLS    :: HLS.HLSVer
+  , jobs         :: Maybe Int
+  , setCompile   :: Bool
+  , updateCabal  :: Bool
+  , ovewrwiteVer :: Either Bool Version
+  , isolateDir   :: Maybe FilePath
+  , cabalProject :: Maybe (Either FilePath URI)
+  , cabalProjectLocal :: Maybe URI
+  , patches      :: Maybe (Either FilePath [URI])
+  , targetGHCs   :: [ToolVersion]
+  , cabalArgs    :: [Text]
+  }
+
+
+
+
+    ---------------
+    --[ Parsers ]--
+    ---------------
+
+
+compileP :: Parser CompileCommand
+compileP = subparser
+  (  command
+      "ghc"
+      (   CompileGHC
+      <$> info
+            (ghcCompileOpts <**> helper)
+            (  progDesc "Compile GHC from source"
+            <> footerDoc (Just $ text compileFooter)
+            )
+      )
+  <>  command
+      "hls"
+      (   CompileHLS
+      <$> info
+            (hlsCompileOpts <**> helper)
+            (  progDesc "Compile HLS from source"
+            <> footerDoc (Just $ text compileHLSFooter)
+            )
+      )
+  )
+ where
+  compileFooter = [s|Discussion:
+  Compiles and installs the specified GHC version into
+  a self-contained "~/.ghcup/ghc/<ghcver>" directory
+  and symlinks the ghc binaries to "~/.ghcup/bin/<binary>-<ghcver>".
+
+  This also allows building a cross-compiler. Consult the documentation
+  first: <https://gitlab.haskell.org/ghc/ghc/-/wikis/building/cross-compiling#configuring-the-build>
+
+ENV variables:
+  Various toolchain variables will be passed onto the ghc build system,
+  such as: CC, LD, OBJDUMP, NM, AR, RANLIB.
+
+Examples:
+  # compile from known version
+  ghcup compile ghc -j 4 -v 8.4.2 -b 8.2.2
+  # compile from git commit/reference
+  ghcup compile ghc -j 4 -g master -b 8.2.2
+  # specify path to bootstrap ghc
+  ghcup compile ghc -j 4 -v 8.4.2 -b /usr/bin/ghc-8.2.2
+  # build cross compiler
+  ghcup compile ghc -j 4 -v 8.4.2 -b 8.2.2 -x armv7-unknown-linux-gnueabihf --config $(pwd)/build.mk -- --enable-unregisterised|]
+
+  compileHLSFooter = [s|Discussion:
+  Compiles and installs the specified HLS version.
+  The --ghc arguments are necessary to specify which GHC version to build for/against.
+  These need to be available in PATH prior to compilation.
+
+Examples:
+  # compile 1.7.0.0 from hackage for 8.10.7, running 'cabal update' before the build
+  ghcup compile hls --version 1.7.0.0 --ghc 8.10.7 --cabal-update
+  # compile from master for ghc 9.2.3 using 'git describe' to name the binary and ignore the pinned index state
+  ghcup compile hls -g master --git-describe-version --ghc 9.2.3 -- --index-state=@(date '+%s')
+  # compile a specific commit for ghc 9.2.3 and set a specifc version for the binary name
+  ghcup compile hls -g a32db0b -o 1.7.0.0-p1 --ghc 9.2.3|]
+
+
+ghcCompileOpts :: Parser GHCCompileOptions
+ghcCompileOpts =
+  GHCCompileOptions
+    <$> ((GHC.SourceDist <$> option
+          (eitherReader
+            (first (const "Not a valid version") . version . T.pack)
+          )
+          (short 'v' <> long "version" <> metavar "VERSION" <> help
+            "The tool version to compile"
+            <> (completer $ versionCompleter Nothing GHC)
+          )
+          ) <|>
+          (GHC.GitDist <$> (GitBranch <$> option
+          str
+          (short 'g' <> long "git-ref" <> metavar "GIT_REFERENCE" <> help
+            "The git commit/branch/ref to build from"
+          ) <*>
+          optional (option str (
+            short 'r' <> long "repository" <> metavar "GIT_REPOSITORY" <> help "The git repository to build from (defaults to GHC upstream)"
+            <> completer (gitFileUri ["https://gitlab.haskell.org/ghc/ghc.git"])
+            ))
+          ))
+          <|>
+          (
+           GHC.RemoteDist <$> (option
+            (eitherReader uriParser)
+            (long "remote-source-dist" <> metavar "URI" <> help
+              "URI (https/http/file) to a GHC source distribution"
+              <> completer fileUri
+            )
+          )
+          )
+          )
+    <*> option
+          (eitherReader
+            (\x ->
+              (bimap (const "Not a valid version") Left . version . T.pack $ x) <|> (if isPathSeparator (head x) then pure $ Right x else Left "Not an absolute Path")
+            )
+          )
+          (  short 'b'
+          <> long "bootstrap-ghc"
+          <> metavar "BOOTSTRAP_GHC"
+          <> help
+               "The GHC version (or full path) to bootstrap with (must be installed)"
+          <> (completer $ versionCompleter Nothing GHC)
+          )
+    <*> optional
+          (option
+            (eitherReader (readEither @Int))
+            (short 'j' <> long "jobs" <> metavar "JOBS" <> help
+              "How many jobs to use for make"
+              <> (completer $ listCompleter $ fmap show ([1..12] :: [Int]))
+            )
+          )
+    <*> optional
+          (option
+            str
+            (short 'c' <> long "config" <> metavar "CONFIG" <> help
+              "Absolute path to build config file"
+             <> completer (bashCompleter "file")
+            )
+          )
+    <*> (optional
+          (
+            (fmap Right $ many $ option
+              (eitherReader uriParser)
+              (long "patch" <> metavar "PATCH_URI" <> help
+                "URI to a patch (https/http/file)"
+               <> completer fileUri
+              )
+            )
+            <|>
+            (fmap Left $ option
+              str
+              (short 'p' <> long "patchdir" <> metavar "PATCH_DIR" <> help
+                "Absolute path to patch directory (applies all .patch and .diff files in order using -p1. This order is determined by a quilt series file if it exists, or the patches are lexicographically ordered)"
+               <> completer (bashCompleter "directory")
+              )
+            )
+          )
+        )
+    <*> optional
+          (option
+            str
+            (short 'x' <> long "cross-target" <> metavar "CROSS_TARGET" <> help
+              "Build cross-compiler for this platform"
+            )
+          )
+    <*> many (argument str (metavar "CONFIGURE_ARGS" <> help "Additional arguments to compile configure, prefix with '-- ' (longopts)"))
+    <*> fmap (fromMaybe False) (invertableSwitch "set" Nothing False (help "Set as active version after install"))
+    <*> optional
+          (option
+            (eitherReader
+              (first (const "Not a valid version") . version . T.pack)
+            )
+            (short 'o' <> long "overwrite-version" <> metavar "OVERWRITE_VERSION" <> help
+              "Allows to overwrite the finally installed VERSION with a different one, e.g. when you build 8.10.4 with your own patches, you might want to set this to '8.10.4-p1'"
+            <> (completer $ versionCompleter Nothing GHC)
+            )
+          )
+    <*> optional
+          (option
+            str
+            (short 'f' <> long "flavour" <> metavar "BUILD_FLAVOUR" <> help
+              "Set the compile build flavour (this value depends on the build system type: 'make' vs 'hadrian')"
+            )
+          )
+    <*> switch
+          (long "hadrian" <> help "Use the hadrian build system instead of make (only git versions seem to be properly supported atm)"
+          )
+    <*> optional
+          (option
+            (eitherReader isolateParser)
+            (  short 'i'
+            <> long "isolate"
+            <> metavar "DIR"
+            <> help "install in an isolated directory instead of the default one, no symlinks to this installation will be made"
+            <> completer (bashCompleter "directory")
+            )
+           )
+
+hlsCompileOpts :: Parser HLSCompileOptions
+hlsCompileOpts =
+  HLSCompileOptions
+    <$> ((HLS.HackageDist <$> option
+          (eitherReader
+            ((>>= first displayException . V.version . V.prettyPVP) . first (const "Not a valid PVP version") . pvp . T.pack)
+          )
+          (short 'v' <> long "version" <> metavar "VERSION" <> help
+            "The version to compile (pulled from hackage)"
+            <> (completer $ versionCompleter' Nothing HLS (either (const False) (const True) . V.pvp . V.prettyVer))
+          )
+          )
+          <|>
+          (HLS.GitDist <$> (GitBranch <$> option
+          str
+          (short 'g' <> long "git-ref" <> metavar "GIT_REFERENCE" <> help
+            "The git commit/branch/ref to build from (accepts anything 'git checkout' accepts)"
+          ) <*>
+          optional (option str (short 'r' <> long "repository" <> metavar "GIT_REPOSITORY" <> help "The git repository to build from (defaults to HLS upstream)"
+            <> completer (gitFileUri ["https://github.com/haskell/haskell-language-server.git"])
+          ))
+          ))
+          <|>
+          (HLS.SourceDist <$> (option
+            (eitherReader
+              (first (const "Not a valid version") . version . T.pack)
+            )
+          (long "source-dist" <> metavar "VERSION" <> help
+            "The version to compile (pulled from packaged git sources)"
+            <> (completer $ versionCompleter Nothing HLS)
+          )
+          ))
+          <|>
+          (
+           HLS.RemoteDist <$> (option
+            (eitherReader uriParser)
+            (long "remote-source-dist" <> metavar "URI" <> help
+              "URI (https/http/file) to a HLS source distribution"
+              <> completer fileUri
+            )
+          )
+          )
+          )
+    <*> optional
+          (option
+            (eitherReader (readEither @Int))
+            (short 'j' <> long "jobs" <> metavar "JOBS" <> help
+              "How many jobs to use for make"
+              <> (completer $ listCompleter $ fmap show ([1..12] :: [Int]))
+            )
+          )
+    <*> fmap (fromMaybe True) (invertableSwitch "set" Nothing True (help "Don't set as active version after install"))
+    <*> switch (long "cabal-update" <> help "Run 'cabal update' before the build")
+    <*>
+         (
+          (Right <$> option
+            (eitherReader
+              (first (const "Not a valid version") . version . T.pack)
+            )
+            (short 'o' <> long "overwrite-version" <> metavar "OVERWRITE_VERSION" <> help
+              "Allows to overwrite the finally installed VERSION with a different one, e.g. when you build 8.10.4 with your own patches, you might want to set this to '8.10.4-p1'"
+            <> (completer $ versionCompleter Nothing HLS)
+            )
+          )
+          <|>
+          (Left <$> (switch
+                      (long "git-describe-version"
+                         <> help "Use the output of 'git describe' (if building from git) as the VERSION component of the installed binary."
+                      )
+                    )
+          )
+          )
+    <*> optional
+          (option
+            (eitherReader isolateParser)
+            (  short 'i'
+            <> long "isolate"
+            <> metavar "DIR"
+            <> help "install in an isolated directory instead of the default one, no symlinks to this installation will be made"
+            <> completer (bashCompleter "directory")
+            )
+           )
+    <*> optional
+          (option
+            ((fmap Right $ eitherReader uriParser) <|> (fmap Left str))
+            (long "cabal-project" <> metavar "CABAL_PROJECT" <> help
+              "If relative filepath, specifies the path to cabal.project inside the unpacked HLS tarball/checkout. Otherwise expects a full URI with https/http/file scheme."
+              <> completer fileUri
+            )
+          )
+    <*> optional
+          (option
+            (eitherReader uriParser)
+            (long "cabal-project-local" <> metavar "CABAL_PROJECT_LOCAL" <> help
+              "URI (https/http/file) to a cabal.project.local to be used for the build. Will be copied over."
+              <> completer fileUri
+            )
+          )
+    <*> (optional
+          (
+            (fmap Right $ many $ option
+              (eitherReader uriParser)
+              (long "patch" <> metavar "PATCH_URI" <> help
+                "URI to a patch (https/http/file)"
+              <> completer fileUri
+              )
+            )
+            <|>
+            (fmap Left $ option
+              str
+              (short 'p' <> long "patchdir" <> metavar "PATCH_DIR" <> help
+                "Absolute path to patch directory (applies all .patch and .diff files in order using -p1)"
+              <> completer (bashCompleter "directory")
+              )
+            )
+          )
+        )
+    <*> some (
+          option (eitherReader ghcVersionTagEither)
+            (  long "ghc" <> metavar "GHC_VERSION|TAG" <> help "For which GHC version to compile for (can be specified multiple times)"
+            <> completer (tagCompleter GHC [])
+            <> completer (versionCompleter Nothing GHC))
+        )
+    <*> many (argument str (metavar "CABAL_ARGS" <> help "Additional arguments to cabal install, prefix with '-- ' (longopts)"))
+
+
+
+
+
+    ---------------------------
+    --[ Effect interpreters ]--
+    ---------------------------
+
+
+type GHCEffects = '[ AlreadyInstalled
+                  , BuildFailed
+                  , DigestError
+                  , ContentLengthError
+                  , GPGError
+                  , DownloadFailed
+                  , GHCupSetError
+                  , NoDownload
+                  , NotFoundInPATH
+                  , PatchFailed
+                  , UnknownArchive
+                  , TarDirDoesNotExist
+                  , NotInstalled
+                  , DirNotEmpty
+                  , ArchiveResult
+                  , FileDoesNotExistError
+                  , HadrianNotFound
+                  , InvalidBuildConfig
+                  , ProcessError
+                  , CopyError
+                  , BuildFailed
+                  , UninstallFailed
+                  , MergeFileTreeError
+                  ]
+type HLSEffects = '[ AlreadyInstalled
+                  , BuildFailed
+                  , DigestError
+                  , ContentLengthError
+                  , GPGError
+                  , DownloadFailed
+                  , GHCupSetError
+                  , NoDownload
+                  , NotFoundInPATH
+                  , PatchFailed
+                  , UnknownArchive
+                  , TarDirDoesNotExist
+                  , TagNotFound
+                  , NextVerNotFound
+                  , NoToolVersionSet
+                  , NotInstalled
+                  , DirNotEmpty
+                  , ArchiveResult
+                  , UninstallFailed
+                  , MergeFileTreeError
+                  ]
+
+
+
+runCompileGHC :: (MonadUnliftIO m, MonadIO m)
+              => (ReaderT AppState m (VEither GHCEffects a) -> m (VEither GHCEffects a))
+              -> Excepts GHCEffects (ResourceT (ReaderT AppState m)) a
+              -> m (VEither GHCEffects a)
+runCompileGHC runAppState =
+        runAppState
+        . runResourceT
+        . runE
+          @GHCEffects
+
+runCompileHLS :: (MonadUnliftIO m, MonadIO m)
+              => (ReaderT AppState m (VEither HLSEffects a) -> m (VEither HLSEffects a))
+              -> Excepts HLSEffects (ResourceT (ReaderT AppState m)) a
+              -> m (VEither HLSEffects a)
+runCompileHLS runAppState =
+        runAppState
+        . runResourceT
+        . runE
+          @HLSEffects
+
+
+
+    ------------------
+    --[ Entrypoint ]--
+    ------------------
+
+
+
+compile :: ( Monad m
+           , MonadMask m
+           , MonadUnliftIO m
+           , MonadFail m
+           )
+      => CompileCommand
+      -> Settings
+      -> Dirs
+      -> (forall eff a . ReaderT AppState m (VEither eff a) -> m (VEither eff a))
+      -> (ReaderT LeanAppState m () -> m ())
+      -> m ExitCode
+compile compileCommand settings Dirs{..} runAppState runLogger = do
+  case compileCommand of
+    (CompileHLS HLSCompileOptions { .. }) -> do
+      runCompileHLS runAppState (do
+        case targetHLS of
+          HLS.SourceDist targetVer -> do
+            GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+            let vi = getVersionInfo targetVer HLS dls
+            forM_ (_viPreCompile =<< vi) $ \msg -> do
+              lift $ logInfo msg
+              lift $ logInfo
+                "...waiting for 5 seconds, you can still abort..."
+              liftIO $ threadDelay 5000000 -- for compilation, give the user a sec to intervene
+          _ -> pure ()
+        ghcs <- liftE $ forM targetGHCs (\ghc -> fmap (_tvVersion . fst) . fromVersion (Just ghc) $ GHC)
+        targetVer <- liftE $ compileHLS
+                    targetHLS
+                    ghcs
+                    jobs
+                    ovewrwiteVer
+                    (maybe GHCupInternal IsolateDir isolateDir)
+                    cabalProject
+                    cabalProjectLocal
+                    updateCabal
+                    patches
+                    cabalArgs
+        GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+        let vi = getVersionInfo targetVer HLS dls
+        when setCompile $ void $ liftE $
+          setHLS targetVer SetHLSOnly Nothing
+        pure (vi, targetVer)
+        )
+        >>= \case
+              VRight (vi, tv) -> do
+                runLogger $ logInfo
+                  "HLS successfully compiled and installed"
+                forM_ (_viPostInstall =<< vi) $ \msg ->
+                  runLogger $ logInfo msg
+                liftIO $ putStr (T.unpack $ prettyVer tv)
+                pure ExitSuccess
+              VLeft err@(V (BuildFailed tmpdir _)) -> do
+                case keepDirs settings of
+                  Never -> runLogger $ logError $ T.pack $ prettyHFError err
+                  _ -> runLogger (logError $ T.pack (prettyHFError err) <> "\n" <>
+                        "Check the logs at " <> T.pack (fromGHCupPath logsDir) <> " and the build directory "
+                        <> T.pack tmpdir <> " for more clues." <> "\n" <>
+                        "Make sure to clean up " <> T.pack tmpdir <> " afterwards.")
+                pure $ ExitFailure 9
+              VLeft e -> do
+                runLogger $ logError $ T.pack $ prettyHFError e
+                pure $ ExitFailure 9
+    (CompileGHC GHCCompileOptions { hadrian = True, crossTarget = Just _ }) -> do
+      runLogger $ logError "Hadrian cross compile support is not yet implemented!"
+      pure $ ExitFailure 9
+    (CompileGHC GHCCompileOptions {..}) ->
+      runCompileGHC runAppState (do
+        case targetGhc of
+          GHC.SourceDist targetVer -> do
+            GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+            let vi = getVersionInfo targetVer GHC dls
+            forM_ (_viPreCompile =<< vi) $ \msg -> do
+              lift $ logInfo msg
+              lift $ logInfo
+                "...waiting for 5 seconds, you can still abort..."
+              liftIO $ threadDelay 5000000 -- for compilation, give the user a sec to intervene
+          _ -> pure ()
+        targetVer <- liftE $ compileGHC
+                    ((\case
+                        GHC.SourceDist v -> GHC.SourceDist $ GHCTargetVersion crossTarget v
+                        GHC.GitDist g -> GHC.GitDist g
+                        GHC.RemoteDist r -> GHC.RemoteDist r) targetGhc)
+                    ovewrwiteVer
+                    bootstrapGhc
+                    jobs
+                    buildConfig
+                    patches
+                    addConfArgs
+                    buildFlavour
+                    hadrian
+                    (maybe GHCupInternal IsolateDir isolateDir)
+        GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+        let vi = getVersionInfo (_tvVersion targetVer) GHC dls
+        when setCompile $ void $ liftE $
+          setGHC targetVer SetGHCOnly Nothing
+        pure (vi, targetVer)
+        )
+        >>= \case
+              VRight (vi, tv) -> do
+                runLogger $ logInfo
+                  "GHC successfully compiled and installed"
+                forM_ (_viPostInstall =<< vi) $ \msg ->
+                  runLogger $ logInfo msg
+                liftIO $ putStr (T.unpack $ tVerToText tv)
+                pure ExitSuccess
+              VLeft (V (AlreadyInstalled _ v)) -> do
+                runLogger $ logWarn $
+                  "GHC ver " <> prettyVer v <> " already installed, remove it first to reinstall"
+                pure ExitSuccess
+              VLeft (V (DirNotEmpty fp)) -> do
+                runLogger $ logError $
+                  "Install directory " <> T.pack fp <> " is not empty."
+                pure $ ExitFailure 3
+              VLeft err@(V (BuildFailed tmpdir _)) -> do
+                case keepDirs settings of
+                  Never -> runLogger $ logError $ T.pack $ prettyHFError err
+                  _ -> runLogger (logError $ T.pack (prettyHFError err) <> "\n" <>
+                        "Check the logs at " <> T.pack (fromGHCupPath logsDir) <> " and the build directory "
+                        <> T.pack tmpdir <> " for more clues." <> "\n" <>
+                        "Make sure to clean up " <> T.pack tmpdir <> " afterwards.")
+                pure $ ExitFailure 9
+              VLeft e -> do
+                runLogger $ logError $ T.pack $ prettyHFError e
+                pure $ ExitFailure 9

app/ghcup/GHCup/OptParse/Config.hs

@@ -0,0 +1,211 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE RankNTypes #-}
+
+module GHCup.OptParse.Config where
+
+
+import           GHCup.Errors
+import           GHCup.Types
+import           GHCup.Utils
+import           GHCup.Prelude
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.String.QQ
+import           GHCup.OptParse.Common
+
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Exception              ( displayException )
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Data.Functor
+import           Data.Maybe
+import           Haskus.Utils.Variant.Excepts
+import           Options.Applicative     hiding ( style, ParseError )
+import           Options.Applicative.Help.Pretty ( text )
+import           Prelude                 hiding ( appendFile )
+import           System.Exit
+import           URI.ByteString          hiding ( uriParser )
+
+import qualified Data.Text                     as T
+import qualified Data.ByteString.UTF8          as UTF8
+import qualified Data.Yaml.Aeson               as Y
+import Control.Exception.Safe (MonadMask)
+
+
+
+
+    ----------------
+    --[ Commands ]--
+    ----------------
+
+
+data ConfigCommand
+  = ShowConfig
+  | SetConfig String (Maybe String)
+  | InitConfig
+  | AddReleaseChannel URI
+
+
+
+    ---------------
+    --[ Parsers ]--
+    ---------------
+
+
+configP :: Parser ConfigCommand
+configP = subparser
+      (  command "init" initP
+      <> command "set"  setP -- [set] KEY VALUE at help lhs
+      <> command "show" showP
+      <> command "add-release-channel" addP
+      )
+    <|> argsP -- add show for a single option
+    <|> pure ShowConfig
+ where
+  initP = info (pure InitConfig) (progDesc "Write default config to ~/.ghcup/config.yaml")
+  showP = info (pure ShowConfig) (progDesc "Show current config (default)")
+  setP  = info argsP (progDesc "Set config KEY to VALUE (or specify as single json value)" <> footerDoc (Just $ text configSetFooter))
+  argsP = SetConfig <$> argument str (metavar "<JSON_VALUE | YAML_KEY>") <*> optional (argument str (metavar "YAML_VALUE"))
+  addP  = info (AddReleaseChannel <$> argument (eitherReader uriParser) (metavar "URI" <> completer fileUri))
+    (progDesc "Add a release channel from a URI")
+
+
+
+
+    --------------
+    --[ Footer ]--
+    --------------
+
+
+configFooter :: String
+configFooter = [s|Examples:
+
+  # show current config
+  ghcup config
+
+  # initialize config
+  ghcup config init
+
+  # set <key> <value> configuration pair
+  ghcup config set <key> <value>|]
+
+
+configSetFooter :: String
+configSetFooter = [s|Examples:
+  # disable caching
+  ghcup config set cache false
+
+  # switch downloader to wget
+  ghcup config set downloader Wget
+
+  # set mirror for ghcup metadata
+  ghcup config set '{url-source: { OwnSource: "<url>"}}'|]
+
+
+
+    -----------------
+    --[ Utilities ]--
+    -----------------
+
+
+formatConfig :: UserSettings -> String
+formatConfig = UTF8.toString . Y.encode
+
+
+updateSettings :: UserSettings -> Settings -> Settings
+updateSettings UserSettings{..} Settings{..} =
+   let cache'      = fromMaybe cache uCache
+       metaCache'  = fromMaybe metaCache uMetaCache
+       metaMode'   = fromMaybe metaMode uMetaMode
+       noVerify'   = fromMaybe noVerify uNoVerify
+       keepDirs'   = fromMaybe keepDirs uKeepDirs
+       downloader' = fromMaybe downloader uDownloader
+       verbose'    = fromMaybe verbose uVerbose
+       urlSource'  = fromMaybe urlSource uUrlSource
+       noNetwork'  = fromMaybe noNetwork uNoNetwork
+       gpgSetting' = fromMaybe gpgSetting uGPGSetting
+       platformOverride' = uPlatformOverride <|> platformOverride
+   in Settings cache' metaCache' metaMode' noVerify' keepDirs' downloader' verbose' urlSource' noNetwork' gpgSetting' noColor platformOverride'
+
+
+
+    ------------------
+    --[ Entrypoint ]--
+    ------------------
+
+
+
+config :: forall m. ( Monad m
+          , MonadMask m
+          , MonadUnliftIO m
+          , MonadFail m
+          )
+     => ConfigCommand
+     -> Settings
+     -> KeyBindings
+     -> (ReaderT LeanAppState m () -> m ())
+     -> m ExitCode
+config configCommand settings keybindings runLogger = case configCommand of
+  InitConfig -> do
+    path <- getConfigFilePath
+    liftIO $ writeFile path $ formatConfig $ fromSettings settings (Just keybindings)
+    runLogger $ logDebug $ "config.yaml initialized at " <> T.pack path
+    pure ExitSuccess
+
+  ShowConfig -> do
+    liftIO $ putStrLn $ formatConfig $ fromSettings settings (Just keybindings)
+    pure ExitSuccess
+
+  (SetConfig k mv) -> do
+    r <- runE @'[JSONError, ParseError] $ do
+      case mv of
+        Just "" ->
+          throwE $ ParseError "Empty values are not allowed"
+        Nothing -> do
+          usersettings <- decodeSettings k
+          lift $ doConfig usersettings
+          pure ()
+        Just v -> do
+          usersettings <- decodeSettings (k <> ": " <> v <> "\n")
+          lift $ doConfig usersettings
+          pure ()
+    case r of
+      VRight _ -> pure ExitSuccess
+      VLeft (V (JSONDecodeError e)) -> do
+        runLogger $ logError $ "Error decoding config: " <> T.pack e
+        pure $ ExitFailure 65
+      VLeft _ -> pure $ ExitFailure 65
+
+  AddReleaseChannel uri -> do
+    case urlSource settings of
+      AddSource xs -> do
+        doConfig (defaultUserSettings { uUrlSource = Just $ AddSource (xs <> [Right uri]) })
+        pure ExitSuccess
+      GHCupURL -> do
+        doConfig (defaultUserSettings { uUrlSource = Just $ AddSource [Right uri] })
+        pure ExitSuccess
+      OwnSource xs -> do
+        doConfig (defaultUserSettings { uUrlSource = Just $ OwnSource (xs <> [Right uri]) })
+        pure ExitSuccess
+      OwnSpec spec -> do
+        doConfig (defaultUserSettings { uUrlSource = Just $ OwnSource ([Left spec, Right uri]) })
+        pure ExitSuccess
+
+ where
+  doConfig :: MonadIO m => UserSettings -> m ()
+  doConfig usersettings = do
+    let settings' = updateSettings usersettings settings
+    path <- liftIO getConfigFilePath
+    liftIO $ writeFile path $ formatConfig $ fromSettings settings' (Just keybindings)
+    runLogger $ logDebug $ T.pack $ show settings'
+    pure ()
+
+  decodeSettings = lE' (JSONDecodeError . displayException) . Y.decodeEither' . UTF8.fromString

app/ghcup/GHCup/OptParse/DInfo.hs

@@ -0,0 +1,119 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE RankNTypes #-}
+
+module GHCup.OptParse.DInfo where
+
+
+
+
+import           GHCup
+import           GHCup.Errors
+import           GHCup.Version
+import           GHCup.Types
+import           GHCup.Utils.Dirs
+import           GHCup.Prelude
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.Process
+
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Data.Functor
+import           Data.Maybe
+import           Haskus.Utils.Variant.Excepts
+import           Options.Applicative     hiding ( style )
+import           Prelude                 hiding ( appendFile )
+import           System.Exit
+import           Text.PrettyPrint.HughesPJClass ( prettyShow )
+
+import qualified Data.Text                     as T
+import Control.Exception.Safe (MonadMask)
+import Language.Haskell.TH
+
+
+
+    -----------------
+    --[ Utilities ]--
+    -----------------
+
+
+describe_result :: String
+describe_result = $( LitE . StringL <$>
+                     runIO (do
+                             CapturedProcess{..} <-  do
+                              dirs <- liftIO getAllDirs
+                              let settings = AppState (defaultSettings { noNetwork = True })
+                                               dirs
+                                               defaultKeyBindings
+                              flip runReaderT settings $ executeOut "git" ["describe"] Nothing
+                             case _exitCode of
+                               ExitSuccess   -> pure . T.unpack . decUTF8Safe' $ _stdOut
+                               ExitFailure _ -> pure numericVer
+                     )
+                   )
+
+
+prettyDebugInfo :: DebugInfo -> String
+prettyDebugInfo DebugInfo {..} = "Debug Info" <> "\n" <>
+  "==========" <> "\n" <>
+  "GHCup base dir: " <> diBaseDir <> "\n" <>
+  "GHCup bin dir: " <> diBinDir <> "\n" <>
+  "GHCup GHC directory: " <> diGHCDir <> "\n" <>
+  "GHCup cache directory: " <> diCacheDir <> "\n" <>
+  "Architecture: " <> prettyShow diArch <> "\n" <>
+  "Platform: " <> prettyShow diPlatform <> "\n" <>
+  "Version: " <> describe_result
+
+
+
+    ---------------------------
+    --[ Effect interpreters ]--
+    ---------------------------
+
+
+type DInfoEffects = '[ NoCompatiblePlatform , NoCompatibleArch , DistroNotFound ]
+
+runDebugInfo :: (ReaderT env m (VEither DInfoEffects a) -> m (VEither DInfoEffects a))
+             -> Excepts DInfoEffects (ReaderT env m) a
+             -> m (VEither DInfoEffects a)
+runDebugInfo runAppState =
+        runAppState
+        . runE
+          @DInfoEffects
+
+
+
+    ------------------
+    --[ Entrypoint ]--
+    ------------------
+
+
+
+dinfo :: ( Monad m
+         , MonadMask m
+         , MonadUnliftIO m
+         , MonadFail m
+         , Alternative m
+         )
+      => (ReaderT AppState m (VEither DInfoEffects DebugInfo)
+          -> m (VEither DInfoEffects DebugInfo))
+      -> (ReaderT LeanAppState m () -> m ())
+      -> m ExitCode
+dinfo runAppState runLogger = do
+  runDebugInfo runAppState (liftE getDebugInfo)
+    >>= \case
+          VRight di -> do
+            liftIO $ putStrLn $ prettyDebugInfo di
+            pure ExitSuccess
+          VLeft e -> do
+            runLogger $ logError $ T.pack $ prettyHFError e
+            pure $ ExitFailure 8

app/ghcup/GHCup/OptParse/GC.hs

@@ -0,0 +1,142 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE RankNTypes #-}
+
+module GHCup.OptParse.GC where
+
+
+import           GHCup
+import           GHCup.Errors
+import           GHCup.Types
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.String.QQ
+
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Data.Functor
+import           Haskus.Utils.Variant.Excepts
+import           Options.Applicative     hiding ( style )
+import           Prelude                 hiding ( appendFile )
+import           System.Exit
+
+import qualified Data.Text                     as T
+import Control.Exception.Safe (MonadMask)
+
+
+
+
+
+    ---------------
+    --[ Options ]--
+    ---------------
+
+
+data GCOptions = GCOptions
+  { gcOldGHC :: Bool
+  , gcProfilingLibs :: Bool
+  , gcShareDir :: Bool
+  , gcHLSNoGHC :: Bool
+  , gcCache :: Bool
+  , gcTmp :: Bool
+  }
+
+
+
+    ---------------
+    --[ Parsers ]--
+    ---------------
+
+
+gcP :: Parser GCOptions
+gcP =
+  GCOptions
+  <$>
+    switch
+      (short 'o' <> long "ghc-old" <> help "Remove GHC versions marked as 'old'")
+  <*>
+    switch
+      (short 'p' <> long "profiling-libs" <> help "Remove profiling libs of GHC versions")
+  <*>
+    switch
+      (short 's' <> long "share-dir" <> help "Remove GHC share directories (documentation)")
+  <*>
+    switch
+      (short 'h' <> long "hls-no-ghc" <> help "Remove HLS versions that don't have a corresponding installed GHC version")
+  <*>
+    switch
+      (short 'c' <> long "cache" <> help "GC the GHCup cache")
+  <*>
+    switch
+      (short 't' <> long "tmpdirs" <> help "Remove tmpdir leftovers")
+
+
+
+    --------------
+    --[ Footer ]--
+    --------------
+
+
+gcFooter :: String
+gcFooter = [s|Discussion:
+  Performs garbage collection. If no switches are specified, does nothing.|]
+
+
+
+
+    ---------------------------
+    --[ Effect interpreters ]--
+    ---------------------------
+
+
+type GCEffects = '[ NotInstalled, UninstallFailed ]
+
+
+runGC :: MonadUnliftIO m
+      => (ReaderT AppState m (VEither GCEffects a) -> m (VEither GCEffects a))
+      -> Excepts GCEffects (ResourceT (ReaderT AppState m)) a
+      -> m (VEither GCEffects a)
+runGC runAppState =
+  runAppState
+    . runResourceT
+    . runE
+      @GCEffects
+
+
+
+    ------------------
+    --[ Entrypoint ]--
+    ------------------
+
+
+
+gc :: ( Monad m
+      , MonadMask m
+      , MonadUnliftIO m
+      , MonadFail m
+      )
+   => GCOptions
+   -> (forall a. ReaderT AppState m (VEither GCEffects a) -> m (VEither GCEffects a))
+   -> (ReaderT LeanAppState m () -> m ())
+   -> m ExitCode
+gc GCOptions{..} runAppState runLogger = runGC runAppState (do
+  when gcOldGHC (liftE rmOldGHC)
+  lift $ when gcProfilingLibs rmProfilingLibs
+  lift $ when gcShareDir rmShareDir
+  liftE $ when gcHLSNoGHC rmHLSNoGHC
+  lift $ when gcCache rmCache
+  lift $ when gcTmp rmTmp
+   ) >>= \case
+            VRight _ -> do
+                  pure ExitSuccess
+            VLeft e -> do
+              runLogger $ logError $ T.pack $ prettyHFError e
+              pure $ ExitFailure 27

app/ghcup/GHCup/OptParse/Install.hs

@@ -0,0 +1,536 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE ViewPatterns      #-}
+{-# LANGUAGE TypeOperators     #-}
+
+module GHCup.OptParse.Install where
+
+
+
+
+import           GHCup.OptParse.Common
+
+import           GHCup
+import           GHCup.Errors
+import           GHCup.Types
+import           GHCup.Utils.Dirs
+import           GHCup.Prelude
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.String.QQ
+
+import           Codec.Archive
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Data.Either
+import           Data.Functor
+import           Data.Maybe
+import           Haskus.Utils.Variant.Excepts
+import           Options.Applicative     hiding ( style )
+import           Options.Applicative.Help.Pretty ( text )
+import           Prelude                 hiding ( appendFile )
+import           System.Exit
+import           URI.ByteString          hiding ( uriParser )
+
+import qualified Data.Text                     as T
+
+
+
+
+    ----------------
+    --[ Commands ]--
+    ----------------
+
+
+data InstallCommand = InstallGHC InstallOptions
+                    | InstallCabal InstallOptions
+                    | InstallHLS InstallOptions
+                    | InstallStack InstallOptions
+
+
+
+
+    ---------------
+    --[ Options ]--
+    ---------------
+
+
+data InstallOptions = InstallOptions
+  { instVer      :: Maybe ToolVersion
+  , instBindist  :: Maybe URI
+  , instSet      :: Bool
+  , isolateDir   :: Maybe FilePath
+  , forceInstall :: Bool
+  , addConfArgs  :: [T.Text]
+  }
+
+
+
+    ---------------
+    --[ Footers ]--
+    ---------------
+
+installCabalFooter :: String
+installCabalFooter = [s|Discussion:
+  Installs the specified cabal-install version (or a recommended default one)
+  into "~/.ghcup/bin", so it can be overwritten by later
+  "cabal install cabal-install", which installs into "~/.cabal/bin" by
+  default. Make sure to set up your PATH appropriately, so the cabal
+  installation takes precedence.|]
+
+
+
+    ---------------
+    --[ Parsers ]--
+    ---------------
+
+installParser :: Parser (Either InstallCommand InstallOptions)
+installParser =
+  (Left <$> subparser
+      (  command
+          "ghc"
+          (   InstallGHC
+          <$> info
+                (installOpts (Just GHC) <**> helper)
+                (  progDesc "Install GHC"
+                <> footerDoc (Just $ text installGHCFooter)
+                )
+          )
+      <> command
+           "cabal"
+           (   InstallCabal
+           <$> info
+                 (installOpts (Just Cabal) <**> helper)
+                 (  progDesc "Install Cabal"
+                 <> footerDoc (Just $ text installCabalFooter)
+                 )
+           )
+      <> command
+           "hls"
+           (   InstallHLS
+           <$> info
+                 (installOpts (Just HLS) <**> helper)
+                 (  progDesc "Install haskell-language-server"
+                 <> footerDoc (Just $ text installHLSFooter)
+                 )
+           )
+      <> command
+           "stack"
+           (   InstallStack
+           <$> info
+                 (installOpts (Just Stack) <**> helper)
+                 (  progDesc "Install stack"
+                 <> footerDoc (Just $ text installStackFooter)
+                 )
+           )
+      )
+    )
+    <|> (Right <$> installOpts Nothing)
+ where
+  installHLSFooter :: String
+  installHLSFooter = [s|Discussion:
+  Installs haskell-language-server binaries and wrapper
+  into "~/.ghcup/bin"
+
+Examples:
+  # install recommended HLS
+  ghcup install hls|]
+
+  installStackFooter :: String
+  installStackFooter = [s|Discussion:
+  Installs stack binaries into "~/.ghcup/bin"
+
+Examples:
+  # install recommended Stack
+  ghcup install stack|]
+
+  installGHCFooter :: String
+  installGHCFooter = [s|Discussion:
+  Installs the specified GHC version (or a recommended default one) into
+  a self-contained "~/.ghcup/ghc/<ghcver>" directory
+  and symlinks the ghc binaries to "~/.ghcup/bin/<binary>-<ghcver>".
+
+Examples:
+  # install recommended GHC
+  ghcup install ghc
+
+  # install latest GHC
+  ghcup install ghc latest
+
+  # install GHC 8.10.2
+  ghcup install ghc 8.10.2
+
+  # install GHC head fedora bindist
+  ghcup install ghc -u 'https://gitlab.haskell.org/ghc/ghc/-/jobs/artifacts/master/raw/ghc-x86_64-linux-fedora33-release.tar.xz?job=x86_64-linux-fedora33-release' head|]
+
+
+installOpts :: Maybe Tool -> Parser InstallOptions
+installOpts tool =
+  (\(u, v) b is f -> InstallOptions v u b is f)
+    <$> (   (   (,)
+            <$> optional
+                  (option
+                    (eitherReader uriParser)
+                    (short 'u' <> long "url" <> metavar "BINDIST_URL" <> help
+                      "Install the specified version from this bindist"
+                      <> completer (toolDlCompleter (fromMaybe GHC tool))
+                    )
+                  )
+            <*> (Just <$> toolVersionTagArgument Nothing tool)
+            )
+        <|> pure (Nothing, Nothing)
+        )
+    <*> fmap (fromMaybe setDefault) (invertableSwitch "set" Nothing setDefault
+      (help $ if not setDefault then "Set as active version after install" else "Don't set as active version after install"))
+    <*> optional
+          (option
+           (eitherReader isolateParser)
+           (  short 'i'
+           <> long "isolate"
+           <> metavar "DIR"
+           <> help "install in an isolated dir instead of the default one"
+           <> completer (bashCompleter "directory")
+           )
+          )
+    <*> switch
+          (short 'f' <> long "force" <> help "Force install (THIS IS UNSAFE, only use it in Dockerfiles or CI)")
+    <*> many (argument str (metavar "CONFIGURE_ARGS" <> help "Additional arguments to bindist configure, prefix with '-- ' (longopts)"))
+ where
+  setDefault = case tool of
+    Nothing  -> False
+    Just GHC -> False
+    Just _   -> True
+
+
+
+
+    --------------
+    --[ Footer ]--
+    --------------
+
+
+installToolFooter :: String
+installToolFooter = [s|Discussion:
+  Installs GHC or cabal. When no command is given, installs GHC
+  with the specified version/tag.
+  It is recommended to always specify a subcommand (ghc/cabal/hls/stack).|]
+
+
+
+
+    ---------------------------
+    --[ Effect interpreters ]--
+    ---------------------------
+
+type InstallEffects = '[ AlreadyInstalled
+                       , UnknownArchive
+                       , ArchiveResult
+                       , FileDoesNotExistError
+                       , CopyError
+                       , NotInstalled
+                       , DirNotEmpty
+                       , NoDownload
+                       , NotInstalled
+                       , BuildFailed
+                       , TagNotFound
+                       , DigestError
+                       , ContentLengthError
+                       , GPGError
+                       , DownloadFailed
+                       , TarDirDoesNotExist
+                       , NextVerNotFound
+                       , NoToolVersionSet
+                       , FileAlreadyExistsError
+                       , ProcessError
+                       , UninstallFailed
+                       , MergeFileTreeError
+                       , InstallSetError
+                       ]
+
+
+runInstTool :: AppState
+            -> Excepts InstallEffects (ResourceT (ReaderT AppState IO)) a
+            -> IO (VEither InstallEffects a)
+runInstTool appstate' =
+  flip runReaderT appstate'
+  . runResourceT
+  . runE
+    @InstallEffects
+
+
+type InstallGHCEffects = '[ AlreadyInstalled
+                          , ArchiveResult
+                          , BuildFailed
+                          , CopyError
+                          , DigestError
+                          , ContentLengthError
+                          , DirNotEmpty
+                          , DownloadFailed
+                          , FileAlreadyExistsError
+                          , FileDoesNotExistError
+                          , GPGError
+                          , MergeFileTreeError
+                          , NextVerNotFound
+                          , NoDownload
+                          , NoToolVersionSet
+                          , NotInstalled
+                          , ProcessError
+                          , TagNotFound
+                          , TarDirDoesNotExist
+                          , UninstallFailed
+                          , UnknownArchive
+                          , InstallSetError
+                          ]
+
+runInstGHC :: AppState
+           -> Excepts InstallGHCEffects (ResourceT (ReaderT AppState IO)) a
+           -> IO (VEither InstallGHCEffects a)
+runInstGHC appstate' =
+  flip runReaderT appstate'
+  . runResourceT
+  . runE
+    @InstallGHCEffects
+
+
+    -------------------
+    --[ Entrypoints ]--
+    -------------------
+
+
+install :: Either InstallCommand InstallOptions -> Settings -> IO AppState -> (ReaderT LeanAppState IO () -> IO ()) -> IO ExitCode
+install installCommand settings getAppState' runLogger = case installCommand of
+  (Right iopts) -> do
+    runLogger (logWarn "This is an old-style command for installing GHC. Use 'ghcup install ghc' instead.")
+    installGHC iopts
+  (Left (InstallGHC iopts)) -> installGHC iopts
+  (Left (InstallCabal iopts)) -> installCabal iopts
+  (Left (InstallHLS iopts)) -> installHLS iopts
+  (Left (InstallStack iopts)) -> installStack iopts
+ where
+  installGHC :: InstallOptions -> IO ExitCode
+  installGHC InstallOptions{..} = do
+    s'@AppState{ dirs = Dirs{ .. } } <- liftIO getAppState'
+    (case instBindist of
+       Nothing -> runInstGHC s' $ do
+         (v, vi) <- liftE $ fromVersion instVer GHC
+         liftE $ runBothE' (installGHCBin
+                     (_tvVersion v)
+                     (maybe GHCupInternal IsolateDir isolateDir)
+                     forceInstall
+                     addConfArgs
+                   )
+                   $ when instSet $ when (isNothing isolateDir) $ liftE $ void $ setGHC v SetGHCOnly Nothing
+         pure vi
+       Just uri -> do
+         runInstGHC s'{ settings = settings {noVerify = True}} $ do
+           (v, vi) <- liftE $ fromVersion instVer GHC
+           liftE $ runBothE' (installGHCBindist
+                       (DownloadInfo uri (Just $ RegexDir "ghc-.*") "" Nothing)
+                       (_tvVersion v)
+                       (maybe GHCupInternal IsolateDir isolateDir)
+                       forceInstall
+                       addConfArgs
+                     )
+                     $ when instSet $ when (isNothing isolateDir) $ liftE $ void $ setGHC v SetGHCOnly Nothing
+           pure vi
+      )
+        >>= \case
+              VRight vi -> do
+                runLogger $ logInfo "GHC installation successful"
+                forM_ (_viPostInstall =<< vi) $ \msg ->
+                  runLogger $ logInfo msg
+                pure ExitSuccess
+
+              VLeft e@(V (AlreadyInstalled _ _)) -> do
+                runLogger $ logWarn $ T.pack $ prettyHFError e
+                pure ExitSuccess
+              VLeft e@(V (AlreadyInstalled _ _)) -> do
+                runLogger $ logWarn $ T.pack $ prettyHFError e
+                pure ExitSuccess
+
+              VLeft (V (DirNotEmpty fp)) -> do
+                runLogger $ logError $
+                  "Install directory " <> T.pack fp <> " is not empty."
+                pure $ ExitFailure 3
+              VLeft (V (DirNotEmpty fp)) -> do
+                runLogger $ logError $
+                  "Install directory " <> T.pack fp <> " is not empty."
+                pure $ ExitFailure 3
+
+              VLeft err@(V (BuildFailed tmpdir _)) -> do
+                case keepDirs settings of
+                  Never -> runLogger (logError $ T.pack $ prettyHFError err)
+                  _ -> runLogger (logError $ T.pack (prettyHFError err) <> "\n" <>
+                    "Check the logs at " <> T.pack (fromGHCupPath logsDir) <> " and the build directory " <> T.pack tmpdir <> " for more clues." <> "\n" <>
+                    "Make sure to clean up " <> T.pack tmpdir <> " afterwards.")
+                pure $ ExitFailure 3
+              VLeft err@(V (BuildFailed tmpdir _)) -> do
+                case keepDirs settings of
+                  Never -> runLogger (logError $ T.pack $ prettyHFError err)
+                  _ -> runLogger (logError $ T.pack (prettyHFError err) <> "\n" <>
+                    "Check the logs at " <> T.pack (fromGHCupPath logsDir) <> " and the build directory " <> T.pack tmpdir <> " for more clues." <> "\n" <>
+                    "Make sure to clean up " <> T.pack tmpdir <> " afterwards.")
+                pure $ ExitFailure 3
+
+              VLeft e -> do
+                runLogger $ do
+                  logError $ T.pack $ prettyHFError e
+                  logError $ "Also check the logs in " <> T.pack (fromGHCupPath logsDir)
+                pure $ ExitFailure 3
+
+
+  installCabal :: InstallOptions -> IO ExitCode
+  installCabal InstallOptions{..} = do
+    s'@AppState{ dirs = Dirs{ .. } } <- liftIO getAppState'
+    (case instBindist of
+       Nothing -> runInstTool s' $ do
+         (_tvVersion -> v, vi) <- liftE $ fromVersion instVer Cabal
+         liftE $ runBothE' (installCabalBin
+                                    v
+                                    (maybe GHCupInternal IsolateDir isolateDir)
+                                    forceInstall
+                                  ) $ when instSet $ when (isNothing isolateDir) $ liftE $ setCabal v
+         pure vi
+       Just uri -> do
+         runInstTool s'{ settings = settings { noVerify = True}} $ do
+           (_tvVersion -> v, vi) <- liftE $ fromVersion instVer Cabal
+           liftE $ runBothE' (installCabalBindist
+                                      (DownloadInfo uri Nothing "" Nothing)
+                                      v
+                                      (maybe GHCupInternal IsolateDir isolateDir)
+                                      forceInstall
+                                    ) $ when instSet $ when (isNothing isolateDir) $ liftE $ setCabal v
+           pure vi
+      )
+      >>= \case
+            VRight vi -> do
+              runLogger $ logInfo "Cabal installation successful"
+              forM_ (_viPostInstall =<< vi) $ \msg ->
+                runLogger $ logInfo msg
+              pure ExitSuccess
+            VLeft e@(V (AlreadyInstalled _ _)) -> do
+              runLogger $ logWarn $ T.pack $ prettyHFError e
+              pure ExitSuccess
+            VLeft (V (FileAlreadyExistsError fp)) -> do
+              runLogger $ logWarn $
+                "File " <> T.pack fp <> " already exists. Use 'ghcup install cabal --isolate " <> T.pack fp <> " --force ..." <> "' if you want to overwrite."
+              pure $ ExitFailure 3
+            VLeft e@(V (AlreadyInstalled _ _)) -> do
+              runLogger $ logWarn $ T.pack $ prettyHFError e
+              pure ExitSuccess
+            VLeft (V (FileAlreadyExistsError fp)) -> do
+              runLogger $ logWarn $
+                "File " <> T.pack fp <> " already exists. Use 'ghcup install cabal --isolate " <> T.pack fp <> " --force ..." <> "' if you want to overwrite."
+              pure $ ExitFailure 3
+            VLeft e -> do
+              runLogger $ do
+                logError $ T.pack $ prettyHFError e
+                logError $ "Also check the logs in " <> T.pack (fromGHCupPath logsDir)
+              pure $ ExitFailure 4
+
+  installHLS :: InstallOptions -> IO ExitCode
+  installHLS InstallOptions{..} = do
+     s'@AppState{ dirs = Dirs{ .. } } <- liftIO getAppState'
+     (case instBindist of
+       Nothing -> runInstTool s' $ do
+         (_tvVersion -> v, vi) <- liftE $ fromVersion instVer HLS
+         liftE $ runBothE' (installHLSBin
+                                    v
+                                    (maybe GHCupInternal IsolateDir isolateDir)
+                                    forceInstall
+                                  ) $ when instSet $ when (isNothing isolateDir) $ liftE $ setHLS v SetHLSOnly Nothing
+         pure vi
+       Just uri -> do
+         runInstTool s'{ settings = settings { noVerify = True}} $ do
+           (_tvVersion -> v, vi) <- liftE $ fromVersion instVer HLS
+           -- TODO: support legacy
+           liftE $ runBothE' (installHLSBindist
+                                      (DownloadInfo uri (if isWindows then Nothing else Just (RegexDir "haskell-language-server-*")) "" Nothing)
+                                      v
+                                      (maybe GHCupInternal IsolateDir isolateDir)
+                                      forceInstall
+                                    ) $ when instSet $ when (isNothing isolateDir) $ liftE $ setHLS v SetHLSOnly Nothing
+           pure vi
+      )
+      >>= \case
+            VRight vi -> do
+              runLogger $ logInfo "HLS installation successful"
+              forM_ (_viPostInstall =<< vi) $ \msg ->
+                runLogger $ logInfo msg
+              pure ExitSuccess
+            VLeft e@(V (AlreadyInstalled _ _)) -> do
+              runLogger $ logWarn $ T.pack $ prettyHFError e
+              pure ExitSuccess
+            VLeft (V (FileAlreadyExistsError fp)) -> do
+              runLogger $ logWarn $
+                "File " <> T.pack fp <> " already exists. Use 'ghcup install hls --isolate " <> T.pack fp <> " --force ..." <> "' if you want to overwrite."
+              pure $ ExitFailure 3
+            VLeft e@(V (AlreadyInstalled _ _)) -> do
+              runLogger $ logWarn $ T.pack $ prettyHFError e
+              pure ExitSuccess
+            VLeft (V (FileAlreadyExistsError fp)) -> do
+              runLogger $ logWarn $
+                "File " <> T.pack fp <> " already exists. Use 'ghcup install hls --isolate " <> T.pack fp <> " --force ..." <> "' if you want to overwrite."
+              pure $ ExitFailure 3
+            VLeft e -> do
+              runLogger $ do
+                logError $ T.pack $ prettyHFError e
+                logError $ "Also check the logs in " <> T.pack (fromGHCupPath logsDir)
+              pure $ ExitFailure 4
+
+  installStack :: InstallOptions -> IO ExitCode
+  installStack InstallOptions{..} = do
+     s'@AppState{ dirs = Dirs{ .. } } <- liftIO getAppState'
+     (case instBindist of
+        Nothing -> runInstTool s' $ do
+          (_tvVersion -> v, vi) <- liftE $ fromVersion instVer Stack
+          liftE $ runBothE' (installStackBin
+                                     v
+                                     (maybe GHCupInternal IsolateDir isolateDir)
+                                     forceInstall
+                                   ) $ when instSet $ when (isNothing isolateDir) $ liftE $ setStack v
+          pure vi
+        Just uri -> do
+          runInstTool s'{ settings = settings { noVerify = True}} $ do
+            (_tvVersion -> v, vi) <- liftE $ fromVersion instVer Stack
+            liftE $ runBothE' (installStackBindist
+                                       (DownloadInfo uri Nothing "" Nothing)
+                                       v
+                                       (maybe GHCupInternal IsolateDir isolateDir)
+                                       forceInstall
+                                     ) $ when instSet $ when (isNothing isolateDir) $ liftE $ setStack v
+            pure vi
+      )
+      >>= \case
+            VRight vi -> do
+              runLogger $ logInfo "Stack installation successful"
+              forM_ (_viPostInstall =<< vi) $ \msg ->
+                runLogger $ logInfo msg
+              pure ExitSuccess
+            VLeft e@(V (AlreadyInstalled _ _)) -> do
+              runLogger $ logWarn $ T.pack $ prettyHFError e
+              pure ExitSuccess
+            VLeft (V (FileAlreadyExistsError fp)) -> do
+              runLogger $ logWarn $
+                "File " <> T.pack fp <> " already exists. Use 'ghcup install stack --isolate " <> T.pack fp <> " --force ..." <> "' if you want to overwrite."
+              pure $ ExitFailure 3
+            VLeft e@(V (AlreadyInstalled _ _)) -> do
+              runLogger $ logWarn $ T.pack $ prettyHFError e
+              pure ExitSuccess
+            VLeft (V (FileAlreadyExistsError fp)) -> do
+              runLogger $ logWarn $
+                "File " <> T.pack fp <> " already exists. Use 'ghcup install stack --isolate " <> T.pack fp <> " --force ..." <> "' if you want to overwrite."
+              pure $ ExitFailure 3
+            VLeft e -> do
+              runLogger $ do
+                logError $ T.pack $ prettyHFError e
+                logError $ "Also check the logs in " <> T.pack (fromGHCupPath logsDir)
+              pure $ ExitFailure 4

app/ghcup/GHCup/OptParse/List.hs

@@ -0,0 +1,183 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE RankNTypes #-}
+
+module GHCup.OptParse.List where
+
+
+
+
+import           GHCup
+import           GHCup.Prelude
+import           GHCup.Prelude.Ansi
+import           GHCup.Types
+import           GHCup.OptParse.Common
+
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Data.Char
+import           Data.List                      ( intercalate, sort )
+import           Data.Functor
+import           Data.Maybe
+import           Data.Versions           hiding ( str )
+import           Data.Void
+import           Options.Applicative     hiding ( style )
+import           Prelude                 hiding ( appendFile )
+import           System.Exit
+import           System.Console.Pretty   hiding ( color )
+
+import qualified Data.Text                     as T
+import qualified System.Console.Pretty         as Pretty
+import Control.Exception.Safe (MonadMask)
+import qualified Text.Megaparsec               as MP
+import qualified Text.Megaparsec.Char          as MPC
+
+
+
+
+
+
+    ---------------
+    --[ Options ]--
+    ---------------
+
+
+data ListOptions = ListOptions
+  { loTool     :: Maybe Tool
+  , lCriteria  :: Maybe ListCriteria
+  , lRawFormat :: Bool
+  }
+
+
+
+
+    ---------------
+    --[ Parsers ]--
+    ---------------
+
+          
+listOpts :: Parser ListOptions
+listOpts =
+  ListOptions
+    <$> optional
+          (option
+            (eitherReader toolParser)
+            (short 't' <> long "tool" <> metavar "<ghc|cabal|hls|stack>" <> help
+              "Tool to list versions for. Default is all"
+              <> completer (toolCompleter)
+            )
+          )
+    <*> optional
+          (option
+            (eitherReader criteriaParser)
+            (  short 'c'
+            <> long "show-criteria"
+            <> metavar "<installed|set|available>"
+            <> help "Show only installed/set/available tool versions"
+              <> completer (listCompleter ["installed", "set", "available"])
+            )
+          )
+    <*> switch
+          (short 'r' <> long "raw-format" <> help "More machine-parsable format"
+          )
+
+
+
+
+    -----------------
+    --[ Utilities ]--
+    -----------------
+
+
+printListResult :: Bool -> Bool -> [ListResult] -> IO ()
+printListResult no_color raw lr = do
+
+  let
+    color | raw || no_color = (\_ x -> x)
+          | otherwise       = Pretty.color
+
+  let
+    printTag Recommended        = color Green "recommended"
+    printTag Latest             = color Yellow "latest"
+    printTag Prerelease         = color Red "prerelease"
+    printTag (Base       pvp'') = "base-" ++ T.unpack (prettyPVP pvp'')
+    printTag (UnknownTag t    ) = t
+    printTag Old                = ""
+
+  let
+    rows =
+      (\x -> if raw
+          then x
+          else [color Green "", "Tool", "Version", "Tags", "Notes"] : x
+        )
+        . fmap
+            (\ListResult {..} ->
+              let marks = if
+                    | lSet       -> (color Green (if isWindows then "IS" else "✔✔"))
+                    | lInstalled -> (color Green (if isWindows then "I " else "✓ "))
+                    | otherwise  -> (color Red   (if isWindows then "X " else "✗ "))
+              in
+                (if raw then [] else [marks])
+                  ++ [ fmap toLower . show $ lTool
+                     , case lCross of
+                       Nothing -> T.unpack . prettyVer $ lVer
+                       Just c  -> T.unpack (c <> "-" <> prettyVer lVer)
+                     , intercalate "," (filter (/= "") . fmap printTag $ sort lTag)
+                     , intercalate ","
+                     $  (if hlsPowered
+                          then [color Green "hls-powered"]
+                          else mempty
+                        )
+                     ++ (if fromSrc then [color Blue "compiled"] else mempty)
+                     ++ (if lStray then [color Yellow "stray"] else mempty)
+                     ++ (if lNoBindist
+                          then [color Red "no-bindist"]
+                          else mempty
+                        )
+                     ]
+            )
+        $ lr
+  let cols =
+        foldr (\xs ys -> zipWith (:) xs ys) (repeat []) rows
+      lengths = fmap (maximum . fmap strWidth) cols
+      padded  = fmap (\xs -> zipWith padTo xs lengths) rows
+
+  forM_ (if raw then rows else padded) $ \row -> putStrLn $ unwords row
+ where
+
+  padTo str' x =
+    let lstr = strWidth str'
+        add' = x - lstr
+    in  if add' < 0 then str' else str' ++ replicate add' ' '
+
+
+
+
+
+    ------------------
+    --[ Entrypoint ]--
+    ------------------
+
+
+
+list :: ( Monad m
+         , MonadMask m
+         , MonadUnliftIO m
+         , MonadFail m
+         )
+      => ListOptions
+      -> Bool
+      -> (ReaderT AppState m ExitCode -> m ExitCode)
+      -> m ExitCode
+list ListOptions{..} no_color runAppState =
+  runAppState (do
+      l <- listVersions loTool lCriteria
+      liftIO $ printListResult no_color lRawFormat l
+      pure ExitSuccess
+    )

app/ghcup/GHCup/OptParse/Nuke.hs

@@ -0,0 +1,98 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE RankNTypes #-}
+
+module GHCup.OptParse.Nuke where
+
+
+
+
+import           GHCup
+import           GHCup.Errors
+import           GHCup.Types
+import           GHCup.Prelude.Logger
+
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Data.Maybe
+import           Haskus.Utils.Variant.Excepts
+import           Options.Applicative     hiding ( style )
+import           Prelude                 hiding ( appendFile )
+import           System.Exit
+
+import qualified Data.Text                     as T
+import Control.Exception.Safe (MonadMask)
+import Control.DeepSeq
+import Control.Exception
+import Control.Concurrent (threadDelay)
+
+
+
+
+    ---------------------------
+    --[ Effect interpreters ]--
+    ---------------------------
+
+
+type NukeEffects = '[ NotInstalled, UninstallFailed ]
+
+
+runNuke :: AppState
+        -> Excepts NukeEffects (ReaderT AppState m) a
+        -> m (VEither NukeEffects a)
+runNuke s' =
+  flip runReaderT s' . runE @NukeEffects
+
+
+
+    ------------------
+    --[ Entrypoint ]--
+    ------------------
+
+
+
+nuke :: ( Monad m
+        , MonadMask m
+        , MonadUnliftIO m
+        , MonadFail m
+        )
+     => IO AppState
+     -> (ReaderT LeanAppState m () -> m ())
+     -> m ExitCode
+nuke appState runLogger = do
+  s' <- liftIO appState
+  void $ liftIO $ evaluate $ force s'
+  runNuke s' (do
+       lift $ logWarn "WARNING: This will remove GHCup and all installed components from your system."
+       lift $ logWarn "Waiting 10 seconds before commencing, if you want to cancel it, now would be the time."
+       liftIO $ threadDelay 10000000  -- wait 10s
+
+       lift $ logInfo "Initiating Nuclear Sequence 🚀🚀🚀"
+       lift $ logInfo "Nuking in 3...2...1"
+  
+       lInstalled <- lift $ listVersions Nothing (Just ListInstalled)
+
+       forM_ lInstalled (liftE . rmTool)
+
+       lift rmGhcupDirs
+
+       ) >>= \case
+                VRight leftOverFiles
+                  | null leftOverFiles -> do
+                      runLogger $ logInfo "Nuclear Annihilation complete!"
+                      pure ExitSuccess
+                  | otherwise -> do
+                      runLogger $ logError "These Files have survived Nuclear Annihilation, you may remove them manually."
+                      liftIO $ forM_ leftOverFiles putStrLn
+                      pure ExitSuccess
+
+                VLeft e -> do
+                  runLogger $ logError $ T.pack $ prettyHFError e
+                  pure $ ExitFailure 15

app/ghcup/GHCup/OptParse/Prefetch.hs

@@ -0,0 +1,219 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE RankNTypes #-}
+
+module GHCup.OptParse.Prefetch where
+
+
+import           GHCup
+import           GHCup.Errors
+import           GHCup.Types
+import           GHCup.Prelude.File
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.String.QQ
+import           GHCup.OptParse.Common
+
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Data.Functor
+import           Data.Maybe
+import           Haskus.Utils.Variant.Excepts
+import           Options.Applicative     hiding ( style )
+import           Prelude                 hiding ( appendFile )
+import           System.Exit
+
+import qualified Data.Text                     as T
+import Control.Exception.Safe (MonadMask)
+import GHCup.Download (getDownloadsF)
+
+
+
+
+    ----------------
+    --[ Commands ]--
+    ----------------
+
+
+data PrefetchCommand = PrefetchGHC PrefetchGHCOptions (Maybe ToolVersion)
+                     | PrefetchCabal PrefetchOptions (Maybe ToolVersion)
+                     | PrefetchHLS PrefetchOptions (Maybe ToolVersion)
+                     | PrefetchStack PrefetchOptions (Maybe ToolVersion)
+                     | PrefetchMetadata
+
+
+
+
+
+    ---------------
+    --[ Options ]--
+    ---------------
+
+
+data PrefetchOptions = PrefetchOptions {
+  pfCacheDir :: Maybe FilePath
+}
+
+data PrefetchGHCOptions = PrefetchGHCOptions {
+    pfGHCSrc :: Bool
+  , pfGHCCacheDir :: Maybe FilePath
+}
+
+
+
+    ---------------
+    --[ Parsers ]--
+    ---------------
+
+
+prefetchP :: Parser PrefetchCommand
+prefetchP = subparser
+  (  command
+      "ghc"
+      (info
+        (PrefetchGHC
+          <$> (PrefetchGHCOptions
+                <$> ( switch (short 's' <> long "source" <> help "Download source tarball instead of bindist") <**> helper )
+                <*> optional (option str (short 'd' <> long "directory" <> help "directory to download into (default: ~/.ghcup/cache/)" <> completer (bashCompleter "directory"))))
+          <*>  optional (toolVersionTagArgument Nothing (Just GHC)) )
+        ( progDesc "Download GHC assets for installation")
+      )
+      <>
+     command
+      "cabal"
+      (info
+        (PrefetchCabal
+          <$> fmap PrefetchOptions (optional (option str (short 'd' <> long "directory" <> help "directory to download into (default: ~/.ghcup/cache/)" <> completer (bashCompleter "directory"))))
+          <*> ( optional (toolVersionTagArgument Nothing (Just Cabal)) <**> helper ))
+        ( progDesc "Download cabal assets for installation")
+      )
+      <>
+     command
+      "hls"
+      (info
+        (PrefetchHLS
+          <$> fmap PrefetchOptions (optional (option str (short 'd' <> long "directory" <> help "directory to download into (default: ~/.ghcup/cache/)" <> completer (bashCompleter "directory"))))
+          <*> ( optional (toolVersionTagArgument Nothing (Just HLS)) <**> helper ))
+        ( progDesc "Download HLS assets for installation")
+      )
+      <>
+     command
+      "stack"
+      (info
+        (PrefetchStack
+          <$> fmap PrefetchOptions (optional (option str (short 'd' <> long "directory" <> help "directory to download into (default: ~/.ghcup/cache/)" <> completer (bashCompleter "directory"))))
+          <*> ( optional (toolVersionTagArgument Nothing (Just Stack)) <**> helper ))
+        ( progDesc "Download stack assets for installation")
+      )
+      <>
+     command
+      "metadata"
+      (PrefetchMetadata <$ info
+        helper
+        ( progDesc "Download ghcup's metadata, needed for various operations")
+      )
+  )
+
+
+
+    --------------
+    --[ Footer ]--
+    --------------
+
+
+prefetchFooter :: String
+prefetchFooter = [s|Discussion:
+  Prefetches tools or assets into "~/.ghcup/cache" directory. This can
+  be then combined later with '--offline' flag, ensuring all assets that
+  are required for offline use have been prefetched.
+
+Examples:
+  ghcup prefetch metadata
+  ghcup prefetch ghc 8.10.5
+  ghcup --offline install ghc 8.10.5|]
+
+
+
+    ---------------------------
+    --[ Effect interpreters ]--
+    ---------------------------
+
+
+type PrefetchEffects = '[ TagNotFound
+                        , NextVerNotFound
+                        , NoToolVersionSet
+                        , NoDownload
+                        , DigestError
+                        , ContentLengthError
+                        , GPGError
+                        , DownloadFailed
+                        , JSONError
+                        , FileDoesNotExistError ]
+
+
+runPrefetch :: MonadUnliftIO m
+            => (ReaderT AppState m (VEither PrefetchEffects a) -> m (VEither PrefetchEffects a))
+            -> Excepts PrefetchEffects (ResourceT (ReaderT AppState m)) a
+            -> m (VEither PrefetchEffects a)
+runPrefetch runAppState =
+  runAppState
+  . runResourceT
+  . runE
+    @PrefetchEffects
+
+
+
+    ------------------
+    --[ Entrypoint ]--
+    ------------------
+
+
+
+prefetch :: ( Monad m
+            , MonadMask m
+            , MonadUnliftIO m
+            , MonadFail m
+            )
+         => PrefetchCommand
+         -> (forall a. ReaderT AppState m (VEither PrefetchEffects a) -> m (VEither PrefetchEffects a))
+         -> (ReaderT LeanAppState m () -> m ())
+         -> m ExitCode
+prefetch prefetchCommand runAppState runLogger =
+  runPrefetch runAppState (do
+    case prefetchCommand of
+      PrefetchGHC
+        (PrefetchGHCOptions pfGHCSrc pfCacheDir) mt -> do
+          forM_ pfCacheDir (liftIO . createDirRecursive')
+          (v, _) <- liftE $ fromVersion mt GHC
+          if pfGHCSrc
+          then liftE $ fetchGHCSrc (_tvVersion v) pfCacheDir
+          else liftE $ fetchToolBindist (_tvVersion v) GHC pfCacheDir
+      PrefetchCabal PrefetchOptions {pfCacheDir} mt   -> do
+        forM_ pfCacheDir (liftIO . createDirRecursive')
+        (v, _) <- liftE $ fromVersion mt Cabal
+        liftE $ fetchToolBindist (_tvVersion v) Cabal pfCacheDir
+      PrefetchHLS PrefetchOptions {pfCacheDir} mt   -> do
+        forM_ pfCacheDir (liftIO . createDirRecursive')
+        (v, _) <- liftE $ fromVersion mt HLS
+        liftE $ fetchToolBindist (_tvVersion v) HLS pfCacheDir
+      PrefetchStack PrefetchOptions {pfCacheDir} mt   -> do
+        forM_ pfCacheDir (liftIO . createDirRecursive')
+        (v, _) <- liftE $ fromVersion mt Stack
+        liftE $ fetchToolBindist (_tvVersion v) Stack pfCacheDir
+      PrefetchMetadata -> do
+        _ <- liftE getDownloadsF
+        pure ""
+       ) >>= \case
+                VRight _ -> do
+                      pure ExitSuccess
+                VLeft e -> do
+                  runLogger $ logError $ T.pack $ prettyHFError e
+                  pure $ ExitFailure 15

app/ghcup/GHCup/OptParse/Rm.hs

@@ -0,0 +1,231 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE RankNTypes #-}
+
+module GHCup.OptParse.Rm where
+
+
+
+
+import           GHCup
+import           GHCup.Errors
+import           GHCup.Types
+import           GHCup.Types.Optics
+import           GHCup.Utils
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.String.QQ
+import           GHCup.OptParse.Common
+
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Data.Functor
+import           Data.Maybe
+import           Data.Versions           hiding ( str )
+import           Haskus.Utils.Variant.Excepts
+import           Options.Applicative     hiding ( style )
+import           Prelude                 hiding ( appendFile )
+import           System.Exit
+
+import qualified Data.Text                     as T
+import Control.Exception.Safe (MonadMask)
+
+
+
+
+    ----------------
+    --[ Commands ]--
+    ----------------
+
+
+data RmCommand = RmGHC RmOptions
+               | RmCabal Version
+               | RmHLS Version
+               | RmStack Version
+
+
+
+
+    ---------------
+    --[ Options ]--
+    ---------------
+
+
+data RmOptions = RmOptions
+  { ghcVer :: GHCTargetVersion
+  }
+
+
+
+
+    ---------------
+    --[ Parsers ]--
+    ---------------
+
+
+rmParser :: Parser (Either RmCommand RmOptions)
+rmParser =
+  (Left <$> subparser
+      (  command
+          "ghc"
+          (RmGHC <$> info (rmOpts (Just GHC) <**> helper) (progDesc "Remove GHC version"))
+      <> command
+           "cabal"
+           (   RmCabal
+           <$> info (versionParser' (Just ListInstalled) (Just Cabal) <**> helper)
+                    (progDesc "Remove Cabal version")
+           )
+      <> command
+           "hls"
+           (   RmHLS
+           <$> info (versionParser' (Just ListInstalled) (Just HLS) <**> helper)
+                    (progDesc "Remove haskell-language-server version")
+           )
+      <> command
+           "stack"
+           (   RmStack
+           <$> info (versionParser' (Just ListInstalled) (Just Stack) <**> helper)
+                    (progDesc "Remove stack version")
+           )
+      )
+    )
+    <|> (Right <$> rmOpts Nothing)
+
+
+
+rmOpts :: Maybe Tool -> Parser RmOptions
+rmOpts tool = RmOptions <$> ghcVersionArgument (Just ListInstalled) tool
+
+
+
+
+    --------------
+    --[ Footer ]--
+    --------------
+
+
+rmFooter :: String
+rmFooter = [s|Discussion:
+  Remove the given GHC or cabal version. When no command is given,
+  defaults to removing GHC with the specified version.
+  It is recommended to always specify a subcommand (ghc/cabal/hls/stack).|]
+
+
+
+
+    ---------------------------
+    --[ Effect interpreters ]--
+    ---------------------------
+
+
+type RmEffects = '[ NotInstalled, UninstallFailed ]
+
+
+runRm :: (ReaderT env m (VEither RmEffects a) -> m (VEither RmEffects a))
+            -> Excepts RmEffects (ReaderT env m) a
+            -> m (VEither RmEffects a)
+runRm runAppState =
+    runAppState
+    . runE
+      @RmEffects
+
+
+
+    ------------------
+    --[ Entrypoint ]--
+    ------------------
+
+
+
+rm :: ( Monad m
+      , MonadMask m
+      , MonadUnliftIO m
+      , MonadFail m
+      )
+   => Either RmCommand RmOptions
+   -> (ReaderT AppState m (VEither RmEffects (Maybe VersionInfo))
+       -> m (VEither RmEffects (Maybe VersionInfo)))
+   -> (ReaderT LeanAppState m () -> m ())
+   -> m ExitCode
+rm rmCommand runAppState runLogger = case rmCommand of
+  (Right rmopts) -> do
+    runLogger (logWarn "This is an old-style command for removing GHC. Use 'ghcup rm ghc' instead.")
+    rmGHC' rmopts
+  (Left (RmGHC rmopts)) -> rmGHC' rmopts
+  (Left (RmCabal rmopts)) -> rmCabal' rmopts
+  (Left (RmHLS rmopts)) -> rmHLS' rmopts
+  (Left (RmStack rmopts)) -> rmStack' rmopts
+
+ where
+  rmGHC' RmOptions{..} =
+    runRm runAppState (do
+        liftE $
+          rmGHCVer ghcVer
+        GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+        pure (getVersionInfo (_tvVersion ghcVer) GHC dls)
+      )
+      >>= \case
+            VRight vi -> do
+              runLogger $ logGHCPostRm ghcVer
+              postRmLog vi
+              pure ExitSuccess
+            VLeft  e -> do
+              runLogger $ logError $ T.pack $ prettyHFError e
+              pure $ ExitFailure 7
+
+  rmCabal' tv =
+    runRm runAppState (do
+        liftE $
+          rmCabalVer tv
+        GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+        pure (getVersionInfo tv Cabal dls)
+      )
+      >>= \case
+            VRight vi -> do
+              postRmLog vi
+              pure ExitSuccess
+            VLeft  e -> do
+              runLogger $ logError $ T.pack $ prettyHFError e
+              pure $ ExitFailure 15
+
+  rmHLS' tv =
+    runRm runAppState (do
+        liftE $
+          rmHLSVer tv
+        GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+        pure (getVersionInfo tv HLS dls)
+      )
+      >>= \case
+            VRight vi -> do
+              postRmLog vi
+              pure ExitSuccess
+            VLeft  e -> do
+              runLogger $ logError $ T.pack $ prettyHFError e
+              pure $ ExitFailure 15
+
+  rmStack' tv =
+    runRm runAppState (do
+        liftE $
+          rmStackVer tv
+        GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+        pure (getVersionInfo tv Stack dls)
+      )
+      >>= \case
+            VRight vi -> do
+              postRmLog vi
+              pure ExitSuccess
+            VLeft  e -> do
+              runLogger $ logError $ T.pack $ prettyHFError e
+              pure $ ExitFailure 15
+
+  postRmLog vi =
+    forM_ (_viPostRemove =<< vi) $ \msg ->
+      runLogger $ logInfo msg

app/ghcup/GHCup/OptParse/Run.hs

@@ -0,0 +1,503 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE RankNTypes        #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE TypeFamilies      #-}
+{-# LANGUAGE ViewPatterns      #-}
+module GHCup.OptParse.Run where
+
+
+import           GHCup
+import           GHCup.Utils
+import           GHCup.OptParse.Common
+import           GHCup.Errors
+import           GHCup.Types
+import           GHCup.Types.Optics
+import           GHCup.Prelude
+import           GHCup.Prelude.File
+#ifdef IS_WINDOWS
+import           GHCup.Prelude.Process
+import           GHCup.Prelude.Process.Windows ( execNoMinGW )
+#endif
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.String.QQ
+
+import           Control.Exception.Safe         ( MonadMask, MonadCatch )
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Codec.Archive
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Data.Functor
+import           Data.Maybe (isNothing)
+import           Data.List                      ( intercalate )
+import           Haskus.Utils.Variant.Excepts
+import           Options.Applicative     hiding ( style )
+import           Prelude                 hiding ( appendFile )
+import           System.FilePath
+import           System.Environment
+import           System.Exit
+
+import qualified Data.Map.Strict               as Map
+import qualified Data.Text                     as T
+#ifndef IS_WINDOWS
+import qualified System.Posix.Process          as SPP
+#endif
+import Data.Versions ( prettyVer, Version )
+
+
+
+
+
+    ---------------
+    --[ Options ]--
+    ---------------
+
+
+data RunOptions = RunOptions
+  { runAppendPATH :: Bool
+  , runInstTool'  :: Bool
+  , runMinGWPath  :: Bool
+  , runGHCVer     :: Maybe ToolVersion
+  , runCabalVer   :: Maybe ToolVersion
+  , runHLSVer     :: Maybe ToolVersion
+  , runStackVer   :: Maybe ToolVersion
+  , runBinDir     :: Maybe FilePath
+  , runQuick      :: Bool
+  , runCOMMAND    :: [String]
+  }
+
+
+
+    ---------------
+    --[ Parsers ]--
+    ---------------
+
+
+
+runOpts :: Parser RunOptions
+runOpts =
+  RunOptions
+    <$> switch
+          (short 'a' <> long "append" <> help "Append bin/ dir to PATH instead of prepending (this means that e.g. a system installation may take precedence)")
+    <*> switch
+          (short 'i' <> long "install" <> help "Install the tool, if missing")
+    <*> switch
+          (short 'm' <> long "mingw-path" <> help "On windows, add mingw64 PATHs to environment (does nothing on unix)")
+    <*> optional
+          (option
+            (eitherReader ghcVersionTagEither)
+            (metavar "GHC_VERSION" <> long "ghc" <> help "The ghc version"
+            <> completer (tagCompleter GHC [])
+            <> (completer $ versionCompleter Nothing GHC)
+            )
+          )
+    <*> optional
+          (option
+            (eitherReader toolVersionTagEither)
+            (metavar "CABAL_VERSION" <> long "cabal" <> help "The cabal version"
+            <> completer (tagCompleter Cabal [])
+            <> (completer $ versionCompleter Nothing Cabal)
+            )
+          )
+    <*> optional
+          (option
+            (eitherReader toolVersionTagEither)
+            (metavar "HLS_VERSION" <> long "hls" <> help "The HLS version"
+            <> completer (tagCompleter HLS [])
+            <> (completer $ versionCompleter Nothing HLS)
+            )
+          )
+    <*> optional
+          (option
+            (eitherReader toolVersionTagEither)
+            (metavar "STACK_VERSION" <> long "stack" <> help "The stack version"
+            <> completer (tagCompleter Stack [])
+            <> (completer $ versionCompleter Nothing Stack)
+            )
+          )
+    <*> optional
+          (option
+           (eitherReader isolateParser)
+           (  short 'b'
+           <> long "bindir"
+           <> metavar "DIR"
+           <> help "directory where to create the tool symlinks (default: newly created system temp dir)"
+           <> completer (bashCompleter "directory")
+           )
+          )
+    <*> switch
+          (short 'q' <> long "quick" <> help "Avoid any expensive work (such as downloads, version/tag resolution etc.). Disables --install.")
+    <*> many (argument str (metavar "COMMAND" <> help "The command to run, with arguments (use longopts --). If omitted, just prints the created bin/ dir to stdout and exits."))
+          
+
+
+
+    --------------
+    --[ Footer ]--
+    --------------
+
+
+runFooter :: String
+runFooter = [s|Discussion:
+  Adds the given tools to a dedicated bin/ directory and adds them to PATH, exposing
+  the relevant binaries, then executes a command.
+
+Examples:
+  # run VSCode with all latest toolchain exposed, installing missing versions if necessary
+  ghcup run --ghc latest --cabal latest --hls latest --stack latest --install -- code Setup.hs
+
+  # create a custom toolchain bin/ dir with GHC and cabal that can be manually added to PATH
+  ghcup run --ghc 8.10.7 --cabal 3.2.0.0 --bindir $HOME/toolchain/bin
+
+  # run a specific ghc version
+  ghcup run --ghc 8.10.7 -- ghc --version|]
+
+
+
+
+    ---------------------------
+    --[ Effect interpreters ]--
+    ---------------------------
+
+
+type RunEffects = '[ AlreadyInstalled
+                   , UnknownArchive
+                   , ArchiveResult
+                   , FileDoesNotExistError
+                   , CopyError
+                   , NotInstalled
+                   , DirNotEmpty
+                   , NoDownload
+                   , NotInstalled
+                   , BuildFailed
+                   , TagNotFound
+                   , DigestError
+                   , ContentLengthError
+                   , GPGError
+                   , DownloadFailed
+                   , TarDirDoesNotExist
+                   , NextVerNotFound
+                   , NoToolVersionSet
+                   , FileAlreadyExistsError
+                   , ProcessError
+                   , UninstallFailed
+                   , MergeFileTreeError
+                   ]
+
+runLeanRUN :: (MonadUnliftIO m, MonadIO m)
+           => LeanAppState
+           -> Excepts RunEffects (ReaderT LeanAppState m) a
+           -> m (VEither RunEffects a)
+runLeanRUN leanAppstate =
+    -- Don't use runLeanAppState here, which is disabled on windows.
+    -- This is the only command on all platforms that doesn't need full appstate.
+    flip runReaderT leanAppstate
+    . runE
+      @RunEffects
+
+runRUN :: MonadUnliftIO m
+      => IO AppState
+      -> Excepts RunEffects (ResourceT (ReaderT AppState m)) a
+      -> m (VEither RunEffects a)
+runRUN appState action' = do
+  s' <- liftIO appState
+  flip runReaderT s'
+    . runResourceT
+    . runE
+      @RunEffects
+    $ action'
+
+
+
+    ------------------
+    --[ Entrypoint ]--
+    ------------------
+
+
+
+run :: forall m .
+       ( MonadFail m
+       , MonadMask m
+       , MonadCatch m
+       , MonadIO m
+       , MonadUnliftIO m
+       )
+   => RunOptions
+   -> IO AppState
+   -> LeanAppState
+   -> (ReaderT LeanAppState m () -> m ())
+   -> m ExitCode
+run RunOptions{..} runAppState leanAppstate runLogger = do
+   r <- if not runQuick
+        then runRUN runAppState $ do
+         toolchain <- liftE resolveToolchainFull
+
+         -- oh dear
+         r <- lift ask
+         tmp <- lift . lift . lift . flip runReaderT (fromAppState r) $ createTmpDir toolchain
+
+         liftE $ installToolChainFull toolchain tmp
+         pure tmp
+        else runLeanRUN leanAppstate $ do
+         toolchain <- resolveToolchain
+         tmp <- lift $ createTmpDir toolchain
+         liftE $ installToolChain toolchain tmp
+         pure tmp
+   case r of
+         VRight tmp -> do
+           case runCOMMAND of
+             [] -> do
+               liftIO $ putStr tmp
+               pure ExitSuccess
+             (cmd:args) -> do
+               newEnv <- liftIO $ addToPath tmp
+#ifndef IS_WINDOWS
+               void $ liftIO $ SPP.executeFile cmd True args (Just newEnv)
+               pure ExitSuccess
+#else
+               r' <- if runMinGWPath
+                     then runLeanRUN leanAppstate $ liftE $ lEM @_ @'[ProcessError] $ exec cmd args Nothing (Just newEnv)
+                     else runLeanRUN leanAppstate $ liftE $ lEM @_ @'[ProcessError] $ execNoMinGW cmd args Nothing (Just newEnv)
+               case r' of
+                 VRight _ -> pure ExitSuccess
+                 VLeft e -> do
+                   runLogger $ logError $ T.pack $ prettyHFError e
+                   pure $ ExitFailure 28
+#endif
+         VLeft e -> do
+           runLogger $ logError $ T.pack $ prettyHFError e
+           pure $ ExitFailure 27
+
+  where
+
+   -- TODO: doesn't work for cross
+   resolveToolchainFull :: ( MonadFail m
+                           , MonadThrow m
+                           , MonadIO m
+                           , MonadCatch m
+                           )
+                        => Excepts
+                             '[ TagNotFound
+                              , NextVerNotFound
+                              , NoToolVersionSet
+                              ] (ResourceT (ReaderT AppState m)) Toolchain
+   resolveToolchainFull = do
+         ghcVer <- forM runGHCVer $ \ver -> do
+           (v, _) <- liftE $ fromVersion (Just ver) GHC
+           pure v
+         cabalVer <- forM runCabalVer $ \ver -> do
+           (v, _) <- liftE $ fromVersion (Just ver) Cabal
+           pure (_tvVersion v)
+         hlsVer <- forM runHLSVer $ \ver -> do
+           (v, _) <- liftE $ fromVersion (Just ver) HLS
+           pure (_tvVersion v)
+         stackVer <- forM runStackVer $ \ver -> do
+           (v, _) <- liftE $ fromVersion (Just ver) Stack
+           pure (_tvVersion v)
+         pure Toolchain{..}
+
+   resolveToolchain = do
+         ghcVer <- case runGHCVer of
+            Just (GHCVersion v) -> pure $ Just v
+            Just (ToolVersion v) -> pure $ Just (mkTVer v)
+            Nothing -> pure Nothing
+            _ -> fail "Internal error"
+         cabalVer <- case runCabalVer of
+            Just (GHCVersion v) -> pure $ Just (_tvVersion v)
+            Just (ToolVersion v) -> pure $ Just v
+            Nothing -> pure Nothing
+            _ -> fail "Internal error"
+         hlsVer <- case runHLSVer of
+            Just (GHCVersion v) -> pure $ Just (_tvVersion v)
+            Just (ToolVersion v) -> pure $ Just v
+            Nothing -> pure Nothing
+            _ -> fail "Internal error"
+         stackVer <- case runStackVer of
+            Just (GHCVersion v) -> pure $ Just (_tvVersion v)
+            Just (ToolVersion v) -> pure $ Just v
+            Nothing -> pure Nothing
+            _ -> fail "Internal error"
+         pure Toolchain{..}
+
+   installToolChainFull :: ( MonadFail m
+                           , MonadThrow m
+                           , MonadIO m
+                           , MonadCatch m
+                           )
+                        => Toolchain
+                        -> FilePath
+                        -> Excepts
+                             '[ TagNotFound
+                              , NextVerNotFound
+                              , NoToolVersionSet
+                              , UnknownArchive
+                              , TarDirDoesNotExist
+                              , ProcessError
+                              , NotInstalled
+                              , NoDownload
+                              , GPGError
+                              , DownloadFailed
+                              , DirNotEmpty
+                              , DigestError
+                              , ContentLengthError
+                              , BuildFailed
+                              , ArchiveResult
+                              , AlreadyInstalled
+                              , FileAlreadyExistsError
+                              , CopyError
+                              , UninstallFailed
+                              , MergeFileTreeError
+                              ] (ResourceT (ReaderT AppState m)) ()
+   installToolChainFull Toolchain{..} tmp = do
+         case ghcVer of
+           Just v -> do
+             isInstalled <- lift $ checkIfToolInstalled' GHC v
+             unless isInstalled $ when (runInstTool' && isNothing (_tvTarget v)) $ void $ liftE $ installGHCBin
+               (_tvVersion v)
+               GHCupInternal
+               False
+               []
+             setGHC' v tmp
+           _ -> pure ()
+         case cabalVer of
+           Just v -> do
+             isInstalled <- lift $ checkIfToolInstalled' Cabal (mkTVer v)
+             unless isInstalled $ when runInstTool' $ void $ liftE $ installCabalBin
+               v
+               GHCupInternal
+               False
+             setCabal' v tmp
+           _ -> pure ()
+         case stackVer of
+           Just v -> do
+             isInstalled <- lift $ checkIfToolInstalled' Stack (mkTVer v)
+             unless isInstalled $ when runInstTool' $ void $ liftE $ installStackBin
+               v
+               GHCupInternal
+               False
+             setStack' v tmp
+           _ -> pure ()
+         case hlsVer of
+           Just v -> do
+             isInstalled <- lift $ checkIfToolInstalled' HLS (mkTVer v)
+             unless isInstalled $ when runInstTool' $ void $ liftE $ installHLSBin
+               v
+               GHCupInternal
+               False
+             setHLS' v tmp
+           _ -> pure ()
+
+   installToolChain :: ( MonadFail m
+                       , MonadThrow m
+                       , MonadIO m
+                       , MonadCatch m
+                       )
+                    => Toolchain
+                    -> FilePath
+                    -> Excepts '[NotInstalled] (ReaderT LeanAppState m) ()
+   installToolChain Toolchain{..} tmp = do
+         case ghcVer of
+           Just v -> setGHC' v tmp
+           _ -> pure ()
+         case cabalVer of
+           Just v -> setCabal' v tmp
+           _ -> pure ()
+         case stackVer of
+           Just v -> setStack' v tmp
+           _ -> pure ()
+         case hlsVer of
+           Just v -> setHLS' v tmp
+           _ -> pure ()
+
+   setGHC' v tmp = do
+          void $ liftE $ setGHC v SetGHC_XYZ (Just tmp)
+          void $ liftE $ setGHC v SetGHCOnly (Just tmp)
+   setCabal' v tmp = do
+          bin  <- liftE $ whereIsTool Cabal (mkTVer v)
+          cbin <- liftIO $ canonicalizePath bin
+          lift $ createLink (relativeSymlink tmp cbin) (tmp </> ("cabal" <.> exeExt))
+   setStack' v tmp = do
+          bin  <- liftE $ whereIsTool Stack (mkTVer v)
+          cbin <- liftIO $ canonicalizePath bin
+          lift $ createLink (relativeSymlink tmp cbin) (tmp </> ("stack" <.> exeExt))
+   setHLS' v tmp = do
+          Dirs {..}  <- getDirs
+          legacy <- isLegacyHLS v
+          if legacy
+          then do
+            -- TODO: factor this out
+            hlsWrapper <- liftE @_ @'[NotInstalled] $ hlsWrapperBinary v !? (NotInstalled HLS (mkTVer v))
+            cw <- liftIO $ canonicalizePath (binDir </> hlsWrapper)
+            lift $ createLink (relativeSymlink tmp cw) (tmp </> takeFileName cw)
+            hlsBins <- hlsServerBinaries v Nothing >>= liftIO . traverse (canonicalizePath . (binDir </>))
+            forM_ hlsBins $ \bin ->
+              lift $ createLink (relativeSymlink tmp bin) (tmp </> takeFileName bin)
+            liftE $ setHLS v SetHLSOnly (Just tmp)
+          else do
+            liftE $ setHLS v SetHLS_XYZ (Just tmp)
+            liftE $ setHLS v SetHLSOnly (Just tmp)
+
+   addToPath path = do
+    cEnv <- Map.fromList <$> getEnvironment
+    let paths          = ["PATH", "Path"]
+        curPaths       = (\x -> maybe [] splitSearchPath (Map.lookup x cEnv)) =<< paths
+        newPath        = intercalate [searchPathSeparator] (if runAppendPATH then (curPaths ++ [path]) else (path : curPaths))
+        envWithoutPath = foldr (\x y -> Map.delete x y) cEnv paths
+        pathVar        = if isWindows then "Path" else "PATH"
+        envWithNewPath = Map.toList $ Map.insert pathVar newPath envWithoutPath
+    liftIO $ setEnv pathVar newPath
+    return envWithNewPath
+
+   createTmpDir :: ( MonadUnliftIO m
+                   , MonadCatch m
+                   , MonadThrow m
+                   , MonadMask m
+                   , MonadIO m
+                   )
+                => Toolchain
+                -> ReaderT LeanAppState m FilePath
+   createTmpDir toolchain =
+     case runBinDir of
+           Just bindir -> do
+             liftIO $ createDirRecursive' bindir
+             liftIO $ canonicalizePath bindir
+           Nothing -> do
+             d <- predictableTmpDir toolchain
+             liftIO $ createDirRecursive' d
+             liftIO $ canonicalizePath d
+
+   predictableTmpDir :: Monad m
+                     => Toolchain
+                     -> ReaderT LeanAppState m FilePath
+   predictableTmpDir (Toolchain Nothing Nothing Nothing Nothing) = do
+     Dirs { tmpDir } <- getDirs
+     pure (fromGHCupPath tmpDir </> "ghcup-none")
+   predictableTmpDir Toolchain{..} = do
+      Dirs { tmpDir } <- getDirs
+      pure $ fromGHCupPath tmpDir
+        </> ("ghcup-" <> intercalate "_"
+              (  maybe [] ( (:[]) . ("ghc-"   <>) . T.unpack . tVerToText) ghcVer
+              <> maybe [] ( (:[]) . ("cabal-" <>) . T.unpack . prettyVer) cabalVer
+              <> maybe [] ( (:[]) . ("hls-"   <>) . T.unpack . prettyVer) hlsVer
+              <> maybe [] ( (:[]) . ("stack-" <>) . T.unpack . prettyVer) stackVer
+              )
+            )
+
+
+
+    -------------------------
+    --[ Other local types ]--
+    -------------------------
+
+
+
+data Toolchain = Toolchain
+  { ghcVer     :: Maybe GHCTargetVersion
+  , cabalVer   :: Maybe Version
+  , hlsVer     :: Maybe Version
+  , stackVer   :: Maybe Version
+  } deriving Show

app/ghcup/GHCup/OptParse/Set.hs

@@ -0,0 +1,351 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE RankNTypes #-}
+
+module GHCup.OptParse.Set where
+
+
+
+
+import           GHCup.OptParse.Common
+
+import           GHCup
+import           GHCup.Errors
+import           GHCup.Types
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.String.QQ
+
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Data.Either
+import           Data.Functor
+import           Data.Maybe
+import           Data.Versions           hiding ( str )
+import           GHC.Unicode
+import           Haskus.Utils.Variant.Excepts
+import           Options.Applicative     hiding ( style )
+import           Options.Applicative.Help.Pretty ( text )
+import           Prelude                 hiding ( appendFile )
+import           System.Exit
+
+import qualified Data.Text                     as T
+import Data.Bifunctor (second)
+import Control.Exception.Safe (MonadMask)
+import GHCup.Types.Optics
+
+
+
+
+    ----------------
+    --[ Commands ]--
+    ----------------
+
+
+data SetCommand = SetGHC SetOptions
+                | SetCabal SetOptions
+                | SetHLS SetOptions
+                | SetStack SetOptions
+
+
+
+
+    ---------------
+    --[ Options ]--
+    ---------------
+
+
+data SetOptions = SetOptions
+  { sToolVer :: SetToolVersion
+  }
+
+
+
+
+    ---------------
+    --[ Parsers ]--
+    ---------------
+
+
+setParser :: Parser (Either SetCommand SetOptions)
+setParser =
+  (Left <$> subparser
+      (  command
+          "ghc"
+          (   SetGHC
+          <$> info
+                (setOpts GHC <**> helper)
+                (  progDesc "Set GHC version"
+                <> footerDoc (Just $ text setGHCFooter)
+                )
+          )
+      <> command
+           "cabal"
+           (   SetCabal
+           <$> info
+                 (setOpts Cabal <**> helper)
+                 (  progDesc "Set Cabal version"
+                 <> footerDoc (Just $ text setCabalFooter)
+                 )
+           )
+      <> command
+           "hls"
+           (   SetHLS
+           <$> info
+                 (setOpts HLS <**> helper)
+                 (  progDesc "Set haskell-language-server version"
+                 <> footerDoc (Just $ text setHLSFooter)
+                 )
+           )
+      <> command
+           "stack"
+           (   SetStack
+           <$> info
+                 (setOpts Stack <**> helper)
+                 (  progDesc "Set stack version"
+                 <> footerDoc (Just $ text setStackFooter)
+                 )
+           )
+      )
+    )
+    <|> (Right <$> setOpts GHC)
+ where
+  setGHCFooter :: String
+  setGHCFooter = [s|Discussion:
+    Sets the the current GHC version by creating non-versioned
+    symlinks for all ghc binaries of the specified version in
+    "~/.ghcup/bin/<binary>".|]
+
+  setCabalFooter :: String
+  setCabalFooter = [s|Discussion:
+    Sets the the current Cabal version.|]
+
+  setStackFooter :: String
+  setStackFooter = [s|Discussion:
+    Sets the the current Stack version.|]
+
+  setHLSFooter :: String
+  setHLSFooter = [s|Discussion:
+    Sets the the current haskell-language-server version.|]
+
+
+setOpts :: Tool -> Parser SetOptions
+setOpts tool = SetOptions <$>
+    (fromMaybe SetRecommended <$>
+      optional (setVersionArgument (Just ListInstalled) tool))
+
+setVersionArgument :: Maybe ListCriteria -> Tool -> Parser SetToolVersion
+setVersionArgument criteria tool =
+  argument (eitherReader setEither)
+    (metavar "VERSION|TAG|next"
+    <> completer (tagCompleter tool ["next"])
+    <> (completer . versionCompleter criteria) tool)
+ where
+  setEither s' =
+        parseSet s'
+    <|> second SetToolTag (tagEither s')
+    <|> se s'
+  se s' = case tool of
+           GHC -> second SetGHCVersion (ghcVersionEither s')
+           _   -> second SetToolVersion (toolVersionEither s')
+  parseSet s' = case fmap toLower s' of
+                  "next" -> Right SetNext
+                  other  -> Left $ "Unknown tag/version " <> other
+
+
+
+
+    --------------
+    --[ Footer ]--
+    --------------
+
+
+setFooter :: String
+setFooter = [s|Discussion:
+  Sets the currently active GHC or cabal version. When no command is given,
+  defaults to setting GHC with the specified version/tag (if no tag
+  is given, sets GHC to 'recommended' version).
+  It is recommended to always specify a subcommand (ghc/cabal/hls/stack).|]
+
+
+
+    ---------------------------
+    --[ Effect interpreters ]--
+    ---------------------------
+
+
+type SetGHCEffects = '[ FileDoesNotExistError
+                   , NotInstalled
+                   , TagNotFound
+                   , NextVerNotFound
+                   , NoToolVersionSet]
+
+runSetGHC :: (ReaderT env m (VEither SetGHCEffects a) -> m (VEither SetGHCEffects a))
+          -> Excepts SetGHCEffects (ReaderT env m) a
+          -> m (VEither SetGHCEffects a)
+runSetGHC runAppState =
+    runAppState
+    . runE
+      @SetGHCEffects
+
+
+type SetCabalEffects = '[ NotInstalled
+                        , TagNotFound
+                        , NextVerNotFound
+                        , NoToolVersionSet]
+
+runSetCabal :: (ReaderT env m (VEither SetCabalEffects a) -> m (VEither SetCabalEffects a))
+            -> Excepts SetCabalEffects (ReaderT env m) a
+            -> m (VEither SetCabalEffects a)
+runSetCabal runAppState =
+    runAppState
+    . runE
+      @SetCabalEffects
+
+
+type SetHLSEffects = '[ NotInstalled
+                      , TagNotFound
+                      , NextVerNotFound
+                      , NoToolVersionSet]
+
+runSetHLS :: (ReaderT env m (VEither SetHLSEffects a) -> m (VEither SetHLSEffects a))
+          -> Excepts SetHLSEffects (ReaderT env m) a
+          -> m (VEither SetHLSEffects a)
+runSetHLS runAppState =
+    runAppState
+    . runE
+      @SetHLSEffects
+
+
+type SetStackEffects = '[ NotInstalled
+                        , TagNotFound
+                        , NextVerNotFound
+                        , NoToolVersionSet]
+
+runSetStack :: (ReaderT env m (VEither SetStackEffects a) -> m (VEither SetStackEffects a))
+            -> Excepts SetStackEffects (ReaderT env m) a
+            -> m (VEither SetStackEffects a)
+runSetStack runAppState =
+    runAppState
+    . runE
+      @SetStackEffects
+
+
+
+    -------------------
+    --[ Entrypoints ]--
+    -------------------
+
+
+set :: forall m env.
+       ( Monad m
+       , MonadMask m
+       , MonadUnliftIO m
+       , MonadFail m
+       , HasDirs env
+       , HasLog env
+       )
+    => Either SetCommand SetOptions
+    -> (forall eff . ReaderT AppState m (VEither eff GHCTargetVersion)
+        -> m (VEither eff GHCTargetVersion))
+    -> (forall eff. ReaderT env m (VEither eff GHCTargetVersion)
+        -> m (VEither eff GHCTargetVersion))
+    -> (ReaderT LeanAppState m () -> m ())
+    -> m ExitCode
+set setCommand runAppState runLeanAppState runLogger = case setCommand of
+  (Right sopts) -> do
+    runLogger (logWarn "This is an old-style command for setting GHC. Use 'ghcup set ghc' instead.")
+    setGHC' sopts
+  (Left (SetGHC sopts))   -> setGHC'   sopts
+  (Left (SetCabal sopts)) -> setCabal' sopts
+  (Left (SetHLS sopts))   -> setHLS'   sopts
+  (Left (SetStack sopts)) -> setStack' sopts
+
+ where
+  setGHC' :: SetOptions
+          -> m ExitCode
+  setGHC' SetOptions{ sToolVer } =
+    case sToolVer of
+      (SetGHCVersion v) -> runSetGHC runLeanAppState (liftE $ setGHC v SetGHCOnly Nothing >> pure v)
+      _ -> runSetGHC runAppState (do
+          v <- liftE $ fst <$> fromVersion' sToolVer GHC
+          liftE $ setGHC v SetGHCOnly Nothing
+        )
+      >>= \case
+            VRight GHCTargetVersion{..} -> do
+              runLogger
+                $ logInfo $
+                    "GHC " <> prettyVer _tvVersion <> " successfully set as default version" <> maybe "" (" for cross target " <>) _tvTarget
+              pure ExitSuccess
+            VLeft e -> do
+              runLogger $ logError $ T.pack $ prettyHFError e
+              pure $ ExitFailure 5
+
+
+  setCabal' :: SetOptions
+            -> m ExitCode
+  setCabal' SetOptions{ sToolVer } =
+    case sToolVer of
+      (SetToolVersion v) -> runSetCabal runLeanAppState (liftE $ setCabal v >> pure (mkTVer v))
+      _ -> runSetCabal runAppState (do
+          v <- liftE $ fst <$> fromVersion' sToolVer Cabal
+          liftE $ setCabal (_tvVersion v)
+          pure v
+        )
+      >>= \case
+            VRight v -> do
+              runLogger
+                $ logInfo $
+                    "Cabal " <> prettyVer (_tvVersion v) <> " successfully set as default version"
+              pure ExitSuccess
+            VLeft  e -> do
+              runLogger $ logError $ T.pack $ prettyHFError e
+              pure $ ExitFailure 14
+
+  setHLS' :: SetOptions
+          -> m ExitCode
+  setHLS' SetOptions{ sToolVer } =
+    case sToolVer of
+      (SetToolVersion v) -> runSetHLS runLeanAppState (liftE $ setHLS v SetHLSOnly Nothing >> pure (mkTVer v))
+      _ -> runSetHLS runAppState (do
+          v <- liftE $ fst <$> fromVersion' sToolVer HLS
+          liftE $ setHLS (_tvVersion v) SetHLSOnly Nothing
+          pure v
+        )
+      >>= \case
+            VRight v -> do
+              runLogger
+                $ logInfo $
+                    "HLS " <> prettyVer (_tvVersion v) <> " successfully set as default version"
+              pure ExitSuccess
+            VLeft  e -> do
+              runLogger $ logError $ T.pack $ prettyHFError e
+              pure $ ExitFailure 14
+
+
+  setStack' :: SetOptions
+            -> m ExitCode
+  setStack' SetOptions{ sToolVer } =
+    case sToolVer of
+      (SetToolVersion v) -> runSetStack runLeanAppState (liftE $ setStack v >> pure (mkTVer v))
+      _ -> runSetStack runAppState (do
+            v <- liftE $ fst <$> fromVersion' sToolVer Stack
+            liftE $ setStack (_tvVersion v)
+            pure v
+          )
+      >>= \case
+            VRight v -> do
+              runLogger
+                $ logInfo $
+                    "Stack " <> prettyVer (_tvVersion v) <> " successfully set as default version"
+              pure ExitSuccess
+            VLeft  e -> do
+              runLogger $ logError $ T.pack $ prettyHFError e
+              pure $ ExitFailure 14

app/ghcup/GHCup/OptParse/ToolRequirements.hs

@@ -0,0 +1,121 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE QuasiQuotes #-}
+
+module GHCup.OptParse.ToolRequirements where
+
+
+import           GHCup.Errors
+import           GHCup.Types
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.String.QQ
+
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Haskus.Utils.Variant.Excepts
+import           Options.Applicative     hiding ( style )
+import           Prelude                 hiding ( appendFile )
+import           System.Exit
+
+import qualified Data.Text                     as T
+import qualified Data.Text.IO                  as T
+import Control.Exception.Safe (MonadMask)
+import GHCup.Types.Optics
+import GHCup.Platform
+import GHCup.Prelude
+import GHCup.Requirements
+import System.IO
+
+
+
+    ---------------
+    --[ Options ]--
+    ---------------
+
+
+data ToolReqOpts = ToolReqOpts
+  { tlrRaw :: Bool
+  }
+
+
+
+
+    ---------------
+    --[ Parsers ]--
+    ---------------
+
+          
+toolReqP :: Parser ToolReqOpts
+toolReqP =
+  ToolReqOpts
+    <$> switch (short 'r' <> long "raw-format" <> help "machine-parsable format")
+
+
+
+
+    --------------
+    --[ Footer ]--
+    --------------
+
+
+toolReqFooter :: String
+toolReqFooter = [s|Discussion:
+  Print tool requirements on the current platform.
+  If you want to pass this to your package manage, use '--raw-format'.|]
+
+
+
+    ---------------------------
+    --[ Effect interpreters ]--
+    ---------------------------
+
+
+type ToolRequirementsEffects = '[ NoCompatiblePlatform , DistroNotFound , NoToolRequirements ]
+
+
+runToolRequirements :: (ReaderT env m (VEither ToolRequirementsEffects a) -> m (VEither ToolRequirementsEffects a))
+                    -> Excepts ToolRequirementsEffects (ReaderT env m) a
+                    -> m (VEither ToolRequirementsEffects a)
+runToolRequirements runAppState =
+    runAppState
+    . runE
+      @ToolRequirementsEffects
+
+
+
+    ------------------
+    --[ Entrypoint ]--
+    ------------------
+
+
+
+toolRequirements :: ( Monad m
+                    , MonadMask m
+                    , MonadUnliftIO m
+                    , MonadFail m
+                    , Alternative m
+                    )
+                 => ToolReqOpts
+                 -> (ReaderT AppState m (VEither ToolRequirementsEffects ()) -> m (VEither ToolRequirementsEffects ()))
+                 -> (ReaderT LeanAppState m () -> m ())
+                 -> m ExitCode
+toolRequirements ToolReqOpts{..} runAppState runLogger = runToolRequirements runAppState (do
+    GHCupInfo { .. } <- lift getGHCupInfo
+    platform' <- liftE getPlatform
+    req       <- getCommonRequirements platform' _toolRequirements ?? NoToolRequirements
+    if tlrRaw
+    then liftIO $ T.hPutStr stdout (rawRequirements req)
+    else liftIO $ T.hPutStr stdout (prettyRequirements req)
+  )
+    >>= \case
+          VRight _ -> pure ExitSuccess
+          VLeft  e -> do
+            runLogger $ logError $ T.pack $ prettyHFError e
+            pure $ ExitFailure 12

app/ghcup/GHCup/OptParse/UnSet.hs

@@ -0,0 +1,204 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE RankNTypes #-}
+
+module GHCup.OptParse.UnSet where
+
+
+
+
+import           GHCup
+import           GHCup.Errors
+import           GHCup.Types
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.String.QQ
+
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Data.Functor
+import           Data.Maybe
+import           Haskus.Utils.Variant.Excepts
+import           Options.Applicative     hiding ( style )
+import           Options.Applicative.Help.Pretty ( text )
+import           Prelude                 hiding ( appendFile )
+import           System.Exit
+
+import qualified Data.Text                     as T
+import Control.Exception.Safe (MonadMask)
+import GHCup.Types.Optics
+
+
+
+
+    ----------------
+    --[ Commands ]--
+    ----------------
+
+
+data UnsetCommand = UnsetGHC   UnsetOptions
+                  | UnsetCabal UnsetOptions
+                  | UnsetHLS   UnsetOptions
+                  | UnsetStack UnsetOptions
+
+
+
+
+    ---------------
+    --[ Options ]--
+    ---------------
+
+
+data UnsetOptions = UnsetOptions
+  { sToolVer :: Maybe T.Text -- target platform triple
+  }
+
+
+
+
+    ---------------
+    --[ Parsers ]--
+    ---------------
+
+          
+unsetParser :: Parser UnsetCommand
+unsetParser =
+  subparser
+      (  command
+          "ghc"
+          (   UnsetGHC
+          <$> info
+                (unsetOpts <**> helper)
+                (  progDesc "Unset GHC version"
+                <> footerDoc (Just $ text unsetGHCFooter)
+                )
+          )
+      <> command
+           "cabal"
+           (   UnsetCabal
+           <$> info
+                (unsetOpts <**> helper)
+                 (  progDesc "Unset Cabal version"
+                 <> footerDoc (Just $ text unsetCabalFooter)
+                 )
+           )
+      <> command
+           "hls"
+           (   UnsetHLS
+           <$> info
+                 (unsetOpts <**> helper)
+                 (  progDesc "Unset haskell-language-server version"
+                 <> footerDoc (Just $ text unsetHLSFooter)
+                 )
+           )
+      <> command
+           "stack"
+           (   UnsetStack
+           <$> info
+                 (unsetOpts <**> helper)
+                 (  progDesc "Unset stack version"
+                 <> footerDoc (Just $ text unsetStackFooter)
+                 )
+           )
+      )
+ where
+  unsetGHCFooter :: String
+  unsetGHCFooter = [s|Discussion:
+    Unsets the the current GHC version. That means there won't
+    be a ~/.ghcup/bin/ghc anymore.|]
+
+  unsetCabalFooter :: String
+  unsetCabalFooter = [s|Discussion:
+    Unsets the the current Cabal version.|]
+
+  unsetStackFooter :: String
+  unsetStackFooter = [s|Discussion:
+    Unsets the the current Stack version.|]
+
+  unsetHLSFooter :: String
+  unsetHLSFooter = [s|Discussion:
+    Unsets the the current haskell-language-server version.|]
+
+
+unsetOpts :: Parser UnsetOptions
+unsetOpts = UnsetOptions . fmap T.pack <$> optional (argument str (metavar "TRIPLE"))
+
+
+
+    --------------
+    --[ Footer ]--
+    --------------
+
+
+unsetFooter :: String
+unsetFooter = [s|Discussion:
+  Unsets the currently active GHC or cabal version.|]
+
+
+
+
+    ---------------------------
+    --[ Effect interpreters ]--
+    ---------------------------
+
+
+type UnsetEffects = '[ NotInstalled ]
+
+
+runUnsetGHC :: (ReaderT env m (VEither UnsetEffects a) -> m (VEither UnsetEffects a))
+            -> Excepts UnsetEffects (ReaderT env m) a
+            -> m (VEither UnsetEffects a)
+runUnsetGHC runLeanAppState =
+    runLeanAppState
+    . runE
+      @UnsetEffects
+
+
+
+    ------------------
+    --[ Entrypoint ]--
+    ------------------
+
+
+
+unset :: ( Monad m
+         , MonadMask m
+         , MonadUnliftIO m
+         , MonadFail m
+         , HasDirs env
+         , HasLog env
+         )
+      => UnsetCommand
+      -> (ReaderT env m (VEither UnsetEffects ())
+          -> m (VEither UnsetEffects ()))
+      -> (ReaderT LeanAppState m () -> m ())
+      -> m ExitCode
+unset unsetCommand runLeanAppState runLogger = case unsetCommand of
+  (UnsetGHC (UnsetOptions triple)) -> runUnsetGHC runLeanAppState (unsetGHC triple)
+        >>= \case
+              VRight _ -> do
+                runLogger $ logInfo "GHC successfully unset"
+                pure ExitSuccess
+              VLeft  e -> do
+                runLogger $ logError $ T.pack $ prettyHFError e
+                pure $ ExitFailure 14
+  (UnsetCabal (UnsetOptions _)) -> do
+    void $ runLeanAppState (VRight <$> unsetCabal)
+    runLogger $ logInfo "Cabal successfully unset"
+    pure ExitSuccess
+  (UnsetHLS (UnsetOptions _)) -> do
+    void $ runLeanAppState (VRight <$> unsetHLS)
+    runLogger $ logInfo "HLS successfully unset"
+    pure ExitSuccess
+  (UnsetStack (UnsetOptions _)) -> do
+    void $ runLeanAppState (VRight <$> unsetStack)
+    runLogger $ logInfo "Stack successfully unset"
+    pure ExitSuccess

app/ghcup/GHCup/OptParse/Upgrade.hs

@@ -0,0 +1,155 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE RankNTypes #-}
+
+module GHCup.OptParse.Upgrade where
+
+
+
+
+import           GHCup
+import           GHCup.Errors
+import           GHCup.Types
+import           GHCup.Prelude.File
+import           GHCup.Prelude.Logger
+
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Data.Functor
+import           Data.Maybe
+import           Haskus.Utils.Variant.Excepts
+import           Options.Applicative     hiding ( style )
+import           Prelude                 hiding ( appendFile )
+import           System.Exit
+
+import qualified Data.Text                     as T
+import Control.Exception.Safe (MonadMask)
+import System.Environment
+import GHCup.Utils
+import System.FilePath
+import GHCup.Types.Optics
+import Data.Versions         hiding (str)
+
+
+
+
+
+
+    ---------------
+    --[ Options ]--
+    ---------------
+
+
+data UpgradeOpts = UpgradeInplace
+                 | UpgradeAt FilePath
+                 | UpgradeGHCupDir
+                 deriving Show
+
+
+
+
+    ---------------
+    --[ Parsers ]--
+    ---------------
+
+
+upgradeOptsP :: Parser UpgradeOpts
+upgradeOptsP =
+  flag'
+      UpgradeInplace
+      (short 'i' <> long "inplace" <> help
+        "Upgrade ghcup in-place"
+      )
+    <|>
+      (   UpgradeAt
+        <$> option
+              str
+              (short 't' <> long "target" <> metavar "TARGET_DIR" <> help
+                "Absolute filepath to write ghcup into"
+                <> completer (bashCompleter "file")
+              )
+        )
+    <|> pure UpgradeGHCupDir
+
+
+
+
+    ---------------------------
+    --[ Effect interpreters ]--
+    ---------------------------
+
+
+type UpgradeEffects = '[ DigestError
+                       , ContentLengthError
+                       , GPGError
+                       , NoDownload
+                       , NoUpdate
+                       , FileDoesNotExistError
+                       , CopyError
+                       , DownloadFailed
+                       , ToolShadowed
+                       ]
+
+
+runUpgrade :: MonadUnliftIO m
+           => (ReaderT AppState m (VEither UpgradeEffects a) -> m (VEither UpgradeEffects a))
+           -> Excepts UpgradeEffects (ResourceT (ReaderT AppState m)) a
+           -> m (VEither UpgradeEffects a)
+runUpgrade runAppState =
+  runAppState
+  . runResourceT
+  . runE
+    @UpgradeEffects
+
+
+
+    ------------------
+    --[ Entrypoint ]--
+    ------------------
+
+
+
+upgrade :: ( Monad m
+           , MonadMask m
+           , MonadUnliftIO m
+           , MonadFail m
+           )
+        => UpgradeOpts
+        -> Bool
+        -> Bool
+        -> Dirs
+        -> (forall a. ReaderT AppState m (VEither UpgradeEffects a) -> m (VEither UpgradeEffects a))
+        -> (ReaderT LeanAppState m () -> m ())
+        -> m ExitCode
+upgrade uOpts force' fatal Dirs{..} runAppState runLogger = do
+  target <- case uOpts of
+    UpgradeInplace  -> Just <$> liftIO getExecutablePath
+    (UpgradeAt p)   -> pure $ Just p
+    UpgradeGHCupDir -> pure (Just (binDir </> "ghcup" <> exeExt))
+
+  runUpgrade runAppState (do
+    v' <- liftE $ upgradeGHCup target force' fatal
+    GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+    pure (v', dls)
+    ) >>= \case
+      VRight (v', dls) -> do
+        let pretty_v = prettyVer v'
+        let vi = fromJust $ snd <$> getLatest dls GHCup
+        runLogger $ logInfo $
+          "Successfully upgraded GHCup to version " <> pretty_v
+        forM_ (_viPostInstall vi) $ \msg ->
+          runLogger $ logInfo msg
+        pure ExitSuccess
+      VLeft (V NoUpdate) -> do
+        runLogger $ logWarn "No GHCup update available"
+        pure ExitSuccess
+      VLeft e -> do
+        runLogger $ logError $ T.pack $ prettyHFError e
+        pure $ ExitFailure 11

app/ghcup/GHCup/OptParse/Whereis.hs

@@ -0,0 +1,341 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE DataKinds         #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE FlexibleContexts  #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE DuplicateRecordFields #-}
+{-# LANGUAGE RankNTypes #-}
+
+module GHCup.OptParse.Whereis where
+
+
+
+
+import           GHCup
+import           GHCup.Errors
+import           GHCup.OptParse.Common
+import           GHCup.Types
+import           GHCup.Utils
+import           GHCup.Prelude.Logger
+import           GHCup.Prelude.String.QQ
+
+#if !MIN_VERSION_base(4,13,0)
+import           Control.Monad.Fail             ( MonadFail )
+#endif
+import           Control.Monad.Reader
+import           Control.Monad.Trans.Resource
+import           Data.Functor
+import           Data.Maybe
+import           Haskus.Utils.Variant.Excepts
+import           Options.Applicative     hiding ( style )
+import           Options.Applicative.Help.Pretty ( text )
+import           Prelude                 hiding ( appendFile )
+import           System.Environment
+import           System.Exit
+
+import qualified Data.Text                     as T
+import Control.Exception.Safe (MonadMask)
+import System.FilePath (takeDirectory)
+import GHCup.Types.Optics
+
+
+
+
+    ----------------
+    --[ Commands ]--
+    ----------------
+
+
+data WhereisCommand = WhereisTool Tool (Maybe ToolVersion)
+                    | WhereisBaseDir
+                    | WhereisBinDir
+                    | WhereisCacheDir
+                    | WhereisLogsDir
+                    | WhereisConfDir
+
+
+
+
+
+    ---------------
+    --[ Options ]--
+    ---------------
+
+
+data WhereisOptions = WhereisOptions {
+   directory :: Bool
+}
+
+
+
+
+    ---------------
+    --[ Parsers ]--
+    ---------------
+
+
+whereisP :: Parser WhereisCommand
+whereisP = subparser
+  (commandGroup "Tools locations:" <>
+    command
+      "ghc"
+      (WhereisTool GHC <$> info
+        ( optional (toolVersionTagArgument Nothing (Just GHC)) <**> helper )
+        ( progDesc "Get GHC location"
+        <> footerDoc (Just $ text whereisGHCFooter ))
+      )
+      <>
+     command
+      "cabal"
+      (WhereisTool Cabal <$> info
+        ( optional (toolVersionTagArgument Nothing (Just Cabal)) <**> helper )
+        ( progDesc "Get cabal location"
+        <> footerDoc (Just $ text whereisCabalFooter ))
+      )
+      <>
+     command
+      "hls"
+      (WhereisTool HLS <$> info
+        ( optional (toolVersionTagArgument Nothing (Just HLS)) <**> helper )
+        ( progDesc "Get HLS location"
+        <> footerDoc (Just $ text whereisHLSFooter ))
+      )
+      <>
+     command
+      "stack"
+      (WhereisTool Stack <$> info
+        ( optional (toolVersionTagArgument Nothing (Just Stack)) <**> helper )
+        ( progDesc "Get stack location"
+        <> footerDoc (Just $ text whereisStackFooter ))
+      )
+      <>
+     command
+      "ghcup"
+      (WhereisTool GHCup <$> info ( pure Nothing <**> helper ) ( progDesc "Get ghcup location" ))
+    ) <|> subparser ( commandGroup "Directory locations:"
+      <>
+     command
+      "basedir"
+      (info (pure WhereisBaseDir <**> helper)
+            ( progDesc "Get ghcup base directory location" )
+      )
+      <>
+     command
+      "bindir"
+      (info (pure WhereisBinDir <**> helper)
+            ( progDesc "Get ghcup binary directory location" )
+      )
+      <>
+     command
+      "cachedir"
+      (info (pure WhereisCacheDir <**> helper)
+            ( progDesc "Get ghcup cache directory location" )
+      )
+      <>
+     command
+      "logsdir"
+      (info (pure WhereisLogsDir <**> helper)
+            ( progDesc "Get ghcup logs directory location" )
+      )
+      <>
+     command
+      "confdir"
+      (info (pure WhereisConfDir <**> helper)
+            ( progDesc "Get ghcup config directory location" )
+      )
+  )
+ where
+  whereisGHCFooter = [s|Discussion:
+  Finds the location of a GHC executable, which usually resides in
+  a self-contained "~/.ghcup/ghc/<ghcver>" directory.
+
+Examples:
+  # outputs ~/.ghcup/ghc/8.10.5/bin/ghc.exe
+  ghcup whereis ghc 8.10.5
+  # outputs ~/.ghcup/ghc/8.10.5/bin/
+  ghcup whereis --directory ghc 8.10.5 |]
+
+  whereisCabalFooter = [s|Discussion:
+  Finds the location of a Cabal executable, which usually resides in
+  "~/.ghcup/bin/".
+
+Examples:
+  # outputs ~/.ghcup/bin/cabal-3.4.0.0
+  ghcup whereis cabal 3.4.0.0
+  # outputs ~/.ghcup/bin
+  ghcup whereis --directory cabal 3.4.0.0|]
+
+  whereisHLSFooter = [s|Discussion:
+  Finds the location of a HLS executable, which usually resides in
+  "~/.ghcup/bin/".
+
+Examples:
+  # outputs ~/.ghcup/bin/haskell-language-server-wrapper-1.2.0
+  ghcup whereis hls 1.2.0
+  # outputs ~/.ghcup/bin/
+  ghcup whereis --directory hls 1.2.0|]
+
+  whereisStackFooter = [s|Discussion:
+  Finds the location of a stack executable, which usually resides in
+  "~/.ghcup/bin/".
+
+Examples:
+  # outputs ~/.ghcup/bin/stack-2.7.1
+  ghcup whereis stack 2.7.1
+  # outputs ~/.ghcup/bin/
+  ghcup whereis --directory stack 2.7.1|]
+
+
+
+    --------------
+    --[ Footer ]--
+    --------------
+
+
+whereisFooter :: String
+whereisFooter = [s|Discussion:
+  Finds the location of a tool. For GHC, this is the ghc binary, that
+  usually resides in a self-contained "~/.ghcup/ghc/<ghcver>" directory.
+  For cabal/stack/hls this the binary usually at "~/.ghcup/bin/<tool>-<ver>".
+
+Examples:
+  # outputs ~/.ghcup/ghc/8.10.5/bin/ghc.exe
+  ghcup whereis ghc 8.10.5
+  # outputs ~/.ghcup/ghc/8.10.5/bin/
+  ghcup whereis --directory ghc 8.10.5
+  # outputs ~/.ghcup/bin/cabal-3.4.0.0
+  ghcup whereis cabal 3.4.0.0
+  # outputs ~/.ghcup/bin/
+  ghcup whereis --directory cabal 3.4.0.0|]
+
+
+
+
+    ---------------------------
+    --[ Effect interpreters ]--
+    ---------------------------
+
+
+type WhereisEffects = '[ NotInstalled
+                , NoToolVersionSet
+                , NextVerNotFound
+                , TagNotFound
+                ]
+
+
+runLeanWhereIs :: (MonadUnliftIO m, MonadIO m)
+               => LeanAppState
+               -> Excepts WhereisEffects (ReaderT LeanAppState m) a
+               -> m (VEither WhereisEffects a)
+runLeanWhereIs leanAppstate =
+    -- Don't use runLeanAppState here, which is disabled on windows.
+    -- This is the only command on all platforms that doesn't need full appstate.
+    flip runReaderT leanAppstate
+    . runE
+      @WhereisEffects
+
+
+runWhereIs :: (MonadUnliftIO m, MonadIO m)
+           => (ReaderT AppState m (VEither WhereisEffects a) -> m (VEither WhereisEffects a))
+           -> Excepts WhereisEffects (ReaderT AppState m) a
+           -> m (VEither WhereisEffects a)
+runWhereIs runAppState =
+    runAppState
+    . runE
+      @WhereisEffects
+
+
+
+    ------------------
+    --[ Entrypoint ]--
+    ------------------
+
+
+
+whereis :: ( Monad m
+         , MonadMask m
+         , MonadUnliftIO m
+         , MonadFail m
+         )
+      => WhereisCommand
+      -> WhereisOptions
+      -> (forall a. ReaderT AppState m (VEither WhereisEffects a) -> m (VEither WhereisEffects a))
+      -> LeanAppState
+      -> (ReaderT LeanAppState m () -> m ())
+      -> m ExitCode
+whereis whereisCommand whereisOptions runAppState leanAppstate runLogger = do
+  Dirs{ .. }  <- runReaderT getDirs leanAppstate
+  case (whereisCommand, whereisOptions) of
+    (WhereisTool GHCup _, WhereisOptions{..}) -> do
+      loc <- liftIO (getExecutablePath >>= canonicalizePath )
+      if directory
+      then liftIO $ putStr $ takeDirectory loc
+      else liftIO $ putStr loc
+      pure ExitSuccess
+
+    (WhereisTool tool (Just (GHCVersion v)), WhereisOptions{..}) ->
+      runLeanWhereIs leanAppstate (do
+        loc <- liftE $ whereIsTool tool v
+        if directory
+        then pure $ takeDirectory loc
+        else pure loc
+        )
+        >>= \case
+              VRight r -> do
+                liftIO $ putStr r
+                pure ExitSuccess
+              VLeft e -> do
+                runLogger $ logError $ T.pack $ prettyHFError e
+                pure $ ExitFailure 30
+    (WhereisTool tool (Just (ToolVersion v)), WhereisOptions{..}) ->
+      runLeanWhereIs leanAppstate (do
+        loc <- liftE $ whereIsTool tool (mkTVer v)
+        if directory
+        then pure $ takeDirectory loc
+        else pure loc
+        )
+        >>= \case
+              VRight r -> do
+                liftIO $ putStr r
+                pure ExitSuccess
+              VLeft e -> do
+                runLogger $ logError $ T.pack $ prettyHFError e
+                pure $ ExitFailure 30
+
+    (WhereisTool tool whereVer, WhereisOptions{..}) -> do
+      runWhereIs runAppState (do
+        (v, _) <- liftE $ fromVersion whereVer tool
+        loc <- liftE $ whereIsTool tool v
+        if directory
+        then pure $ takeDirectory loc
+        else pure loc
+        )
+        >>= \case
+              VRight r -> do
+                liftIO $ putStr r
+                pure ExitSuccess
+              VLeft e -> do
+                runLogger $ logError $ T.pack $ prettyHFError e
+                pure $ ExitFailure 30
+
+    (WhereisBaseDir, _) -> do
+      liftIO $ putStr $ fromGHCupPath baseDir
+      pure ExitSuccess
+
+    (WhereisBinDir, _) -> do
+      liftIO $ putStr binDir
+      pure ExitSuccess
+
+    (WhereisCacheDir, _) -> do
+      liftIO $ putStr $ fromGHCupPath cacheDir
+      pure ExitSuccess
+
+    (WhereisLogsDir, _) -> do
+      liftIO $ putStr $ fromGHCupPath logsDir
+      pure ExitSuccess
+
+    (WhereisConfDir, _) -> do
+      liftIO $ putStr $ fromGHCupPath confDir
+      pure ExitSuccess

bootstrap-haskell

@@ -1,201 +0,0 @@
-#!/bin/sh
-
-# safety subshell to avoid executing anything in case this script is not downloaded properly
-(
-
-: "${GHCUP_INSTALL_BASE_PREFIX:=$HOME}"
-
-die() {
-    (>&2 printf "\\033[0;31m%s\\033[0m\\n" "$1")
-    exit 2
-}
-
-edo()
-{
-    "$@" || die "\"$*\" failed!"
-}
-
-eghcup() {
-    if [ -z "${BOOTSTRAP_HASKELL_VERBOSE}" ] ; then
-        edo ghcup "$@"
-    else
-        edo ghcup --verbose "$@"
-    fi
-}
-
-download_ghcup() {
-	_plat="$(uname -s)"
-	_arch=$(uname -m)
-
-    case "${_plat}" in
-        "linux"|"Linux")
-			case "${_arch}" in
-				x86_64|amd64)
-					_url=https://downloads.haskell.org/~ghcup/x86_64-linux-ghcup
-					;;
-				i*86)
-					_url=https://downloads.haskell.org/~ghcup/i386-linux-ghcup
-					;;
-				*) die "Unknown architecture: ${_arch}"
-					;;
-			esac
-			;;
-        "FreeBSD"|"freebsd")
-			case "${_arch}" in
-				x86_64|amd64)
-					;;
-				i*86)
-					die "i386 currently not supported!"
-					;;
-				*) die "Unknown architecture: ${_arch}"
-					;;
-			esac
-			_url=https://downloads.haskell.org/~ghcup/x86_64-portbld-freebsd-ghcup
-            ;;
-        "Darwin"|"darwin")
-			case "${_arch}" in
-				x86_64|amd64)
-					;;
-				i*86)
-					die "i386 currently not supported!"
-					;;
-				*) die "Unknown architecture: ${_arch}"
-					;;
-			esac
-			_url=https://downloads.haskell.org/~ghcup/x86_64-apple-darwin-ghcup ;;
-        *) die "Unknown platform: ${_plat}"
-			;;
-    esac
-
-	edo curl -Lf "${_url}" > "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/ghcup
-
-	unset _plat _arch _url
-}
-
-
-echo
-echo "Welcome to Haskell!"
-echo
-echo "This will download and install the Glasgow Haskell Compiler (GHC)"
-echo "and the Cabal build tool."
-echo
-echo "ghcup installs only into the following directory, which can be removed anytime:"
-echo "  $GHCUP_INSTALL_BASE_PREFIX/.ghcup"
-echo
-
-if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-    printf "\\033[0;35m%s\\033[0m\\n" "Press ENTER to proceed"
-    printf "\\033[0;35m%s\\033[0m\\n" "or ctrl-c to abort."
-    printf "\\033[0;35m%s\\033[0m\\n" "Note that this script can be re-run at any given time."
-    echo
-    # Wait for user input to continue.
-    # shellcheck disable=SC2034
-    read -r answer </dev/tty
-fi
-
-edo mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin
-
-if command -V "ghcup" >/dev/null 2>&1 ; then
-    if [ -z "${BOOTSTRAP_HASKELL_NO_UPGRADE}" ] ; then
-        eghcup upgrade
-    fi
-else
-	download_ghcup
-    edo chmod +x "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/ghcup
-
-	cat <<-EOF > "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/env || die "Failed to create env file"
-		export PATH="\$HOME/.cabal/bin:\${GHCUP_INSTALL_BASE_PREFIX:=\$HOME}/.ghcup/bin:\$PATH"
-		EOF
-	# shellcheck disable=SC1090
-    edo . "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/env
-fi
-
-echo
-echo "$(ghcup tool-requirements)"
-echo
-
-if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-    printf "\\033[0;35m%s\\033[0m\\n" "Press ENTER to proceed"
-    printf "\\033[0;35m%s\\033[0m\\n" "or ctrl-c to abort."
-    printf "\\033[0;35m%s\\033[0m\\n" "Installation may take a while."
-    echo
-
-    # Wait for user input to continue.
-    # shellcheck disable=SC2034
-    read -r answer </dev/tty
-fi
-
-eghcup --cache install
-
-eghcup set
-eghcup --cache install-cabal
-
-edo cabal new-update
-
-printf "\\033[0;35m%s\\033[0m\\n" ""
-printf "\\033[0;35m%s\\033[0m\\n" "Installation done!"
-printf "\\033[0;35m%s\\033[0m\\n" ""
-
-if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-    echo "In order to run ghc and cabal, you need to adjust your PATH variable."
-    echo "You may want to source '$GHCUP_INSTALL_BASE_PREFIX/.ghcup/env' in your shell"
-    echo "configuration to do so (e.g. ~/.bashrc)."
-
-	case $SHELL in
-		*/zsh) # login shell is zsh
-			GHCUP_PROFILE_FILE="$HOME/.zshrc"
-			MY_SHELL="zsh" ;;
-		*/bash) # login shell is bash
-			if [ -f "$HOME/.bashrc" ] ; then # bashrc is not sourced by default, so assume it isn't if file does not exist
-				GHCUP_PROFILE_FILE="$HOME/.bashrc"
-			else
-				GHCUP_PROFILE_FILE="$HOME/.bash_profile"
-			fi
-
-			MY_SHELL="bash" ;;
-		*/sh) # login shell is sh, but might be a symlink to bash or zsh
-			if [ -n "${BASH}" ] ; then
-				if [ -f "$HOME/.bashrc" ] ; then # bashrc is not sourced by default, so assume it isn't if file does not exist
-					GHCUP_PROFILE_FILE="$HOME/.bashrc"
-				else
-					GHCUP_PROFILE_FILE="$HOME/.bash_profile"
-				fi
-
-				MY_SHELL="bash"
-			elif [ -n "${ZSH_VERSION}" ] ; then
-				GHCUP_PROFILE_FILE="$HOME/.zshrc"
-				MY_SHELL="zsh"
-			else
-				exit 0
-			fi
-			;;
-		*) exit 0 ;;
-	esac
-
-
-	printf "\\033[0;35m%s\\033[0m\\n" ""
-	printf "\\033[0;35m%s\\033[0m\\n" "Detected ${MY_SHELL} shell on your system..."
-	printf "\\033[0;35m%s\\033[0m\\n" "If you want ghcup to automatically add the required PATH variable to \"${GHCUP_PROFILE_FILE}\""
-	printf "\\033[0;35m%s\\033[0m\\n" "answer with YES, otherwise with NO and press ENTER."
-	printf "\\033[0;35m%s\\033[0m\\n" ""
-
-    while true; do
-        read -r next_answer </dev/tty
-
-        case $next_answer in
-            [Yy]*)
-                echo "[ -f \"\${GHCUP_INSTALL_BASE_PREFIX:=\$HOME}/.ghcup/env\" ] && source \"\${GHCUP_INSTALL_BASE_PREFIX:=\$HOME}/.ghcup/env\"" >> "${GHCUP_PROFILE_FILE}"
-                printf "\\033[0;35m%s\\033[0m\\n" "OK! ${GHCUP_PROFILE_FILE} has been modified. Restart your terminal for the changes to take effect,"
-                printf "\\033[0;35m%s\\033[0m\\n" "or type \"source ${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/env\" to apply them in your current terminal session."
-                exit 0;;
-            [Nn]*)
-                exit 0;;
-            *)
-                echo "Please type YES or NO and press enter.";;
-        esac
-    done
-fi
-)
-
-# vim: tabstop=4 shiftwidth=4 expandtab
-

cabal.ghc8107.project

@@ -0,0 +1,37 @@
+packages: ./ghcup.cabal
+
+optional-packages: ./vendored/*/*.cabal
+
+optimization: 2
+
+package ghcup
+    tests: True
+    flags: +tui
+
+source-repository-package
+  type: git
+  location: https://github.com/bgamari/terminal-size.git
+  tag: 34ea816bd63f75f800eedac12c6908c6f3736036
+
+constraints: http-io-streams -brotli,
+             any.Cabal ==3.6.2.0,
+             any.aeson >= 2.0.1.0,
+
+package libarchive
+  flags: -system-libarchive
+
+package aeson-pretty
+  flags: +lib-only
+
+package cabal-plan
+  flags: -exe
+
+package aeson
+  flags: +ordered-keymap
+
+package streamly
+  flags: +use-unliftio
+
+allow-newer: base, ghc-prim, template-haskell, language-c
+
+with-compiler: ghc-8.10.7

cabal.ghc8107.project.freeze

@@ -0,0 +1,238 @@
+active-repositories: hackage.haskell.org:merge
+constraints: any.Cabal ==3.6.2.0,
+             Cabal -bundled-binary-generic,
+             any.HUnit ==1.6.2.0,
+             any.HsOpenSSL ==0.11.7.2,
+             HsOpenSSL -fast-bignum -homebrew-openssl -macports-openssl -use-pkg-config,
+             any.OneTuple ==0.3.1,
+             any.QuickCheck ==2.14.2,
+             QuickCheck -old-random +templatehaskell,
+             any.StateVar ==1.2.2,
+             any.abstract-deque ==0.3,
+             abstract-deque -usecas,
+             any.aeson ==2.0.3.0,
+             aeson -cffi +ordered-keymap,
+             any.aeson-pretty ==0.8.9,
+             aeson-pretty +lib-only,
+             any.alex ==3.2.7.1,
+             any.ansi-terminal ==0.11.3,
+             ansi-terminal -example,
+             any.ansi-wl-pprint ==0.6.9,
+             ansi-wl-pprint -example,
+             any.array ==0.5.4.0,
+             any.assoc ==1.0.2,
+             any.async ==2.2.4,
+             async -bench,
+             any.atomic-primops ==0.8.4,
+             atomic-primops -debug,
+             any.attoparsec ==0.14.4,
+             attoparsec -developer,
+             any.base ==4.14.3.0,
+             any.base-compat ==0.12.1,
+             any.base-compat-batteries ==0.12.1,
+             any.base-orphans ==0.8.6,
+             any.base16-bytestring ==1.0.2.0,
+             any.base64-bytestring ==1.2.1.0,
+             any.bifunctors ==5.5.12,
+             bifunctors +semigroups +tagged,
+             any.binary ==0.8.8.0,
+             any.blaze-builder ==0.4.2.2,
+             any.brick ==0.64.2,
+             brick -demos,
+             any.bytestring ==0.10.12.0,
+             any.bz2 ==1.0.1.0,
+             bz2 -cross +with-bzlib,
+             any.c2hs ==0.28.8,
+             c2hs +base3 -regression,
+             any.cabal-plan ==0.7.2.1,
+             cabal-plan -_ -exe -license-report,
+             any.call-stack ==0.4.0,
+             any.case-insensitive ==1.2.1.0,
+             any.casing ==0.1.4.1,
+             any.chs-cabal ==0.1.1.1,
+             any.chs-deps ==0.1.0.0,
+             chs-deps -cross,
+             any.clock ==0.8.3,
+             clock -llvm,
+             any.colour ==2.3.6,
+             any.comonad ==5.0.8,
+             comonad +containers +distributive +indexed-traversable,
+             any.composition-prelude ==3.0.0.2,
+             composition-prelude -development,
+             any.config-ini ==0.2.4.0,
+             config-ini -enable-doctests,
+             any.containers ==0.6.5.1,
+             any.contravariant ==1.5.5,
+             contravariant +semigroups +statevar +tagged,
+             any.cpphs ==1.20.9.1,
+             cpphs -old-locale,
+             any.cryptohash-sha1 ==0.11.101.0,
+             any.cryptohash-sha256 ==0.11.102.1,
+             cryptohash-sha256 -exe +use-cbits,
+             any.data-clist ==0.2,
+             any.data-fix ==0.3.2,
+             any.deepseq ==1.4.4.0,
+             any.directory ==1.3.6.0,
+             any.disk-free-space ==0.1.0.1,
+             any.distributive ==0.6.2.1,
+             distributive +semigroups +tagged,
+             any.dlist ==1.0,
+             dlist -werror,
+             any.exceptions ==0.10.4,
+             any.filepath ==1.4.2.1,
+             any.free ==5.1.8,
+             any.fusion-plugin-types ==0.1.0,
+             any.generic-arbitrary ==0.2.2,
+             any.ghc ==8.10.7,
+             any.ghc-boot ==8.10.7,
+             any.ghc-boot-th ==8.10.7,
+             any.ghc-byteorder ==4.11.0.0.10,
+             any.ghc-heap ==8.10.7,
+             any.ghc-prim ==0.6.1,
+             any.ghci ==8.10.7,
+             any.happy ==1.20.0,
+             any.hashable ==1.4.0.2,
+             hashable +containers +integer-gmp -random-initial-seed,
+             any.haskus-utils-data ==1.4,
+             any.haskus-utils-types ==1.5.1,
+             any.haskus-utils-variant ==3.2.1,
+             any.heaps ==0.4,
+             any.hpc ==0.6.1.0,
+             any.hsc2hs ==0.68.8,
+             hsc2hs -in-ghc-tree,
+             any.hspec ==2.9.7,
+             any.hspec-core ==2.9.7,
+             any.hspec-discover ==2.9.7,
+             any.hspec-expectations ==0.8.2,
+             any.hspec-golden-aeson ==0.9.0.0,
+             any.http-io-streams ==0.1.6.1,
+             http-io-streams -brotli +fast-xor,
+             any.indexed-profunctors ==0.1.1,
+             any.indexed-traversable ==0.1.2,
+             any.indexed-traversable-instances ==0.1.1,
+             any.integer-gmp ==1.0.3.0,
+             any.integer-logarithms ==1.0.3.1,
+             integer-logarithms -check-bounds +integer-gmp,
+             any.io-streams ==1.5.2.1,
+             io-streams +network -nointeractivetests +zlib,
+             any.language-c ==0.9.1,
+             language-c -allwarnings +iecfpextension +usebytestrings,
+             any.libarchive ==3.0.3.2,
+             libarchive -cross -low-memory +no-exe -system-libarchive,
+             any.libyaml-streamly ==0.2.1,
+             libyaml-streamly -no-unicode -system-libyaml,
+             any.lockfree-queue ==0.2.3.1,
+             any.lzma-static ==5.2.5.4,
+             any.megaparsec ==9.2.1,
+             megaparsec -dev,
+             any.microlens ==0.4.12.0,
+             any.microlens-mtl ==0.2.0.2,
+             any.microlens-th ==0.4.3.10,
+             any.mtl ==2.2.2,
+             any.network ==3.1.2.7,
+             network -devel,
+             any.network-uri ==2.6.4.1,
+             any.openssl-streams ==1.2.3.0,
+             any.optics ==0.4.2,
+             any.optics-core ==0.4.1,
+             optics-core -explicit-generic-labels,
+             any.optics-extra ==0.4.2.1,
+             any.optics-th ==0.4.1,
+             any.optparse-applicative ==0.17.0.0,
+             optparse-applicative +process,
+             any.os-release ==1.0.2.1,
+             os-release -devel,
+             any.parallel ==3.2.2.0,
+             any.parsec ==3.1.14.0,
+             any.parser-combinators ==1.3.0,
+             parser-combinators -dev,
+             any.polyparse ==1.13,
+             any.pretty ==1.1.3.6,
+             any.pretty-terminal ==0.1.0.0,
+             any.primitive ==0.7.4.0,
+             any.process ==1.6.13.2,
+             any.profunctors ==5.6.2,
+             any.quickcheck-arbitrary-adt ==0.3.1.0,
+             any.quickcheck-io ==0.2.0,
+             any.random ==1.2.1.1,
+             any.recursion-schemes ==5.2.2.2,
+             recursion-schemes +template-haskell,
+             any.regex-base ==0.94.0.2,
+             any.regex-posix ==0.96.0.1,
+             regex-posix -_regex-posix-clib,
+             any.resourcet ==1.2.5,
+             any.retry ==0.8.1.2,
+             retry -lib-werror,
+             any.rts ==1.0.1,
+             any.safe ==0.3.19,
+             any.safe-exceptions ==0.1.7.3,
+             any.scientific ==0.3.7.0,
+             scientific -bytestring-builder -integer-simple,
+             any.semialign ==1.2.0.1,
+             semialign +semigroupoids,
+             any.semigroupoids ==5.3.7,
+             semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
+             any.setenv ==0.1.1.3,
+             any.split ==0.2.3.4,
+             any.splitmix ==0.1.0.4,
+             splitmix -optimised-mixer,
+             any.stm ==2.5.0.1,
+             any.streamly ==0.8.2,
+             streamly -debug -dev -fusion-plugin -has-llvm -inspection -limit-build-mem -no-fusion +opt -streamk -streamly-core -use-c-malloc +use-unliftio,
+             any.strict ==0.4.0.1,
+             strict +assoc,
+             any.strict-base ==0.4.0.0,
+             any.tagged ==0.8.6.1,
+             tagged +deepseq +transformers,
+             any.tagsoup ==0.14.8,
+             any.template-haskell ==2.16.0.0,
+             any.temporary ==1.3,
+             any.terminal-progress-bar ==0.4.1,
+             any.terminal-size ==0.3.2.1,
+             any.terminfo ==0.4.1.4,
+             any.text ==1.2.4.1,
+             any.text-short ==0.1.5,
+             text-short -asserts,
+             any.text-zipper ==0.11,
+             any.tf-random ==0.5,
+             any.th-abstraction ==0.4.3.0,
+             any.th-compat ==0.1.3,
+             any.th-lift ==0.8.2,
+             any.th-lift-instances ==0.1.19,
+             any.these ==1.1.1.1,
+             these +assoc,
+             any.time ==1.9.3,
+             any.time-compat ==1.9.6.1,
+             time-compat -old-locale,
+             any.transformers ==0.5.6.2,
+             any.transformers-base ==0.4.6,
+             transformers-base +orphaninstances,
+             any.transformers-compat ==0.7.1,
+             transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
+             any.unicode-data ==0.3.0,
+             unicode-data -ucd2haskell,
+             any.unix ==2.7.2.2,
+             any.unix-bytestring ==0.3.7.7,
+             any.unix-compat ==0.6,
+             unix-compat -old-time,
+             any.unliftio-core ==0.2.0.1,
+             any.unordered-containers ==0.2.19.1,
+             unordered-containers -debug,
+             any.uri-bytestring ==0.3.3.1,
+             uri-bytestring -lib-werror,
+             any.utf8-string ==1.0.2,
+             any.uuid-types ==1.0.5,
+             any.vector ==0.12.3.1,
+             vector +boundschecks -internalchecks -unsafechecks -wall,
+             any.versions ==5.0.3,
+             any.vty ==5.33,
+             any.witherable ==0.4.2,
+             any.word-wrap ==0.5,
+             any.word8 ==0.1.3,
+             any.xor ==0.0.1.1,
+             any.yaml-streamly ==0.12.1,
+             yaml-streamly +no-examples +no-exe,
+             any.zlib ==0.6.3.0,
+             zlib -bundled-c-zlib -non-blocking-ffi -pkg-config,
+             any.zlib-bindings ==0.1.1.5
+index-state: hackage.haskell.org 2022-06-04T19:47:01Z

cabal.ghc902.project

@@ -0,0 +1,37 @@
+packages: ./ghcup.cabal
+
+optional-packages: ./vendored/*/*.cabal
+
+optimization: 2
+
+package ghcup
+    tests: True
+    flags: +tui
+
+source-repository-package
+  type: git
+  location: https://github.com/bgamari/terminal-size.git
+  tag: 34ea816bd63f75f800eedac12c6908c6f3736036
+
+constraints: http-io-streams -brotli,
+             any.Cabal ==3.6.2.0,
+             any.aeson >= 2.0.1.0,
+
+package libarchive
+  flags: -system-libarchive
+
+package aeson-pretty
+  flags: +lib-only
+
+package cabal-plan
+  flags: -exe
+
+package aeson
+  flags: +ordered-keymap
+
+package streamly
+  flags: +use-unliftio
+
+allow-newer: base, ghc-prim, template-haskell, language-c
+
+with-compiler: ghc-9.0.2

cabal.ghc902.project.freeze

@@ -0,0 +1,238 @@
+active-repositories: hackage.haskell.org:merge
+constraints: any.Cabal ==3.6.2.0,
+             Cabal -bundled-binary-generic,
+             any.HUnit ==1.6.2.0,
+             any.HsOpenSSL ==0.11.7.2,
+             HsOpenSSL -fast-bignum -homebrew-openssl -macports-openssl -use-pkg-config,
+             any.OneTuple ==0.3.1,
+             any.QuickCheck ==2.14.2,
+             QuickCheck -old-random +templatehaskell,
+             any.StateVar ==1.2.2,
+             any.abstract-deque ==0.3,
+             abstract-deque -usecas,
+             any.aeson ==2.0.3.0,
+             aeson -cffi +ordered-keymap,
+             any.aeson-pretty ==0.8.9,
+             aeson-pretty +lib-only,
+             any.alex ==3.2.7.1,
+             any.ansi-terminal ==0.11.3,
+             ansi-terminal -example,
+             any.ansi-wl-pprint ==0.6.9,
+             ansi-wl-pprint -example,
+             any.array ==0.5.4.0,
+             any.assoc ==1.0.2,
+             any.async ==2.2.4,
+             async -bench,
+             any.atomic-primops ==0.8.4,
+             atomic-primops -debug,
+             any.attoparsec ==0.14.4,
+             attoparsec -developer,
+             any.base ==4.15.1.0,
+             any.base-compat ==0.12.1,
+             any.base-compat-batteries ==0.12.1,
+             any.base-orphans ==0.8.6,
+             any.base16-bytestring ==1.0.2.0,
+             any.base64-bytestring ==1.2.1.0,
+             any.bifunctors ==5.5.12,
+             bifunctors +semigroups +tagged,
+             any.binary ==0.8.8.0,
+             any.blaze-builder ==0.4.2.2,
+             any.brick ==0.64.2,
+             brick -demos,
+             any.bytestring ==0.10.12.1,
+             any.bz2 ==1.0.1.0,
+             bz2 -cross +with-bzlib,
+             any.c2hs ==0.28.8,
+             c2hs +base3 -regression,
+             any.cabal-plan ==0.7.2.1,
+             cabal-plan -_ -exe -license-report,
+             any.call-stack ==0.4.0,
+             any.case-insensitive ==1.2.1.0,
+             any.casing ==0.1.4.1,
+             any.chs-cabal ==0.1.1.1,
+             any.chs-deps ==0.1.0.0,
+             chs-deps -cross,
+             any.clock ==0.8.3,
+             clock -llvm,
+             any.colour ==2.3.6,
+             any.comonad ==5.0.8,
+             comonad +containers +distributive +indexed-traversable,
+             any.composition-prelude ==3.0.0.2,
+             composition-prelude -development,
+             any.config-ini ==0.2.4.0,
+             config-ini -enable-doctests,
+             any.containers ==0.6.4.1,
+             any.contravariant ==1.5.5,
+             contravariant +semigroups +statevar +tagged,
+             any.cpphs ==1.20.9.1,
+             cpphs -old-locale,
+             any.cryptohash-sha1 ==0.11.101.0,
+             any.cryptohash-sha256 ==0.11.102.1,
+             cryptohash-sha256 -exe +use-cbits,
+             any.data-clist ==0.2,
+             any.data-fix ==0.3.2,
+             any.deepseq ==1.4.5.0,
+             any.directory ==1.3.6.2,
+             any.disk-free-space ==0.1.0.1,
+             any.distributive ==0.6.2.1,
+             distributive +semigroups +tagged,
+             any.dlist ==1.0,
+             dlist -werror,
+             any.exceptions ==0.10.4,
+             any.filepath ==1.4.2.1,
+             any.free ==5.1.8,
+             any.fusion-plugin-types ==0.1.0,
+             any.generic-arbitrary ==0.2.2,
+             any.ghc ==9.0.2,
+             any.ghc-bignum ==1.1,
+             any.ghc-boot ==9.0.2,
+             any.ghc-boot-th ==9.0.2,
+             any.ghc-byteorder ==4.11.0.0.10,
+             any.ghc-heap ==9.0.2,
+             any.ghc-prim ==0.7.0,
+             any.ghci ==9.0.2,
+             any.happy ==1.20.0,
+             any.hashable ==1.4.0.2,
+             hashable +containers +integer-gmp -random-initial-seed,
+             any.haskus-utils-data ==1.4,
+             any.haskus-utils-types ==1.5.1,
+             any.haskus-utils-variant ==3.2.1,
+             any.heaps ==0.4,
+             any.hpc ==0.6.1.0,
+             any.hsc2hs ==0.68.8,
+             hsc2hs -in-ghc-tree,
+             any.hspec ==2.9.7,
+             any.hspec-core ==2.9.7,
+             any.hspec-discover ==2.9.7,
+             any.hspec-expectations ==0.8.2,
+             any.hspec-golden-aeson ==0.9.0.0,
+             any.http-io-streams ==0.1.6.1,
+             http-io-streams -brotli +fast-xor,
+             any.indexed-profunctors ==0.1.1,
+             any.indexed-traversable ==0.1.2,
+             any.indexed-traversable-instances ==0.1.1,
+             any.integer-logarithms ==1.0.3.1,
+             integer-logarithms -check-bounds +integer-gmp,
+             any.io-streams ==1.5.2.1,
+             io-streams +network -nointeractivetests +zlib,
+             any.language-c ==0.9.1,
+             language-c -allwarnings +iecfpextension +usebytestrings,
+             any.libarchive ==3.0.3.2,
+             libarchive -cross -low-memory +no-exe -system-libarchive,
+             any.libyaml-streamly ==0.2.1,
+             libyaml-streamly -no-unicode -system-libyaml,
+             any.lockfree-queue ==0.2.3.1,
+             any.lzma-static ==5.2.5.4,
+             any.megaparsec ==9.2.1,
+             megaparsec -dev,
+             any.microlens ==0.4.12.0,
+             any.microlens-mtl ==0.2.0.2,
+             any.microlens-th ==0.4.3.10,
+             any.mtl ==2.2.2,
+             any.network ==3.1.2.7,
+             network -devel,
+             any.network-uri ==2.6.4.1,
+             any.openssl-streams ==1.2.3.0,
+             any.optics ==0.4.2,
+             any.optics-core ==0.4.1,
+             optics-core -explicit-generic-labels,
+             any.optics-extra ==0.4.2.1,
+             any.optics-th ==0.4.1,
+             any.optparse-applicative ==0.17.0.0,
+             optparse-applicative +process,
+             any.os-release ==1.0.2.1,
+             os-release -devel,
+             any.parallel ==3.2.2.0,
+             any.parsec ==3.1.14.0,
+             any.parser-combinators ==1.3.0,
+             parser-combinators -dev,
+             any.polyparse ==1.13,
+             any.pretty ==1.1.3.6,
+             any.pretty-terminal ==0.1.0.0,
+             any.primitive ==0.7.4.0,
+             any.process ==1.6.13.2,
+             any.profunctors ==5.6.2,
+             any.quickcheck-arbitrary-adt ==0.3.1.0,
+             any.quickcheck-io ==0.2.0,
+             any.random ==1.2.1.1,
+             any.recursion-schemes ==5.2.2.2,
+             recursion-schemes +template-haskell,
+             any.regex-base ==0.94.0.2,
+             any.regex-posix ==0.96.0.1,
+             regex-posix -_regex-posix-clib,
+             any.resourcet ==1.2.5,
+             any.retry ==0.8.1.2,
+             retry -lib-werror,
+             any.rts ==1.0.2,
+             any.safe ==0.3.19,
+             any.safe-exceptions ==0.1.7.3,
+             any.scientific ==0.3.7.0,
+             scientific -bytestring-builder -integer-simple,
+             any.semialign ==1.2.0.1,
+             semialign +semigroupoids,
+             any.semigroupoids ==5.3.7,
+             semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
+             any.setenv ==0.1.1.3,
+             any.split ==0.2.3.4,
+             any.splitmix ==0.1.0.4,
+             splitmix -optimised-mixer,
+             any.stm ==2.5.0.0,
+             any.streamly ==0.8.2,
+             streamly -debug -dev -fusion-plugin -has-llvm -inspection -limit-build-mem -no-fusion +opt -streamk -streamly-core -use-c-malloc +use-unliftio,
+             any.strict ==0.4.0.1,
+             strict +assoc,
+             any.strict-base ==0.4.0.0,
+             any.tagged ==0.8.6.1,
+             tagged +deepseq +transformers,
+             any.tagsoup ==0.14.8,
+             any.template-haskell ==2.17.0.0,
+             any.temporary ==1.3,
+             any.terminal-progress-bar ==0.4.1,
+             any.terminal-size ==0.3.2.1,
+             any.terminfo ==0.4.1.5,
+             any.text ==1.2.5.0,
+             any.text-short ==0.1.5,
+             text-short -asserts,
+             any.text-zipper ==0.11,
+             any.tf-random ==0.5,
+             any.th-abstraction ==0.4.3.0,
+             any.th-compat ==0.1.3,
+             any.th-lift ==0.8.2,
+             any.th-lift-instances ==0.1.19,
+             any.these ==1.1.1.1,
+             these +assoc,
+             any.time ==1.9.3,
+             any.time-compat ==1.9.6.1,
+             time-compat -old-locale,
+             any.transformers ==0.5.6.2,
+             any.transformers-base ==0.4.6,
+             transformers-base +orphaninstances,
+             any.transformers-compat ==0.7.1,
+             transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
+             any.unicode-data ==0.3.0,
+             unicode-data -ucd2haskell,
+             any.unix ==2.7.2.2,
+             any.unix-bytestring ==0.3.7.7,
+             any.unix-compat ==0.6,
+             unix-compat -old-time,
+             any.unliftio-core ==0.2.0.1,
+             any.unordered-containers ==0.2.19.1,
+             unordered-containers -debug,
+             any.uri-bytestring ==0.3.3.1,
+             uri-bytestring -lib-werror,
+             any.utf8-string ==1.0.2,
+             any.uuid-types ==1.0.5,
+             any.vector ==0.12.3.1,
+             vector +boundschecks -internalchecks -unsafechecks -wall,
+             any.versions ==5.0.3,
+             any.vty ==5.33,
+             any.witherable ==0.4.2,
+             any.word-wrap ==0.5,
+             any.word8 ==0.1.3,
+             any.xor ==0.0.1.1,
+             any.yaml-streamly ==0.12.1,
+             yaml-streamly +no-examples +no-exe,
+             any.zlib ==0.6.3.0,
+             zlib -bundled-c-zlib -non-blocking-ffi -pkg-config,
+             any.zlib-bindings ==0.1.1.5
+index-state: hackage.haskell.org 2022-06-04T19:47:01Z

cabal.ghc923.project

@@ -0,0 +1,37 @@
+packages: ./ghcup.cabal
+
+optional-packages: ./vendored/*/*.cabal
+
+optimization: 2
+
+package ghcup
+    tests: True
+    flags: +tui
+
+source-repository-package
+  type: git
+  location: https://github.com/bgamari/terminal-size.git
+  tag: 34ea816bd63f75f800eedac12c6908c6f3736036
+
+constraints: http-io-streams -brotli,
+             any.Cabal ==3.6.2.0,
+             any.aeson >= 2.0.1.0,
+
+package libarchive
+  flags: -system-libarchive
+
+package aeson-pretty
+  flags: +lib-only
+
+package cabal-plan
+  flags: -exe
+
+package aeson
+  flags: +ordered-keymap
+
+package streamly
+  flags: +use-unliftio
+
+allow-newer: base, ghc-prim, template-haskell, language-c
+
+with-compiler: ghc-9.2.3

cabal.ghc923.project.freeze

@@ -0,0 +1,233 @@
+active-repositories: hackage.haskell.org:merge
+constraints: any.Cabal ==3.6.2.0,
+             Cabal -bundled-binary-generic,
+             any.HUnit ==1.6.2.0,
+             any.HsOpenSSL ==0.11.7.2,
+             HsOpenSSL -fast-bignum -homebrew-openssl -macports-openssl -use-pkg-config,
+             any.OneTuple ==0.3.1,
+             any.QuickCheck ==2.14.2,
+             QuickCheck -old-random +templatehaskell,
+             any.StateVar ==1.2.2,
+             any.abstract-deque ==0.3,
+             abstract-deque -usecas,
+             any.aeson ==2.0.3.0,
+             aeson -cffi +ordered-keymap,
+             any.aeson-pretty ==0.8.9,
+             aeson-pretty +lib-only,
+             any.alex ==3.2.7.1,
+             any.ansi-terminal ==0.11.3,
+             ansi-terminal -example,
+             any.ansi-wl-pprint ==0.6.9,
+             ansi-wl-pprint -example,
+             any.array ==0.5.4.0,
+             any.assoc ==1.0.2,
+             any.async ==2.2.4,
+             async -bench,
+             any.atomic-primops ==0.8.4,
+             atomic-primops -debug,
+             any.attoparsec ==0.14.4,
+             attoparsec -developer,
+             any.base ==4.16.2.0,
+             any.base-compat ==0.12.1,
+             any.base-compat-batteries ==0.12.1,
+             any.base-orphans ==0.8.6,
+             any.base16-bytestring ==1.0.2.0,
+             any.base64-bytestring ==1.2.1.0,
+             any.bifunctors ==5.5.12,
+             bifunctors +semigroups +tagged,
+             any.binary ==0.8.9.0,
+             any.blaze-builder ==0.4.2.2,
+             any.brick ==0.64.2,
+             brick -demos,
+             any.bytestring ==0.11.3.1,
+             any.bz2 ==1.0.1.0,
+             bz2 -cross +with-bzlib,
+             any.c2hs ==0.28.8,
+             c2hs +base3 -regression,
+             any.cabal-plan ==0.7.2.1,
+             cabal-plan -_ -exe -license-report,
+             any.call-stack ==0.4.0,
+             any.case-insensitive ==1.2.1.0,
+             any.casing ==0.1.4.1,
+             any.chs-cabal ==0.1.1.1,
+             any.chs-deps ==0.1.0.0,
+             chs-deps -cross,
+             any.clock ==0.8.3,
+             clock -llvm,
+             any.colour ==2.3.6,
+             any.comonad ==5.0.8,
+             comonad +containers +distributive +indexed-traversable,
+             any.composition-prelude ==3.0.0.2,
+             composition-prelude -development,
+             any.config-ini ==0.2.4.0,
+             config-ini -enable-doctests,
+             any.containers ==0.6.5.1,
+             any.contravariant ==1.5.5,
+             contravariant +semigroups +statevar +tagged,
+             any.cpphs ==1.20.9.1,
+             cpphs -old-locale,
+             any.cryptohash-sha1 ==0.11.101.0,
+             any.cryptohash-sha256 ==0.11.102.1,
+             cryptohash-sha256 -exe +use-cbits,
+             any.data-clist ==0.2,
+             any.data-fix ==0.3.2,
+             any.deepseq ==1.4.6.1,
+             any.directory ==1.3.7.0,
+             any.disk-free-space ==0.1.0.1,
+             any.distributive ==0.6.2.1,
+             distributive +semigroups +tagged,
+             any.dlist ==1.0,
+             dlist -werror,
+             any.exceptions ==0.10.4,
+             any.filepath ==1.4.2.2,
+             any.free ==5.1.8,
+             any.fusion-plugin-types ==0.1.0,
+             any.generic-arbitrary ==0.2.2,
+             any.ghc-bignum ==1.2,
+             any.ghc-boot-th ==9.2.3,
+             any.ghc-byteorder ==4.11.0.0.10,
+             any.ghc-prim ==0.8.0,
+             any.happy ==1.20.0,
+             any.hashable ==1.4.0.2,
+             hashable +containers +integer-gmp -random-initial-seed,
+             any.haskus-utils-data ==1.4,
+             any.haskus-utils-types ==1.5.1,
+             any.haskus-utils-variant ==3.2.1,
+             any.heaps ==0.4,
+             any.hsc2hs ==0.68.8,
+             hsc2hs -in-ghc-tree,
+             any.hspec ==2.9.2,
+             any.hspec-core ==2.9.2,
+             any.hspec-discover ==2.9.2,
+             any.hspec-expectations ==0.8.2,
+             any.hspec-golden-aeson ==0.9.0.0,
+             any.http-io-streams ==0.1.6.1,
+             http-io-streams -brotli +fast-xor,
+             any.indexed-profunctors ==0.1.1,
+             any.indexed-traversable ==0.1.2,
+             any.indexed-traversable-instances ==0.1.1,
+             any.integer-logarithms ==1.0.3.1,
+             integer-logarithms -check-bounds +integer-gmp,
+             any.io-streams ==1.5.2.1,
+             io-streams +network -nointeractivetests +zlib,
+             any.language-c ==0.9.1,
+             language-c -allwarnings +iecfpextension +usebytestrings,
+             any.libarchive ==3.0.3.2,
+             libarchive -cross -low-memory +no-exe -system-libarchive,
+             any.libyaml-streamly ==0.2.1,
+             libyaml-streamly -no-unicode -system-libyaml,
+             any.lockfree-queue ==0.2.3.1,
+             any.lzma-static ==5.2.5.4,
+             any.megaparsec ==9.2.1,
+             megaparsec -dev,
+             any.microlens ==0.4.12.0,
+             any.microlens-mtl ==0.2.0.2,
+             any.microlens-th ==0.4.3.10,
+             any.mtl ==2.2.2,
+             any.network ==3.1.2.7,
+             network -devel,
+             any.network-uri ==2.6.4.1,
+             any.openssl-streams ==1.2.3.0,
+             any.optics ==0.4.2,
+             any.optics-core ==0.4.1,
+             optics-core -explicit-generic-labels,
+             any.optics-extra ==0.4.2.1,
+             any.optics-th ==0.4.1,
+             any.optparse-applicative ==0.17.0.0,
+             optparse-applicative +process,
+             any.os-release ==1.0.2.1,
+             os-release -devel,
+             any.parallel ==3.2.2.0,
+             any.parsec ==3.1.15.0,
+             any.parser-combinators ==1.3.0,
+             parser-combinators -dev,
+             any.polyparse ==1.13,
+             any.pretty ==1.1.3.6,
+             any.pretty-terminal ==0.1.0.0,
+             any.primitive ==0.7.4.0,
+             any.process ==1.6.14.0,
+             any.profunctors ==5.6.2,
+             any.quickcheck-arbitrary-adt ==0.3.1.0,
+             any.quickcheck-io ==0.2.0,
+             any.random ==1.2.1.1,
+             any.recursion-schemes ==5.2.2.2,
+             recursion-schemes +template-haskell,
+             any.regex-base ==0.94.0.2,
+             any.regex-posix ==0.96.0.1,
+             regex-posix -_regex-posix-clib,
+             any.resourcet ==1.2.5,
+             any.retry ==0.8.1.2,
+             retry -lib-werror,
+             any.rts ==1.0.2,
+             any.safe ==0.3.19,
+             any.safe-exceptions ==0.1.7.3,
+             any.scientific ==0.3.7.0,
+             scientific -bytestring-builder -integer-simple,
+             any.semialign ==1.2.0.1,
+             semialign +semigroupoids,
+             any.semigroupoids ==5.3.7,
+             semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
+             any.setenv ==0.1.1.3,
+             any.split ==0.2.3.4,
+             any.splitmix ==0.1.0.4,
+             splitmix -optimised-mixer,
+             any.stm ==2.5.0.2,
+             any.streamly ==0.8.2,
+             streamly -debug -dev -fusion-plugin -has-llvm -inspection -limit-build-mem -no-fusion +opt -streamk -streamly-core -use-c-malloc +use-unliftio,
+             any.strict ==0.4.0.1,
+             strict +assoc,
+             any.strict-base ==0.4.0.0,
+             any.tagged ==0.8.6.1,
+             tagged +deepseq +transformers,
+             any.tagsoup ==0.14.8,
+             any.template-haskell ==2.18.0.0,
+             any.temporary ==1.3,
+             any.terminal-progress-bar ==0.4.1,
+             any.terminal-size ==0.3.2.1,
+             any.terminfo ==0.4.1.5,
+             any.text ==1.2.5.0,
+             any.text-short ==0.1.5,
+             text-short -asserts,
+             any.text-zipper ==0.11,
+             any.tf-random ==0.5,
+             any.th-abstraction ==0.4.3.0,
+             any.th-compat ==0.1.3,
+             any.th-lift ==0.8.2,
+             any.th-lift-instances ==0.1.19,
+             any.these ==1.1.1.1,
+             these +assoc,
+             any.time ==1.9.3,
+             any.time-compat ==1.9.6.1,
+             time-compat -old-locale,
+             any.transformers ==0.5.6.2,
+             any.transformers-base ==0.4.6,
+             transformers-base +orphaninstances,
+             any.transformers-compat ==0.7.1,
+             transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
+             any.unicode-data ==0.3.0,
+             unicode-data -ucd2haskell,
+             any.unix ==2.7.2.2,
+             any.unix-bytestring ==0.3.7.7,
+             any.unix-compat ==0.6,
+             unix-compat -old-time,
+             any.unliftio-core ==0.2.0.1,
+             any.unordered-containers ==0.2.19.1,
+             unordered-containers -debug,
+             any.uri-bytestring ==0.3.3.1,
+             uri-bytestring -lib-werror,
+             any.utf8-string ==1.0.2,
+             any.uuid-types ==1.0.5,
+             any.vector ==0.12.3.1,
+             vector +boundschecks -internalchecks -unsafechecks -wall,
+             any.versions ==5.0.3,
+             any.vty ==5.33,
+             any.witherable ==0.4.2,
+             any.word-wrap ==0.5,
+             any.word8 ==0.1.3,
+             any.xor ==0.0.1.1,
+             any.yaml-streamly ==0.12.1,
+             yaml-streamly +no-examples +no-exe,
+             any.zlib ==0.6.3.0,
+             zlib -bundled-c-zlib -non-blocking-ffi -pkg-config,
+             any.zlib-bindings ==0.1.1.5
+index-state: hackage.haskell.org 2022-06-04T19:47:01Z

cabal.project

@@ -1,16 +1,35 @@
 packages: ./ghcup.cabal
 
+optional-packages: ./vendored/*/*.cabal
+
 optimization: 2
 
-package streamly
-    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
-
 package ghcup
-    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+    tests: True
+    flags: +tui-ansi
 
-package tar-bytestring
-    ghc-options: -O2
+source-repository-package
+  type: git
+  location: https://github.com/bgamari/terminal-size.git
+  tag: 34ea816bd63f75f800eedac12c6908c6f3736036
 
-constraints: http-io-streams -brotli
+constraints: http-io-streams -brotli,
+             any.Cabal ==3.6.2.0,
+             any.aeson >= 2.0.1.0,
 
-allow-newer: base
+package libarchive
+  flags: -system-libarchive
+
+package aeson-pretty
+  flags: +lib-only
+
+package cabal-plan
+  flags: -exe
+
+package aeson
+  flags: +ordered-keymap
+
+package streamly
+  flags: +use-unliftio
+
+allow-newer: base, ghc-prim, template-haskell, language-c

cabal.project.freeze

@@ -0,0 +1,2 @@
+-- windows picks weird version
+constraints: any.hsc2hs ==0.68.7

cbits/dirutils.c

@@ -0,0 +1,7 @@
+#include "dirutils.h"
+
+unsigned int
+    __posixdir_d_type(struct dirent* d)
+    {
+      return(d -> d_type);
+    }

cbits/dirutils.h

@@ -0,0 +1,16 @@
+#ifndef POSIXPATHS_CBITS_DIRUTILS_H
+#define POSIXPATHS_CBITS_DIRUTILS_H
+
+#include <HsFFI.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+
+extern unsigned int
+    __posixdir_d_type(struct dirent* d)
+    ;
+
+#endif

data/build_mk/cross

@@ -0,0 +1,9 @@
+V=0
+BUILD_MAN = NO
+BUILD_SPHINX_HTML = NO
+BUILD_SPHINX_PDF = NO
+HADDOCK_DOCS = NO
+ifneq "$(BuildFlavour)" ""
+include mk/flavours/$(BuildFlavour).mk
+endif
+Stage1Only = YES

data/build_mk/default

@@ -0,0 +1,8 @@
+V=0
+BUILD_MAN = NO
+BUILD_SPHINX_HTML = NO
+BUILD_SPHINX_PDF = NO
+HADDOCK_DOCS = YES
+ifneq "$(BuildFlavour)" ""
+include mk/flavours/$(BuildFlavour).mk
+endif

data/config.yaml

@@ -0,0 +1,94 @@
+# Cache downloads in ~/.ghcup/cache
+cache: False
+# Skip tarball checksum verification
+no-verify: False
+# enable verbosity
+verbose: False
+# When to keep build directories
+keep-dirs: Errors  # Always | Never | Errors
+# Which downloader to use
+downloader: Curl   # Curl | Wget | Internal
+# whether to run in offline mode
+no-network: False
+# whether/how to do gpg verification
+gpg-setting: GPGNone # GPGStrict | GPGLax | GPGNone
+
+# TUI key bindings,
+# see https://hackage.haskell.org/package/vty-5.31/docs/Graphics-Vty-Input-Events.html#t:Key
+# for possible values.
+key-bindings:
+  up:
+    KUp: []
+  down:
+    KDown: []
+  quit:
+    KChar: 'q'
+  install:
+    KChar: 'i'
+  uninstall:
+    KChar: 'u'
+  set:
+    KChar: 's'
+  changelog:
+    KChar: 'c'
+  show-all:
+    KChar: 'a'
+  show-all-tools:
+    KChar: 't'
+
+# The caching for the metadata files containing download info, depending on last access time
+# of the file. These usually are in '~/.ghcup/cache/ghcup-<ver>.yaml'.
+meta-cache: 300 # in seconds
+
+# When trying to download ghcup metadata, this option decides what to do
+# when the download fails:
+#   1. Lax: use existing ~/.ghcup/cache/ghcup-<ver>.yaml as fallback (default)
+#   2. Strict: fail hard
+meta-mode: Lax # Strict | Lax
+
+# Where to get GHC/cabal/hls download info/versions from. For more detailed explanation
+# check the 'URLSource' type in the code.
+url-source:
+  ## Use the internal download uri, this is the default
+  GHCupURL: []
+
+  ## Example 1: Read download info from this location instead
+  ## Accepts file/http/https scheme
+  ## Can also be an array of URLs or an array of 'Either GHCupInfo URL', in
+  ## which case they are merged right-biased (overwriting duplicate versions).
+  # OwnSource: "file:///home/jule/git/ghcup-hs/ghcup-0.0.3.yaml"
+
+  ## Example 2: Add custom tarballs to the default downloads, overwriting duplicate versions.
+  ## Can also be an array of 'Either GHCupInfo URL', also see Example 3.
+  # AddSource:
+    # Left:
+      # globalTools: {}
+      # toolRequirements: {}
+      # ghcupDownloads:
+        # GHC:
+          # 9.10.2:
+            # viTags: []
+            # viArch:
+              # A_64:
+                # Linux_UnknownLinux:
+                  # unknown_versioning:
+                    # dlUri: https://downloads.haskell.org/~ghc/7.10.3/ghc-7.10.3-x86_64-deb8-linux.tar.bz2
+                    # dlSubdir: ghc-7.10.3
+                    # dlHash: 01cfbad8dff1e8b34a5fdca8caeaf843b56e36af919e29cd68870d2588563db5
+
+  ## Example 3: Add multiple custom download files to the default downloads via right-biased merge (overwriting duplicate
+  ## versions).
+  # AddSource:
+    # - Right: "file:///home/jule/git/ghcup-hs/ghcup-prereleases.yaml"
+    # - Right: "file:///home/jule/git/ghcup-hs/ghcup-custom.yaml"
+
+# This is a way to override platform detection, e.g. when you're running
+# a Ubuntu derivate based on 18.04, you could do:
+#
+# platform-override:
+#   arch: A_64
+#   platform:
+#     contents: Ubuntu
+#     tag: Linux
+#   version: '18.04'
+platform-override: null

docker/alpine32/Dockerfile

@@ -0,0 +1,71 @@
+FROM i386/alpine:3.12
+
+ENV LANG C.UTF-8
+
+RUN apk add --no-cache \
+            curl \
+            gcc \
+            g++ \
+            binutils \
+            binutils-gold \
+			coreutils \
+            bsd-compat-headers \
+            gmp-dev \
+            ncurses-dev \
+            libffi-dev \
+            make \
+            xz \
+            tar \
+            perl \
+            bash \
+            diffutils \
+            git \
+			gzip \
+			gnupg && \
+    apk add --no-cache \
+            zlib \
+            zlib-dev \
+            zlib-static \
+            bzip2 \
+            bzip2-dev \
+            bzip2-static \
+            gmp \
+            gmp-dev \
+            openssl-dev \
+            openssl-libs-static \
+            xz \
+            xz-dev \
+            ncurses-static
+
+ARG GHCUP_VERSION=0.1.18.0
+ARG GPG_KEY=7784930957807690A66EBDBE3786C5262ECB4A3F
+
+# install ghcup
+RUN gpg --batch --keyserver keys.openpgp.org --recv-keys $GPG_KEY && \
+    curl -sSfL -O https://downloads.haskell.org/~ghcup/$GHCUP_VERSION/i386-linux-ghcup-$GHCUP_VERSION && \
+    curl -sSfL -O https://downloads.haskell.org/~ghcup/$GHCUP_VERSION/SHA256SUMS && \
+    curl -sSfL -O https://downloads.haskell.org/~ghcup/$GHCUP_VERSION/SHA256SUMS.sig && \
+    gpg --verify SHA256SUMS.sig SHA256SUMS && \
+    sha256sum -c --ignore-missing SHA256SUMS && \
+    mv i386-linux-ghcup-$GHCUP_VERSION /usr/bin/ghcup && \
+    chmod +x /usr/bin/ghcup && \
+    rm -rf SHA256SUMS SHA256SUMS.sig
+
+ARG GHC=8.10.7
+ARG CABAL_INSTALL=3.6.2.0
+ARG STACK=2.9.1
+
+ENV GHCUP_CURL_OPTS="--silent"
+ENV NO_COLOR=1
+
+# install haskell toolchain
+RUN ghcup config set gpg-setting GPGStrict && \
+	ghcup --verbose install ghc   --isolate=/usr     --force ${GHC} && \
+	ghcup --verbose install cabal --isolate=/usr/bin --force ${CABAL_INSTALL} && \
+	find "/usr/lib/ghc-${GHC}/" \( -name "*_p.a" -o -name "*.p_hi" \) -type f -delete && \
+	rm -r "/usr/share/doc/ghc-${GHC}" && \
+	rm -rf /tmp/ghcup* && \
+	ghcup gc -p -s -c -t
+
+ENV PATH /root/.cabal/bin:/root/.ghcup:/root/.local/bin:$PATH
+

docker/alpine64/Dockerfile

@@ -0,0 +1,71 @@
+FROM alpine:3.12
+
+ENV LANG C.UTF-8
+
+RUN apk add --no-cache \
+            curl \
+            gcc \
+            g++ \
+            binutils \
+            binutils-gold \
+			coreutils \
+            bsd-compat-headers \
+            gmp-dev \
+            ncurses-dev \
+            libffi-dev \
+            make \
+            xz \
+            tar \
+            perl \
+            bash \
+            diffutils \
+            git \
+			gzip \
+			gnupg && \
+    apk add --no-cache \
+            zlib \
+            zlib-dev \
+            zlib-static \
+            bzip2 \
+            bzip2-dev \
+            bzip2-static \
+            gmp \
+            gmp-dev \
+            openssl-dev \
+            openssl-libs-static \
+            xz \
+            xz-dev \
+            ncurses-static
+
+ARG GHCUP_VERSION=0.1.18.0
+ARG GPG_KEY=7784930957807690A66EBDBE3786C5262ECB4A3F
+
+# install ghcup
+RUN gpg --batch --keyserver keys.openpgp.org --recv-keys $GPG_KEY && \
+    curl -sSfL -O https://downloads.haskell.org/~ghcup/$GHCUP_VERSION/x86_64-linux-ghcup-$GHCUP_VERSION && \
+    curl -sSfL -O https://downloads.haskell.org/~ghcup/$GHCUP_VERSION/SHA256SUMS && \
+    curl -sSfL -O https://downloads.haskell.org/~ghcup/$GHCUP_VERSION/SHA256SUMS.sig && \
+    gpg --verify SHA256SUMS.sig SHA256SUMS && \
+    sha256sum -c --ignore-missing SHA256SUMS && \
+    mv x86_64-linux-ghcup-$GHCUP_VERSION /usr/bin/ghcup && \
+    chmod +x /usr/bin/ghcup && \
+    rm -rf SHA256SUMS SHA256SUMS.sig
+
+ARG GHC=8.10.7
+ARG CABAL_INSTALL=3.6.2.0
+ARG STACK=2.9.1
+
+ENV GHCUP_CURL_OPTS="--silent"
+ENV NO_COLOR=1
+
+# install haskell toolchain
+RUN ghcup config set gpg-setting GPGStrict && \
+	ghcup --verbose install ghc   --isolate=/usr     --force ${GHC} && \
+	ghcup --verbose install cabal --isolate=/usr/bin --force ${CABAL_INSTALL} && \
+	find "/usr/lib/ghc-${GHC}/" \( -name "*_p.a" -o -name "*.p_hi" \) -type f -delete && \
+	rm -r "/usr/share/doc/ghc-${GHC}" && \
+	rm -rf /tmp/ghcup* && \
+	ghcup gc -p -s -c -t
+
+ENV PATH /root/.cabal/bin:/root/.ghcup:/root/.local/bin:$PATH
+

docker/arm32v7/Dockerfile

@@ -0,0 +1,64 @@
+FROM arm32v7/ubuntu:focal
+
+ENV LANG C.UTF-8
+ENV DEBIAN_FRONTEND=noninteractive
+ENV TZ=Asia/Singapore
+
+COPY update_opt.sh /usr/bin/update_opt.sh
+RUN chmod +x /usr/bin/update_opt.sh
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        ca-certificates \
+        curl \
+        dirmngr \
+        g++ \
+        git \
+        gnupg \
+        libsqlite3-dev \
+        libtinfo-dev \
+        libgmp-dev \
+        make \
+        netbase \
+        openssh-client \
+        xz-utils \
+        zlib1g-dev \
+		libnuma-dev libgmp10 libssl-dev liblzma-dev libbz2-dev wget lsb-release software-properties-common apt-transport-https gcc autoconf automake build-essential gzip patchelf tree \
+		llvm-9 clang-9 && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN update_opt.sh 9 1
+
+ARG GHCUP_VERSION=0.1.17.8
+ARG GPG_KEY=7784930957807690A66EBDBE3786C5262ECB4A3F
+
+# install ghcup
+RUN gpg --batch --keyserver keys.openpgp.org --recv-keys $GPG_KEY && \
+    curl -sSfL -O https://downloads.haskell.org/~ghcup/$GHCUP_VERSION/armv7-linux-ghcup-$GHCUP_VERSION && \
+    curl -sSfL -O https://downloads.haskell.org/~ghcup/$GHCUP_VERSION/SHA256SUMS && \
+    curl -sSfL -O https://downloads.haskell.org/~ghcup/$GHCUP_VERSION/SHA256SUMS.sig && \
+    gpg --verify SHA256SUMS.sig SHA256SUMS && \
+    sha256sum -c --ignore-missing SHA256SUMS && \
+    mv armv7-linux-ghcup-$GHCUP_VERSION /usr/bin/ghcup && \
+    chmod +x /usr/bin/ghcup && \
+    rm -rf SHA256SUMS SHA256SUMS.sig
+
+ARG GHC=8.10.7
+ARG CABAL_INSTALL=3.6.2.0
+ARG STACK=2.9.1
+
+ENV GHCUP_CURL_OPTS="--silent"
+ENV NO_COLOR=1
+
+# install haskell toolchain
+RUN ghcup config set gpg-setting GPGStrict && \
+	ghcup --verbose install ghc   --isolate=/usr     --force ${GHC} && \
+	ghcup --verbose install cabal --isolate=/usr/bin --force ${CABAL_INSTALL} && \
+	find "/usr/lib/ghc-${GHC}/" \( -name "*_p.a" -o -name "*.p_hi" \) -type f -delete && \
+	rm -r "/usr/share/doc/ghc-${GHC}" && \
+	rm -rf /tmp/ghcup* && \
+	ghcup gc -p -s -c -t
+
+ENV PATH /root/.cabal/bin:/root/.ghcup/bin:/root/.local/bin:$PATH
+
+CMD ["ghci"]

docker/arm32v7/update_opt.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# update_alternatives.sh
+
+update_alternatives() {
+    local version=${1}
+    local priority=${2}
+    local master=${3}
+    local slaves=${4}
+    local path=${5}
+    local cmdln
+
+    cmdln="--verbose --install ${path}${master} ${master} ${path}${master}-${version} ${priority}"
+    for slave in ${slaves}; do
+        cmdln="${cmdln} --slave ${path}${slave} ${slave} ${path}${slave}-${version}"
+    done
+    update-alternatives ${cmdln}
+}
+
+if [[ ${#} -ne 2 ]]; then
+    echo usage: "${0}" clang_version priority
+    exit 1
+fi
+
+version=${1}
+priority=${2}
+path="/usr/bin/"
+
+master="llvm-config"
+slaves="llvm-addr2line llvm-ar llvm-as llvm-bcanalyzer llvm-bitcode-strip llvm-cat llvm-cfi-verify llvm-cov llvm-c-test llvm-cvtres llvm-cxxdump llvm-cxxfilt llvm-cxxmap llvm-debuginfod llvm-debuginfod-find llvm-diff llvm-dis llvm-dlltool llvm-dwarfdump llvm-dwarfutil llvm-dwp llvm-exegesis llvm-extract llvm-gsymutil llvm-ifs llvm-install-name-tool llvm-jitlink llvm-jitlink-executor llvm-lib llvm-libtool-darwin llvm-link llvm-lipo llvm-lto llvm-lto2 llvm-mc llvm-mca llvm-ml llvm-modextract llvm-mt llvm-nm llvm-objcopy llvm-objdump llvm-omp-device-info llvm-opt-report llvm-otool llvm-pdbutil llvm-PerfectShuffle llvm-profdata llvm-profgen llvm-ranlib llvm-rc llvm-readelf llvm-readobj llvm-reduce llvm-remark-size-diff llvm-rtdyld llvm-sim llvm-size llvm-split llvm-stress llvm-strings llvm-strip llvm-symbolizer llvm-tapi-diff llvm-tblgen llvm-tli-checker llvm-undname llvm-windres llvm-xray"
+
+update_alternatives "${version}" "${priority}" "${master}" "${slaves}" "${path}"
+
+master="clang"
+slaves="analyze-build asan_symbolize bugpoint c-index-test clang++ clang-apply-replacements clang-change-namespace clang-check clang-cl clang-cpp clangd clang-doc clang-extdef-mapping clang-format clang-format-diff clang-include-fixer clang-linker-wrapper clang-move clang-nvlink-wrapper clang-offload-bundler clang-offload-packager clang-offload-wrapper clang-pseudo clang-query clang-refactor clang-rename clang-reorder-fields clang-repl clang-scan-deps clang-tidy count diagtool dsymutil FileCheck find-all-symbols git-clang-format hmaptool hwasan_symbolize intercept-build ld64.lld ld.lld llc lld lldb lldb-argdumper lldb-instr lldb-server lldb-vscode lld-link lli lli-child-target modularize not obj2yaml opt pp-trace run-clang-tidy sancov sanstats scan-build scan-build-py scan-view split-file UnicodeNameMappingGenerator verify-uselistorder wasm-ld yaml2obj yaml-bench"
+
+update_alternatives "${version}" "${priority}" "${master}" "${slaves}" "${path}"