Fix ghcToolFiles for upcoming GHC build system changes

Also see: https://gitlab.haskell.org/ghc/ghc/-/issues/20074#note_363720

.github/release.yaml

@@ -1,109 +0,0 @@
-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/workflows/release.yaml

@@ -1,109 +0,0 @@
-name: Create Release
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  draft_release:
-    name: Draft 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
-    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 --constraint="zlib +bundled-c-zlib" --constraint="lzma +static" -ftui
-        shell: bash
-
-      - name: Build
-        run: cabal build --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/workflows/shimgen.yaml

@@ -1,29 +0,0 @@
-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
-

.gitlab-ci.yml

@@ -21,7 +21,6 @@ variables:
     OS: "LINUX"
     ARCH: "64"
     CABAL_DIR: "$CI_PROJECT_DIR/cabal"
-    CROSS: ""
 
 .alpine:64bit:
   image: "alpine:3.12"
@@ -42,7 +41,7 @@ variables:
     CABAL_DIR: "$CI_PROJECT_DIR/cabal"
 
 .linux:armv7:
-  image: "registry.gitlab.haskell.org/ghc/ci-images/armv7-linux-deb10:$DOCKER_REV"
+  image: "arm32v7/fedora"
   tags:
     - armv7-linux
   variables:
@@ -51,7 +50,7 @@ variables:
     CABAL_DIR: "$CI_PROJECT_DIR/cabal"
 
 .linux:aarch64:
-  image: "registry.gitlab.haskell.org/ghc/ci-images/aarch64-linux-deb10:$DOCKER_REV"
+  image: "arm64v8/fedora"
   tags:
     - aarch64-linux
   variables:
@@ -106,10 +105,6 @@ variables:
       - golden
     when: on_failure
 
-# .test_ghcup_scoop:
-  # script:
-    # - cl /O1 scoop-better-shimexe/shim.c
-
 .test_ghcup_version:linux:
   extends:
     - .test_ghcup_version
@@ -129,14 +124,14 @@ variables:
     - .test_ghcup_version
     - .linux:armv7
   before_script:
-    - ./.gitlab/before_script/linux/install_deps.sh
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
 
 .test_ghcup_version:aarch64:
   extends:
     - .test_ghcup_version
     - .linux:aarch64
   before_script:
-    - ./.gitlab/before_script/linux/install_deps.sh
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
 
 .test_ghcup_version:darwin:
   extends:
@@ -189,12 +184,6 @@ variables:
     - set CABAL_DIR="$CI_PROJECT_DIR/cabal"
     - bash ./.gitlab/before_script/windows/install_deps.sh
 
-# .test_ghcup_scoop:windows:
-  # extends:
-    # - .windows
-    # - .test_ghcup_scoop
-    # - .root_cleanup
-
 .release_ghcup:
   script:
     - bash ./.gitlab/script/ghcup_release.sh
@@ -269,24 +258,6 @@ test:linux:latest:
     CABAL_VERSION: "3.4.0.0"
   needs: []
 
-test:linux:cross-armv7:
-  stage: test
-  extends:
-    - .test_ghcup_version
-    - .debian
-  variables:
-    GHC_VERSION: "8.10.4"
-    GHC_TARGET_VERSION: "8.10.5"
-    CABAL_VERSION: "3.4.0.0"
-    CROSS: "arm-linux-gnueabihf"
-  needs: []
-  when: manual
-  before_script:
-    - ./.gitlab/before_script/linux/install_deps.sh
-  script:
-    - ./.gitlab/script/ghcup_cross.sh
-
-
 ######## linux 32bit test ########
 
 test:linux:recommended:32bit:
@@ -305,7 +276,6 @@ test:linux:recommended:armv7:
   variables:
     GHC_VERSION: "8.10.4"
     CABAL_VERSION: "3.4.0.0"
-    CROSS: ""
   when: manual
   needs: []
 
@@ -315,7 +285,6 @@ test:linux:recommended:aarch64:
   variables:
     GHC_VERSION: "8.10.4"
     CABAL_VERSION: "3.4.0.0"
-    CROSS: ""
   when: manual
   needs: []
 
@@ -369,11 +338,6 @@ test:windows:recommended:
     CABAL_VERSION: "3.4.0.0"
   needs: []
 
-# test:windows:scoop:
-  # stage: test
-  # extends: .test_ghcup_scoop:windows
-  # needs: []
-
 ######## linux release ########
 
 release:linux:64bit:
@@ -410,12 +374,11 @@ release:linux:armv7:
     - .linux:armv7
     - .release_ghcup
   before_script:
-    - ./.gitlab/before_script/linux/install_deps.sh
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
   variables:
     ARTIFACT: "armv7-linux-ghcup"
     GHC_VERSION: "8.10.4"
     CABAL_VERSION: "3.4.0.0"
-    CROSS: ""
 
 release:linux:aarch64:
   stage: release
@@ -424,12 +387,11 @@ release:linux:aarch64:
     - .linux:aarch64
     - .release_ghcup
   before_script:
-    - ./.gitlab/before_script/linux/install_deps.sh
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
   variables:
     ARTIFACT: "aarch64-linux-ghcup"
     GHC_VERSION: "8.10.4"
     CABAL_VERSION: "3.4.0.0"
-    CROSS: ""
 
 ######## darwin release ########
 
@@ -458,19 +420,13 @@ release:darwin:aarch64:
   script: |
     set -Eeuo pipefail
     function runInNixShell() {
-      time nix-shell $CI_PROJECT_DIR/.gitlab/shell.nix \
+      time nix-shell .gitlab/shell.nix \
         -I nixpkgs=https://github.com/angerman/nixpkgs/archive/75f7281738b.tar.gz \
         --argstr system "aarch64-darwin" \
         --pure \
-        --keep CI_PROJECT_DIR \
+        --keep CI_PROJECT_DIR --keep MAKE_ARGS --keep HADRIAN_ARGS --keep CABAL_CACHE \
         --keep MACOSX_DEPLOYMENT_TARGET \
-        --keep JSON_VERSION \
+        --keep JSON_VERSION --keep ARTIFACT \
-        --keep ARTIFACT \
-        --keep OS \
-        --keep ARCH \
-        --keep CABAL_DIR \
-        --keep GHC_VERSION \
-        --keep CABAL_VERSION \
         --run "$1" 2>&1
     }
     runInNixShell ./.gitlab/before_script/darwin/install_deps.sh 2>&1

.gitlab/before_script/linux/install_deps.sh

@@ -7,67 +7,13 @@ set -eux
 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
+sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev libbz2-dev git wget
 
-if [ "${CROSS}" = "arm-linux-gnueabihf" ] ; then
+curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-linux-ghcup > ./ghcup-bin
-	sudo apt-get install -y autoconf build-essential gcc-arm-linux-gnueabihf
+chmod +x ghcup-bin
-	sudo dpkg --add-architecture armhf
-	sudo apt-get update -y
-	sudo apt-get install -y libncurses-dev:armhf
-fi
 
-case "${ARCH}" in
+./ghcup-bin upgrade -i -f
-	ARM*)
+./ghcup-bin install ${GHC_VERSION}
-		case "${ARCH}" in
+./ghcup-bin set ${GHC_VERSION}
-			"ARM")
+./ghcup-bin install-cabal ${CABAL_VERSION}
-				ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-armv7-deb10-linux.tar.xz
-				cabal_url=home.smart-cactus.org/~ben/cabal-install-${CABAL_VERSION}-armv7-linux-bootstrapped.tar.xz
-				;;
-			"ARM64")
-				ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-aarch64-deb10-linux.tar.xz
-				cabal_url=https://downloads.haskell.org/~cabal/cabal-install-${CABAL_VERSION}/cabal-install-${CABAL_VERSION}-aarch64-ubuntu-18.04.tar.xz
-				;;
-			*)
-				exit 1 ;;
-		esac
-
-		mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin
-
-		curl -O "${ghc_url}"
-		tar -xf ghc-*.tar.*
-		cd ghc-${GHC_VERSION}
-		./configure --prefix="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}
-		make install
-		for i in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}/bin/*-${GHC_VERSION} ; do
-			ln -s "${i}" "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/${i##*/}
-		done
-		for x in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/*-${GHC_VERSION} ; do
-			ln -s ${x##*/} ${x%-${GHC_VERSION}}
-		done
-		cd ..
-		rm -rf ghc-${GHC_VERSION} ghc-*.tar.*
-		unset x i
-
-		mkdir cabal-install
-		cd cabal-install
-		curl -O "${cabal_url}"
-		tar -xf cabal-install-*
-		mv cabal "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/cabal
-		cd ..
-		rm -rf cabal-install
-
-		;;
-	*) 
-		url=https://downloads.haskell.org/~ghcup/x86_64-linux-ghcup
-
-		curl -sSfL "${url}" > ./ghcup-bin
-		chmod +x ghcup-bin
-
-		./ghcup-bin upgrade -i -f
-		./ghcup-bin install ghc ${GHC_VERSION}
-		./ghcup-bin set ghc ${GHC_VERSION}
-		./ghcup-bin install cabal ${CABAL_VERSION}
-
-		;;
-esac
 

.gitlab/before_script/linux/install_deps_manual.sh

@@ -0,0 +1,64 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}"
+
+ednf() {
+	case "${ARCH}" in
+		"ARM")
+			sudo dnf -y --forcearch armv7hl "$@"
+			;;
+		"ARM64")
+			sudo dnf -y --forcearch aarch64 "$@"
+			;;
+		*) exit 1 ;;
+	esac
+}
+
+ednf update
+ednf install gcc gcc-c++ gmp gmp-devel make ncurses ncurses-devel xz xz-devel perl zlib zlib-devel openssl-devel openssl-libs openssl libffi libffi-devel lbzip2 lbzip2-utils bzip2-devel
+if [ "${ARCH}" = "ARM64" ] ; then
+	ednf install numactl numactl-libs numactl-devel
+fi
+ednf install bash wget curl git tar
+ednf install llvm9.0 llvm9.0-devel llvm9.0-libs llvm9.0-static
+
+case "${ARCH}" in
+	"ARM")
+		ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-armv7-deb10-linux.tar.xz
+		cabal_url=home.smart-cactus.org/~ben/cabal-install-${CABAL_VERSION}-armv7-linux-bootstrapped.tar.xz
+		;;
+	"ARM64")
+		ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-aarch64-deb10-linux.tar.xz
+		cabal_url=https://downloads.haskell.org/~cabal/cabal-install-${CABAL_VERSION}/cabal-install-${CABAL_VERSION}-aarch64-ubuntu-18.04.tar.xz
+		;;
+	*) exit 1 ;;
+esac
+
+mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin
+
+curl -O "${ghc_url}"
+tar -xf ghc-*.tar.*
+cd ghc-${GHC_VERSION}
+./configure --prefix="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}
+make install
+for i in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}/bin/*-${GHC_VERSION} ; do
+	ln -s "${i}" "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/${i##*/}
+done
+for x in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/*-${GHC_VERSION} ; do
+	ln -s ${x##*/} ${x%-${GHC_VERSION}}
+done
+cd ..
+rm -rf ghc-${GHC_VERSION} ghc-*.tar.*
+unset x i
+
+mkdir cabal-install
+cd cabal-install
+curl -O "${cabal_url}"
+tar -xf cabal-install-*
+mv cabal "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/cabal
+cd ..
+rm -rf cabal-install

.gitlab/ghcup_env

@@ -4,6 +4,6 @@ if [ "${OS}" = "WINDOWS" ] ; then
 	export TMPDIR="$CI_PROJECT_DIR/tmp"
 else
 	export GHCUP_INSTALL_BASE_PREFIX="$CI_PROJECT_DIR"
-	export PATH="$CI_PROJECT_DIR/.ghcup/bin:$CI_PROJECT_DIR/.local/bin:/opt/llvm/bin:$PATH"
+	export PATH="$CI_PROJECT_DIR/.ghcup/bin:$CI_PROJECT_DIR/.local/bin:$PATH"
 	export TMPDIR="$CI_PROJECT_DIR/tmp"
 fi

.gitlab/script/ghcup_cross.sh

@@ -1,52 +0,0 @@
-#!/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/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_release.sh

@@ -15,6 +15,10 @@ git describe
 # build
 ecabal update
 
+(
+	cd /tmp
+	ecabal install -w ghc-${GHC_VERSION} --installdir="$CI_PROJECT_DIR"/.local/bin hspec-discover
+)
 
 if [ "${OS}" = "LINUX" ] ; then
 	if [ "${ARCH}" = "32" ] ; then

.gitlab/script/ghcup_version.sh

@@ -26,6 +26,11 @@ git describe --always
 
 ecabal update
 
+(
+	cd /tmp
+	ecabal install -w ghc-${GHC_VERSION} --installdir="$CI_PROJECT_DIR"/.local/bin hspec-discover
+)
+
 if [ "${OS}" = "DARWIN" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} -ftui
 	ecabal test -w ghc-${GHC_VERSION} -ftui ghcup-test
@@ -78,11 +83,9 @@ ghcup-gen check -f ghcup-${JSON_VERSION}.yaml
 
 eghcup --numeric-version
 
-eghcup install ghc ${GHC_VERSION}
+eghcup install ${GHC_VERSION}
-[ `$(eghcup whereis ghc ${GHC_VERSION}) --numeric-version` = "${GHC_VERSION}" ]
+eghcup set ${GHC_VERSION}
-eghcup set ghc ${GHC_VERSION}
+eghcup install-cabal ${CABAL_VERSION}
-eghcup install cabal ${CABAL_VERSION}
-[ `$(eghcup whereis cabal ${CABAL_VERSION}) --numeric-version` = "${CABAL_VERSION}" ]
 
 cabal --version
 
@@ -107,27 +110,25 @@ 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 --downloader=wget install 8.10.3
-		eghcup --offline install ghc 8.10.3
 	else # test wget a bit
-		eghcup prefetch ghc 8.10.3
+		eghcup install 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
 	eghcup set 8.10.3
 	[ "$(ghc --numeric-version)" = "8.10.3" ]
 	eghcup set ${GHC_VERSION}
 	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-	eghcup --offline rm 8.10.3
+	eghcup rm 8.10.3
 	[ "$(ghc --numeric-version)" = "${ghc_ver}" ]
 
 	if [ "${OS}" = "DARWIN" ] ; then
 		eghcup install hls
-		$(eghcup whereis hls) --version
+		haskell-language-server-wrapper --version
 
 		eghcup install stack
-		$(eghcup whereis stack) --version
+		stack --version
 	elif [ "${OS}" = "LINUX" ] ; then
 		if [ "${ARCH}" = "64" ] ; then
 			eghcup install hls
@@ -139,11 +140,6 @@ else
 	fi
 fi
 
-# check that lazy loading works for 'whereis'
-cp "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml" "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml.bak"
-echo '**' > "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml"
-eghcup whereis ghc $(ghc --numeric-version)
-mv -f "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml.bak" "$CI_PROJECT_DIR/ghcup-${JSON_VERSION}.yaml"
 
 eghcup rm $(ghc --numeric-version)
 
@@ -155,7 +151,6 @@ if [ "${OS}" = "LINUX" ] ; then
 	fi
 fi
 
-
 eghcup upgrade
 eghcup upgrade -f
 

.travis.yml

@@ -0,0 +1,37 @@
+jobs:
+  include:
+    - os: osx
+      osx_image: xcode8
+      language: generic
+      env: ARTIFACT=x86_64-apple-darwin-10.11-ghcup
+
+    - os: osx
+      osx_image: xcode10.1
+      language: generic
+      env: ARTIFACT=x86_64-apple-darwin-10.13-ghcup
+
+    - os: osx
+      osx_image: xcode11.3
+      language: generic
+      env: ARTIFACT=x86_64-apple-darwin-10.14-ghcup
+
+  allow_failures:
+    - os: osx
+      osx_image: xcode8
+      language: generic
+      env: ARTIFACT=x86_64-apple-darwin-10.11-ghcup
+
+
+script: ".travis/build.sh"
+
+deploy:
+  provider: releases
+  api_key:
+    secure: GQESg4TcYf3PQJRRaZV/kWS0hsF+OFnH2+EcwpgnIcfx4+aogMyprdh745KtBXe1FlFN1luKHksFjqceqhcg/xcNyeCJiSnLWMn4D/i4WUperEHseRBi5yZZCB1AvOjIlHrE4DS3a8pyEm1GV3G7CKY5Fu8jBjof2SnyENfd7fofhjtNHWmeFS+jBn8HRDf1YaSRYxzTw6uHLrPLsybfgQZVl7babMu/38Ghin0f5pz5OlNokzDxaubIYQHOZ7st7YndHJtBWWql/KualBWbMILy88dUVQBnbqQLP2P8d1ME8ILUjJVqz33HiRU0JzlEJyWfbvEjcJ6iD8M6n4nXTaxfu3i2UhhGsQ6SSBNKssMP4tji8nkNpMqG59wLQ/zhcetEm71fKkgJNrIMNllkqlWSo5K74IqqP9kiLg/qm8ipOJjui0gPk8tZXKcV+ztX1d1OVCapoLfiDM5l/0LLQXaTOXOV1x3e5LLQ/w2doNiH3eh5CV4II9dRu7owpaiiMBHMssmT0pH99jEeF6giHLKtt3y7l2GWoRLPdhsZZ54gxsaBxZt9GuypmkbNcr97CEnAVaWij5v0CF3w4rAWqy/tAxQpIDJOIOQBgmwG5WrBAKyKrFvEpBL5a8BPcRWJDvqKC83QeWpvPrEVdgJevC6ZN1MKzrb2SiPOwC2Kerc=
+  file: $ARTIFACT
+  on:
+    repo: haskell/ghcup-hs
+    tags: true
+  skip_cleanup: true
+  draft: true
+

.travis/build.sh

@@ -0,0 +1,28 @@
+#!/bin/sh
+
+set -ex
+
+mkdir -p ~/.ghcup/bin
+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.10.4
+ghcup install-cabal 3.4.0.0
+ghcup set 8.10.4
+
+
+## install ghcup
+
+cabal update
+
+(
+	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}"

HACKING.md

@@ -69,7 +69,3 @@ yaml files: `ghcup-<yaml-ver>.yaml`.
    Most of the `Version` parameters to functions had to be replaced with
    that and ensured the logic is consistent for cross and non-cross
    installs.
-2. This refactor added windows support wrt [#130](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/130).
-   The major changes here were switching `hpath` library out for `filepath`/`directory` (sadly) and
-   introducing a non-unix way of handling processes via the `process` library. It also introduced considerable
-   amounts of CPP wrt file handling, installation etc.

app/ghcup-gen/Validate.hs

@@ -12,7 +12,7 @@ import           GHCup
 import           GHCup.Download
 import           GHCup.Errors
 import           GHCup.Platform
-import           GHCup.Types                  hiding ( LeanAppState (..) )
+import           GHCup.Types
 import           GHCup.Types.Optics
 import           GHCup.Utils
 import           GHCup.Utils.Logger
@@ -226,7 +226,7 @@ validateTarballs (TarballFilter etool versionRegex) dls gt = do
                                      , rawOutter    = \_ -> pure ()
                                      }
   downloadAll dli = do
-    dirs <- liftIO getAllDirs
+    dirs <- liftIO getDirs
 
     pfreq <- (
       runLogger . runE @'[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound] . liftE $ platformRequest
@@ -237,7 +237,7 @@ validateTarballs (TarballFilter etool versionRegex) dls gt = do
                   ($(logError) $ T.pack $ prettyShow e)
                 liftIO $ exitWith (ExitFailure 2)
 
-    let appstate = AppState (Settings True False Never Curl False GHCupURL False) dirs defaultKeyBindings (GHCupInfo mempty mempty mempty) pfreq
+    let appstate = AppState (Settings True False Never Curl False GHCupURL) dirs defaultKeyBindings (GHCupInfo mempty mempty mempty) pfreq
 
     r <-
       runLogger
@@ -256,17 +256,17 @@ validateTarballs (TarballFilter etool versionRegex) dls gt = do
         case etool of
           Right (Just GHCup) -> do
             tmpUnpack <- lift mkGhcupTmpDir
-            _ <- liftE $ download dli tmpUnpack Nothing
+            _ <- liftE $ download (settings appstate) dli tmpUnpack Nothing
             pure Nothing
           Right _ -> do
-            p <- liftE $ downloadCached dli Nothing
+            p <- liftE $ downloadCached (settings appstate) dirs dli Nothing
             fmap (Just . head . splitDirectories . head)
               . liftE
               . getArchiveFiles
               $ p
           Left ShimGen -> do
             tmpUnpack <- lift mkGhcupTmpDir
-            _ <- liftE $ download dli tmpUnpack Nothing
+            _ <- liftE $ download (settings appstate) dli tmpUnpack Nothing
             pure Nothing
     case r of
       VRight (Just basePath) -> do

app/ghcup/BrickMain.hs

@@ -13,7 +13,7 @@ module BrickMain where
 import           GHCup
 import           GHCup.Download
 import           GHCup.Errors
-import           GHCup.Types         hiding ( LeanAppState(..) )
+import           GHCup.Types
 import           GHCup.Utils
 import           GHCup.Utils.Prelude ( decUTF8Safe )
 import           GHCup.Utils.File
@@ -53,6 +53,8 @@ import           System.IO.Unsafe
 import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           URI.ByteString
 
+import qualified GHCup.Types                   as GT
+
 import qualified Data.Text                     as T
 import qualified Graphics.Vty                  as Vty
 import qualified Data.Vector                   as V
@@ -548,14 +550,13 @@ changelog' _ (_, ListResult {..}) = do
 settings' :: IORef AppState
 {-# NOINLINE settings' #-}
 settings' = unsafePerformIO $ do
-  dirs <- getAllDirs
+  dirs <- getDirs
   newIORef $ AppState (Settings { cache      = True
                                 , noVerify   = False
                                 , keepDirs   = Never
                                 , downloader = Curl
                                 , verbose    = False
                                 , urlSource  = GHCupURL
-                                , noNetwork  = False
                                 , ..
                                 })
                       dirs
@@ -577,8 +578,9 @@ logger' = unsafePerformIO
 
 brickMain :: AppState
           -> LoggerConfig
+          -> GHCupInfo
           -> IO ()
-brickMain s l = do
+brickMain s l gi = do
   writeIORef settings' s
   -- logger interpreter
   writeIORef logger'   l
@@ -586,7 +588,7 @@ brickMain s l = do
 
   no_color <- isJust <$> lookupEnv "NO_COLOR"
 
-  eAppData <- getAppData (Just $ ghcupInfo s)
+  eAppData <- getAppData (Just gi)
   case eAppData of
     Right ad ->
       defaultMain
@@ -594,7 +596,7 @@ brickMain s l = do
           (BrickState ad
                     defaultAppSettings
                     (constructList ad defaultAppSettings Nothing)
-                    (keyBindings (s :: AppState))
+                    (keyBindings s)
 
           )
         $> ()
@@ -618,7 +620,7 @@ getGHCupInfo = do
     . flip runReaderT settings
     . runE @'[JSONError , DownloadFailed , FileDoesNotExistError]
     $ liftE
-    $ getDownloadsF
+    $ getDownloadsF (GT.settings settings) (GT.dirs settings)
 
   case r of
     VRight a -> pure $ Right a

app/ghcup/Main.hs

@@ -21,7 +21,6 @@ import           GHCup.Errors
 import           GHCup.Platform
 import           GHCup.Requirements
 import           GHCup.Types
-import           GHCup.Types.Optics
 import           GHCup.Utils
 import           GHCup.Utils.File
 import           GHCup.Utils.Logger
@@ -34,8 +33,6 @@ import           GHCup.Version
 import           Codec.Archive
 #endif
 import           Control.Concurrent
-import           Control.DeepSeq                ( force )
-import           Control.Exception              ( evaluate )
 import           Control.Exception.Safe
 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
@@ -91,7 +88,6 @@ data Options = Options
   , optNoVerify  :: Maybe Bool
   , optKeepDirs  :: Maybe KeepDirs
   , optsDownloader :: Maybe Downloader
-  , optNoNetwork :: Maybe Bool
   -- commands
   , optCommand   :: Command
   }
@@ -104,7 +100,6 @@ data Command
   | Rm (Either RmCommand RmOptions)
   | DInfo
   | Compile CompileCommand
-  | Whereis WhereisOptions WhereisCommand
   | Upgrade UpgradeOpts Bool
   | ToolRequirements
   | ChangeLog ChangeLogOptions
@@ -112,7 +107,6 @@ data Command
 #if defined(BRICK)
   | Interactive
 #endif
-  | Prefetch PrefetchCommand
 
 data ToolVersion = ToolVersion GHCTargetVersion -- target is ignored for cabal
                  | ToolTag Tag
@@ -196,28 +190,6 @@ data ChangeLogOptions = ChangeLogOptions
   }
 
 
-data WhereisCommand = WhereisTool Tool (Maybe ToolVersion)
-
-data WhereisOptions = WhereisOptions {
-   directory :: Bool
-}
-
-data PrefetchOptions = PrefetchOptions {
-  pfCacheDir :: Maybe FilePath
-}
-
-data PrefetchCommand = PrefetchGHC PrefetchGHCOptions (Maybe ToolVersion)
-                     | PrefetchCabal PrefetchOptions (Maybe ToolVersion)
-                     | PrefetchHLS PrefetchOptions (Maybe ToolVersion)
-                     | PrefetchStack PrefetchOptions (Maybe ToolVersion)
-                     | PrefetchMetadata
-
-data PrefetchGHCOptions = PrefetchGHCOptions {
-    pfGHCSrc :: Bool
-  , pfGHCCacheDir :: Maybe FilePath
-}
-
-
 -- https://github.com/pcapriotti/optparse-applicative/issues/148
 
 -- | A switch that can be enabled using --foo and disabled using --no-foo.
@@ -294,7 +266,6 @@ opts =
 #endif
           <> hidden
           ))
-    <*> invertableSwitch "offline" 'o' False (help "Don't do any network calls, trying cached assets and failing if missing.")
     <*> com
  where
   parseUri s' =
@@ -364,27 +335,6 @@ com =
            <$> 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 ))
-           )
       <> commandGroup "Main commands:"
       )
     <|> subparser
@@ -452,34 +402,6 @@ com =
   By default returns the URI of the ChangeLog of the latest GHC release.
   Pass '-o' to automatically open via xdg-open.|]
 
-  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|]
-
-  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|]
-
-
 installCabalFooter :: String
 installCabalFooter = [s|Discussion:
   Installs the specified cabal-install version (or a recommended default one)
@@ -784,135 +706,6 @@ Examples:
   ghcup compile ghc -j 4 -v 8.4.2 -b 8.2.2 -x armv7-unknown-linux-gnueabihf --config $(pwd)/build.mk -- --enable-unregisterised|]
 
 
-whereisP :: Parser WhereisCommand
-whereisP = subparser
-  (  command
-      "ghc"
-      (WhereisTool GHC <$> info
-        ( optional (toolVersionArgument Nothing (Just GHC)) <**> helper )
-        ( progDesc "Get GHC location"
-        <> footerDoc (Just $ text whereisGHCFooter ))
-      )
-      <>
-     command
-      "cabal"
-      (WhereisTool Cabal <$> info
-        ( optional (toolVersionArgument Nothing (Just Cabal)) <**> helper )
-        ( progDesc "Get cabal location"
-        <> footerDoc (Just $ text whereisCabalFooter ))
-      )
-      <>
-     command
-      "hls"
-      (WhereisTool HLS <$> info
-        ( optional (toolVersionArgument Nothing (Just HLS)) <**> helper )
-        ( progDesc "Get HLS location"
-        <> footerDoc (Just $ text whereisHLSFooter ))
-      )
-      <>
-     command
-      "stack"
-      (WhereisTool Stack <$> info
-        ( optional (toolVersionArgument Nothing (Just Stack)) <**> helper )
-        ( progDesc "Get stack location"
-        <> footerDoc (Just $ text whereisStackFooter ))
-      )
-      <>
-     command
-      "ghcup"
-      (WhereisTool GHCup <$> info ( (pure Nothing) <**> helper ) ( progDesc "Get ghcup 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|]
-
-
-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/)")))
-          <*> ( optional (toolVersionArgument 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/)")))
-          <*> ( optional (toolVersionArgument 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/)")))
-          <*> ( optional (toolVersionArgument 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/)")))
-          <*> ( optional (toolVersionArgument Nothing (Just Stack)) <**> helper ))
-        ( progDesc "Download stack assets for installation")
-      )
-      <>
-     command
-      "metadata"
-      (const PrefetchMetadata <$> info
-        helper
-        ( progDesc "Download ghcup's metadata, needed for various operations")
-      )
-  )
-
-
 ghcCompileOpts :: Parser GHCCompileOptions
 ghcCompileOpts =
   GHCCompileOptions
@@ -1030,20 +823,14 @@ versionArgument criteria tool = argument (eitherReader tVersionEither) (metavar
 
 tagCompleter :: Tool -> [String] -> Completer
 tagCompleter tool add = listIOCompleter $ do
-  dirs' <- liftIO getAllDirs
+  dirs' <- liftIO getDirs
-  let appState = LeanAppState
-        (Settings True False Never Curl False GHCupURL True)
-        dirs'
-        defaultKeyBindings
-
   let loggerConfig = LoggerConfig
         { lcPrintDebug = False
         , colorOutter  = mempty
         , rawOutter    = mempty
         }
   let runLogger = myLoggerT loggerConfig
-
+  mGhcUpInfo <- runLogger . runE $ readFromCache dirs'
-  mGhcUpInfo <- runLogger . flip runReaderT appState . runE $ getDownloadsF
   case mGhcUpInfo of
     VRight ghcupInfo -> do
       let allTags = filter (\t -> t /= Old)
@@ -1056,24 +843,19 @@ tagCompleter tool add = listIOCompleter $ do
 
 versionCompleter :: Maybe ListCriteria -> Tool -> Completer
 versionCompleter criteria tool = listIOCompleter $ do
-  dirs' <- liftIO getAllDirs
+  dirs' <- liftIO getDirs
   let loggerConfig = LoggerConfig
         { lcPrintDebug = False
         , colorOutter  = mempty
         , rawOutter    = mempty
         }
   let runLogger = myLoggerT loggerConfig
-      settings = Settings True False Never Curl False GHCupURL True
+  mGhcUpInfo <- runLogger . runE $ readFromCache dirs'
-  let leanAppState = LeanAppState
+  mpFreq <- runLogger . runE $ platformRequest
-                   settings
+  forFold mpFreq $ \pfreq ->
-                   dirs'
-                   defaultKeyBindings
-  mpFreq <- runLogger . flip runReaderT leanAppState . runE $ platformRequest
-  mGhcUpInfo <- runLogger . flip runReaderT leanAppState . runE $ getDownloadsF
-  forFold mpFreq $ \pfreq -> do
     forFold mGhcUpInfo $ \ghcupInfo -> do
       let appState = AppState
-            settings
+            (Settings True False Never Curl False GHCupURL)
             dirs'
             defaultKeyBindings
             ghcupInfo
@@ -1222,7 +1004,6 @@ toSettings options = do
          downloader  = fromMaybe (fromMaybe defaultDownloader uDownloader) optsDownloader
          keyBindings = maybe defaultKeyBindings mergeKeys uKeyBindings
          urlSource   = maybe (fromMaybe GHCupURL uUrlSource) OwnSource optUrlSource
-         noNetwork   = fromMaybe (fromMaybe False uNoNetwork) optNoNetwork
      in (Settings {..}, keyBindings)
 #if defined(INTERNAL_DOWNLOADER)
    defaultDownloader = Internal
@@ -1267,10 +1048,8 @@ describe_result :: String
 describe_result = $( LitE . StringL <$>
                      runIO (do
                              CapturedProcess{..} <-  do
-                              dirs <- liftIO getAllDirs
+                              dirs <- liftIO getDirs
-                              let settings = AppState (Settings True False Never Curl False GHCupURL False)
+                              let settings = AppState (Settings True False Never Curl False GHCupURL) dirs defaultKeyBindings
-                                               dirs
-                                               defaultKeyBindings
                               flip runReaderT settings $ executeOut "git" ["describe"] Nothing
                              case _exitCode of
                                ExitSuccess   -> pure . T.unpack . decUTF8Safe' $ _stdOut
@@ -1322,7 +1101,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
             (footerDoc (Just $ text main_footer))
       )
     >>= \opt@Options {..} -> do
-          dirs@Dirs{..} <- getAllDirs
+          dirs <- getDirs
 
           -- create ~/.ghcup dir
           ensureDirectories dirs
@@ -1330,7 +1109,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
           (settings, keybindings) <- toSettings opt
 
           -- logger interpreter
-          logfile <- initGHCupFileLogging logsDir
+          logfile <- initGHCupFileLogging (logsDir dirs)
           let loggerConfig = LoggerConfig
                 { lcPrintDebug = verbose settings
                 , colorOutter  = B.hPut stderr
@@ -1342,14 +1121,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
           let runLogger = myLoggerT loggerConfig
           let siletRunLogger = myLoggerT loggerConfig { colorOutter = \_ -> pure () }
 
-
-          -------------------------
-          -- Setting up appstate --
-          -------------------------
-
-
-          let leanAppstate = LeanAppState settings dirs keybindings
-              appState = do
           pfreq <- (
             runLogger . runE @'[NoCompatiblePlatform, NoCompatibleArch, DistroNotFound] . liftE $ platformRequest
             ) >>= \case
@@ -1359,12 +1130,17 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                         ($(logError) $ T.pack $ prettyShow e)
                       exitWith (ExitFailure 2)
 
+
+
+          ----------------------------------------
+          -- Getting download and platform info --
+          ----------------------------------------
+
           ghcupInfo <-
             ( runLogger
-                    . flip runReaderT leanAppstate
               . runE @'[JSONError , DownloadFailed, FileDoesNotExistError]
               $ liftE
-                    $ getDownloadsF
+              $ getDownloadsF settings dirs
               )
               >>= \case
                     VRight r -> pure r
@@ -1372,34 +1148,26 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                       runLogger
                         ($(logError) $ T.pack $ prettyShow e)
                       exitWith (ExitFailure 2)
-                let s' = AppState settings dirs keybindings ghcupInfo pfreq
 
+          let appstate@AppState{dirs = Dirs{..}
+                               , ghcupInfo = GHCupInfo { _ghcupDownloads = dls, .. }
+                               } = AppState settings dirs keybindings ghcupInfo pfreq
+
+          case optCommand of
+            Upgrade _ _ -> pure ()
+            _ -> do
               lookupEnv "GHCUP_SKIP_UPDATE_CHECK" >>= \case
-                  Nothing -> runLogger $ flip runReaderT s' $ checkForUpdates
+                Nothing -> runLogger $ flip runReaderT appstate $ checkForUpdates
                 Just _ -> pure ()
 
-                -- TODO: always run for windows
+
-                (siletRunLogger $ flip runReaderT s' $ runE ensureGlobalTools) >>= \case
+          -- ensure global tools
+          (siletRunLogger $ flip runReaderT appstate $ runE ensureGlobalTools) >>= \case
             VRight _ -> pure ()
             VLeft e -> do
               runLogger
                 ($(logError) $ T.pack $ prettyShow e)
               exitWith (ExitFailure 30)
-                pure s'
-
-
-#if defined(IS_WINDOWS)
-              -- FIXME: windows needs 'ensureGlobalTools', which requires
-              -- full appstate
-              runLeanAppState = runAppState
-#else
-              runLeanAppState = flip runReaderT leanAppstate
-#endif
-              runAppState action' = do
-                s' <- liftIO appState
-                flip runReaderT s' action'
-                  
-
 
 
           -------------------------
@@ -1408,7 +1176,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 
           let runInstTool' appstate' mInstPlatform =
                 runLogger
-                  . flip runReaderT (maybe appstate' (\x -> appstate'{ pfreq = x } :: AppState) mInstPlatform)
+                  . flip runReaderT (maybe appstate' (\x -> appstate'{ pfreq = x }) mInstPlatform)
                   . runResourceT
                   . runE
                     @'[ AlreadyInstalled
@@ -1429,25 +1197,12 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                       , NoToolVersionSet
                       ]
 
-          let runInstTool mInstPlatform action' = do
+          let runInstTool = runInstTool' appstate
-                s' <- liftIO appState
-                runInstTool' s' mInstPlatform action'
 
           let
-            runLeanSetGHC =
-              runLogger
-                . runLeanAppState
-                . runE
-                  @'[ FileDoesNotExistError
-                    , NotInstalled
-                    , TagNotFound
-                    , NextVerNotFound
-                    , NoToolVersionSet
-                    ]
-
             runSetGHC =
               runLogger
-                . runAppState
+                . flip runReaderT appstate
                 . runE
                   @'[ FileDoesNotExistError
                     , NotInstalled
@@ -1457,19 +1212,9 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                     ]
 
           let
-            runLeanSetCabal =
-              runLogger
-                . runLeanAppState
-                . runE
-                  @'[ NotInstalled
-                    , TagNotFound
-                    , NextVerNotFound
-                    , NoToolVersionSet
-                    ]
-
             runSetCabal =
               runLogger
-                . runAppState
+                . flip runReaderT appstate
                 . runE
                   @'[ NotInstalled
                     , TagNotFound
@@ -1480,7 +1225,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
           let
             runSetHLS =
               runLogger
-                . runAppState
+                . flip runReaderT appstate
                 . runE
                   @'[ NotInstalled
                     , TagNotFound
@@ -1488,30 +1233,20 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                     , NoToolVersionSet
                     ]
 
-            runLeanSetHLS =
+          let runListGHC = runLogger . flip runReaderT appstate
-              runLogger
-                . runLeanAppState
-                . runE
-                  @'[ NotInstalled
-                    , TagNotFound
-                    , NextVerNotFound
-                    , NoToolVersionSet
-                    ]
-
-          let runListGHC = runLogger . runAppState
 
           let runRm =
-                runLogger . runAppState . runE @'[NotInstalled]
+                runLogger . flip runReaderT appstate . runE @'[NotInstalled]
 
           let runDebugInfo =
                 runLogger
-                  . runAppState
+                  . flip runReaderT appstate
                   . runE
                     @'[NoCompatiblePlatform , NoCompatibleArch , DistroNotFound]
 
           let runCompileGHC =
                 runLogger
-                  . runAppState
+                  . flip runReaderT appstate
                   . runResourceT
                   . runE
                     @'[ AlreadyInstalled
@@ -1530,32 +1265,9 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 #endif
                       ]
 
-          let
-            runLeanWhereIs =
-              runLogger
-                -- 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
-                  @'[ NotInstalled
-                    , NoToolVersionSet
-                    , NextVerNotFound
-                    , TagNotFound
-                    ]
-
-            runWhereIs =
-              runLogger
-                . runAppState
-                . runE
-                  @'[ NotInstalled
-                    , NoToolVersionSet
-                    , NextVerNotFound
-                    , TagNotFound
-                    ]
-
           let runUpgrade =
                 runLogger
-                  . runAppState
+                  . flip runReaderT appstate
                   . runResourceT
                   . runE
                     @'[ DigestError
@@ -1566,21 +1278,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                       , DownloadFailed
                       ]
 
-          let runPrefetch =
-                runLogger
-                  . runAppState
-                  . runResourceT
-                  . runE
-                    @'[ TagNotFound
-                      , NextVerNotFound
-                      , NoToolVersionSet
-                      , NoDownload
-                      , DigestError
-                      , DownloadFailed
-                      , JSONError
-                      , FileDoesNotExistError
-                      ]
-
 
           -----------------------
           -- Command functions --
@@ -1593,9 +1290,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                        liftE $ installGHCBin (_tvVersion v)
                        when instSet $ void $ liftE $ setGHC v SetGHCOnly
                        pure vi
-                     Just uri -> do
+                     Just uri -> runInstTool' appstate{ settings = settings {noVerify = True}} instPlatform $ do
-                       s' <- liftIO appState
-                       runInstTool' s'{ settings = settings {noVerify = True}} instPlatform $ do
                        (v, vi) <- liftE $ fromVersion instVer GHC
                        liftE $ installGHCBindist
                          (DownloadInfo uri (Just $ RegexDir "ghc-.*") "")
@@ -1633,9 +1328,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                      (v, vi) <- liftE $ fromVersion instVer Cabal
                      liftE $ installCabalBin (_tvVersion v)
                      pure vi
-                   Just uri -> do
+                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} instPlatform $ do
-                     s' <- appState
-                     runInstTool' s'{ settings = settings { noVerify = True}} instPlatform $ do
                      (v, vi) <- liftE $ fromVersion instVer Cabal
                      liftE $ installCabalBindist
                          (DownloadInfo uri Nothing "")
@@ -1664,9 +1357,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                      (v, vi) <- liftE $ fromVersion instVer HLS
                      liftE $ installHLSBin (_tvVersion v)
                      pure vi
-                   Just uri -> do
+                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} instPlatform $ do
-                     s' <- appState
-                     runInstTool' s'{ settings = settings { noVerify = True}} instPlatform $ do
                      (v, vi) <- liftE $ fromVersion instVer HLS
                      liftE $ installHLSBindist
                          (DownloadInfo uri Nothing "")
@@ -1695,9 +1386,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                      (v, vi) <- liftE $ fromVersion instVer Stack
                      liftE $ installStackBin (_tvVersion v)
                      pure vi
-                   Just uri -> do
+                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} instPlatform $ do
-                     s' <- appState
-                     runInstTool' s'{ settings = settings { noVerify = True}} instPlatform $ do
                      (v, vi) <- liftE $ fromVersion instVer Stack
                      liftE $ installStackBindist
                          (DownloadInfo uri Nothing "")
@@ -1721,10 +1410,8 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                           pure $ ExitFailure 4
 
 
-          let setGHC' SetOptions{ sToolVer } =
+          let setGHC' SetOptions{..} =
-                case sToolVer of
+                runSetGHC (do
-                  (SetToolVersion v) -> runLeanSetGHC (liftE $ setGHC v SetGHCOnly >> pure v)
-                  _ -> runSetGHC (do
                     v <- liftE $ fst <$> fromVersion' sToolVer GHC
                     liftE $ setGHC v SetGHCOnly
                   )
@@ -1738,10 +1425,8 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                           runLogger $ $(logError) $ T.pack $ prettyShow e
                           pure $ ExitFailure 5
 
-          let setCabal' SetOptions{ sToolVer } =
+          let setCabal' SetOptions{..} =
-                case sToolVer of
+                runSetCabal (do
-                  (SetToolVersion v) -> runLeanSetCabal (liftE $ setCabal (_tvVersion v) >> pure v)
-                  _ -> runSetCabal (do
                     v <- liftE $ fst <$> fromVersion' sToolVer Cabal
                     liftE $ setCabal (_tvVersion v)
                     pure v
@@ -1756,10 +1441,8 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                           runLogger $ $(logError) $ T.pack $ prettyShow e
                           pure $ ExitFailure 14
 
-          let setHLS' SetOptions{ sToolVer } =
+          let setHLS' SetOptions{..} =
-                case sToolVer of
+                runSetHLS (do
-                  (SetToolVersion v) -> runLeanSetHLS (liftE $ setHLS (_tvVersion v) >> pure v)
-                  _ -> runSetHLS (do
                     v <- liftE $ fst <$> fromVersion' sToolVer HLS
                     liftE $ setHLS (_tvVersion v)
                     pure v
@@ -1774,10 +1457,8 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                           runLogger $ $(logError) $ T.pack $ prettyShow e
                           pure $ ExitFailure 14
 
-          let setStack' SetOptions{ sToolVer } =
+          let setStack' SetOptions{..} =
-                case sToolVer of
+                runSetCabal (do
-                  (SetToolVersion v) -> runSetCabal (liftE $ setStack (_tvVersion v) >> pure v)
-                  _ -> runSetCabal (do
                     v <- liftE $ fst <$> fromVersion' sToolVer Stack
                     liftE $ setStack (_tvVersion v)
                     pure v
@@ -1796,7 +1477,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                 runRm (do
                     liftE $
                       rmGHCVer ghcVer
-                    GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
                     pure (getVersionInfo (_tvVersion ghcVer) GHC dls)
                   )
                   >>= \case
@@ -1812,7 +1492,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                 runRm (do
                     liftE $
                       rmCabalVer tv
-                    GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
                     pure (getVersionInfo tv Cabal dls)
                   )
                   >>= \case
@@ -1828,7 +1507,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                 runRm (do
                     liftE $
                       rmHLSVer tv
-                    GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
                     pure (getVersionInfo tv HLS dls)
                   )
                   >>= \case
@@ -1844,7 +1522,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                 runRm (do
                     liftE $
                       rmStackVer tv
-                    GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
                     pure (getVersionInfo tv Stack dls)
                   )
                   >>= \case
@@ -1859,8 +1536,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
           res <- case optCommand of
 #if defined(BRICK)
             Interactive -> do
-              s' <- appState
+              liftIO $ brickMain appstate loggerConfig ghcupInfo >> pure ExitSuccess
-              liftIO $ brickMain s' loggerConfig >> pure ExitSuccess
 #endif
             Install (Right iopts) -> do
               runLogger ($(logWarn) [i|This is an old-style command for installing GHC. Use 'ghcup install ghc' instead.|])
@@ -1910,7 +1586,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
               runCompileGHC (do
                 case targetGhc of
                   Left targetVer -> do
-                    GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
                     let vi = getVersionInfo targetVer GHC dls
                     forM_ (_viPreCompile =<< vi) $ \msg -> do
                       lift $ $(logInfo) msg
@@ -1926,19 +1601,17 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                             buildConfig
                             patchDir
                             addConfArgs
-                GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
                 let vi = getVersionInfo (_tvVersion targetVer) GHC dls
                 when setCompile $ void $ liftE $
                   setGHC targetVer SetGHCOnly
-                pure (vi, targetVer)
+                pure vi
                 )
                 >>= \case
-                      VRight (vi, tv) -> do
+                      VRight vi -> do
                         runLogger $ $(logInfo)
                           "GHC successfully compiled and installed"
                         forM_ (_viPostInstall =<< vi) $ \msg ->
                           runLogger $ $(logInfo) msg
-                        putStr (T.unpack $ tVerToText tv)
                         pure ExitSuccess
                       VLeft (V (AlreadyInstalled _ v)) -> do
                         runLogger $ $(logWarn)
@@ -1955,46 +1628,14 @@ Make sure to clean up #{tmpdir} afterwards.|])
                         runLogger $ $(logError) $ T.pack $ prettyShow e
                         pure $ ExitFailure 9
 
-            Whereis WhereisOptions{..} (WhereisTool tool (Just (ToolVersion v))) ->
+            Upgrade uOpts force -> do
-              runLeanWhereIs (do
-                loc <- liftE $ whereIsTool tool v
-                if directory
-                then pure $ takeDirectory loc
-                else pure loc
-                )
-                >>= \case
-                      VRight r -> do
-                        putStr r
-                        pure ExitSuccess
-                      VLeft e -> do
-                        runLogger $ $(logError) $ T.pack $ prettyShow e
-                        pure $ ExitFailure 30
-
-            Whereis WhereisOptions{..} (WhereisTool tool whereVer) ->
-              runWhereIs (do
-                (v, _) <- liftE $ fromVersion whereVer tool
-                loc <- liftE $ whereIsTool tool v
-                if directory
-                then pure $ takeDirectory loc
-                else pure loc
-                )
-                >>= \case
-                      VRight r -> do
-                        putStr r
-                        pure ExitSuccess
-                      VLeft e -> do
-                        runLogger $ $(logError) $ T.pack $ prettyShow e
-                        pure $ ExitFailure 30
-
-            Upgrade uOpts force' -> do
               target <- case uOpts of
                 UpgradeInplace  -> Just <$> liftIO getExecutablePath
                 (UpgradeAt p)   -> pure $ Just p
                 UpgradeGHCupDir -> pure (Just (binDir </> "ghcup" <> exeExt))
 
-              runUpgrade (liftE $ upgradeGHCup target force') >>= \case
+              runUpgrade (liftE $ upgradeGHCup target force) >>= \case
                 VRight v' -> do
-                  GHCupInfo { _ghcupDownloads = dls } <- runAppState getGHCupInfo
                   let pretty_v = prettyVer v'
                   let vi = fromJust $ snd <$> getLatest dls GHCup
                   runLogger $ $(logInfo)
@@ -2009,16 +1650,14 @@ Make sure to clean up #{tmpdir} afterwards.|])
                   runLogger $ $(logError) $ T.pack $ prettyShow e
                   pure $ ExitFailure 11
 
-            ToolRequirements -> do
+            ToolRequirements ->
-              s' <- appState
+              flip runReaderT appstate
-              flip runReaderT s'
               $ runLogger
                 (runE
                   @'[NoCompatiblePlatform , DistroNotFound , NoToolRequirements]
                 $ do
-                      GHCupInfo { .. } <- lift getGHCupInfo
+                    platform <- liftE getPlatform
-                      platform' <- liftE getPlatform
+                    req      <- getCommonRequirements platform _toolRequirements ?? NoToolRequirements
-                      req      <- getCommonRequirements platform' _toolRequirements ?? NoToolRequirements
                     liftIO $ T.hPutStr stdout (prettyRequirements req)
                 )
                 >>= \case
@@ -2028,7 +1667,6 @@ Make sure to clean up #{tmpdir} afterwards.|])
                         pure $ ExitFailure 12
 
             ChangeLog ChangeLogOptions{..} -> do
-              GHCupInfo { _ghcupDownloads = dls } <- runAppState getGHCupInfo
               let tool = fromMaybe GHC clTool
                   ver' = maybe
                     (Right Latest)
@@ -2046,7 +1684,6 @@ Make sure to clean up #{tmpdir} afterwards.|])
                     )
                   pure ExitSuccess
                 Just uri -> do
-                  pfreq <- runAppState getPlatformReq
                   let uri' = T.unpack . decUTF8Safe . serializeURIRef' $ uri
                       cmd = case _rPlatform pfreq of
                               Darwin  -> "open"
@@ -2055,9 +1692,8 @@ Make sure to clean up #{tmpdir} afterwards.|])
                               Windows -> "start"
 
                   if clOpen
-                    then do
+                    then
-                      s' <- appState
+                      flip runReaderT appstate $
-                      flip runReaderT s' $
                       exec cmd
                            [T.unpack $ decUTF8Safe $ serializeURIRef' uri]
                            Nothing
@@ -2070,8 +1706,6 @@ Make sure to clean up #{tmpdir} afterwards.|])
 
             Nuke ->
               runRm (do
-                   s' <- liftIO appState
-                   void $ liftIO $ evaluate $ force s'
                    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
@@ -2098,37 +1732,6 @@ Make sure to clean up #{tmpdir} afterwards.|])
                             VLeft e -> do
                               runLogger $ $(logError) $ T.pack $ prettyShow e
                               pure $ ExitFailure 15
-            Prefetch pfCom ->
-              runPrefetch (do
-                case pfCom 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 $ prettyShow e
-                              pure $ ExitFailure 15
 
 
           case res of
@@ -2138,46 +1741,22 @@ Make sure to clean up #{tmpdir} afterwards.|])
 
   pure ()
 
-fromVersion :: ( MonadLogger m
+fromVersion :: (MonadLogger m, MonadFail m, MonadReader AppState m, MonadThrow m, MonadIO m, MonadCatch m)
-               , MonadFail m
-               , MonadReader env m
-               , HasGHCupInfo env
-               , HasDirs env
-               , MonadThrow m
-               , MonadIO m
-               , MonadCatch m
-               )
             => Maybe ToolVersion
             -> Tool
-            -> Excepts
+            -> Excepts '[TagNotFound, NextVerNotFound, NoToolVersionSet] m (GHCTargetVersion, Maybe VersionInfo)
-                 '[ TagNotFound
-                  , NextVerNotFound
-                  , NoToolVersionSet
-                  ] m (GHCTargetVersion, Maybe VersionInfo)
 fromVersion tv = fromVersion' (toSetToolVer tv)
 
-fromVersion' :: ( MonadLogger m
+fromVersion' :: (MonadLogger m, MonadFail m, MonadReader AppState m, MonadThrow m, MonadIO m, MonadCatch m)
-                , MonadFail m
-                , MonadReader env m
-                , HasGHCupInfo env
-                , HasDirs env
-                , MonadThrow m
-                , MonadIO m
-                , MonadCatch m
-                )
              => SetToolVersion
              -> Tool
-             -> Excepts
+             -> Excepts '[TagNotFound, NextVerNotFound, NoToolVersionSet] m (GHCTargetVersion, Maybe VersionInfo)
-                  '[ TagNotFound
-                   , NextVerNotFound
-                   , NoToolVersionSet
-                   ] m (GHCTargetVersion, Maybe VersionInfo)
 fromVersion' SetRecommended tool = do
-  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
   (\(x, y) -> (mkTVer x, Just y)) <$> getRecommended dls tool
     ?? TagNotFound Recommended tool
 fromVersion' (SetToolVersion v) tool = do
-  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
   let vi = getVersionInfo (_tvVersion v) tool dls
   case pvp $ prettyVer (_tvVersion v) of
     Left _ -> pure (v, vi)
@@ -2187,16 +1766,16 @@ fromVersion' (SetToolVersion v) tool = do
         Nothing -> pure (v, vi)
     Right _ -> pure (v, vi)
 fromVersion' (SetToolTag Latest) tool = do
-  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
   (\(x, y) -> (mkTVer x, Just y)) <$> getLatest dls tool ?? TagNotFound Latest tool
 fromVersion' (SetToolTag Recommended) tool = do
-  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
   (\(x, y) -> (mkTVer x, Just y)) <$> getRecommended dls tool ?? TagNotFound Recommended tool
 fromVersion' (SetToolTag (Base pvp'')) GHC = do
-  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
   (\(x, y) -> (mkTVer x, Just y)) <$> getLatestBaseVersion dls pvp'' ?? TagNotFound (Base pvp'') GHC
 fromVersion' SetNext tool = do
-  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
   next <- case tool of
     GHC -> do
       set <- fmap _tvVersion $ ghcSet Nothing !? NoToolVersionSet tool
@@ -2397,10 +1976,7 @@ printListResult raw lr = do
       | otherwise                        -> 1
 
 
-checkForUpdates :: ( MonadReader env m
+checkForUpdates :: ( MonadReader AppState m
-                   , HasGHCupInfo env
-                   , HasDirs env
-                   , HasPlatformReq env
                    , MonadCatch m
                    , MonadLogger m
                    , MonadThrow m
@@ -2410,7 +1986,7 @@ checkForUpdates :: ( MonadReader env m
                    )
                 => m ()
 checkForUpdates = do
-  GHCupInfo { _ghcupDownloads = dls } <- getGHCupInfo
+  AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
   lInstalled <- listVersions Nothing (Just ListInstalled)
   let latestInstalled tool = (fmap lVer . lastMay . filter (\lr -> lTool lr == tool)) lInstalled
 

bootstrap-haskell

@@ -5,12 +5,8 @@
 #   * BOOTSTRAP_HASKELL_NO_UPGRADE - any nonzero value to not trigger the upgrade
 #   * GHCUP_USE_XDG_DIRS - any nonzero value to respect The XDG Base Directory Specification
 #   * BOOTSTRAP_HASKELL_VERBOSE - any nonzero value for more verbose installation
-#   * BOOTSTRAP_HASKELL_GHC_VERSION - the ghc version to install
+#   * BOOTSTRAP_HASKELL_GHC_VERSION
-#   * BOOTSTRAP_HASKELL_CABAL_VERSION - the cabal version to install
+#   * BOOTSTRAP_HASKELL_CABAL_VERSION
-#   * BOOTSTRAP_HASKELL_INSTALL_STACK - whether to install latest stack
-#   * BOOTSTRAP_HASKELL_INSTALL_HLS - whether to install latest hls
-#   * BOOTSTRAP_HASKELL_ADJUST_BASHRC - whether to adjust PATH in bashrc (prepend)
-#   * BOOTSTRAP_HASKELL_ADJUST_CABAL_CONFIG - whether to adjust mingw paths in cabal.config on windows
 
 # License: LGPL-3.0
 
@@ -23,8 +19,6 @@ arch=$(uname -m)
 ghver="0.1.15.2"
 base_url="https://downloads.haskell.org/~ghcup"
 
-export GHCUP_SKIP_UPDATE_CHECK=yes
-
 case "${plat}" in
         MSYS*|MINGW*)
 			: "${GHCUP_INSTALL_BASE_PREFIX:=/c}"
@@ -66,28 +60,6 @@ warn() {
 	esac
 }
 
-yellow() {
-	case "${plat}" in
-			MSYS*|MINGW*)
-				echo -e "\\033[0;33m$1\\033[0m"
-				;;
-			*)
-				printf "\\033[0;33m%s\\033[0m\\n" "$1"
-				;;
-	esac
-}
-
-green() {
-	case "${plat}" in
-			MSYS*|MINGW*)
-				echo -e "\\033[0;32m$1\\033[0m"
-				;;
-			*)
-				printf "\\033[0;32m%s\\033[0m\\n" "$1"
-				;;
-	esac
-}
-
 edo() {
     "$@" || die "\"$*\" failed!"
 }
@@ -108,42 +80,40 @@ _eghcup() {
 }
 
 _done() {
-	echo
-	echo "==============================================================================="
 	case "${plat}" in
 			MSYS*|MINGW*)
-				green
+				echo
-				green "All done!"
+				echo "All done!"
-				green
+				echo
-				green "In a new powershell or cmd.exe session, now you can..."
+				echo "In a new powershell or cmd.exe session, now you can..."
-				green
+				echo
-				green "Start a simple repl via:"
+				echo "Start a simple repl via:"
-				green "  ghci"
+				echo "  ghci"
-				green
+				echo
-				green "Start a new haskell project in the current directory via:"
+				echo "Start a new haskell project in the current directory via:"
-				green "  cabal init --interactive"
+				echo "  cabal init --interactive"
-				green
+				echo
-				green "Install other GHC versions and tools via:"
+				echo "Install other GHC versions and tools via:"
-				green "  ghcup list"
+				echo "  ghcup list"
-				green "  ghcup install <tool> <version>"
+				echo "  ghcup install <tool> <version>"
-				green
+				echo
-				green "To install system libraries and update msys2/mingw64,"
+				echo "To install system libraries and update msys2/mingw64,"
-				green "open the \"Mingw haskell shell\""
+				echo "open the \"Mingw haskell shell\""
-				green "and the \"Mingw package management docs\""
+				echo "and the \"Mingw package management docs\""
-				green "desktop shortcuts."
+				echo "desktop shortcuts."
 				;;
 			*)
-				green
+				echo
-				green "All done!"
+				echo "All done!"
-				green
+				echo
-				green "To start a simple repl, run:"
+				echo "To start a simple repl, run:"
-				green "  ghci"
+				echo "  ghci"
-				green
+				echo
-				green "To start a new haskell project in the current directory, run:"
+				echo "To start a new haskell project in the current directory, run:"
-				green "  cabal init --interactive"
+				echo "  cabal init --interactive"
-				green
+				echo
-				green "To install other GHC versions and tools, run:"
+				echo "To install other GHC versions and tools, run:"
-				green "  ghcup tui"
+				echo "  ghcup tui"
 				;;
 
 	esac
@@ -232,20 +202,15 @@ download_ghcup() {
 	esac
 
   edo mkdir -p "${GHCUP_DIR}"
-
-	# we may overwrite this in adjust_bashrc
 	cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
 		export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
 		EOF
-
 	# shellcheck disable=SC1090
     edo . "${GHCUP_DIR}"/env
     eghcup upgrade
 }
 
-# Figures out the users login shell and sets
+adjust_bashrc() {
-# GHCUP_PROFILE_FILE and MY_SHELL variables.
-find_shell() {
 	case $SHELL in
 		*/zsh) # login shell is zsh
 			GHCUP_PROFILE_FILE="$HOME/.zshrc"
@@ -269,84 +234,32 @@ find_shell() {
 			MY_SHELL="fish" ;;
 		*) return ;;
 	esac
-}
 
-# Ask user if they want to adjust the bashrc.
-ask_bashrc() {
-	if [ -n "${BOOTSTRAP_HASKELL_ADJUST_BASHRC}" ] ; then
-		return 1
-	fi
-
-	while true; do
-		if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-			echo "-------------------------------------------------------------------------------"
 
 	warn ""
 	warn "Detected ${MY_SHELL} shell on your system..."
-			warn "Do you want ghcup to automatically add the required PATH variable to \"${GHCUP_PROFILE_FILE}\"?"
+	warn "If you want ghcup to automatically add the required PATH variable to \"${GHCUP_PROFILE_FILE}\""
 	warn ""
-			warn "[P] Yes, prepend  [A] Yes, append  [N] No  [?] Help (default is \"P\")."
+	warn "[Y] Yes  [N] No  [?] Help (default is \"Y\")."
 	warn ""
 
-			read -r bashrc_answer </dev/tty
+	while true; do
+		if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
+			read -r next_answer </dev/tty
 		else
-			return 1
+			next_answer="yes"
 		fi
-		case $bashrc_answer in
+
-			[Pp]* | "")
+		case $next_answer in
-				return 1
-				;;
-			[Aa]*)
-				return 2
-				;;
 			[Nn]*)
-				return 0;;
+				return ;;
-			*)
+			[Yy]* | "")
-				echo "Possible choices are:"
-				echo
-				echo "P - Yes, prepend to PATH, taking precedence (default)"
-				echo "A - Yes, append to PATH"
-				echo "N - No, don't mess with my configuration"
-				echo
-				echo "Please make your choice and press ENTER."
-				;;
-		esac
-	done
-
-	unset bashrc_answer
-}
-
-# Needs 'find_shell' to be called beforehand.
-adjust_bashrc() {
-	case $1 in
-		1)
-			cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
-				export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
-				EOF
-			;;
-		2)
-			cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
-				export PATH="\$HOME/.cabal/bin:\$PATH:${GHCUP_BIN}"
-				EOF
-			;;
-		*) ;;
-	esac
-
-	case $1 in
-		1 | 2)
 				case $MY_SHELL in
 					"") break ;;
 					fish)
 							mkdir -p "${GHCUP_PROFILE_FILE%/*}"
 							sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
-					case $1 in
+							echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME ; test -f $GHCUP_DIR/env ; and set -gx PATH \$HOME/.cabal/bin $GHCUP_BIN \$PATH # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-						1)
-							echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME ; set -gx PATH \$HOME/.cabal/bin $GHCUP_BIN \$PATH # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-							;;
-						2)
-							echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME ; set -gx PATH \$HOME/.cabal/bin \$PATH $GHCUP_BIN # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-							;;
-					esac
 						break ;;
 					bash)
 						sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
@@ -369,159 +282,18 @@ adjust_bashrc() {
 				warn "or type \"source ${GHCUP_DIR}/env\" to apply them in your current terminal session."
 				return
 				;;
-		*)
-			;;
-	esac
-}
-
-adjust_cabal_config() {
-	edo cabal user-config -a "extra-prog-path: $(cygpath -w "$GHCUP_BIN"), $(cygpath -w "$HOME"/AppData/Roaming/cabal/bin), $(cygpath -w "$GHCUP_MSYS2"/usr/bin), $(cygpath -w "$GHCUP_MSYS2"/mingw64/bin)" -a "extra-include-dirs: $(cygpath -w "$GHCUP_MSYS2"/mingw64/include)" -a "extra-lib-dirs: $(cygpath -w "$GHCUP_MSYS2"/mingw64/lib)" -f init
-}
-
-ask_cabal_config_init() {
-	case "${plat}" in
-			MSYS*|MINGW*)
-				if [ -n "${BOOTSTRAP_HASKELL_ADJUST_CABAL_CONFIG}" ] ; then
-					return 1
-				fi
-
-				if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-					echo "-------------------------------------------------------------------------------"
-					warn "Create an initial cabal.config including relevant msys2 paths (recommended)?"
-					warn "[Y] Yes  [N] No  [?] Help (default is \"Y\")."
-					echo
-					while true; do
-						read -r mingw_answer </dev/tty
-
-						case $mingw_answer in
-							[Yy]* | "")
-								return 1 ;;
-							[Nn]*)
-								return 0 ;;
 			*)
 				echo "Possible choices are:"
 				echo
-								echo "Y - Yes, create a cabal.config with pre-set paths to msys2/mingw64 (default)"
+				echo "Y - Yes, update my \"${GHCUP_PROFILE_FILE}\" (default)"
-								echo "N - No, leave the current/default cabal config untouched"
+				echo "N - No, don't mess with my configuration"
 				echo
 				echo "Please make your choice and press ENTER."
 				;;
 		esac
 	done
-				else
-					return 1
-				fi
-				;;
-	esac
-
-	unset mingw_answer
-
-    return 0
 }
 
-do_cabal_config_init() {
-	case "${plat}" in
-			MSYS*|MINGW*)
-		case $1 in
-			1)
-				adjust_cabal_config
-				;;
-			0)
-				echo "Make sure that your global cabal.config references the correct mingw64 paths (extra-prog-path, extra-include-dirs and extra-lib-dirs)."
-				echo "And set the environment variable GHCUP_MSYS2 to the root path of your msys2 installation."
-				sleep 5
-				return ;;
-			*) ;;
-		esac
-	esac
-}
-
-ask_hls() {
-	if [ -n "${BOOTSTRAP_HASKELL_INSTALL_HLS}" ] ; then
-		return 1
-	fi
-
-	if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-		echo "-------------------------------------------------------------------------------"
-
-		warn "Do you want to install haskell-language-server (HLS)?"
-		warn "HLS is a language-server that provides IDE-like functionality"
-		warn "and can integrate with different editors, such as Vim, Emacs, VS Code, Atom, ..."
-		warn "Also see https://github.com/haskell/haskell-language-server/blob/master/README.md"
-		warn ""
-		warn "[Y] Yes  [N] No  [?] Help (default is \"N\")."
-		warn ""
-
-		while true; do
-			read -r hls_answer </dev/tty
-
-			case $hls_answer in
-				[Yy]*)
-					return 1
-					;;
-				[Nn]* | "")
-					return 0
-					;;
-				*)
-					echo "Possible choices are:"
-					echo
-					echo "Y - Yes, install the haskell-langauge-server"
-					echo "N - No, don't install anything more (default)"
-					echo
-					echo "Please make your choice and press ENTER."
-					;;
-			esac
-		done
-	else
-		return 0
-	fi
-
-	unset hls_answer
-}
-
-ask_stack() {
-	if [ -n "${BOOTSTRAP_HASKELL_INSTALL_STACK}" ] ; then
-		return 1
-	fi
-
-	if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-		echo "-------------------------------------------------------------------------------"
-
-		warn "Do you want to install stack?"
-		warn "Stack is a haskell build tool similar to cabal that is used by some projects."
-		warn "Also see https://docs.haskellstack.org/"
-		warn ""
-		warn "[Y] Yes  [N] No  [?] Help (default is \"N\")."
-		warn ""
-
-		while true; do
-			read -r stack_answer </dev/tty
-
-			case $stack_answer in
-				[Yy]*)
-					return 1 ;;
-				[Nn]* | "")
-					return 0 ;;
-				*)
-					echo "Possible choices are:"
-					echo
-					echo "Y - Yes, install stack"
-					echo "N - No, don't install anything more (default)"
-					echo
-					echo "Please make your choice and press ENTER."
-					;;
-			esac
-		done
-	else
-		return 0
-	fi
-
-	unset stack_answer
-}
-
-
-find_shell
-
 
 echo
 echo "Welcome to Haskell!"
@@ -553,20 +325,12 @@ echo
 if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
     warn "Press ENTER to proceed or ctrl-c to abort."
     warn "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
 
-ask_bashrc
-ask_bashrc_answer=$?
-ask_cabal_config_init
-ask_cabal_config_init_answer=$?
-ask_hls
-ask_hls_answer=$?
-ask_stack
-ask_stack_answer=$?
-
 edo mkdir -p "${GHCUP_BIN}"
 
 if command -V "ghcup" >/dev/null 2>&1 ; then
@@ -596,52 +360,118 @@ eghcup --cache install ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
 eghcup set ghc "${BOOTSTRAP_HASKELL_GHC_VERSION}"
 eghcup --cache install cabal "${BOOTSTRAP_HASKELL_CABAL_VERSION}"
 
-do_cabal_config_init $ask_cabal_config_init_answer
+adjust_cabal_config() {
+	edo cabal user-config -a "extra-prog-path: $(cygpath -w "$GHCUP_BIN"), $(cygpath -w "$HOME"/AppData/Roaming/cabal/bin), $(cygpath -w "$GHCUP_MSYS2"/usr/bin), $(cygpath -w "$GHCUP_MSYS2"/mingw64/bin)" -a "extra-include-dirs: $(cygpath -w "$GHCUP_MSYS2"/mingw64/include)" -a "extra-lib-dirs: $(cygpath -w "$GHCUP_MSYS2"/mingw64/lib)" -f init
+}
+
+case "${plat}" in
+        MSYS*|MINGW*)
+			if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
+				warn "Create an initial cabal.config including relevant msys2 paths (recommended)?"
+				warn "[Y] Yes  [N] No  [?] Help (default is \"Y\")."
+				echo
+				while true; do
+					read -r mingw_answer </dev/tty
+
+					case $mingw_answer in
+						[Yy]* | "")
+							adjust_cabal_config
+							break ;;
+						[Nn]*)
+							echo "Make sure that your global cabal.config references the correct mingw64 paths (extra-prog-path, extra-include-dirs and extra-lib-dirs)."
+							echo "And set the environment variable GHCUP_MSYS2 to the root path of your msys2 installation."
+							sleep 5
+							break ;;
+						*)
+							echo "Possible choices are:"
+							echo
+							echo "Y - Yes, create a cabal.config with pre-set paths to msys2/mingw64 (default)"
+							echo "N - No, leave the current/default cabal config untouched"
+							echo
+							echo "Please make your choice and press ENTER."
+							;;
+					esac
+				done
+			else
+				adjust_cabal_config
+			fi
+			;;
+esac
+
 
 edo cabal new-update
 
-case $ask_hls_answer in
+
-	1)
+if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-		_eghcup --cache install hls || warn "HLS installation failed, continuing anyway"
+	warn "Do you want to install haskell-language-server (HLS) now?"
+	warn "HLS is a language-server that provides IDE-like functionality"
+	warn "and can integrate with different editors, such as Vim, Emacs, VS Code, Atom, ..."
+	warn "Also see https://github.com/haskell/haskell-language-server/blob/master/README.md"
+	warn ""
+	warn "[Y] Yes  [N] No  [?] Help (default is \"N\")."
+	warn ""
+
+	while true; do
+		read -r hls_answer </dev/tty
+
+		case $hls_answer in
+			[Yy]*)
+				eghcup --cache install hls || warn "HLS installation failed, continuing anyway"
+				break ;;
+			[Nn]* | "")
+				break ;;
+			*)
+				echo "Possible choices are:"
+				echo
+				echo "Y - Yes, install the haskell-langauge-server"
+				echo "N - No, don't install anything more (default)"
+				echo
+				echo "Please make your choice and press ENTER."
 				;;
-	*) ;;
+		esac
-esac
+	done
 
-case $ask_stack_answer in
+	warn "Do you want to install stack now?"
-	1)
+	warn "Stack is a haskell build tool similar to cabal that is used by some projects."
-		_eghcup --cache install stack || warn "Stack installation failed, continuing anyway"
+	warn "Also see https://docs.haskellstack.org/"
+	warn ""
+	warn "[Y] Yes  [N] No  [?] Help (default is \"N\")."
+	warn ""
+
+	while true; do
+		read -r stack_answer </dev/tty
+
+		case $stack_answer in
+			[Yy]*)
+				eghcup --cache install stack || warn "Stack installation failed, continuing anyway"
+				break ;;
+			[Nn]* | "")
+				break ;;
+			*)
+				echo "Possible choices are:"
+				echo
+				echo "Y - Yes, install stack"
+				echo "N - No, don't install anything more (default)"
+				echo
+				echo "Please make your choice and press ENTER."
 				;;
-	*) ;;
+		esac
-esac
+	done
-
+fi
-
 
 # short-circuit script based on platform
 case "${plat}" in
         MSYS*|MINGW*)
 			# For windows we always adjust bashrc, since it's inside msys2
-			adjust_bashrc $adjust_bashrc_answer
+			adjust_bashrc
 			;;
 		*)
         	if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
-				case $ask_bashrc_answer in
+				echo "In order to run ghc and cabal, you need to adjust your PATH variable."
-					1 | 2)
+				echo "You may want to source '$GHCUP_DIR/env' in your shell"
-						echo
+				echo "configuration to do so (e.g. ~/.bashrc)."
-						echo "==============================================================================="
+
-						echo
+				adjust_bashrc
-						yellow "In order to run ghc and cabal, start a new shell or"
-						yellow "run 'source $GHCUP_DIR/env' in your current shell session."
-						adjust_bashrc $adjust_bashrc_answer
-						;;
-					*)
-						echo
-						echo "==============================================================================="
-						echo
-						yellow "In order to run ghc and cabal, you need to adjust your PATH variable."
-						yellow "You may want to source '$GHCUP_DIR/env' in your shell"
-						yellow "configuration to do so (e.g. ~/.bashrc)."
-						;;
-				esac
 			fi
 			;;
 esac

bootstrap-haskell.ps1

@@ -26,13 +26,7 @@ param (
     # Specify the bootstrap url (default: 'https://www.haskell.org/ghcup/sh/bootstrap-haskell')
     [string]$BootstrapUrl,
     # Run the final bootstrap script via 'bash' instead of a full newly spawned msys2 shell
-    [switch]$InBash,
+    [switch]$InBash
-    # Whether to install stack as well
-    [switch]$InstallStack,
-    # Whether to install hls as well
-    [switch]$InstallHLS,
-    # Skip adjusting cabal.config with mingw paths
-    [switch]$NoAdjustCabalConfig
 )
 
 $Silent = !$Interactive
@@ -184,7 +178,6 @@ if ($GhcupBasePrefixEnv) {
   }
 }
 
-# ask for base install prefix
 if ($Silent -and !($InstallDir)) {
   $GhcupBasePrefix = $defaultGhcupBasePrefix
 } elseif ($InstallDir) {
@@ -232,7 +225,6 @@ $GhcupMsys2 = [System.Environment]::GetEnvironmentVariable('GHCUP_MSYS2', 'user'
 
 Print-Msg -msg 'Preparing for GHCup installation...'
 
-# ask what to do in case ghcup is already installed
 if (Test-Path -LiteralPath ('{0}' -f $GhcupDir)) {
   Print-Msg -msg ('GHCup already installed at ''{0}''...' -f $GhcupDir)
   if ($Overwrite) {
@@ -262,73 +254,8 @@ if (Test-Path -LiteralPath ('{0}' -f $GhcupDir)) {
 $null = New-Item -Path ('{0}' -f $GhcupDir) -ItemType 'directory' -ErrorAction SilentlyContinue
 $null = New-Item -Path ('{0}' -f $GhcupDir) -Name 'bin' -ItemType 'directory' -ErrorAction SilentlyContinue
 
-# ask for cabal dir destination
-if ($CabalDir) {
-  $CabDirEnv = $CabalDir
-  if (!($CabDirEnv)) {
-    Print-Msg -color Red -msg "No directory specified!"
-    Exit 1        
-  } elseif (!(Split-Path -IsAbsolute -Path "$CabDirEnv")) {
-    Print-Msg -color Red -msg "Invalid/Non-absolute Path specified"
-    Exit 1
-  }
-} elseif (!($Silent)) {
-  while ($true) {
-
-    $defaultCabalDir = ('{0}\cabal' -f $GhcupBasePrefix)
-    Print-Msg -color Magenta -msg ('Specify Cabal directory (this is where haskell packages end up). Press enter to accept the default [{0}]:' -f $defaultCabalDir)
-    $CabalDirPrompt = Read-Host
-    $CabDirEnv = ($defaultCabalDir,$CabalDirPrompt)[[bool]$CabalDirPrompt]
-
-    if (!($CabDirEnv)) {
-      Print-Msg -color Red -msg "No directory specified!"         
-    } elseif (!(Split-Path -IsAbsolute -Path "$CabDirEnv")) {
-      Print-Msg -color Red -msg "Invalid/Non-absolute Path specified"
-    } else {
-      Break
-    }
-  }
-} else {
-  $CabDirEnv = ('{0}\cabal' -f $GhcupBasePrefix)
-}
-
-# ask whether to install HLS
-if (!($InstallHLS)) {
-  if (!($Silent)) {
-    $HLSdecision = $Host.UI.PromptForChoice('Install HLS'
-      , 'Do you want to install the haskell-language-server (HLS) for development purposes as well?'
-      , [System.Management.Automation.Host.ChoiceDescription[]] @('&Yes'
-          '&No'
-          '&Abort'), 1)
-
-    if ($HLSdecision -eq 0) {
-      $InstallHLS = $true
-    } elseif ($HLSdecision -eq 2) {
-      Exit 0
-    }
-  }
-}
-
-# ask whether to install stack
-if (!($InstallStack)) {
-  if (!($Silent)) {
-    $StackDecision = $Host.UI.PromptForChoice('Install stack'
-      , 'Do you want to install stack as well?'
-      , [System.Management.Automation.Host.ChoiceDescription[]] @('&Yes'
-          '&No'
-          '&Abort'), 1)
-
-    if ($StackDecision -eq 0) {
-      $InstallStack = $true
-    } elseif ($StackDecision -eq 2) {
-      Exit 0
-    }
-  }
-}
-
-
-# mingw foo
 Print-Msg -msg 'First checking for Msys2...'
+
 if (!(Test-Path -Path ('{0}' -f $MsysDir))) {
   if ($Silent) {
     $msys2Decision = 0
@@ -340,10 +267,7 @@ if (!(Test-Path -Path ('{0}' -f $MsysDir))) {
   }
 
   if ($msys2Decision -eq 0) {
-    Print-Msg -msg ('...Msys2 doesn''t exist, installing into {0}' -f $MsysDir)
+    Print-Msg -msg ('...Msys2 doesn''t exist, installing into {0} ...this may take a while' -f $MsysDir)
-
-	Print-Msg -msg 'Starting installation in 5 seconds, this may take a while...'
-	Start-Sleep -s 5
 
     # Download the archive
     Print-Msg -msg 'Downloading Msys2 archive...'
@@ -406,9 +330,6 @@ if (!(Test-Path -Path ('{0}' -f $MsysDir))) {
   }
 } else {
     Print-Msg -msg ('...Msys2 found in {0} ...skipping Msys2 installation.' -f $MsysDir)
-
-	Print-Msg -msg 'Starting installation in 5 seconds, this may take a while...'
-	Start-Sleep -s 5
 }
 
 Print-Msg -msg 'Creating shortcuts...'
@@ -421,7 +342,34 @@ Create-Shortcut -SourceExe 'https://www.msys2.org/docs/package-management' -Argu
 Print-Msg -msg ('Adding {0}\bin to Users Path...' -f $GhcupDir)
 Add-EnvPath -Path ('{0}\bin' -f ([System.IO.Path]::GetFullPath("$GhcupDir"))) -Container 'User'
 
+if ($CabalDir) {
+  $CabDirEnv = $CabalDir
+  if (!($CabDirEnv)) {
+    Print-Msg -color Red -msg "No directory specified!"
+    Exit 1        
+  } elseif (!(Split-Path -IsAbsolute -Path "$CabDirEnv")) {
+    Print-Msg -color Red -msg "Invalid/Non-absolute Path specified"
+    Exit 1
+  }
+} elseif (!($Silent)) {
+  while ($true) {
 
+    $defaultCabalDir = ('{0}\cabal' -f $GhcupBasePrefix)
+    Print-Msg -color Magenta -msg ('Specify Cabal directory (this is where haskell packages end up). Press enter to accept the default [{0}]:' -f $defaultCabalDir)
+    $CabalDirPrompt = Read-Host
+    $CabDirEnv = ($defaultCabalDir,$CabalDirPrompt)[[bool]$CabalDirPrompt]
+
+    if (!($CabDirEnv)) {
+      Print-Msg -color Red -msg "No directory specified!"         
+    } elseif (!(Split-Path -IsAbsolute -Path "$CabDirEnv")) {
+      Print-Msg -color Red -msg "Invalid/Non-absolute Path specified"
+    } else {
+      Break
+    }
+  }
+} else {
+  $CabDirEnv = ('{0}\cabal' -f $GhcupBasePrefix)
+}
 
 $CabalDirFull = [System.IO.Path]::GetFullPath("$CabDirEnv")
 Print-Msg -msg ('Setting CABAL_DIR to ''{0}''' -f $CabalDirFull)
@@ -431,25 +379,16 @@ Print-Msg -msg 'Starting GHCup installer...'
 
 $Msys2Shell = ('{0}\msys2_shell.cmd' -f $MsysDir)
 
-# The bootstrap script is always silent, since we ask relevant questions here
+if ($Silent) {
-$SilentExport = 'export BOOTSTRAP_HASKELL_NONINTERACTIVE=1 ;'
+  $SilentExport = 'export BOOTSTRAP_HASKELL_NONINTERACTIVE=1 ;'
-
+} else {
-if ($InstallStack) {
+  $SilentExport = ''
-  $StackInstallExport = 'export BOOTSTRAP_HASKELL_INSTALL_STACK=1 ;'
-}
-
-if ($InstallHLS) {
-  $HLSInstallExport = 'export BOOTSTRAP_HASKELL_INSTALL_HLS=1 ;'
-}
-
-if (!($NoAdjustCabalConfig)) {
-  $AdjustCabalConfigExport = 'export BOOTSTRAP_HASKELL_ADJUST_CABAL_CONFIG=1 ;'
 }
 
 if ((Get-Process -ID $PID).ProcessName.StartsWith("bootstrap-haskell") -Or $InBash) {
-  Exec "$Bash" '-lc' ('{4} {6} {7} {8} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull, $StackInstallExport, $HLSInstallExport, $AdjustCabalConfigExport)
+  Exec "$Bash" '-lc' ('{4} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull)
 } else {
-  Exec "$Msys2Shell" '-mingw64' '-mintty' '-c' ('{4} {6} {7} {8} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; trap ''echo Press any key to exit && read -n 1 && exit'' 2 ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash ; echo ''Press any key to exit'' && read -n 1' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull, $StackInstallExport, $HLSInstallExport, $AdjustCabalConfigExport)
+  Exec "$Msys2Shell" '-mingw64' '-mintty' '-c' ('{4} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; trap ''echo Press any key to exit && read -n 1 && exit'' 2 ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash ; echo ''Press any key to exit'' && read -n 1' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull)
 }
 
 
@@ -481,5 +420,3 @@ if ((Get-Process -ID $PID).ProcessName.StartsWith("bootstrap-haskell") -Or $InBa
 
 
 
-
-

cabal.ghc8104.project

@@ -0,0 +1,20 @@
+packages: ./ghcup.cabal
+
+with-compiler: ghc-8.10.4
+
+optional-packages: ./3rdparty/*/*.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
+
+constraints: http-io-streams -brotli
+
+package libarchive
+  flags: -system-libarchive
+
+allow-newer: base, ghc-prim, template-haskell

cabal.ghc8104.project.freeze

@@ -1,11 +1,12 @@
 active-repositories: hackage.haskell.org:merge
 constraints: any.Cabal ==3.2.1.0,
              any.HUnit ==1.6.2.0,
-             any.HsOpenSSL ==0.11.7,
+             any.IfElse ==0.85,
-             HsOpenSSL -fast-bignum -homebrew-openssl -macports-openssl -use-pkg-config,
              any.QuickCheck ==2.14.2,
              QuickCheck -old-random +templatehaskell,
              any.StateVar ==1.2.1,
+             any.abstract-deque ==0.3,
+             abstract-deque -usecas,
              any.aeson ==1.5.6.0,
              aeson -bytestring-builder -cffi -developer -fast,
              any.aeson-pretty ==0.8.8,
@@ -17,32 +18,31 @@ constraints: any.Cabal ==3.2.1.0,
              any.ansi-wl-pprint ==0.6.9,
              ansi-wl-pprint -example,
              any.array ==0.5.4.0,
+             any.ascii-string ==1.0.1.4,
              any.assoc ==1.0.2,
              any.async ==2.2.3,
              async -bench,
+             any.atomic-primops ==0.8.4,
+             atomic-primops -debug,
              any.attoparsec ==0.13.2.5,
              attoparsec -developer,
              any.auto-update ==0.1.6,
-             any.base ==4.14.2.0,
+             any.base ==4.14.1.0,
              any.base-compat ==0.11.2,
              any.base-compat-batteries ==0.11.2,
              any.base-orphans ==0.8.4,
              any.base16-bytestring ==1.0.1.0,
-             any.base64-bytestring ==1.1.0.0,
+             any.base64-bytestring ==1.2.0.1,
-             any.bifunctors ==5.5.11,
+             any.bifunctors ==5.5.10,
              bifunctors +semigroups +tagged,
              any.binary ==0.8.8.0,
-             any.bindings-DSL ==1.0.25,
              any.blaze-builder ==0.4.2.1,
-             any.brick ==0.61,
-             brick -demos,
              any.bytestring ==0.10.12.0,
              any.bz2 ==1.0.1.0,
              bz2 -cross +with-bzlib,
-             any.bzlib-conduit ==0.3.0.2,
+             any.c2hs ==0.28.7,
-             any.c2hs ==0.28.8,
              c2hs +base3 -regression,
-             any.call-stack ==0.4.0,
+             any.call-stack ==0.3.0,
              any.case-insensitive ==1.2.1.0,
              any.casing ==0.1.4.1,
              any.cereal ==0.5.8.1,
@@ -54,7 +54,7 @@ constraints: any.Cabal ==3.2.1.0,
              clock -llvm,
              any.cmdargs ==0.10.21,
              cmdargs +quotation -testprog,
-             any.colour ==2.3.6,
+             any.colour ==2.3.5,
              any.comonad ==5.0.8,
              comonad +containers +distributive +indexed-traversable,
              any.composition-prelude ==3.0.0.2,
@@ -62,25 +62,16 @@ constraints: any.Cabal ==3.2.1.0,
              any.concurrent-output ==1.10.12,
              any.conduit ==1.3.4.1,
              any.conduit-extra ==1.3.5,
-             any.conduit-zstd ==0.0.2.0,
+             any.containers ==0.6.2.1,
-             any.config-ini ==0.2.4.0,
-             config-ini -enable-doctests,
-             any.containers ==0.6.4.1,
              any.contravariant ==1.5.3,
              contravariant +semigroups +statevar +tagged,
-             any.cpphs ==1.20.9.1,
-             cpphs -old-locale,
-             any.cryptohash-sha1 ==0.11.100.1,
              any.cryptohash-sha256 ==0.11.102.0,
              cryptohash-sha256 -exe +use-cbits,
-             any.data-clist ==0.1.2.3,
              any.data-default-class ==0.1.2.0,
              any.data-fix ==0.3.1,
              any.deepseq ==1.4.4.0,
-             any.digest ==0.0.1.3,
+             any.deferred-folds ==0.9.17,
-             digest -bytestring-in-base,
              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,
@@ -88,55 +79,62 @@ constraints: any.Cabal ==3.2.1.0,
              any.easy-file ==0.2.2,
              any.errors ==2.3.0,
              any.exceptions ==0.10.4,
-             any.extra ==1.7.9,
+             any.fast-logger ==3.0.3,
-             any.fast-logger ==3.0.5,
              any.filepath ==1.4.2.1,
-             any.free ==5.1.7,
+             any.focus ==1.0.2,
+             any.foldl ==1.4.11,
+             any.free ==5.1.6,
+             any.fusion-plugin-types ==0.1.0,
              any.generic-arbitrary ==0.1.0,
              any.generics-sop ==0.5.1.1,
-             any.ghc-boot-th ==8.10.5,
+             any.ghc-boot-th ==8.10.4,
-             any.ghc-byteorder ==4.11.0.0.10,
              any.ghc-prim ==0.6.1,
+             ghcup -internal-downloader -tar -tui,
              any.happy ==1.20.0,
-             any.hashable ==1.3.2.0,
+             any.hashable ==1.3.1.0,
-             hashable +integer-gmp -random-initial-seed,
+             hashable +integer-gmp,
              any.haskell-src-exts ==1.23.1,
              any.haskell-src-meta ==0.8.7,
              any.haskus-utils-data ==1.4,
              any.haskus-utils-types ==1.5.1,
              any.haskus-utils-variant ==3.1,
+             any.heaps ==0.3.6.1,
+             any.hpath ==0.11.0,
+             any.hpath-directory ==0.14.1,
              any.hpath-filepath ==0.10.4,
-             any.hpath-posix ==0.13.3,
+             any.hpath-io ==0.14.1,
+             any.hpath-posix ==0.13.2,
              any.hsc2hs ==0.68.7,
              hsc2hs -in-ghc-tree,
-             any.hspec ==2.7.10,
+             any.hspec ==2.7.8,
-             any.hspec-core ==2.7.10,
+             any.hspec-core ==2.7.8,
-             any.hspec-discover ==2.7.10,
+             any.hspec-discover ==2.7.8,
              any.hspec-expectations ==0.8.2,
-             any.hspec-golden-aeson ==0.9.0.0,
+             any.hspec-golden-aeson ==0.7.0.0,
-             any.http-io-streams ==0.1.6.0,
+             any.indexed-profunctors ==0.1,
-             http-io-streams -brotli +fast-xor,
-             any.indexed-profunctors ==0.1.1,
              any.indexed-traversable ==0.1.1,
              any.indexed-traversable-instances ==0.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,
+             any.language-c ==0.8.3,
-             io-streams +network -nointeractivetests +zlib,
+             language-c -allwarnings +iecfpextension +separatesyb +usebytestrings,
-             any.language-c ==0.9.0.1,
+             any.libarchive ==3.0.2.1,
-             language-c -allwarnings +iecfpextension +usebytestrings,
-             any.libarchive ==3.0.2.2,
              libarchive -cross -low-memory -system-libarchive,
              any.libyaml ==0.1.2,
              libyaml -no-unicode -system-libyaml,
              any.lifted-base ==0.2.3.12,
-             any.lzma-static ==5.2.5.4,
+             any.list-t ==1.0.4,
+             any.lockfree-queue ==0.2.3.1,
+             lzma -static,
+             any.math-functions ==0.3.4.1,
+             math-functions +system-erf +system-expm1,
              any.megaparsec ==9.0.1,
              megaparsec -dev,
              any.microlens ==0.4.12.0,
              any.microlens-mtl ==0.2.0.1,
-             any.microlens-th ==0.4.3.10,
+             any.microlens-th ==0.4.3.9,
+             any.mmorph ==1.1.5,
              any.monad-control ==1.0.2.3,
              any.monad-logger ==0.3.36,
              monad-logger +template_haskell,
@@ -144,12 +142,11 @@ constraints: any.Cabal ==3.2.1.0,
              monad-loops +base4,
              any.mono-traversable ==1.0.15.1,
              any.mtl ==2.2.2,
-             any.network ==3.1.2.2,
+             any.mwc-random ==0.15.0.1,
+             any.network ==3.1.2.1,
              network -devel,
-             any.network-uri ==2.6.4.1,
              any.old-locale ==1.0.0.7,
              any.old-time ==1.1.0.3,
-             any.openssl-streams ==1.2.3.0,
              any.optics ==0.4,
              any.optics-core ==0.4,
              optics-core -explicit-generic-labels,
@@ -164,25 +161,25 @@ constraints: any.Cabal ==3.2.1.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.1.0,
+             any.primitive-extras ==0.8.2,
+             any.primitive-unlifted ==0.1.3.0,
              any.process ==1.6.9.0,
              any.profunctors ==5.6.2,
              any.quickcheck-arbitrary-adt ==0.3.1.0,
              any.quickcheck-io ==0.2.0,
              any.random ==1.2.0,
-             any.recursion-schemes ==5.2.2.1,
+             any.recursion-schemes ==5.2.2,
              recursion-schemes +template-haskell,
-             any.regex-base ==0.94.0.1,
              any.regex-posix ==0.96.0.0,
              regex-posix -_regex-posix-clib,
              any.resourcet ==1.2.4.2,
-             any.rts ==1.0.1,
+             any.rts ==1.0,
              any.safe ==0.3.19,
-             any.safe-exceptions ==0.1.7.2,
+             any.safe-exceptions ==0.1.7.1,
-             any.scientific ==0.3.7.0,
+             any.scientific ==0.3.6.2,
              scientific -bytestring-builder -integer-simple,
              any.semigroupoids ==5.3.5,
              semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
@@ -191,31 +188,36 @@ constraints: any.Cabal ==3.2.1.0,
              any.split ==0.2.3.4,
              any.splitmix ==0.1.0.3,
              splitmix -optimised-mixer,
-             any.stm ==2.5.0.1,
+             any.stm ==2.5.0.0,
              any.stm-chans ==3.0.0.4,
              any.streaming-commons ==0.2.2.1,
              streaming-commons -use-bytestring-builder,
+             any.streamly ==0.7.3,
+             streamly -debug -dev -examples -examples-sdl -fusion-plugin -has-llvm -inspection -no-fusion -streamk,
+             any.streamly-bytestring ==0.1.2,
+             any.streamly-posix ==0.1.0.1,
              any.strict ==0.4.0.1,
              strict +assoc,
              any.strict-base ==0.4.0.0,
-             any.string-interpolate ==0.3.1.1,
+             any.string-interpolate ==0.3.1.0,
              string-interpolate -bytestring-builder -extended-benchmarks -text-builder,
              any.syb ==0.7.2.1,
              any.tagged ==0.8.6.1,
              tagged +deepseq +transformers,
-             any.tar ==0.6.0.0,
+             any.tasty ==1.3.1,
+             tasty +clock,
+             any.tasty-hunit ==0.10.0.3,
+             any.tasty-quickcheck ==0.10.1.2,
              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-conversions ==0.3.1,
-             any.text-zipper ==0.11,
+             any.text-short ==0.1.3,
+             text-short -asserts,
              any.tf-random ==0.5,
              any.th-abstraction ==0.4.2.0,
-             any.th-compat ==0.1.2,
+             any.th-compat ==0.1.1,
-             any.th-expand-syns ==0.4.8.0,
              any.th-lift ==0.8.2,
              any.th-lift-instances ==0.1.18,
              any.th-orphans ==0.13.11,
@@ -223,7 +225,7 @@ constraints: any.Cabal ==3.2.1.0,
              any.these ==1.1.1.1,
              these +assoc,
              any.time ==1.9.3,
-             any.time-compat ==1.9.6,
+             any.time-compat ==1.9.5,
              time-compat -old-locale,
              any.transformers ==0.5.6.2,
              any.transformers-base ==0.4.5.2,
@@ -231,34 +233,29 @@ constraints: any.Cabal ==3.2.1.0,
              any.transformers-compat ==0.6.6,
              transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
              any.typed-process ==0.2.6.0,
+             any.unbounded-delays ==0.1.1.1,
              any.unix ==2.7.2.2,
              any.unix-bytestring ==0.3.7.3,
              any.unix-compat ==0.5.3,
              unix-compat -old-time,
              any.unix-time ==0.4.7,
              any.unliftio-core ==0.2.0.1,
-             any.unordered-containers ==0.2.14.0,
+             any.unordered-containers ==0.2.13.0,
              unordered-containers -debug,
-             any.uri-bytestring ==0.3.3.1,
+             any.uri-bytestring ==0.3.3.0,
              uri-bytestring -lib-werror,
              any.utf8-string ==1.0.2,
-             any.uuid-types ==1.0.5,
+             any.uuid-types ==1.0.4,
-             any.vector ==0.12.3.0,
+             any.vector ==0.12.2.0,
              vector +boundschecks -internalchecks -unsafechecks -wall,
              any.vector-algorithms ==0.8.0.4,
              vector-algorithms +bench +boundschecks -internalchecks -llvm +properties -unsafechecks,
-             any.versions ==5.0.0,
+             any.versions ==4.0.3,
              any.vty ==5.33,
-             any.word-wrap ==0.4.1,
+             any.wcwidth ==0.0.2,
+             wcwidth -cli +split-base,
              any.word8 ==0.1.3,
-             any.xor ==0.0.1.0,
              any.yaml ==0.11.5.0,
              yaml +no-examples +no-exe,
-             any.zip ==1.7.1,
+             zlib -non-blocking-ffi -pkg-config -static
-             zip -dev -disable-bzip2 -disable-zstd,
+index-state: hackage.haskell.org 2021-03-07T18:36:25Z
-             any.zlib ==0.6.2.3,
-             zlib -bundled-c-zlib -non-blocking-ffi -pkg-config,
-             any.zlib-bindings ==0.1.1.5,
-             any.zstd ==0.1.2.0,
-             zstd +standalone
-index-state: hackage.haskell.org 2021-07-12T18:00:24Z

cabal.ghc8105.project

@@ -1,28 +0,0 @@
-packages: ./ghcup.cabal
-
-optional-packages: ./vendored/*/*.cabal
-
-optimization: 2
-
-package ghcup
-    tests: True
-    flags: +tui
-
-source-repository-package
-    type: git
-    location: https://github.com/Bodigrim/tar
-    tag: ac197ec7ea4838dc2b4e22b9b888b080cedf29cf
-
-source-repository-package
-    type: git
-    location: https://github.com/bgamari/terminal-size
-    tag: 34ea816bd63f75f800eedac12c6908c6f3736036
-
-constraints: http-io-streams -brotli
-
-package libarchive
-  flags: -system-libarchive
-
-allow-newer: base, ghc-prim, template-haskell, language-c
-
-with-compiler: ghc-8.10.5

cabal.ghc884.project

@@ -0,0 +1,20 @@
+packages: ./ghcup.cabal
+
+with-compiler: ghc-8.8.4
+
+optional-packages: ./3rdparty/*/*.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
+
+constraints: http-io-streams -brotli
+
+package libarchive
+  flags: -system-libarchive
+
+allow-newer: base, ghc-prim, template-haskell

cabal.ghc884.project.freeze

@@ -1,11 +1,12 @@
 active-repositories: hackage.haskell.org:merge
-constraints: any.Cabal ==3.4.0.0,
+constraints: any.Cabal ==3.0.1.0,
              any.HUnit ==1.6.2.0,
-             any.HsOpenSSL ==0.11.7,
+             any.IfElse ==0.85,
-             HsOpenSSL -fast-bignum -homebrew-openssl -macports-openssl -use-pkg-config,
              any.QuickCheck ==2.14.2,
              QuickCheck -old-random +templatehaskell,
              any.StateVar ==1.2.1,
+             any.abstract-deque ==0.3,
+             abstract-deque -usecas,
              any.aeson ==1.5.6.0,
              aeson -bytestring-builder -cffi -developer -fast,
              any.aeson-pretty ==0.8.8,
@@ -17,32 +18,31 @@ constraints: any.Cabal ==3.4.0.0,
              any.ansi-wl-pprint ==0.6.9,
              ansi-wl-pprint -example,
              any.array ==0.5.4.0,
+             any.ascii-string ==1.0.1.4,
              any.assoc ==1.0.2,
              any.async ==2.2.3,
              async -bench,
+             any.atomic-primops ==0.8.4,
+             atomic-primops -debug,
              any.attoparsec ==0.13.2.5,
              attoparsec -developer,
              any.auto-update ==0.1.6,
-             any.base ==4.15.0.0,
+             any.base ==4.13.0.0,
              any.base-compat ==0.11.2,
              any.base-compat-batteries ==0.11.2,
              any.base-orphans ==0.8.4,
              any.base16-bytestring ==1.0.1.0,
-             any.base64-bytestring ==1.1.0.0,
+             any.base64-bytestring ==1.2.0.1,
-             any.bifunctors ==5.5.11,
+             any.bifunctors ==5.5.10,
              bifunctors +semigroups +tagged,
-             any.binary ==0.8.8.0,
+             any.binary ==0.8.7.0,
-             any.bindings-DSL ==1.0.25,
              any.blaze-builder ==0.4.2.1,
-             any.brick ==0.61,
+             any.bytestring ==0.10.10.1,
-             brick -demos,
-             any.bytestring ==0.10.12.1,
              any.bz2 ==1.0.1.0,
              bz2 -cross +with-bzlib,
-             any.bzlib-conduit ==0.3.0.2,
+             any.c2hs ==0.28.7,
-             any.c2hs ==0.28.8,
              c2hs +base3 -regression,
-             any.call-stack ==0.4.0,
+             any.call-stack ==0.3.0,
              any.case-insensitive ==1.2.1.0,
              any.casing ==0.1.4.1,
              any.cereal ==0.5.8.1,
@@ -54,7 +54,7 @@ constraints: any.Cabal ==3.4.0.0,
              clock -llvm,
              any.cmdargs ==0.10.21,
              cmdargs +quotation -testprog,
-             any.colour ==2.3.6,
+             any.colour ==2.3.5,
              any.comonad ==5.0.8,
              comonad +containers +distributive +indexed-traversable,
              any.composition-prelude ==3.0.0.2,
@@ -62,25 +62,16 @@ constraints: any.Cabal ==3.4.0.0,
              any.concurrent-output ==1.10.12,
              any.conduit ==1.3.4.1,
              any.conduit-extra ==1.3.5,
-             any.conduit-zstd ==0.0.2.0,
+             any.containers ==0.6.2.1,
-             any.config-ini ==0.2.4.0,
-             config-ini -enable-doctests,
-             any.containers ==0.6.4.1,
              any.contravariant ==1.5.3,
              contravariant +semigroups +statevar +tagged,
-             any.cpphs ==1.20.9.1,
-             cpphs -old-locale,
-             any.cryptohash-sha1 ==0.11.100.1,
              any.cryptohash-sha256 ==0.11.102.0,
              cryptohash-sha256 -exe +use-cbits,
-             any.data-clist ==0.1.2.3,
              any.data-default-class ==0.1.2.0,
              any.data-fix ==0.3.1,
-             any.deepseq ==1.4.5.0,
+             any.deepseq ==1.4.4.0,
-             any.digest ==0.0.1.3,
+             any.deferred-folds ==0.9.17,
-             digest -bytestring-in-base,
+             any.directory ==1.3.6.0,
-             any.directory ==1.3.6.1,
-             any.disk-free-space ==0.1.0.1,
              any.distributive ==0.6.2.1,
              distributive +semigroups +tagged,
              any.dlist ==1.0,
@@ -88,55 +79,63 @@ constraints: any.Cabal ==3.4.0.0,
              any.easy-file ==0.2.2,
              any.errors ==2.3.0,
              any.exceptions ==0.10.4,
-             any.extra ==1.7.9,
+             exceptions +transformers-0-4,
-             any.fast-logger ==3.0.5,
+             any.fast-logger ==3.0.3,
              any.filepath ==1.4.2.1,
-             any.free ==5.1.7,
+             any.focus ==1.0.2,
+             any.foldl ==1.4.11,
+             any.free ==5.1.6,
+             any.fusion-plugin-types ==0.1.0,
              any.generic-arbitrary ==0.1.0,
              any.generics-sop ==0.5.1.1,
-             any.ghc-bignum ==1.0,
+             any.ghc-boot-th ==8.8.4,
-             any.ghc-boot-th ==9.0.1,
+             any.ghc-prim ==0.5.3,
-             any.ghc-byteorder ==4.11.0.0.10,
+             ghcup -internal-downloader -tar -tui,
-             any.ghc-prim ==0.7.0,
              any.happy ==1.20.0,
-             any.hashable ==1.3.2.0,
+             any.hashable ==1.3.1.0,
-             hashable +integer-gmp -random-initial-seed,
+             hashable +integer-gmp,
              any.haskell-src-exts ==1.23.1,
              any.haskell-src-meta ==0.8.7,
              any.haskus-utils-data ==1.4,
              any.haskus-utils-types ==1.5.1,
              any.haskus-utils-variant ==3.1,
+             any.heaps ==0.3.6.1,
+             any.hpath ==0.11.0,
+             any.hpath-directory ==0.14.1,
              any.hpath-filepath ==0.10.4,
-             any.hpath-posix ==0.13.3,
+             any.hpath-io ==0.14.1,
+             any.hpath-posix ==0.13.2,
              any.hsc2hs ==0.68.7,
              hsc2hs -in-ghc-tree,
-             any.hspec ==2.7.10,
+             any.hspec ==2.7.8,
-             any.hspec-core ==2.7.10,
+             any.hspec-core ==2.7.8,
-             any.hspec-discover ==2.7.10,
+             any.hspec-discover ==2.7.8,
              any.hspec-expectations ==0.8.2,
-             any.hspec-golden-aeson ==0.9.0.0,
+             any.hspec-golden-aeson ==0.7.0.0,
-             any.http-io-streams ==0.1.6.0,
+             any.indexed-profunctors ==0.1,
-             http-io-streams -brotli +fast-xor,
-             any.indexed-profunctors ==0.1.1,
              any.indexed-traversable ==0.1.1,
              any.indexed-traversable-instances ==0.1,
+             any.integer-gmp ==1.0.2.0,
              any.integer-logarithms ==1.0.3.1,
              integer-logarithms -check-bounds +integer-gmp,
-             any.io-streams ==1.5.2.1,
+             any.language-c ==0.8.3,
-             io-streams +network -nointeractivetests +zlib,
+             language-c -allwarnings +iecfpextension +separatesyb +usebytestrings,
-             any.language-c ==0.9.0.1,
+             any.libarchive ==3.0.2.1,
-             language-c -allwarnings +iecfpextension +usebytestrings,
-             any.libarchive ==3.0.2.2,
              libarchive -cross -low-memory -system-libarchive,
              any.libyaml ==0.1.2,
              libyaml -no-unicode -system-libyaml,
              any.lifted-base ==0.2.3.12,
-             any.lzma-static ==5.2.5.4,
+             any.list-t ==1.0.4,
+             any.lockfree-queue ==0.2.3.1,
+             lzma -static,
+             any.math-functions ==0.3.4.1,
+             math-functions +system-erf +system-expm1,
              any.megaparsec ==9.0.1,
              megaparsec -dev,
              any.microlens ==0.4.12.0,
              any.microlens-mtl ==0.2.0.1,
-             any.microlens-th ==0.4.3.10,
+             any.microlens-th ==0.4.3.9,
+             any.mmorph ==1.1.5,
              any.monad-control ==1.0.2.3,
              any.monad-logger ==0.3.36,
              monad-logger +template_haskell,
@@ -144,12 +143,11 @@ constraints: any.Cabal ==3.4.0.0,
              monad-loops +base4,
              any.mono-traversable ==1.0.15.1,
              any.mtl ==2.2.2,
-             any.network ==3.1.2.2,
+             any.mwc-random ==0.15.0.1,
+             any.network ==3.1.2.1,
              network -devel,
-             any.network-uri ==2.6.4.1,
              any.old-locale ==1.0.0.7,
              any.old-time ==1.1.0.3,
-             any.openssl-streams ==1.2.3.0,
              any.optics ==0.4,
              any.optics-core ==0.4,
              optics-core -explicit-generic-labels,
@@ -164,25 +162,25 @@ constraints: any.Cabal ==3.4.0.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.1.0,
-             any.process ==1.6.11.0,
+             any.primitive-extras ==0.8.2,
+             any.primitive-unlifted ==0.1.3.0,
+             any.process ==1.6.9.0,
              any.profunctors ==5.6.2,
              any.quickcheck-arbitrary-adt ==0.3.1.0,
              any.quickcheck-io ==0.2.0,
              any.random ==1.2.0,
-             any.recursion-schemes ==5.2.2.1,
+             any.recursion-schemes ==5.2.2,
              recursion-schemes +template-haskell,
-             any.regex-base ==0.94.0.1,
              any.regex-posix ==0.96.0.0,
              regex-posix -_regex-posix-clib,
              any.resourcet ==1.2.4.2,
              any.rts ==1.0,
              any.safe ==0.3.19,
-             any.safe-exceptions ==0.1.7.2,
+             any.safe-exceptions ==0.1.7.1,
-             any.scientific ==0.3.7.0,
+             any.scientific ==0.3.6.2,
              scientific -bytestring-builder -integer-simple,
              any.semigroupoids ==5.3.5,
              semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
@@ -195,27 +193,32 @@ constraints: any.Cabal ==3.4.0.0,
              any.stm-chans ==3.0.0.4,
              any.streaming-commons ==0.2.2.1,
              streaming-commons -use-bytestring-builder,
+             any.streamly ==0.7.3,
+             streamly -debug -dev -examples -examples-sdl -fusion-plugin -has-llvm -inspection -no-fusion -streamk,
+             any.streamly-bytestring ==0.1.2,
+             any.streamly-posix ==0.1.0.1,
              any.strict ==0.4.0.1,
              strict +assoc,
              any.strict-base ==0.4.0.0,
-             any.string-interpolate ==0.3.1.1,
+             any.string-interpolate ==0.3.1.0,
              string-interpolate -bytestring-builder -extended-benchmarks -text-builder,
              any.syb ==0.7.2.1,
              any.tagged ==0.8.6.1,
              tagged +deepseq +transformers,
-             any.tar ==0.6.0.0,
+             any.tasty ==1.3.1,
-             any.template-haskell ==2.17.0.0,
+             tasty +clock,
-             any.temporary ==1.3,
+             any.tasty-hunit ==0.10.0.3,
-             any.terminal-progress-bar ==0.4.1,
+             any.tasty-quickcheck ==0.10.1.2,
+             any.template-haskell ==2.15.0.0,
              any.terminal-size ==0.3.2.1,
              any.terminfo ==0.4.1.4,
-             any.text ==1.2.4.1,
+             any.text ==1.2.4.0,
              any.text-conversions ==0.3.1,
-             any.text-zipper ==0.11,
+             any.text-short ==0.1.3,
+             text-short -asserts,
              any.tf-random ==0.5,
              any.th-abstraction ==0.4.2.0,
-             any.th-compat ==0.1.2,
+             any.th-compat ==0.1.1,
-             any.th-expand-syns ==0.4.8.0,
              any.th-lift ==0.8.2,
              any.th-lift-instances ==0.1.18,
              any.th-orphans ==0.13.11,
@@ -223,7 +226,7 @@ constraints: any.Cabal ==3.4.0.0,
              any.these ==1.1.1.1,
              these +assoc,
              any.time ==1.9.3,
-             any.time-compat ==1.9.6,
+             any.time-compat ==1.9.5,
              time-compat -old-locale,
              any.transformers ==0.5.6.2,
              any.transformers-base ==0.4.5.2,
@@ -231,34 +234,29 @@ constraints: any.Cabal ==3.4.0.0,
              any.transformers-compat ==0.6.6,
              transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
              any.typed-process ==0.2.6.0,
+             any.unbounded-delays ==0.1.1.1,
              any.unix ==2.7.2.2,
              any.unix-bytestring ==0.3.7.3,
              any.unix-compat ==0.5.3,
              unix-compat -old-time,
              any.unix-time ==0.4.7,
              any.unliftio-core ==0.2.0.1,
-             any.unordered-containers ==0.2.14.0,
+             any.unordered-containers ==0.2.13.0,
              unordered-containers -debug,
-             any.uri-bytestring ==0.3.3.1,
+             any.uri-bytestring ==0.3.3.0,
              uri-bytestring -lib-werror,
              any.utf8-string ==1.0.2,
-             any.uuid-types ==1.0.5,
+             any.uuid-types ==1.0.4,
-             any.vector ==0.12.3.0,
+             any.vector ==0.12.2.0,
              vector +boundschecks -internalchecks -unsafechecks -wall,
              any.vector-algorithms ==0.8.0.4,
              vector-algorithms +bench +boundschecks -internalchecks -llvm +properties -unsafechecks,
-             any.versions ==5.0.0,
+             any.versions ==4.0.3,
              any.vty ==5.33,
-             any.word-wrap ==0.4.1,
+             any.wcwidth ==0.0.2,
+             wcwidth -cli +split-base,
              any.word8 ==0.1.3,
-             any.xor ==0.0.1.0,
              any.yaml ==0.11.5.0,
              yaml +no-examples +no-exe,
-             any.zip ==1.7.1,
+             zlib -non-blocking-ffi -pkg-config -static
-             zip -dev -disable-bzip2 -disable-zstd,
+index-state: hackage.haskell.org 2021-03-07T18:36:25Z
-             any.zlib ==0.6.2.3,
-             zlib -bundled-c-zlib -non-blocking-ffi -pkg-config,
-             any.zlib-bindings ==0.1.1.5,
-             any.zstd ==0.1.2.0,
-             zstd +standalone
-index-state: hackage.haskell.org 2021-07-12T18:00:24Z

cabal.ghc901.project

@@ -1,28 +0,0 @@
-packages: ./ghcup.cabal
-
-optional-packages: ./vendored/*/*.cabal
-
-optimization: 2
-
-package ghcup
-    tests: True
-    flags: +tui
-
-source-repository-package
-    type: git
-    location: https://github.com/Bodigrim/tar
-    tag: ac197ec7ea4838dc2b4e22b9b888b080cedf29cf
-
-source-repository-package
-    type: git
-    location: https://github.com/bgamari/terminal-size
-    tag: 34ea816bd63f75f800eedac12c6908c6f3736036
-
-constraints: http-io-streams -brotli
-
-package libarchive
-  flags: -system-libarchive
-
-allow-newer: base, ghc-prim, template-haskell, language-c
-
-with-compiler: ghc-9.0.1

ghcup-0.0.5.yaml

@@ -2060,8 +2060,8 @@ ghcupDownloads:
         A_ARM64:
           Linux_UnknownLinux:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/aarch64-linux-ghcup-0.1.15.2-r1
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/aarch64-linux-ghcup-0.1.15.2
-              dlHash: d853372440f3d43babbb868fad399811241760f2233829c92403fcbea8c547ec
+              dlHash: d91b7a5416f292f2cf813824eb419f76ad9976d258cee3581123cb6eb01db9a7
           Darwin:
             unknown_versioning:
               dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/aarch64-apple-darwin-ghcup-0.1.15.2
@@ -2069,8 +2069,8 @@ ghcupDownloads:
         A_ARM:
           Linux_UnknownLinux:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/armv7-linux-ghcup-0.1.15.2-r1
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/armv7-linux-ghcup-0.1.15.2
-              dlHash: f8add9b39e1f7d0f03904dc69a8683259972a4472432c1ade27d918c39a4a874
+              dlHash: 03a4af5ed895ada1dd21f4cc3f64dc9078a5bf4268313021d004c04bea7f9c2e
   HLS:
     1.1.0:
       viTags: []
@@ -2120,17 +2120,8 @@ ghcupDownloads:
         - old
       viChangeLog: https://github.com/commercialhaskell/stack/blob/master/ChangeLog.md#v251
       viPostInstall: &stack-post |
-        Stack manages GHC versions internally by default. In order to make it use ghcup installed
+        Stack manages GHC versions internally by default. In order to make it use ghcup installed GHC versions have a look at the options 'system-ghc', 'compiler-check' and 'compiler': https://docs.haskellstack.org/en/stable/yaml_configuration/#system-ghc
-        GHC versions you can run the following commands:
+        Additionally, you should upgrade stack only through ghcup.
-          stack config set install-ghc false --global
-          stack config set system-ghc  true  --global
-        
-        On windows, you may find the following config options useful too:
-          skip-msys, extra-path, extra-include-dirs, extra-lib-dirs
-
-        Also check out: https://docs.haskellstack.org/en/stable/yaml_configuration
-
-        !!! Additionally, you should upgrade stack only through ghcup and not use 'stack upgrade' !!!
       viArch:
         A_64:
           Linux_UnknownLinux:
@@ -2155,13 +2146,14 @@ ghcupDownloads:
             unknown_versioning: *stack-251-64
     2.7.1:
       viTags:
-        - old
+        - Recommended
+        - Latest
       viChangeLog: https://github.com/commercialhaskell/stack/blob/master/ChangeLog.md#v271
       viPostInstall: *stack-post
       viArch:
         A_64:
           Linux_UnknownLinux:
-            unknown_versioning: &stack-271-64
+            unknown_versioning: &stack-64
               dlUri: https://github.com/commercialhaskell/stack/releases/download/v2.7.1/stack-2.7.1-linux-x86_64.tar.gz
               dlHash: 2bc47749ee4be5eccb52a2d4a6a00b0f3b28b92517742b40c675836d7db2777d
               dlSubdir:
@@ -2179,33 +2171,5 @@ ghcupDownloads:
               dlSubdir:
                 RegexDir: "stack-.*"
           Linux_Alpine:
-            unknown_versioning: *stack-271-64
+            unknown_versioning: *stack-64
-    2.7.3:
-      viTags:
-        - Latest
-        - Recommended
-      viChangeLog: https://github.com/commercialhaskell/stack/blob/master/ChangeLog.md#v273
-      viPostInstall: *stack-post
-      viArch:
-        A_64:
-          Linux_UnknownLinux:
-            unknown_versioning: &stack-273-64
-              dlUri: https://github.com/commercialhaskell/stack/releases/download/v2.7.3/stack-2.7.3-linux-x86_64.tar.gz
-              dlHash: a6c090555fa1c64aa61c29aa4449765a51d79e870cf759cde192937cd614e72b
-              dlSubdir:
-                RegexDir: "stack-.*"
-          Darwin:
-            unknown_versioning:
-              dlUri: https://github.com/commercialhaskell/stack/releases/download/v2.7.3/stack-2.7.3-osx-x86_64.tar.gz
-              dlHash: 42e5000a00af44a7b26852421ac63ce75f510ad1a97742cb131107088ee9fe30
-              dlSubdir:
-                RegexDir: "stack-.*"
-          Windows:
-            unknown_versioning:
-              dlUri: https://github.com/commercialhaskell/stack/releases/download/v2.7.3/stack-2.7.3-windows-x86_64.tar.gz
-              dlHash: e6ba12e0ecabf0df2567d88a0d247da238bc114bcccfca4195f5e86472c9330c
-              dlSubdir:
-                RegexDir: "stack-.*"
-          Linux_Alpine:
-            unknown_versioning: *stack-273-64
 

ghcup.cabal

@@ -82,6 +82,7 @@ library
     QuasiQuotes
     RecordWildCards
     ScopedTypeVariables
+    Strict
     StrictData
     TupleSections
     TypeApplications
@@ -116,7 +117,7 @@ library
     , megaparsec            >=8.0.0      && <9.1
     , monad-logger          ^>=0.3.31
     , mtl                   ^>=2.2
-    , optics                ^>=0.4
+    , optics                >=0.2        && <0.5
     , optics-vl             ^>=0.2
     , os-release            ^>=1.0.0
     , parsec                ^>=3.1
@@ -194,6 +195,7 @@ executable ghcup
     PackageImports
     RecordWildCards
     ScopedTypeVariables
+    Strict
     StrictData
     TupleSections
 
@@ -205,7 +207,6 @@ executable ghcup
     , base                  >=4.13     && <5
     , bytestring            ^>=0.10
     , containers            ^>=0.6
-    , deepseq               ^>=1.4
     , filepath              ^>=1.4.2.1
     , ghcup
     , haskus-utils-variant  >=3.0      && <3.2
@@ -260,6 +261,7 @@ executable ghcup-gen
     QuasiQuotes
     RecordWildCards
     ScopedTypeVariables
+    Strict
     StrictData
     TupleSections
     TypeApplications
@@ -279,7 +281,7 @@ executable ghcup-gen
     , haskus-utils-variant  >=3.0      && <3.2
     , monad-logger          ^>=0.3.31
     , mtl                   ^>=2.2
-    , optics                ^>=0.4
+    , optics                >=0.2      && <0.5
     , optparse-applicative  >=0.15.1.0 && <0.17
     , pretty                ^>=1.1.3.1
     , pretty-terminal       ^>=0.1.0.0
@@ -303,7 +305,6 @@ executable ghcup-gen
 test-suite ghcup-test
   type:               exitcode-stdio-1.0
   main-is:            Main.hs
-  build-tool-depends: hspec-discover:hspec-discover -any
   hs-source-dirs:     test
   other-modules:
     GHCup.ArbitraryTypes

lib/GHCup.hs

@@ -1,5 +1,4 @@
 {-# LANGUAGE CPP                   #-}
-{-# LANGUAGE BangPatterns          #-}
 {-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE FlexibleInstances     #-}
@@ -43,7 +42,6 @@ import           GHCup.Version
 import           Codec.Archive                  ( ArchiveResult )
 #endif
 import           Control.Applicative
-import           Control.DeepSeq                ( force )
 import           Control.Exception              ( evaluate )
 import           Control.Exception.Safe
 import           Control.Monad
@@ -77,9 +75,6 @@ import           System.Directory        hiding ( findFiles )
 import           System.Environment
 import           System.FilePath
 import           System.IO.Error
-#if defined(IS_WINDOWS)
-import           System.IO.Temp
-#endif
 import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           Text.Regex.Posix
 
@@ -98,69 +93,6 @@ import GHCup.Utils.MegaParsec
 import Control.Concurrent (threadDelay)
 
 
-    ---------------------
-    --[ Tool fetching ]--
-    ---------------------
-
-
-fetchToolBindist :: ( MonadFail m
-                    , MonadMask m
-                    , MonadCatch m
-                    , MonadReader env m
-                    , HasDirs env
-                    , HasSettings env
-                    , HasPlatformReq env
-                    , HasGHCupInfo env
-                    , MonadLogger m
-                    , MonadResource m
-                    , MonadIO m
-                    , MonadUnliftIO m
-                    )
-                 => Version
-                 -> Tool
-                 -> Maybe FilePath
-                 -> Excepts
-                      '[ DigestError
-                       , DownloadFailed
-                       , NoDownload
-                       ]
-                      m
-                      FilePath
-fetchToolBindist v t mfp = do
-  dlinfo <- liftE $ getDownloadInfo t v
-  liftE $ downloadCached' dlinfo Nothing mfp
-
-
-fetchGHCSrc :: ( MonadFail m
-               , MonadMask m
-               , MonadCatch m
-               , MonadReader env m
-               , HasDirs env
-               , HasSettings env
-               , HasPlatformReq env
-               , HasGHCupInfo env
-               , MonadLogger m
-               , MonadResource m
-               , MonadIO m
-               , MonadUnliftIO m
-               )
-            => Version
-            -> Maybe FilePath
-            -> Excepts
-                 '[ DigestError
-                  , DownloadFailed
-                  , NoDownload
-                  ]
-                 m
-                 FilePath
-fetchGHCSrc v mfp = do
-  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-  dlInfo <-
-    preview (ix GHC % ix v % viSourceDL % _Just) dls
-      ?? NoDownload
-  liftE $ downloadCached' dlInfo Nothing mfp
-
-
 
     -------------------------
     --[ Tool installation ]--
@@ -172,10 +104,7 @@ fetchGHCSrc v mfp = do
 installGHCBindist :: ( MonadFail m
                      , MonadMask m
                      , MonadCatch m
-                     , MonadReader env m
+                     , MonadReader AppState m
-                     , HasDirs env
-                     , HasSettings env
-                     , HasPlatformReq env
                      , MonadLogger m
                      , MonadResource m
                      , MonadIO m
@@ -199,12 +128,14 @@ installGHCBindist :: ( MonadFail m
                        m
                        ()
 installGHCBindist dlinfo ver = do
+  AppState { dirs , settings } <- lift ask
+
   let tver = mkTVer ver
   lift $ $(logDebug) [i|Requested to install GHC with #{ver}|]
   whenM (lift $ ghcInstalled tver) (throwE $ AlreadyInstalled GHC ver)
 
   -- download (or use cached version)
-  dl <- liftE $ downloadCached dlinfo Nothing
+  dl                           <- liftE $ downloadCached settings dirs dlinfo Nothing
 
   -- prepare paths
   ghcdir <- lift $ ghcupGHCDir tver
@@ -230,10 +161,7 @@ installGHCBindist dlinfo ver = do
 -- build system and nothing else.
 installPackedGHC :: ( MonadMask m
                     , MonadCatch m
-                    , MonadReader env m
+                    , MonadReader AppState m
-                    , HasDirs env
-                    , HasPlatformReq env
-                    , HasSettings env
                     , MonadThrow m
                     , MonadLogger m
                     , MonadIO m
@@ -252,23 +180,7 @@ installPackedGHC :: ( MonadMask m
 #endif
                        ] m ()
 installPackedGHC dl msubdir inst ver = do
-#if defined(IS_WINDOWS)
+  AppState { pfreq = PlatformRequest {..} } <- lift ask
-  lift $ $(logInfo) "Installing GHC (this may take a while)"
-
-  Dirs { tmpDir } <- lift getDirs
-  unpackDir <- liftIO $ emptyTempFile tmpDir "ghc"
-  liftIO $ rmFile unpackDir
-
-  liftE $ unpackToDir unpackDir dl
-
-  d <- case msubdir of
-    Just td -> liftE $ intoSubdir unpackDir td
-    Nothing -> pure unpackDir
-
-  liftIO $ Win32.moveFileEx d (Just inst) 0
-  liftIO $ rmPath unpackDir
-#else
-  PlatformRequest {..} <- lift getPlatformReq
 
   -- unpack
   tmpUnpack <- lift mkGhcupTmpDir
@@ -283,15 +195,11 @@ installPackedGHC dl msubdir inst ver = do
   liftE $ runBuildAction tmpUnpack
                          (Just inst)
                          (installUnpackedGHC workdir inst ver)
-#endif
 
 
 -- | Install an unpacked GHC distribution. This only deals with the GHC
 -- build system and nothing else.
-installUnpackedGHC :: ( MonadReader env m
+installUnpackedGHC :: ( MonadReader AppState m
-                      , HasPlatformReq env
-                      , HasDirs env
-                      , HasSettings env
                       , MonadThrow m
                       , MonadLogger m
                       , MonadIO m
@@ -300,8 +208,15 @@ installUnpackedGHC :: ( MonadReader env m
                    -> FilePath      -- ^ Path to install to
                    -> Version       -- ^ The GHC version
                    -> Excepts '[ProcessError] m ()
+#if defined(IS_WINDOWS)
+installUnpackedGHC path inst _ = do
+  lift $ $(logInfo) "Installing GHC (this may take a while)"
+  -- windows bindists are relocatable and don't need
+  -- to run configure
+  liftIO $ copyDirectoryRecursive path inst
+#else
 installUnpackedGHC path inst ver = do
-  PlatformRequest {..} <- lift getPlatformReq
+  AppState { pfreq = PlatformRequest {..} } <- lift ask
 
   let alpineArgs
        | ver >= [vver|8.2.2|], Linux Alpine <- _rPlatform
@@ -322,6 +237,7 @@ installUnpackedGHC path inst ver = do
                    Nothing
   lEM $ make ["install"] (Just path)
   pure ()
+#endif
 
 
 -- | Installs GHC into @~\/.ghcup\/ghc/\<ver\>@ and places the
@@ -332,11 +248,7 @@ installUnpackedGHC path inst ver = do
 installGHCBin :: ( MonadFail m
                  , MonadMask m
                  , MonadCatch m
-                 , MonadReader env m
+                 , MonadReader AppState m
-                 , HasPlatformReq env
-                 , HasGHCupInfo env
-                 , HasDirs env
-                 , HasSettings env
                  , MonadLogger m
                  , MonadResource m
                  , MonadIO m
@@ -359,7 +271,9 @@ installGHCBin :: ( MonadFail m
                    m
                    ()
 installGHCBin ver = do
-  dlinfo <- liftE $ getDownloadInfo GHC ver
+  AppState { pfreq
+           , ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
+  dlinfo <- lE $ getDownloadInfo GHC ver pfreq dls
   installGHCBindist dlinfo ver
 
 
@@ -367,10 +281,7 @@ installGHCBin ver = do
 -- argument instead of looking it up from 'GHCupDownloads'.
 installCabalBindist :: ( MonadMask m
                        , MonadCatch m
-                       , MonadReader env m
+                       , MonadReader AppState m
-                       , HasPlatformReq env
-                       , HasDirs env
-                       , HasSettings env
                        , MonadLogger m
                        , MonadResource m
                        , MonadIO m
@@ -397,8 +308,9 @@ installCabalBindist :: ( MonadMask m
 installCabalBindist dlinfo ver = do
   lift $ $(logDebug) [i|Requested to install cabal version #{ver}|]
 
-  PlatformRequest {..} <- lift getPlatformReq
+  AppState { dirs = dirs@Dirs {..}
-  Dirs {..} <- lift getDirs
+           , pfreq = PlatformRequest {..}
+           , settings } <- lift ask
 
   whenM
       (lift (cabalInstalled ver) >>= \a -> liftIO $
@@ -410,7 +322,7 @@ installCabalBindist dlinfo ver = do
       (throwE $ AlreadyInstalled Cabal ver)
 
   -- download (or use cached version)
-  dl <- liftE $ downloadCached dlinfo Nothing
+  dl                           <- liftE $ downloadCached settings dirs dlinfo Nothing
 
   -- unpack
   tmpUnpack                    <- lift withGHCupTmpDir
@@ -450,11 +362,7 @@ installCabalBindist dlinfo ver = do
 -- the latest installed version.
 installCabalBin :: ( MonadMask m
                    , MonadCatch m
-                   , MonadReader env m
+                   , MonadReader AppState m
-                   , HasPlatformReq env
-                   , HasGHCupInfo env
-                   , HasDirs env
-                   , HasSettings env
                    , MonadLogger m
                    , MonadResource m
                    , MonadIO m
@@ -478,7 +386,9 @@ installCabalBin :: ( MonadMask m
                      m
                      ()
 installCabalBin ver = do
-  dlinfo <- liftE $ getDownloadInfo Cabal ver
+  AppState { pfreq
+           , ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
+  dlinfo <- lE $ getDownloadInfo Cabal ver pfreq dls
   installCabalBindist dlinfo ver
 
 
@@ -486,10 +396,7 @@ installCabalBin ver = do
 -- argument instead of looking it up from 'GHCupDownloads'.
 installHLSBindist :: ( MonadMask m
                      , MonadCatch m
-                     , MonadReader env m
+                     , MonadReader AppState m
-                     , HasPlatformReq env
-                     , HasDirs env
-                     , HasSettings env
                      , MonadLogger m
                      , MonadResource m
                      , MonadIO m
@@ -516,14 +423,15 @@ installHLSBindist :: ( MonadMask m
 installHLSBindist dlinfo ver = do
   lift $ $(logDebug) [i|Requested to install hls version #{ver}|]
 
-  PlatformRequest {..} <- lift getPlatformReq
+  AppState { dirs = dirs@Dirs {..}
-  Dirs {..} <- lift getDirs
+           , pfreq = PlatformRequest {..}
+           , settings } <- lift ask
 
   whenM (lift (hlsInstalled ver))
     (throwE $ AlreadyInstalled HLS ver)
 
   -- download (or use cached version)
-  dl <- liftE $ downloadCached dlinfo Nothing
+  dl                           <- liftE $ downloadCached settings dirs dlinfo Nothing
 
   -- unpack
   tmpUnpack                    <- lift withGHCupTmpDir
@@ -578,11 +486,7 @@ installHLSBindist dlinfo ver = do
 -- into @~\/.ghcup\/bin/@, as well as @haskell-languager-server-wrapper@.
 installHLSBin :: ( MonadMask m
                  , MonadCatch m
-                 , MonadReader env m
+                 , MonadReader AppState m
-                 , HasPlatformReq env
-                 , HasGHCupInfo env
-                 , HasDirs env
-                 , HasSettings env
                  , MonadLogger m
                  , MonadResource m
                  , MonadIO m
@@ -606,7 +510,9 @@ installHLSBin :: ( MonadMask m
                    m
                    ()
 installHLSBin ver = do
-  dlinfo <- liftE $ getDownloadInfo HLS ver
+  AppState { pfreq
+           , ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
+  dlinfo <- lE $ getDownloadInfo HLS ver pfreq dls
   installHLSBindist dlinfo ver
 
 
@@ -615,11 +521,7 @@ installHLSBin ver = do
 -- the latest installed version.
 installStackBin :: ( MonadMask m
                    , MonadCatch m
-                   , MonadReader env m
+                   , MonadReader AppState m
-                   , HasDirs env
-                   , HasSettings env
-                   , HasPlatformReq env
-                   , HasGHCupInfo env
                    , MonadLogger m
                    , MonadResource m
                    , MonadIO m
@@ -643,7 +545,8 @@ installStackBin :: ( MonadMask m
                      m
                      ()
 installStackBin ver = do
-  dlinfo <- liftE $ getDownloadInfo Stack ver
+  AppState { pfreq, ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- lift ask
+  dlinfo <- lE $ getDownloadInfo Stack ver pfreq dls
   installStackBindist dlinfo ver
 
 
@@ -651,10 +554,7 @@ installStackBin ver = do
 -- argument instead of looking it up from 'GHCupDownloads'.
 installStackBindist :: ( MonadMask m
                        , MonadCatch m
-                       , MonadReader env m
+                       , MonadReader AppState m
-                       , HasPlatformReq env
-                       , HasDirs env
-                       , HasSettings env
                        , MonadLogger m
                        , MonadResource m
                        , MonadIO m
@@ -681,14 +581,16 @@ installStackBindist :: ( MonadMask m
 installStackBindist dlinfo ver = do
   lift $ $(logDebug) [i|Requested to install stack version #{ver}|]
 
-  PlatformRequest {..} <- lift getPlatformReq
+  AppState { dirs = dirs@Dirs {..}
-  Dirs {..} <- lift getDirs
+           , pfreq = PlatformRequest {..}
+           , settings
+           } <- lift ask
 
-  whenM (lift (stackInstalled ver))
+  whenM (lift (hlsInstalled ver))
     (throwE $ AlreadyInstalled Stack ver)
 
   -- download (or use cached version)
-  dl <- liftE $ downloadCached dlinfo Nothing
+  dl                           <- liftE $ downloadCached settings dirs dlinfo Nothing
 
   -- unpack
   tmpUnpack                    <- lift withGHCupTmpDir
@@ -740,8 +642,7 @@ installStackBindist dlinfo ver = do
 --
 -- Additionally creates a @~\/.ghcup\/share -> ~\/.ghcup\/ghc\/\<ver\>\/share symlink@
 -- for 'SetGHCOnly' constructor.
-setGHC :: ( MonadReader env m
+setGHC :: ( MonadReader AppState m
-          , HasDirs env
           , MonadLogger m
           , MonadThrow m
           , MonadFail m
@@ -760,7 +661,7 @@ setGHC ver sghc = do
   whenM (lift $ not <$> ghcInstalled ver) (throwE (NotInstalled GHC ver))
 
   -- symlink destination
-  Dirs {..} <- lift getDirs
+  AppState { dirs = Dirs {..} } <- lift ask
 
   -- first delete the old symlinks (this fixes compatibility issues
   -- with old ghcup)
@@ -798,15 +699,12 @@ setGHC ver sghc = do
 
  where
 
-  symlinkShareDir :: ( MonadReader env m
+  symlinkShareDir :: (MonadReader AppState m, MonadIO m, MonadLogger m)
-                     , HasDirs env
-                     , MonadIO m
-                     , MonadLogger m)
                   => FilePath
                   -> String
                   -> m ()
   symlinkShareDir ghcdir ver' = do
-    Dirs {..} <- getDirs
+    AppState { dirs = Dirs {..} } <- ask
     let destdir = baseDir
     case sghc of
       SetGHCOnly -> do
@@ -833,8 +731,7 @@ setGHC ver sghc = do
 
 -- | Set the @~\/.ghcup\/bin\/cabal@ symlink.
 setCabal :: ( MonadMask m
-            , MonadReader env m
+            , MonadReader AppState m
-            , HasDirs env
             , MonadLogger m
             , MonadThrow m
             , MonadFail m
@@ -846,7 +743,7 @@ setCabal ver = do
   let targetFile = "cabal-" <> T.unpack (prettyVer ver) <> exeExt
 
   -- symlink destination
-  Dirs {..} <- lift getDirs
+  AppState {dirs = Dirs {..}} <- lift ask
 
   whenM (liftIO $ not <$> doesFileExist (binDir </> targetFile))
     $ throwE
@@ -865,8 +762,7 @@ setCabal ver = do
 
 -- | Set the haskell-language-server symlinks.
 setHLS :: ( MonadCatch m
-          , MonadReader env m
+          , MonadReader AppState m
-          , HasDirs env
           , MonadLogger m
           , MonadThrow m
           , MonadFail m
@@ -877,7 +773,7 @@ setHLS :: ( MonadCatch m
        => Version
        -> Excepts '[NotInstalled] m ()
 setHLS ver = do
-  Dirs {..} <- lift getDirs
+  AppState { dirs = Dirs {..} } <- lift ask
 
   -- Delete old symlinks, since these might have different ghc versions than the
   -- selected version, so we could end up with stray or incorrect symlinks.
@@ -906,8 +802,7 @@ setHLS ver = do
 
 -- | Set the @~\/.ghcup\/bin\/stack@ symlink.
 setStack :: ( MonadMask m
-            , MonadReader env m
+            , MonadReader AppState m
-            , HasDirs env
             , MonadLogger m
             , MonadThrow m
             , MonadFail m
@@ -920,7 +815,7 @@ setStack ver = do
   let targetFile = "stack-" <> T.unpack (prettyVer ver) <> exeExt
 
   -- symlink destination
-  Dirs {..} <- lift getDirs
+  AppState {dirs = Dirs {..}} <- lift ask
 
   whenM (liftIO $ not <$> doesFileExist (binDir </> targetFile))
     $ throwE
@@ -975,10 +870,7 @@ listVersions :: ( MonadCatch m
                 , MonadThrow m
                 , MonadLogger m
                 , MonadIO m
-                , MonadReader env m
+                , MonadReader AppState m
-                , HasDirs env
-                , HasPlatformReq env
-                , HasGHCupInfo env
                 )
              => Maybe Tool
              -> Maybe ListCriteria
@@ -997,7 +889,7 @@ listVersions lt' criteria = do
   go lt cSet cabals hlsSet' hlses sSet stacks = do
     case lt of
       Just t -> do
-        GHCupInfo { _ghcupDownloads = dls } <- getGHCupInfo
+        AppState { ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
         -- get versions from GHCupDownloads
         let avTools = availableToolVersions dls t
         lr <- filter' <$> forM (Map.toList avTools) (toListResult t cSet cabals hlsSet' hlses sSet stacks)
@@ -1023,13 +915,7 @@ listVersions lt' criteria = do
         ghcupvers <- go (Just GHCup) cSet cabals hlsSet' hlses sSet stacks
         stackvers <- go (Just Stack) cSet cabals hlsSet' hlses sSet stacks
         pure (ghcvers <> cabalvers <> hlsvers <> stackvers <> ghcupvers)
-  strayGHCs :: ( MonadCatch m
+  strayGHCs :: (MonadCatch m, MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m)
-               , MonadReader env m
-               , HasDirs env
-               , MonadThrow m
-               , MonadLogger m
-               , MonadIO m
-               )
             => Map.Map Version [Tag]
             -> m [ListResult]
   strayGHCs avTools = do
@@ -1071,13 +957,7 @@ listVersions lt' criteria = do
           [i|Could not parse version of stray directory #{e}|]
         pure Nothing
 
-  strayCabals :: ( MonadReader env m
+  strayCabals :: (MonadReader AppState m, MonadCatch m, MonadThrow m, MonadLogger m, MonadIO m)
-                 , HasDirs env
-                 , MonadCatch m
-                 , MonadThrow m
-                 , MonadLogger m
-                 , MonadIO m
-                 )
             => Map.Map Version [Tag]
             -> Maybe Version
             -> [Either FilePath Version]
@@ -1106,12 +986,7 @@ listVersions lt' criteria = do
           [i|Could not parse version of stray directory #{e}|]
         pure Nothing
 
-  strayHLS :: ( MonadReader env m
+  strayHLS :: (MonadReader AppState m, MonadCatch m, MonadThrow m, MonadLogger m, MonadIO m)
-              , HasDirs env
-              , MonadCatch m
-              , MonadThrow m
-              , MonadLogger m
-              , MonadIO m)
            => Map.Map Version [Tag]
            -> m [ListResult]
   strayHLS avTools = do
@@ -1139,13 +1014,7 @@ listVersions lt' criteria = do
           [i|Could not parse version of stray directory #{e}|]
         pure Nothing
 
-  strayStacks :: ( MonadReader env m
+  strayStacks :: (MonadReader AppState m, MonadCatch m, MonadThrow m, MonadLogger m, MonadIO m)
-                 , HasDirs env
-                 , MonadCatch m
-                 , MonadThrow m
-                 , MonadLogger m
-                 , MonadIO m
-                 )
               => Map.Map Version [Tag]
               -> m [ListResult]
   strayStacks avTools = do
@@ -1174,14 +1043,7 @@ listVersions lt' criteria = do
         pure Nothing
 
   -- NOTE: this are not cross ones, because no bindists
-  toListResult :: ( MonadLogger m
+  toListResult :: (MonadLogger m, MonadReader AppState m, MonadIO m, MonadCatch m)
-                  , MonadReader env m
-                  , HasDirs env
-                  , HasGHCupInfo env
-                  , HasPlatformReq env
-                  , MonadIO m
-                  , MonadCatch m
-                  )
                => Tool
                -> Maybe Version
                -> [Either FilePath Version]
@@ -1192,9 +1054,12 @@ listVersions lt' criteria = do
                -> (Version, [Tag])
                -> m ListResult
   toListResult t cSet cabals hlsSet' hlses stackSet' stacks (v, tags) = do
+    AppState { pfreq
+             , ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
+
     case t of
       GHC -> do
-        lNoBindist <- fmap (isLeft . veitherToEither) $ runE @'[NoDownload] $ getDownloadInfo GHC v
+        let lNoBindist = isLeft $ getDownloadInfo GHC v pfreq dls
         let tver = mkTVer v
         lSet       <- fmap (maybe False (\(GHCTargetVersion _ v') -> v' == v)) $ ghcSet Nothing
         lInstalled <- ghcInstalled tver
@@ -1202,7 +1067,7 @@ listVersions lt' criteria = do
         hlsPowered <- fmap (elem v) hlsGHCVersions
         pure ListResult { lVer = v, lCross = Nothing , lTag = tags, lTool = t, lStray = False, .. }
       Cabal -> do
-        lNoBindist <- fmap (isLeft . veitherToEither) $ runE @'[NoDownload] $ getDownloadInfo Cabal v
+        let lNoBindist = isLeft $ getDownloadInfo Cabal v pfreq dls
         let lSet = cSet == Just v
         let lInstalled = elem v $ rights cabals
         pure ListResult { lVer    = v
@@ -1228,7 +1093,7 @@ listVersions lt' criteria = do
                         , ..
                         }
       HLS -> do
-        lNoBindist <- fmap (isLeft . veitherToEither) $ runE @'[NoDownload] $ getDownloadInfo HLS v
+        let lNoBindist = isLeft $ getDownloadInfo HLS v pfreq dls
         let lSet = hlsSet' == Just v
         let lInstalled = elem v $ rights hlses
         pure ListResult { lVer    = v
@@ -1241,7 +1106,7 @@ listVersions lt' criteria = do
                         , ..
                         }
       Stack -> do
-        lNoBindist <- fmap (isLeft . veitherToEither) $ runE @'[NoDownload] $ getDownloadInfo Stack v
+        let lNoBindist = isLeft $ getDownloadInfo Stack v pfreq dls
         let lSet = stackSet' == Just v
         let lInstalled = elem v $ rights stacks
         pure ListResult { lVer    = v
@@ -1273,8 +1138,7 @@ listVersions lt' criteria = do
 -- This may leave GHCup without a "set" version.
 -- Will try to fix the ghc-x.y symlink after removal (e.g. to an
 -- older version).
-rmGHCVer :: ( MonadReader env m
+rmGHCVer :: ( MonadReader AppState m
-            , HasDirs env
             , MonadThrow m
             , MonadLogger m
             , MonadIO m
@@ -1315,7 +1179,7 @@ rmGHCVer ver = do
   forM_ v' $ \(mj, mi) -> lift (getGHCForMajor mj mi (_tvTarget ver))
     >>= mapM_ (\v -> liftE $ setGHC v SetGHC_XY)
 
-  Dirs {..} <- lift getDirs
+  AppState { dirs = Dirs {..} } <- lift ask
 
   liftIO
     $ hideError doesNotExistErrorType
@@ -1325,8 +1189,7 @@ rmGHCVer ver = do
 -- | Delete a cabal version. Will try to fix the @cabal@ symlink
 -- after removal (e.g. setting it to an older version).
 rmCabalVer :: ( MonadMask m
-              , MonadReader env m
+              , MonadReader AppState m
-              , HasDirs env
               , MonadThrow m
               , MonadLogger m
               , MonadIO m
@@ -1341,7 +1204,7 @@ rmCabalVer ver = do
 
   cSet      <- lift cabalSet
 
-  Dirs {..} <- lift getDirs
+  AppState {dirs = Dirs {..}} <- lift ask
 
   let cabalFile = "cabal-" <> T.unpack (prettyVer ver) <> exeExt
   liftIO $ hideError doesNotExistErrorType $ rmFile (binDir </> cabalFile)
@@ -1356,8 +1219,7 @@ rmCabalVer ver = do
 -- | Delete a hls version. Will try to fix the hls symlinks
 -- after removal (e.g. setting it to an older version).
 rmHLSVer :: ( MonadMask m
-            , MonadReader env m
+            , MonadReader AppState m
-            , HasDirs env
             , MonadThrow m
             , MonadLogger m
             , MonadIO m
@@ -1372,7 +1234,7 @@ rmHLSVer ver = do
 
   isHlsSet      <- lift hlsSet
 
-  Dirs {..} <- lift getDirs
+  AppState {dirs = Dirs {..}} <- lift ask
 
   bins <- lift $ hlsAllBinaries ver
   forM_ bins $ \f -> liftIO $ rmFile (binDir </> f)
@@ -1394,8 +1256,7 @@ rmHLSVer ver = do
 -- | Delete a stack version. Will try to fix the @stack@ symlink
 -- after removal (e.g. setting it to an older version).
 rmStackVer :: ( MonadMask m
-              , MonadReader env m
+              , MonadReader AppState m
-              , HasDirs env
               , MonadThrow m
               , MonadLogger m
               , MonadIO m
@@ -1410,7 +1271,7 @@ rmStackVer ver = do
 
   sSet      <- lift stackSet
 
-  Dirs {..} <- lift getDirs
+  AppState {dirs = Dirs {..}} <- lift ask
 
   let stackFile = "stack-" <> T.unpack (prettyVer ver) <> exeExt
   liftIO $ hideError doesNotExistErrorType $ rmFile (binDir </> stackFile)
@@ -1423,15 +1284,15 @@ rmStackVer ver = do
 
 
 -- assuming the current scheme of having just 1 ghcup bin, no version info is required.
-rmGhcup :: ( MonadReader env m
+rmGhcup :: ( MonadReader AppState m
-           , HasDirs env
            , MonadIO m
            , MonadCatch m
            , MonadLogger m
            )
         => m ()
+
 rmGhcup = do
-  Dirs {binDir} <- getDirs
+  AppState {dirs = Dirs {binDir}} <- ask
   let ghcupFilename = "ghcup" <> exeExt
   let ghcupFilepath = binDir </> ghcupFilename
 
@@ -1475,14 +1336,14 @@ rmGhcup = do
       <> path <>
       "\n you may have to uninstall it manually."
 
-rmTool :: ( MonadReader env m
+rmTool :: ( MonadReader AppState m
-          , HasDirs env
            , MonadLogger m
            , MonadFail m
            , MonadMask m
            , MonadUnliftIO m)
            => ListResult
            -> Excepts '[NotInstalled ] m ()
+
 rmTool ListResult {lVer, lTool, lCross} = do
   case lTool of
     GHC ->
@@ -1494,8 +1355,7 @@ rmTool ListResult {lVer, lTool, lCross} = do
     GHCup -> lift rmGhcup
 
 
-rmGhcupDirs :: ( MonadReader env m
+rmGhcupDirs :: ( MonadReader AppState m
-               , HasDirs env
                , MonadIO m
                , MonadLogger m
                , MonadCatch m
@@ -1507,8 +1367,7 @@ rmGhcupDirs = do
     , binDir
     , logsDir
     , cacheDir
-    , tmpDir
+    } <- asks dirs
-    } <- getDirs
 
   let envFilePath = baseDir </> "env"
 
@@ -1519,7 +1378,6 @@ rmGhcupDirs = do
   rmDir cacheDir
   rmDir logsDir
   rmBinDir   binDir
-  rmDir tmpDir
 #if defined(IS_WINDOWS)
   rmDir (baseDir </> "msys64")
 #endif
@@ -1535,21 +1393,19 @@ rmGhcupDirs = do
     rmEnvFile :: (MonadCatch m, MonadLogger m, MonadIO m) => FilePath -> m ()
     rmEnvFile enFilePath = do
       $logInfo "Removing Ghcup Environment File"
-      liftIO $ deleteFile enFilePath
+      hideError doesNotExistErrorType $ liftIO $ deleteFile enFilePath
 
     rmConfFile :: (MonadCatch m, MonadLogger m, MonadIO m) => FilePath -> m ()
     rmConfFile confFilePath = do
       $logInfo "removing Ghcup Config File"
-      liftIO $ deleteFile confFilePath
+      hideError doesNotExistErrorType $ liftIO $ deleteFile confFilePath
 
     rmDir :: (MonadLogger m, MonadIO m, MonadCatch m) => FilePath -> m ()
-    rmDir dir =
+    rmDir dir = do
-      -- 'getDirectoryContentsRecursive' is lazy IO. In case
-      -- an error leaks through, we catch it here as well,
-      -- althought 'deleteFile' should already handle it.
-      hideErrorDef [doesNotExistErrorType] () $ do
       $logInfo [i|removing #{dir}|]
-        contents <- liftIO $ getDirectoryContentsRecursive dir
+      contents <- hideErrorDef [doesNotExistErrorType] []
+        $ liftIO
+        (getDirectoryContentsRecursive dir >>= evaluate)
       forM_ contents (liftIO . deleteFile . (dir </>))
 
     rmBinDir :: (MonadCatch m, MonadIO m) => FilePath -> m ()
@@ -1565,9 +1421,7 @@ rmGhcupDirs = do
 
     reportRemainingFiles :: MonadIO m => FilePath -> m [FilePath]
     reportRemainingFiles dir = do
-      -- force the files so the errors don't leak
+      remainingFiles <- liftIO $ getDirectoryContentsRecursive dir
-      (force -> !remainingFiles) <- liftIO
-        (getDirectoryContentsRecursive dir >>= evaluate)
       let normalizedFilePaths = fmap normalise remainingFiles
       let sortedByDepthRemainingFiles = sortBy (flip compareFn) normalizedFilePaths
       let remainingFilesAbsolute = fmap (dir </>) sortedByDepthRemainingFiles
@@ -1594,8 +1448,7 @@ rmGhcupDirs = do
 
     deleteFile :: FilePath -> IO ()
     deleteFile filepath = do
-      hideError doesNotExistErrorType
+      hideError InappropriateType $ rmFile filepath
-        $ hideError InappropriateType $ rmFile filepath
 
     removeDirIfEmptyOrIsSymlink :: (MonadCatch m, MonadIO m) => FilePath -> m ()
     removeDirIfEmptyOrIsSymlink filepath =
@@ -1617,20 +1470,13 @@ rmGhcupDirs = do
     ------------------
 
 
-getDebugInfo :: ( Alternative m
+getDebugInfo :: (Alternative m, MonadFail m, MonadReader AppState m, MonadLogger m, MonadCatch m, MonadIO m)
-                , MonadFail m
-                , MonadReader env m
-                , HasDirs env
-                , MonadLogger m
-                , MonadCatch m
-                , MonadIO m
-                )
              => Excepts
                   '[NoCompatiblePlatform , NoCompatibleArch , DistroNotFound]
                   m
                   DebugInfo
 getDebugInfo = do
-  Dirs {..} <- lift getDirs
+  AppState {dirs = Dirs {..}} <- lift ask
   let diBaseDir  = baseDir
   let diBinDir   = binDir
   diGHCDir       <- lift ghcupGHCBaseDir
@@ -1650,11 +1496,7 @@ getDebugInfo = do
 -- | Compile a GHC from source. This behaves wrt symlinks and installation
 -- the same as 'installGHCBin'.
 compileGHC :: ( MonadMask m
-              , MonadReader env m
+              , MonadReader AppState m
-              , HasDirs env
-              , HasPlatformReq env
-              , HasGHCupInfo env
-              , HasSettings env
               , MonadThrow m
               , MonadResource m
               , MonadLogger m
@@ -1689,9 +1531,10 @@ compileGHC :: ( MonadMask m
                 GHCTargetVersion
 compileGHC targetGhc ov bstrap jobs mbuildConfig patchdir aargs
   = do
-    PlatformRequest { .. } <- lift getPlatformReq
+    AppState { pfreq = PlatformRequest {..}
-    GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+             , ghcupInfo = GHCupInfo { _ghcupDownloads = dls }
-
+             , settings
+             , dirs } <- lift ask
     (workdir, tmpUnpack, tver) <- case targetGhc of
       -- unpack from version tarball
       Left tver -> do
@@ -1701,7 +1544,7 @@ compileGHC targetGhc ov bstrap jobs mbuildConfig patchdir aargs
         dlInfo <-
           preview (ix GHC % ix (tver ^. tvVersion) % viSourceDL % _Just) dls
             ?? NoDownload
-        dl <- liftE $ downloadCached dlInfo Nothing
+        dl        <- liftE $ downloadCached settings dirs dlInfo Nothing
 
         -- unpack
         tmpUnpack <- lift mkGhcupTmpDir
@@ -1768,11 +1611,11 @@ compileGHC targetGhc ov bstrap jobs mbuildConfig patchdir aargs
       Right g    -> pure $ Right g
       Left  bver -> pure $ Left ("ghc-" <> (T.unpack . prettyVer $ bver) <> exeExt)
 
-    (mBindist, bmk) <- liftE $ runBuildAction
+    (bindist, bmk) <- liftE $ runBuildAction
       tmpUnpack
       Nothing
       (do
-        b <- compileBindist bghc tver workdir ghcdir
+        b <- compileBindist bghc tver workdir
         bmk <- liftIO $ B.readFile (build_mk workdir)
         pure (b, bmk)
       )
@@ -1780,8 +1623,6 @@ compileGHC targetGhc ov bstrap jobs mbuildConfig patchdir aargs
     when alreadyInstalled $ do
       lift $ $(logInfo) [i|Deleting existing installation|]
       liftE $ rmGHCVer tver
-
-    forM_ mBindist $ \bindist -> do
     liftE $ installPackedGHC bindist
                              (Just $ RegexDir "ghc-.*")
                              ghcdir
@@ -1812,10 +1653,7 @@ BUILD_SPHINX_HTML = NO
 BUILD_SPHINX_PDF = NO
 HADDOCK_DOCS = YES|]
 
-  compileBindist :: ( MonadReader env m
+  compileBindist :: ( MonadReader AppState m
-                    , HasDirs env
-                    , HasSettings env
-                    , HasPlatformReq env
                     , MonadThrow m
                     , MonadCatch m
                     , MonadLogger m
@@ -1825,17 +1663,15 @@ HADDOCK_DOCS = YES|]
                  => Either FilePath FilePath
                  -> GHCTargetVersion
                  -> FilePath
-                 -> FilePath
                  -> Excepts
                       '[FileDoesNotExistError, InvalidBuildConfig, PatchFailed, ProcessError, NotFoundInPATH, CopyError]
                       m
-                      (Maybe FilePath)  -- ^ output path of bindist, None for cross
+                      FilePath  -- ^ output path of bindist
-  compileBindist bghc tver workdir ghcdir = do
+  compileBindist bghc tver workdir = do
     lift $ $(logInfo) [i|configuring build|]
     liftE checkBuildConfig
 
-    Dirs {..} <- lift getDirs
+    AppState { dirs = Dirs {..}, pfreq } <- lift ask
-    pfreq <- lift getPlatformReq
 
     forM_ patchdir $ \dir -> liftE $ applyPatches dir workdir
 
@@ -1852,7 +1688,6 @@ HADDOCK_DOCS = YES|]
             ("./configure" :  maybe mempty
                       (\x -> ["--target=" <> T.unpack x])
                       (_tvTarget tver)
-            ++ ["--prefix=" <> ghcdir]
 #if defined(IS_WINDOWS)
             ++ ["--enable-tarballs-autodownload"]
 #endif
@@ -1869,7 +1704,6 @@ HADDOCK_DOCS = YES|]
           ++ maybe mempty
                    (\x -> ["--target=" <> T.unpack x])
                    (_tvTarget tver)
-          ++ ["--prefix=" <> ghcdir]
 #if defined(IS_WINDOWS)
             ++ ["--enable-tarballs-autodownload"]
 #endif
@@ -1890,11 +1724,6 @@ HADDOCK_DOCS = YES|]
     lift $ $(logInfo) [i|Building (this may take a while)...|]
     lEM $ make (maybe [] (\j -> ["-j" <> fS (show j)]) jobs) (Just workdir)
 
-    if | isCross tver -> do
-          lift $ $(logInfo) [i|Installing cross toolchain...|]
-          lEM $ make ["install"] (Just workdir)
-          pure Nothing
-       | otherwise -> do
     lift $ $(logInfo) [i|Creating bindist...|]
     lEM $ make ["binary-dist"] (Just workdir)
     [tar] <- liftIO $ findFiles
@@ -1918,7 +1747,7 @@ HADDOCK_DOCS = YES|]
     handleIO (throwE . CopyError . show) $ liftIO $ copyFile (workdir </> tar)
                                                              tarPath
     lift $ $(logInfo) [i|Copied bindist to #{tarPath}|]
-          pure $ Just tarPath
+    pure tarPath
 
   build_mk workdir = workdir </> "mk" </> "build.mk"
 
@@ -1945,9 +1774,6 @@ HADDOCK_DOCS = YES|]
         )
       _ -> pure ()
 
-  isCross :: GHCTargetVersion -> Bool
-  isCross = isJust . _tvTarget
-
 
 
 
@@ -1959,11 +1785,7 @@ HADDOCK_DOCS = YES|]
 -- | Upgrade ghcup and place it in @~\/.ghcup\/bin\/ghcup@,
 -- if no path is provided.
 upgradeGHCup :: ( MonadMask m
-                , MonadReader env m
+                , MonadReader AppState m
-                , HasDirs env
-                , HasPlatformReq env
-                , HasGHCupInfo env
-                , HasSettings env
                 , MonadCatch m
                 , MonadLogger m
                 , MonadThrow m
@@ -1984,16 +1806,17 @@ upgradeGHCup :: ( MonadMask m
                   m
                   Version
 upgradeGHCup mtarget force' = do
-  Dirs {..} <- lift getDirs
+  AppState { dirs = Dirs {..}
-  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+           , pfreq
-
+           , ghcupInfo = GHCupInfo { _ghcupDownloads = dls }
+           , settings } <- lift ask
   lift $ $(logInfo) [i|Upgrading GHCup...|]
   let latestVer = fromJust $ fst <$> getLatest dls GHCup
   when (not force' && (latestVer <= pvpToVersion ghcUpVer)) $ throwE NoUpdate
-  dli   <- liftE $ getDownloadInfo GHCup latestVer
+  dli   <- lE $ getDownloadInfo GHCup latestVer pfreq dls
   tmp   <- lift withGHCupTmpDir
   let fn = "ghcup" <> exeExt
-  p <- liftE $ download dli tmp (Just fn)
+  p <- liftE $ download settings dli tmp (Just fn)
   let destDir = takeDirectory destFile
       destFile = fromMaybe (binDir </> fn <> exeExt) mtarget
   lift $ $(logDebug) [i|mkdir -p #{destDir}|]
@@ -2035,8 +1858,7 @@ upgradeGHCup mtarget force' = do
 
 -- | Creates @ghc-x.y.z@ and @ghc-x.y@ symlinks. This is used for
 -- both installing from source and bindist.
-postGHCInstall :: ( MonadReader env m
+postGHCInstall :: ( MonadReader AppState m
-                  , HasDirs env
                   , MonadLogger m
                   , MonadThrow m
                   , MonadFail m
@@ -2058,53 +1880,3 @@ postGHCInstall ver@GHCTargetVersion {..} = do
     $ getMajorMinorV _tvVersion
   forM_ v' $ \(mj, mi) -> lift (getGHCForMajor mj mi _tvTarget)
     >>= mapM_ (\v -> liftE $ setGHC v SetGHC_XY)
-
-
--- | Reports the binary location of a given tool:
---
---   * for GHC, this reports: @~\/.ghcup\/ghc\/\<ver\>\/bin\/ghc@
---   * for cabal, this reports @~\/.ghcup\/bin\/cabal-\<ver\>@
---   * for hls, this reports @~\/.ghcup\/bin\/haskell-language-server-wrapper-\<ver\>@
---   * for stack, this reports @~\/.ghcup\/bin\/stack-\<ver\>@
---   * for ghcup, this reports the location of the currently running executable
-whereIsTool :: ( MonadReader env m
-               , HasDirs env
-               , MonadLogger m
-               , MonadThrow m
-               , MonadFail m
-               , MonadIO m
-               , MonadCatch m
-               , MonadMask m
-               , MonadUnliftIO m
-               )
-            => Tool
-            -> GHCTargetVersion
-            -> Excepts '[NotInstalled] m FilePath
-whereIsTool tool ver@GHCTargetVersion {..} = do
-  dirs <- lift getDirs
-
-  case tool of
-    GHC -> do
-      whenM (lift $ fmap not $ ghcInstalled ver)
-        $ throwE (NotInstalled GHC ver)
-      bdir <- lift $ ghcupGHCDir ver
-      pure (bdir </> "bin" </> ghcBinaryName ver)
-    Cabal -> do
-      whenM (lift $ fmap not $ cabalInstalled _tvVersion)
-        $ throwE (NotInstalled Cabal (GHCTargetVersion Nothing _tvVersion))
-      pure (binDir dirs </> "cabal-" <> T.unpack (prettyVer _tvVersion) <> exeExt)
-    HLS -> do
-      whenM (lift $ fmap not $ hlsInstalled _tvVersion)
-        $ throwE (NotInstalled HLS (GHCTargetVersion Nothing _tvVersion))
-      pure (binDir dirs </> "haskell-language-server-wrapper-" <> T.unpack (prettyVer _tvVersion) <> exeExt)
-
-    Stack -> do
-      whenM (lift $ fmap not $ stackInstalled _tvVersion)
-        $ throwE (NotInstalled Stack (GHCTargetVersion Nothing _tvVersion))
-      pure (binDir dirs </> "stack-" <> T.unpack (prettyVer _tvVersion) <> exeExt)
-    GHCup -> do
-      currentRunningExecPath <- liftIO getExecutablePath
-      liftIO $ canonicalizePath currentRunningExecPath
-
-
-

lib/GHCup/Download.hs

@@ -107,31 +107,32 @@ import qualified Data.Yaml                     as Y
 getDownloadsF :: ( FromJSONKey Tool
                  , FromJSONKey Version
                  , FromJSON VersionInfo
-                 , MonadReader env m
-                 , HasSettings env
-                 , HasDirs env
                  , MonadIO m
                  , MonadCatch m
                  , MonadLogger m
                  , MonadThrow m
                  , MonadFail m
                  )
-              => Excepts
+              => Settings
+              -> Dirs
+              -> Excepts
                    '[JSONError , DownloadFailed , FileDoesNotExistError]
                    m
                    GHCupInfo
-getDownloadsF = do
+getDownloadsF settings@Settings{ urlSource } dirs = do
-  Settings { urlSource } <- lift getSettings
   case urlSource of
-    GHCupURL -> liftE $ getBase ghcupURL
+    GHCupURL -> liftE $ getBase dirs settings
-    (OwnSource url) -> liftE $ getBase url
+    (OwnSource url) -> do
+      bs <- reThrowAll DownloadFailed $ downloadBS (downloader settings) url
+      lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bs)
     (OwnSpec av) -> pure av
     (AddSource (Left ext)) -> do
-      base <- liftE $ getBase ghcupURL
+      base <- liftE $ getBase dirs settings
       pure (mergeGhcupInfo base ext)
     (AddSource (Right uri)) -> do
-      base <- liftE $ getBase ghcupURL
+      base <- liftE $ getBase dirs settings
-      ext  <- liftE $ getBase uri
+      bsExt <- reThrowAll DownloadFailed $ downloadBS (downloader settings) uri
+      ext <- lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bsExt)
       pure (mergeGhcupInfo base ext)
 
     where
@@ -148,49 +149,33 @@ getDownloadsF = do
     in GHCupInfo tr newDownloads newGlobalTools
 
 
-readFromCache :: ( MonadReader env m
+readFromCache :: (MonadIO m, MonadCatch m, MonadLogger m)
-                 , HasDirs env
+              => Dirs
-                 , MonadIO m
+              -> Excepts '[JSONError, FileDoesNotExistError] m GHCupInfo
-                 , MonadCatch m)
+readFromCache Dirs {..} = do
-              => URI
+  lift $ $(logWarn)
-              -> Excepts '[JSONError, FileDoesNotExistError] m L.ByteString
-readFromCache uri = do
-  Dirs{..} <- lift getDirs
-  let yaml_file = cacheDir </> (T.unpack . decUTF8Safe . urlBaseName . view pathL' $ uri)
-  handleIO' NoSuchThing (\_ -> throwE $ FileDoesNotExistError yaml_file)
-    . liftIO
-    . L.readFile
-    $ yaml_file
-
-
-getBase :: ( MonadReader env m
-           , HasDirs env
-           , HasSettings env
-           , MonadFail m
-           , MonadIO m
-           , MonadCatch m
-           , MonadLogger m
-           )
-        => URI
-        -> Excepts '[JSONError , FileDoesNotExistError] m GHCupInfo
-getBase uri = do
-  Settings { noNetwork } <- lift getSettings
-  bs <- if noNetwork
-        then readFromCache uri
-        else handleIO (\_ -> warnCache >> readFromCache uri)
-               . catchE @_ @'[JSONError, FileDoesNotExistError] (\(DownloadFailed _) -> warnCache >> readFromCache uri)
-               . reThrowAll @_ @_ @'[JSONError, DownloadFailed] DownloadFailed
-               $ smartDl uri
-  liftE
-    . lE' @_ @_ @'[JSONError] JSONDecodeError
-    . first show
-    . Y.decodeEither'
-    . L.toStrict
-    $ bs
- where
-  warnCache = lift $ $(logWarn)
     [i|Could not get download info, trying cached version (this may not be recent!)|]
+  let path = view pathL' ghcupURL
+  let yaml_file = cacheDir </> (T.unpack . decUTF8Safe . urlBaseName $ path)
+  bs        <-
+    handleIO' NoSuchThing
+              (\_ -> throwE $ FileDoesNotExistError yaml_file)
+    $ liftIO
+    $ L.readFile yaml_file
+  lE' JSONDecodeError $ first show $ Y.decodeEither' (L.toStrict bs)
 
+
+getBase :: (MonadFail m, MonadIO m, MonadCatch m, MonadLogger m)
+        => Dirs
+        -> Settings
+        -> Excepts '[JSONError , FileDoesNotExistError] m GHCupInfo
+getBase dirs@Dirs{..} Settings{ downloader }  =
+  handleIO (\_ -> readFromCache dirs)
+  $ catchE @_ @'[JSONError, FileDoesNotExistError]
+      (\(DownloadFailed _) -> readFromCache dirs)
+  (reThrowAll @_ @_ @'[JSONError, DownloadFailed] DownloadFailed (smartDl ghcupURL)
+    >>= (liftE . lE' @_ @_ @'[JSONError] JSONDecodeError . first show . Y.decodeEither' . L.toStrict))
+    where
   -- First check if the json file is in the ~/.ghcup/cache dir
   -- and check it's access time. If it has been accessed within the
   -- last 5 minutes, just reuse it.
@@ -200,11 +185,8 @@ getBase uri = do
   -- than the local file.
   --
   -- Always save the local file with the mod time of the remote file.
-  smartDl :: forall m1 env1
+  smartDl :: forall m1
-           . ( MonadReader env1 m1
+           . ( MonadCatch m1
-             , HasDirs env1
-             , HasSettings env1
-             , MonadCatch m1
              , MonadIO m1
              , MonadFail m1
              , MonadLogger m1
@@ -218,12 +200,10 @@ getBase uri = do
                 , NoLocationHeader
                 , TooManyRedirs
                 , ProcessError
-                , NoNetwork
                 ]
                m1
                L.ByteString
   smartDl uri' = do
-    Dirs{..} <- lift getDirs
     let path = view pathL' uri'
     let json_file = cacheDir </> (T.unpack . decUTF8Safe . urlBaseName $ path)
     e         <- liftIO $ doesFileExist json_file
@@ -257,11 +237,11 @@ getBase uri = do
 
    where
     dlWithMod modTime json_file = do
-      bs <- liftE $ downloadBS uri'
+      bs <- liftE $ downloadBS downloader uri'
       liftIO $ writeFileWithModTime modTime json_file bs
       pure bs
     dlWithoutMod json_file = do
-      bs <- liftE $ downloadBS uri'
+      bs <- liftE $ downloadBS downloader uri'
       liftIO $ hideError doesNotExistErrorType $ rmFile json_file
       liftIO $ L.writeFile json_file bs
       liftIO $ setModificationTime json_file (posixSecondsToUTCTime (fromIntegral @Int 0))
@@ -299,22 +279,27 @@ getBase uri = do
     setModificationTime path utctime
 
 
-getDownloadInfo :: ( MonadReader env m
+getDownloadInfo :: Tool
-                   , HasPlatformReq env
-                   , HasGHCupInfo env
-                   )
-                => Tool
                 -> Version
                 -- ^ tool version
-                -> Excepts
+                -> PlatformRequest
-                     '[NoDownload]
+                -> GHCupDownloads
-                     m
+                -> Either NoDownload DownloadInfo
-                     DownloadInfo
+getDownloadInfo t v (PlatformRequest a p mv) dls = maybe
-getDownloadInfo t v = do
+  (Left NoDownload)
-  (PlatformRequest a p mv) <- lift getPlatformReq
+  Right
-  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  (case p of
+    -- non-musl won't work on alpine
+    Linux Alpine -> with_distro <|> without_distro_ver
+    _            -> with_distro <|> without_distro_ver <|> without_distro
+  )
 
-  let distro_preview f g =
+ where
+  with_distro        = distro_preview id id
+  without_distro_ver = distro_preview id (const Nothing)
+  without_distro     = distro_preview (set _Linux UnknownLinux) (const Nothing)
+
+  distro_preview f g =
     let platformVersionSpec =
           preview (ix t % ix v % viArch % ix a % ix (f p)) dls
         mv' = g mv
@@ -327,18 +312,6 @@ getDownloadInfo t v = do
                 )
           .   M.toList
           =<< platformVersionSpec
-      with_distro        = distro_preview id id
-      without_distro_ver = distro_preview id (const Nothing)
-      without_distro     = distro_preview (set _Linux UnknownLinux) (const Nothing)
-
-  maybe
-    (throwE NoDownload)
-    pure
-    (case p of
-      -- non-musl won't work on alpine
-      Linux Alpine -> with_distro <|> without_distro_ver
-      _            -> with_distro <|> without_distro_ver <|> without_distro
-    )
 
 
 -- | Tries to download from the given http or https url
@@ -348,19 +321,17 @@ getDownloadInfo t v = do
 --   2. otherwise create a random file
 --
 -- The file must not exist.
-download :: ( MonadReader env m
+download :: ( MonadMask m
-            , HasSettings env
-            , HasDirs env
-            , MonadMask m
             , MonadThrow m
             , MonadLogger m
             , MonadIO m
             )
-         => DownloadInfo
+         => Settings
+         -> DownloadInfo
          -> FilePath          -- ^ destination dir
          -> Maybe FilePath    -- ^ optional filename
          -> Excepts '[DigestError , DownloadFailed] m FilePath
-download dli dest mfn
+download settings@Settings{ downloader } dli dest mfn
   | scheme == "https" = dl
   | scheme == "http"  = dl
   | scheme == "file"  = cp
@@ -391,8 +362,6 @@ download dli dest mfn
             liftIO (hideError doesNotExistErrorType $ rmFile destFile)
               >> (throwE . DownloadFailed $ e)
           ) $ do
-              Settings{ downloader, noNetwork } <- lift getSettings
-              when noNetwork $ throwE (DownloadFailed (V NoNetwork :: V '[NoNetwork]))
               case downloader of
                 Curl -> do
                   o' <- liftIO getCurlOpts
@@ -408,66 +377,58 @@ download dli dest mfn
                   liftE $ downloadToFile https host fullPath port destFile
 #endif
 
-    liftE $ checkDigest dli destFile
+    liftE $ checkDigest settings dli destFile
     pure destFile
 
   -- Manage to find a file we can write the body into.
   getDestFile :: FilePath
-  getDestFile = maybe (dest </> T.unpack (decUTF8Safe (urlBaseName path)))
+  getDestFile = maybe (dest </> T.unpack (decUTF8Safe (urlBaseName path))) (dest </>) mfn
-                  (dest </>)
-                  mfn
 
   path        = view (dlUri % pathL') dli
 
 
 -- | Download into tmpdir or use cached version, if it exists. If filename
 -- is omitted, infers the filename from the url.
-downloadCached :: ( MonadReader env m
+downloadCached :: ( MonadMask m
-                  , HasDirs env
-                  , HasSettings env
-                  , MonadMask m
                   , MonadResource m
                   , MonadThrow m
                   , MonadLogger m
                   , MonadIO m
                   , MonadUnliftIO m
                   )
-               => DownloadInfo
+               => Settings
+               -> Dirs
+               -> DownloadInfo
                -> Maybe FilePath  -- ^ optional filename
                -> Excepts '[DigestError , DownloadFailed] m FilePath
-downloadCached dli mfn = do
+downloadCached settings@Settings{ cache } dirs dli mfn = do
-  Settings{ cache } <- lift getSettings
   case cache of
-    True -> downloadCached' dli mfn Nothing
+    True -> downloadCached' settings dirs dli mfn
     False -> do
       tmp <- lift withGHCupTmpDir
-      liftE $ download dli tmp mfn
+      liftE $ download settings dli tmp mfn
 
 
-downloadCached' :: ( MonadReader env m
+downloadCached' :: ( MonadMask m
-                   , HasDirs env
-                   , HasSettings env
-                   , MonadMask m
                    , MonadThrow m
                    , MonadLogger m
                    , MonadIO m
                    , MonadUnliftIO m
                    )
-                => DownloadInfo
+                => Settings
+                -> Dirs
+                -> DownloadInfo
                 -> Maybe FilePath  -- ^ optional filename
-                -> Maybe FilePath  -- ^ optional destination dir (default: cacheDir)
                 -> Excepts '[DigestError , DownloadFailed] m FilePath
-downloadCached' dli mfn mDestDir = do
+downloadCached' settings Dirs{..} dli mfn = do
-  Dirs { cacheDir } <- lift getDirs
-  let destDir = fromMaybe cacheDir mDestDir
   let fn = fromMaybe ((T.unpack . decUTF8Safe) $ urlBaseName $ view (dlUri % pathL') dli) mfn
-  let cachfile = destDir </> fn
+  let cachfile = cacheDir </> fn
   fileExists <- liftIO $ doesFileExist cachfile
   if
     | fileExists -> do
-      liftE $ checkDigest dli cachfile
+      liftE $ checkDigest settings dli cachfile
       pure cachfile
-    | otherwise -> liftE $ download dli destDir mfn
+    | otherwise -> liftE $ download settings dli cacheDir mfn
 
 
 
@@ -480,13 +441,9 @@ downloadCached' dli mfn mDestDir = do
 
 
 -- | This is used for downloading the JSON.
-downloadBS :: ( MonadReader env m
+downloadBS :: (MonadCatch m, MonadIO m, MonadLogger m)
-              , HasSettings env
+           => Downloader
-              , MonadCatch m
+           -> URI
-              , MonadIO m
-              , MonadLogger m
-              )
-           => URI
            -> Excepts
                 '[ FileDoesNotExistError
                  , HTTPStatusError
@@ -495,11 +452,10 @@ downloadBS :: ( MonadReader env m
                  , NoLocationHeader
                  , TooManyRedirs
                  , ProcessError
-                 , NoNetwork
                  ]
                 m
                 L.ByteString
-downloadBS uri'
+downloadBS downloader uri'
   | scheme == "https"
   = dl True
   | scheme == "http"
@@ -519,8 +475,6 @@ downloadBS uri'
   dl _ = do
 #endif
     lift $ $(logDebug) [i|downloading: #{serializeURIRef' uri'}|]
-    Settings{ downloader, noNetwork } <- lift getSettings
-    when noNetwork $ throwE NoNetwork
     case downloader of
       Curl -> do
         o' <- liftIO getCurlOpts
@@ -545,18 +499,12 @@ downloadBS uri'
 #endif
 
 
-checkDigest :: ( MonadReader env m
+checkDigest :: (MonadIO m, MonadThrow m, MonadLogger m)
-               , HasDirs env
+            => Settings
-               , HasSettings env
+            -> DownloadInfo
-               , MonadIO m
-               , MonadThrow m
-               , MonadLogger m
-               )
-            => DownloadInfo
             -> FilePath
             -> Excepts '[DigestError] m ()
-checkDigest dli file = do
+checkDigest Settings{ noVerify } dli file = do
-  Settings{ noVerify } <- lift getSettings
   let verify = not noVerify
   when verify $ do
     let p' = takeFileName file

lib/GHCup/Errors.hs

@@ -233,13 +233,6 @@ instance Pretty NoToolVersionSet where
   pPrint (NoToolVersionSet tool) =
     text [i|No version is set for tool "#{tool}".|]
 
-data NoNetwork = NoNetwork
-  deriving Show
-
-instance Pretty NoNetwork where
-  pPrint NoNetwork =
-    text [i|A download was required or requested, but '--offline' was specified.|]
-
 
     -------------------------
     --[ High-level errors ]--

lib/GHCup/Types.hs

@@ -1,12 +1,7 @@
 {-# OPTIONS_GHC -Wno-orphans #-}
 {-# LANGUAGE CPP               #-}
-{-# LANGUAGE BangPatterns      #-}
-{-# LANGUAGE DataKinds         #-}
 {-# LANGUAGE DeriveGeneric     #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE FlexibleContexts  #-}
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE DuplicateRecordFields #-}
 
 {-|
 Module      : GHCup.Types
@@ -26,7 +21,6 @@ module GHCup.Types
   where
 
 import           Control.Applicative
-import           Control.DeepSeq                ( NFData, rnf )
 import           Control.Monad.Logger
 import           Data.Map.Strict                ( Map )
 import           Data.List.NonEmpty             ( NonEmpty (..) )
@@ -66,8 +60,6 @@ data GHCupInfo = GHCupInfo
   }
   deriving (Show, GHC.Generic)
 
-instance NFData GHCupInfo
-
 
 
     -------------------------
@@ -87,8 +79,6 @@ data Requirements = Requirements
   }
   deriving (Show, GHC.Generic)
 
-instance NFData Requirements
-
 
 
 
@@ -115,13 +105,9 @@ data Tool = GHC
           | Stack
   deriving (Eq, GHC.Generic, Ord, Show, Enum, Bounded)
 
-instance NFData Tool
-
 data GlobalTool = ShimGen
   deriving (Eq, GHC.Generic, Ord, Show, Enum, Bounded)
 
-instance NFData GlobalTool
-
 
 -- | All necessary information of a tool version, including
 -- source download and per-architecture downloads.
@@ -137,8 +123,6 @@ data VersionInfo = VersionInfo
   }
   deriving (Eq, GHC.Generic, Show)
 
-instance NFData VersionInfo
-
 
 -- | A tag. These are currently attached to a version of a tool.
 data Tag = Latest
@@ -149,8 +133,6 @@ data Tag = Latest
          | UnknownTag String  -- ^ used for upwardscompat
          deriving (Ord, Eq, GHC.Generic, Show) -- FIXME: manual JSON instance
 
-instance NFData Tag
-
 tagToString :: Tag -> String
 tagToString Recommended        = "recommended"
 tagToString Latest             = "latest"
@@ -177,8 +159,6 @@ data Architecture = A_64
                   | A_ARM64
   deriving (Eq, GHC.Generic, Ord, Show)
 
-instance NFData Architecture
-
 archToString :: Architecture -> String
 archToString A_64 = "x86_64"
 archToString A_32 = "i386"
@@ -201,8 +181,6 @@ data Platform = Linux LinuxDistro
               -- ^ must exit
   deriving (Eq, GHC.Generic, Ord, Show)
 
-instance NFData Platform
-
 platformToString :: Platform -> String
 platformToString (Linux distro) = "linux-" ++ distroToString distro
 platformToString Darwin = "darwin"
@@ -228,8 +206,6 @@ data LinuxDistro = Debian
                  -- ^ must exit
   deriving (Eq, GHC.Generic, Ord, Show)
 
-instance NFData LinuxDistro
-
 distroToString :: LinuxDistro -> String
 distroToString Debian = "debian"
 distroToString Ubuntu = "ubuntu"
@@ -256,7 +232,6 @@ data DownloadInfo = DownloadInfo
   }
   deriving (Eq, Ord, GHC.Generic, Show)
 
-instance NFData DownloadInfo
 
 
 
@@ -270,8 +245,6 @@ data TarDir = RealDir FilePath
             | RegexDir String     -- ^ will be compiled to regex, the first match will "win"
             deriving (Eq, Ord, GHC.Generic, Show)
 
-instance NFData TarDir
-
 instance Pretty TarDir where
   pPrint (RealDir path) = text path
   pPrint (RegexDir regex) = text regex
@@ -284,10 +257,6 @@ data URLSource = GHCupURL
                | AddSource (Either GHCupInfo URI) -- ^ merge with GHCupURL
                deriving (GHC.Generic, Show)
 
-instance NFData URLSource
-instance NFData (URIRef Absolute) where
-  rnf (URI !_ !_ !_ !_ !_) = ()
-
 
 data UserSettings = UserSettings
   { uCache       :: Maybe Bool
@@ -297,12 +266,11 @@ data UserSettings = UserSettings
   , uDownloader  :: Maybe Downloader
   , uKeyBindings :: Maybe UserKeyBindings
   , uUrlSource   :: Maybe URLSource
-  , uNoNetwork   :: Maybe Bool
   }
   deriving (Show, GHC.Generic)
 
 defaultUserSettings :: UserSettings
-defaultUserSettings = UserSettings Nothing Nothing Nothing Nothing Nothing Nothing Nothing Nothing
+defaultUserSettings = UserSettings Nothing Nothing Nothing Nothing Nothing Nothing Nothing
 
 data UserKeyBindings = UserKeyBindings
   { kUp        :: Maybe Key
@@ -330,9 +298,6 @@ data KeyBindings = KeyBindings
   }
   deriving (Show, GHC.Generic)
 
-instance NFData KeyBindings
-instance NFData Key
-
 defaultKeyBindings :: KeyBindings
 defaultKeyBindings = KeyBindings
   { bUp = KUp
@@ -352,18 +317,7 @@ data AppState = AppState
   , keyBindings :: KeyBindings
   , ghcupInfo :: GHCupInfo
   , pfreq :: PlatformRequest
-  } deriving (Show, GHC.Generic)
+  } deriving (Show)
-
-instance NFData AppState
-
-data LeanAppState = LeanAppState
-  { settings :: Settings
-  , dirs :: Dirs
-  , keyBindings :: KeyBindings
-  } deriving (Show, GHC.Generic)
-
-instance NFData LeanAppState
-
 
 data Settings = Settings
   { cache      :: Bool
@@ -372,39 +326,29 @@ data Settings = Settings
   , downloader :: Downloader
   , verbose    :: Bool
   , urlSource  :: URLSource
-  , noNetwork  :: Bool
   }
   deriving (Show, GHC.Generic)
 
-instance NFData Settings
-
 data Dirs = Dirs
   { baseDir  :: FilePath
   , binDir   :: FilePath
   , cacheDir :: FilePath
   , logsDir  :: FilePath
   , confDir  :: FilePath
-  , tmpDir   :: FilePath
   }
-  deriving (Show, GHC.Generic)
+  deriving Show
-
-instance NFData Dirs
 
 data KeepDirs = Always
               | Errors
               | Never
-  deriving (Eq, Show, Ord, GHC.Generic)
+  deriving (Eq, Show, Ord)
-
-instance NFData KeepDirs
 
 data Downloader = Curl
                 | Wget
 #if defined(INTERNAL_DOWNLOADER)
                 | Internal
 #endif
-  deriving (Eq, Show, Ord, GHC.Generic)
+  deriving (Eq, Show, Ord)
-
-instance NFData Downloader
 
 data DebugInfo = DebugInfo
   { diBaseDir  :: FilePath
@@ -427,9 +371,7 @@ data PlatformResult = PlatformResult
   { _platform      :: Platform
   , _distroVersion :: Maybe Versioning
   }
-  deriving (Eq, Show, GHC.Generic)
+  deriving (Eq, Show)
-
-instance NFData PlatformResult
 
 platResToString :: PlatformResult -> String
 platResToString PlatformResult { _platform = plat, _distroVersion = Just v' }
@@ -445,9 +387,7 @@ data PlatformRequest = PlatformRequest
   , _rPlatform :: Platform
   , _rVersion  :: Maybe Versioning
   }
-  deriving (Eq, Show, GHC.Generic)
+  deriving (Eq, Show)
-
-instance NFData PlatformRequest
 
 pfReqToString :: PlatformRequest -> String
 pfReqToString (PlatformRequest arch plat ver) =
@@ -494,8 +434,6 @@ data VersionCmp = VR_gt Versioning
                 | VR_eq Versioning
   deriving (Eq, GHC.Generic, Ord, Show)
 
-instance NFData VersionCmp
-
 
 -- | A version range. Supports && and ||, but not  arbitrary
 -- combinations. This is a little simplified.
@@ -503,7 +441,6 @@ data VersionRange = SimpleRange (NonEmpty VersionCmp) -- And
                   | OrRange (NonEmpty VersionCmp) VersionRange
   deriving (Eq, GHC.Generic, Ord, Show)
 
-instance NFData VersionRange
 
 instance Pretty Versioning where
   pPrint = text . T.unpack . prettyV
@@ -522,3 +459,4 @@ instance (Monad m, Alternative m) => Alternative (LoggingT m) where
 instance MonadLogger m => MonadLogger (Excepts e m) where
   monadLoggerLog a b c d = Trans.lift $ monadLoggerLog a b c d
 
+

lib/GHCup/Types/Optics.hs

@@ -1,9 +1,4 @@
 {-# LANGUAGE TemplateHaskell #-}
-{-# LANGUAGE ConstraintKinds       #-}
-{-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE AllowAmbiguousTypes   #-}
 
 {-|
 Module      : GHCup.Types.Optics
@@ -18,7 +13,6 @@ module GHCup.Types.Optics where
 
 import           GHCup.Types
 
-import           Control.Monad.Reader
 import           Data.ByteString                ( ByteString )
 import           Optics
 import           URI.ByteString
@@ -64,82 +58,3 @@ pathL' = lensVL pathL
 
 queryL' :: Lens' (URIRef a) Query
 queryL' = lensVL queryL
-
-
-
-    ----------------------
-    --[ Lens utilities ]--
-    ----------------------
-
-
-gets :: forall f a env m . (MonadReader env m, LabelOptic' f A_Lens env a)
-     => m a
-gets = asks (^. labelOptic @f)
-
-
-getAppState :: MonadReader AppState m => m AppState
-getAppState = ask
-
-
-getLeanAppState :: ( MonadReader env m
-                   , LabelOptic' "settings"    A_Lens env Settings
-                   , LabelOptic' "dirs"        A_Lens env Dirs
-                   , LabelOptic' "keyBindings" A_Lens env KeyBindings
-                   )
-                => m LeanAppState
-getLeanAppState = do
-  s <- gets @"settings"
-  d <- gets @"dirs"
-  k <- gets @"keyBindings"
-  pure (LeanAppState s d k)
-
-
-getSettings :: ( MonadReader env m
-               , LabelOptic' "settings" A_Lens env Settings
-               )
-            => m Settings
-getSettings = gets @"settings"
-
-
-getDirs :: ( MonadReader env m
-           , LabelOptic' "dirs" A_Lens env Dirs
-           )
-        => m Dirs
-getDirs = gets @"dirs"
-
-
-getKeyBindings :: ( MonadReader env m
-                  , LabelOptic' "keyBindings" A_Lens env KeyBindings
-                  )
-               => m KeyBindings
-getKeyBindings = gets @"keyBindings"
-
-
-getGHCupInfo :: ( MonadReader env m
-                , LabelOptic' "ghcupInfo" A_Lens env GHCupInfo
-                )
-             => m GHCupInfo
-getGHCupInfo = gets @"ghcupInfo"
-
-
-getPlatformReq :: ( MonadReader env m
-                  , LabelOptic' "pfreq" A_Lens env PlatformRequest
-                  )
-               => m PlatformRequest
-getPlatformReq = gets @"pfreq"
-
-
-type HasSettings env = (LabelOptic' "settings" A_Lens env Settings)
-type HasDirs env = (LabelOptic' "dirs" A_Lens env Dirs)
-type HasKeyBindings env = (LabelOptic' "keyBindings" A_Lens env KeyBindings)
-type HasGHCupInfo env = (LabelOptic' "ghcupInfo" A_Lens env GHCupInfo)
-type HasPlatformReq env = (LabelOptic' "pfreq" A_Lens env PlatformRequest)
-
-
-getCache :: (MonadReader env m, HasSettings env) => m Bool
-getCache = getSettings <&> cache
-
-
-getDownloader :: (MonadReader env m, HasSettings env) => m Downloader
-getDownloader = getSettings <&> downloader
-

lib/GHCup/Utils.hs

@@ -103,30 +103,28 @@ import qualified Text.Megaparsec               as MP
 
 
 -- | The symlink destination of a ghc tool.
-ghcLinkDestination :: ( MonadReader env m
+ghcLinkDestination :: (MonadReader AppState m, MonadThrow m, MonadIO m)
-                      , HasDirs env
-                      , MonadThrow m, MonadIO m)
                    => FilePath -- ^ the tool, such as 'ghc', 'haddock' etc.
                    -> GHCTargetVersion
                    -> m FilePath
 ghcLinkDestination tool ver = do
-  Dirs {..}  <- getDirs
+  AppState { dirs = Dirs {..} } <- ask
   ghcd <- ghcupGHCDir ver
   pure (relativeSymlink binDir (ghcd </> "bin" </> tool))
 
 
 -- | Removes the minor GHC symlinks, e.g. ghc-8.6.5.
-rmMinorSymlinks :: ( MonadReader env m
+rmMinorSymlinks :: ( MonadReader AppState m
-                   , HasDirs env
                    , MonadIO m
                    , MonadLogger m
                    , MonadThrow m
                    , MonadFail m
+                   , MonadReader AppState m
                    )
                 => GHCTargetVersion
                 -> Excepts '[NotInstalled] m ()
 rmMinorSymlinks tv@GHCTargetVersion{..} = do
-  Dirs {..}  <- lift getDirs
+  AppState { dirs = Dirs {..} } <- lift ask
 
   files                         <- liftE $ ghcToolFiles tv
   forM_ files $ \f -> do
@@ -137,8 +135,7 @@ rmMinorSymlinks tv@GHCTargetVersion{..} = do
 
 
 -- | Removes the set ghc version for the given target, if any.
-rmPlain :: ( MonadReader env m
+rmPlain :: ( MonadReader AppState m
-           , HasDirs env
            , MonadLogger m
            , MonadThrow m
            , MonadFail m
@@ -147,7 +144,7 @@ rmPlain :: ( MonadReader env m
         => Maybe Text -- ^ target
         -> Excepts '[NotInstalled] m ()
 rmPlain target = do
-  Dirs {..}  <- lift getDirs
+  AppState { dirs = Dirs {..} } <- lift ask
   mtv                           <- lift $ ghcSet target
   forM_ mtv $ \tv -> do
     files <- liftE $ ghcToolFiles tv
@@ -162,17 +159,17 @@ rmPlain target = do
 
 
 -- | Remove the major GHC symlink, e.g. ghc-8.6.
-rmMajorSymlinks :: ( MonadReader env m
+rmMajorSymlinks :: ( MonadReader AppState m
-                   , HasDirs env
                    , MonadIO m
                    , MonadLogger m
                    , MonadThrow m
                    , MonadFail m
+                   , MonadReader AppState m
                    )
                 => GHCTargetVersion
                 -> Excepts '[NotInstalled] m ()
 rmMajorSymlinks tv@GHCTargetVersion{..} = do
-  Dirs {..}  <- lift getDirs
+  AppState { dirs = Dirs {..} } <- lift ask
   (mj, mi) <- getMajorMinorV _tvVersion
   let v' = intToText mj <> "." <> intToText mi
 
@@ -192,26 +189,26 @@ rmMajorSymlinks tv@GHCTargetVersion{..} = do
 
 
 -- | Whether the given GHC versin is installed.
-ghcInstalled :: (MonadIO m, MonadReader env m, HasDirs env, MonadThrow m) => GHCTargetVersion -> m Bool
+ghcInstalled :: (MonadIO m, MonadReader AppState m, MonadThrow m) => GHCTargetVersion -> m Bool
 ghcInstalled ver = do
   ghcdir <- ghcupGHCDir ver
   liftIO $ doesDirectoryExist ghcdir
 
 
 -- | Whether the given GHC version is installed from source.
-ghcSrcInstalled :: (MonadIO m, MonadReader env m, HasDirs env, MonadThrow m) => GHCTargetVersion -> m Bool
+ghcSrcInstalled :: (MonadIO m, MonadReader AppState m, MonadThrow m) => GHCTargetVersion -> m Bool
 ghcSrcInstalled ver = do
   ghcdir <- ghcupGHCDir ver
   liftIO $ doesFileExist (ghcdir </> ghcUpSrcBuiltFile)
 
 
 -- | Whether the given GHC version is set as the current.
-ghcSet :: (MonadReader env m, HasDirs env, MonadThrow m, MonadIO m)
+ghcSet :: (MonadReader AppState m, MonadThrow m, MonadIO m)
        => Maybe Text   -- ^ the target of the GHC version, if any
                        --  (e.g. armv7-unknown-linux-gnueabihf)
        -> m (Maybe GHCTargetVersion)
 ghcSet mtarget = do
-  Dirs {..}  <- getDirs
+  AppState {dirs = Dirs {..}} <- ask
   let ghc = maybe "ghc" (\t -> T.unpack t <> "-ghc") mtarget
   let ghcBin = binDir </> ghc <> exeExt
 
@@ -242,7 +239,7 @@ ghcSet mtarget = do
 
 -- | Get all installed GHCs by reading ~/.ghcup/ghc/<dir>.
 -- If a dir cannot be parsed, returns left.
-getInstalledGHCs :: (MonadReader env m, HasDirs env, MonadIO m) => m [Either FilePath GHCTargetVersion]
+getInstalledGHCs :: (MonadReader AppState m, MonadIO m) => m [Either FilePath GHCTargetVersion]
 getInstalledGHCs = do
   ghcdir <- ghcupGHCBaseDir
   fs     <- liftIO $ hideErrorDef [NoSuchThing] [] $ listDirectory ghcdir
@@ -252,15 +249,10 @@ getInstalledGHCs = do
 
 
 -- | Get all installed cabals, by matching on @~\/.ghcup\/bin/cabal-*@.
-getInstalledCabals :: ( MonadLogger m
+getInstalledCabals :: (MonadLogger m, MonadReader AppState m, MonadIO m, MonadCatch m)
-                      , MonadReader env m
-                      , HasDirs env
-                      , MonadIO m
-                      , MonadCatch m
-                      )
                    => m [Either FilePath Version]
 getInstalledCabals = do
-  Dirs {..} <- getDirs
+  AppState {dirs = Dirs {..}} <- ask
   bins   <- liftIO $ handleIO (\_ -> pure []) $ findFiles
     binDir
     (makeRegexOpts compExtended execBlank ([s|^cabal-.*$|] :: ByteString))
@@ -272,16 +264,16 @@ getInstalledCabals = do
 
 
 -- | Whether the given cabal version is installed.
-cabalInstalled :: (MonadLogger m, MonadIO m, MonadReader env m, HasDirs env, MonadCatch m) => Version -> m Bool
+cabalInstalled :: (MonadLogger m, MonadIO m, MonadReader AppState m, MonadCatch m) => Version -> m Bool
 cabalInstalled ver = do
   vers <- fmap rights getInstalledCabals
   pure $ elem ver vers
 
 
 -- Return the currently set cabal version, if any.
-cabalSet :: (MonadLogger m, MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
+cabalSet :: (MonadLogger m, MonadReader AppState m, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
 cabalSet = do
-  Dirs {..}  <- getDirs
+  AppState {dirs = Dirs {..}} <- ask
   let cabalbin = binDir </> "cabal" <> exeExt
 
   handleIO' NoSuchThing (\_ -> pure Nothing) $ do
@@ -325,10 +317,10 @@ cabalSet = do
 
 -- | Get all installed hls, by matching on
 -- @~\/.ghcup\/bin/haskell-language-server-wrapper-<\hlsver\>@.
-getInstalledHLSs :: (MonadReader env m, HasDirs env, MonadIO m, MonadCatch m)
+getInstalledHLSs :: (MonadReader AppState m, MonadIO m, MonadCatch m)
                  => m [Either FilePath Version]
 getInstalledHLSs = do
-  Dirs {..}  <- getDirs
+  AppState { dirs = Dirs {..} } <- ask
   bins                          <- liftIO $ handleIO (\_ -> pure []) $ findFiles
     binDir
     (makeRegexOpts compExtended
@@ -345,10 +337,10 @@ getInstalledHLSs = do
 
 -- | Get all installed stacks, by matching on
 -- @~\/.ghcup\/bin/stack-<\stackver\>@.
-getInstalledStacks :: (MonadReader env m, HasDirs env, MonadIO m, MonadCatch m)
+getInstalledStacks :: (MonadReader AppState m, MonadIO m, MonadCatch m)
                    => m [Either FilePath Version]
 getInstalledStacks = do
-  Dirs {..}  <- getDirs
+  AppState { dirs = Dirs {..} } <- ask
   bins                          <- liftIO $ handleIO (\_ -> pure []) $ findFiles
     binDir
     (makeRegexOpts compExtended
@@ -363,9 +355,9 @@ getInstalledStacks = do
 
 -- Return the currently set stack version, if any.
 -- TODO: there's a lot of code duplication here :>
-stackSet :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadCatch m, MonadLogger m) => m (Maybe Version)
+stackSet :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadCatch m, MonadLogger m) => m (Maybe Version)
 stackSet = do
-  Dirs {..}  <- getDirs
+  AppState {dirs = Dirs {..}} <- ask
   let stackBin = binDir </> "stack" <> exeExt
 
   handleIO' NoSuchThing (\_ -> pure Nothing) $ do
@@ -403,13 +395,13 @@ stackSet = do
     stripRelativePath = MP.many (MP.try stripPathComponet)
 
 -- | Whether the given Stack version is installed.
-stackInstalled :: (MonadIO m, MonadReader env m, HasDirs env, MonadCatch m) => Version -> m Bool
+stackInstalled :: (MonadIO m, MonadReader AppState m, MonadCatch m) => Version -> m Bool
 stackInstalled ver = do
   vers <- fmap rights getInstalledStacks
   pure $ elem ver vers
 
 -- | Whether the given HLS version is installed.
-hlsInstalled :: (MonadIO m, MonadReader env m, HasDirs env, MonadCatch m) => Version -> m Bool
+hlsInstalled :: (MonadIO m, MonadReader AppState m, MonadCatch m) => Version -> m Bool
 hlsInstalled ver = do
   vers <- fmap rights getInstalledHLSs
   pure $ elem ver vers
@@ -417,9 +409,9 @@ hlsInstalled ver = do
 
 
 -- Return the currently set hls version, if any.
-hlsSet :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
+hlsSet :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
 hlsSet = do
-  Dirs {..}  <- getDirs
+  AppState {dirs = Dirs {..}} <- ask
   let hlsBin = binDir </> "haskell-language-server-wrapper" <> exeExt
 
   liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ do
@@ -451,8 +443,7 @@ hlsSet = do
 
 
 -- | Return the GHC versions the currently selected HLS supports.
-hlsGHCVersions :: ( MonadReader env m
+hlsGHCVersions :: ( MonadReader AppState m
-                  , HasDirs env
                   , MonadIO m
                   , MonadThrow m
                   , MonadCatch m
@@ -475,11 +466,11 @@ hlsGHCVersions = do
 
 
 -- | Get all server binaries for an hls version, if any.
-hlsServerBinaries :: (MonadReader env m, HasDirs env, MonadIO m)
+hlsServerBinaries :: (MonadReader AppState m, MonadIO m)
                   => Version
                   -> m [FilePath]
 hlsServerBinaries ver = do
-  Dirs {..}  <- getDirs
+  AppState { dirs = Dirs {..} } <- ask
   liftIO $ handleIO (\_ -> pure []) $ findFiles
     binDir
     (makeRegexOpts
@@ -491,11 +482,11 @@ hlsServerBinaries ver = do
 
 
 -- | Get the wrapper binary for an hls version, if any.
-hlsWrapperBinary :: (MonadReader env m, HasDirs env, MonadThrow m, MonadIO m)
+hlsWrapperBinary :: (MonadReader AppState m, MonadThrow m, MonadIO m)
                  => Version
                  -> m (Maybe FilePath)
 hlsWrapperBinary ver = do
-  Dirs {..}  <- getDirs
+  AppState { dirs = Dirs {..} } <- ask
   wrapper                       <- liftIO $ handleIO (\_ -> pure []) $ findFiles
     binDir
     (makeRegexOpts
@@ -512,7 +503,7 @@ hlsWrapperBinary ver = do
 
 
 -- | Get all binaries for an hls version, if any.
-hlsAllBinaries :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m) => Version -> m [FilePath]
+hlsAllBinaries :: (MonadReader AppState m, MonadIO m, MonadThrow m) => Version -> m [FilePath]
 hlsAllBinaries ver = do
   hls     <- hlsServerBinaries ver
   wrapper <- hlsWrapperBinary ver
@@ -520,9 +511,9 @@ hlsAllBinaries ver = do
 
 
 -- | Get the active symlinks for hls.
-hlsSymlinks :: (MonadReader env m, HasDirs env, MonadIO m, MonadCatch m) => m [FilePath]
+hlsSymlinks :: (MonadReader AppState m, MonadIO m, MonadCatch m) => m [FilePath]
 hlsSymlinks = do
-  Dirs {..}  <- getDirs
+  AppState { dirs = Dirs {..} } <- ask
   oldSyms                       <- liftIO $ handleIO (\_ -> pure []) $ findFiles
     binDir
     (makeRegexOpts compExtended
@@ -558,7 +549,7 @@ matchMajor v' major' minor' = case getMajorMinorV v' of
 
 -- | Get the latest installed full GHC version that satisfies X.Y.
 -- This reads `ghcupGHCBaseDir`.
-getGHCForMajor :: (MonadReader env m, HasDirs env, MonadIO m, MonadThrow m)
+getGHCForMajor :: (MonadReader AppState m, MonadIO m, MonadThrow m)
                => Int        -- ^ major version component
                -> Int        -- ^ minor version component
                -> Maybe Text -- ^ the target triple
@@ -738,6 +729,19 @@ getLatestBaseVersion av pvpVer =
 
 
 
+    -----------------------
+    --[ AppState Getter ]--
+    -----------------------
+
+
+getCache :: MonadReader AppState m => m Bool
+getCache = ask <&> cache . settings
+
+
+getDownloader :: MonadReader AppState m => m Downloader
+getDownloader = ask <&> downloader . settings
+
+
 
     -------------
     --[ Other ]--
@@ -750,7 +754,7 @@ getLatestBaseVersion av pvpVer =
 -- Returns unversioned relative files without extension, e.g.:
 --
 --   - @["hsc2hs","haddock","hpc","runhaskell","ghc","ghc-pkg","ghci","runghc","hp2ps"]@
-ghcToolFiles :: (MonadReader env m, HasDirs env, MonadThrow m, MonadFail m, MonadIO m)
+ghcToolFiles :: (MonadReader AppState m, MonadThrow m, MonadFail m, MonadIO m)
              => GHCTargetVersion
              -> Excepts '[NotInstalled] m [FilePath]
 ghcToolFiles ver = do
@@ -761,49 +765,22 @@ ghcToolFiles ver = do
   whenM (fmap not $ liftIO $ doesDirectoryExist ghcdir)
         (throwE (NotInstalled GHC ver))
 
-  files    <- liftIO $ listDirectory bindir
+  files <- liftIO (listDirectory bindir >>= filterM (doesFileExist . (bindir </>)))
-  -- figure out the <ver> suffix, because this might not be `Version` for
+  pure (getUniqueTools . groupToolFiles . fmap (dropSuffix exeExt) $ files)
-  -- alpha/rc releases, but x.y.a.somedate.
 
-  ghcIsHadrian    <- liftIO $ isHadrian bindir
-  onlyUnversioned <- case ghcIsHadrian of
-    Right () -> pure id
-    Left (fmap (dropSuffix exeExt) -> [ghc, ghc_ver])
-      | (Just symver) <- stripPrefix (ghc <> "-") ghc_ver
-      , not (null symver) -> pure $ filter (\x -> not $ symver `isInfixOf` x)
-    _ -> fail "Fatal: Could not find internal GHC version"
-
-  pure $ onlyUnversioned $ fmap (dropSuffix exeExt) files
  where
-  isNotAnyInfix xs t = foldr (\a b -> not (a `isInfixOf` t) && b) True xs
-    -- GHC is moving some builds to Hadrian for bindists,
-    -- which doesn't create versioned binaries.
-    -- https://gitlab.haskell.org/haskell/ghcup-hs/issues/31
-  isHadrian :: FilePath -- ^ ghcbin path
-            -> IO (Either [String] ()) -- ^ Right for Hadrian
-  isHadrian dir = do
-    -- Non-hadrian has e.g. ["ghc", "ghc-8.10.4"]
-    -- which also requires us to discover the internal version
-    -- to filter the correct tool files.
-    -- We can't use the symlink on windows, so we fall back to some
-    -- more complicated logic.
-    fs <- fmap
-         -- regex over-matches
-         (filter (isNotAnyInfix ["haddock", "ghc-pkg", "ghci"]))
-       $ liftIO $ findFiles
-      dir
-      (makeRegexOpts compExtended
-                     execBlank
-                     -- for cross, this won't be "ghc", but e.g.
-                     -- "armv7-unknown-linux-gnueabihf-ghc"
-                     ([s|^([a-zA-Z0-9_-]*[a-zA-Z0-9_]-)?ghc.*$|] :: ByteString)
-      )
-    if | length fs == 1 -> pure $ Right ()        -- hadrian
-       | length fs == 2 -> pure $ Left
-                              (sortOn length fs)  -- legacy make, result should
-                                                  -- be ["ghc", "ghc-8.10.4"]
-       | otherwise      -> fail "isHadrian failed!"
 
+  groupToolFiles :: [FilePath] -> [[(FilePath, String)]]
+  groupToolFiles = groupBy (\(a, _) (b, _) -> a == b) . fmap (splitOnPVP "-")
+
+  getUniqueTools :: [[(FilePath, String)]] -> [String]
+  getUniqueTools = filter (isNotAnyInfix blackListedTools) . nub . fmap fst . filter ((== "") . snd) . concat
+
+  blackListedTools :: [String]
+  blackListedTools = ["haddock-ghc"]
+
+  isNotAnyInfix :: [String] -> String -> Bool
+  isNotAnyInfix xs t = foldr (\a b -> not (a `isInfixOf` t) && b) True xs
 
 
 -- | This file, when residing in @~\/.ghcup\/ghc\/\<ver\>\/@ signals that
@@ -813,12 +790,7 @@ ghcUpSrcBuiltFile = ".ghcup_src_built"
 
 
 -- | Calls gmake if it exists in PATH, otherwise make.
-make :: ( MonadThrow m
+make :: (MonadThrow m, MonadIO m, MonadReader AppState m)
-        , MonadIO m
-        , MonadReader env m
-        , HasDirs env
-        , HasSettings env
-        )
      => [String]
      -> Maybe FilePath
      -> m (Either ProcessError ())
@@ -828,7 +800,7 @@ make args workdir = do
   let mymake = if has_gmake then "gmake" else "make"
   execLogged mymake args workdir "ghc-make" Nothing
 
-makeOut :: (MonadReader env m, HasDirs env, MonadIO m)
+makeOut :: (MonadReader AppState m, MonadIO m)
         => [String]
         -> Maybe FilePath
         -> m CapturedProcess
@@ -841,7 +813,7 @@ makeOut args workdir = do
 
 -- | Try to apply patches in order. Fails with 'PatchFailed'
 -- on first failure.
-applyPatches :: (MonadReader env m, HasDirs env, MonadLogger m, MonadIO m)
+applyPatches :: (MonadReader AppState m, MonadLogger m, MonadIO m)
              => FilePath   -- ^ dir containing patches
              -> FilePath   -- ^ dir to apply patches in
              -> Excepts '[PatchFailed] m ()
@@ -859,7 +831,7 @@ applyPatches pdir ddir = do
 
 
 -- | https://gitlab.haskell.org/ghc/ghc/-/issues/17353
-darwinNotarization :: (MonadReader env m, HasDirs env, MonadIO m)
+darwinNotarization :: (MonadReader AppState m, MonadIO m)
                    => Platform
                    -> FilePath
                    -> m (Either ProcessError ())
@@ -882,13 +854,13 @@ getChangeLog dls tool (Right tag) =
 --
 --   1. the build directory, depending on the KeepDirs setting
 --   2. the install destination, depending on whether the build failed
-runBuildAction :: (Show (V e), MonadReader env m, HasDirs env, HasSettings env, MonadIO m, MonadMask m)
+runBuildAction :: (Show (V e), MonadReader AppState m, MonadIO m, MonadMask m)
                => FilePath          -- ^ build directory (cleaned up depending on Settings)
                -> Maybe FilePath  -- ^ dir to *always* clean up on exception
                -> Excepts e m a
                -> Excepts '[BuildFailed] m a
 runBuildAction bdir instdir action = do
-  Settings {..} <- lift getSettings
+  AppState { settings = Settings {..} } <- lift ask
   let exAction = do
         forM_ instdir $ \dir ->
           liftIO $ hideError doesNotExistErrorType $ rmPath dir
@@ -1017,8 +989,7 @@ createLink :: ( MonadMask m
               , MonadThrow m
               , MonadLogger m
               , MonadIO m
-              , MonadReader env m
+              , MonadReader AppState m
-              , HasDirs env
               , MonadUnliftIO m
               , MonadFail m
               )
@@ -1027,7 +998,7 @@ createLink :: ( MonadMask m
            -> m ()
 createLink link exe = do
 #if defined(IS_WINDOWS)
-  dirs <- getDirs
+  AppState { dirs } <- ask
   let shimGen = cacheDir dirs </> "gs.exe"
 
   let shim = dropExtension exe <.> "shim"
@@ -1056,22 +1027,17 @@ ensureGlobalTools :: ( MonadMask m
                      , MonadThrow m
                      , MonadLogger m
                      , MonadIO m
-                     , MonadReader env m
+                     , MonadReader AppState m
-                     , HasDirs env
-                     , HasSettings env
-                     , HasGHCupInfo env
                      , MonadUnliftIO m
                      , MonadFail m
                      )
                   => Excepts '[DigestError , DownloadFailed, NoDownload] m ()
 ensureGlobalTools = do
 #if defined(IS_WINDOWS)
-  (GHCupInfo _ _ gTools) <- lift getGHCupInfo
+  AppState { ghcupInfo = GHCupInfo _ _ gTools, settings, dirs } <- lift ask
-  settings <- lift getSettings
-  dirs <- lift getDirs
   shimDownload <- liftE $ lE @_ @'[NoDownload]
     $ maybe (Left NoDownload) Right $ Map.lookup ShimGen gTools
-  let dl = downloadCached' shimDownload (Just "gs.exe") Nothing
+  let dl = downloadCached' settings dirs shimDownload (Just "gs.exe")
   void $ (\(DigestError _ _) -> do
       lift $ $(logWarn) [i|Digest doesn't match, redownloading gs.exe...|]
       lift $ $(logDebug) [i|rm -f #{shimDownload}|]
@@ -1086,25 +1052,17 @@ ensureGlobalTools = do
 
 -- | Ensure ghcup directory structure exists.
 ensureDirectories :: Dirs -> IO ()
-ensureDirectories (Dirs baseDir binDir cacheDir logsDir confDir tmpDir) = do
+ensureDirectories dirs = do
+  let Dirs
+        { baseDir
+        , binDir
+        , cacheDir
+        , logsDir
+        , confDir
+        } = dirs
   createDirRecursive' baseDir
-  createDirRecursive' (baseDir </> "ghc")
   createDirRecursive' binDir
   createDirRecursive' cacheDir
   createDirRecursive' logsDir
   createDirRecursive' confDir
-  createDirRecursive' tmpDir
   pure ()
-
-
--- | For ghc without arch triple, this is:
---
---    - ghc-<ver> (e.g. ghc-8.10.4)
---
--- For ghc with arch triple:
---
---    - <triple>-ghc-<ver> (e.g. arm-linux-gnueabihf-ghc-8.10.4)
-ghcBinaryName :: GHCTargetVersion -> String
-ghcBinaryName (GHCTargetVersion (Just t) v') = T.unpack (t <> "-ghc-" <> prettyVer v' <> T.pack exeExt)
-ghcBinaryName (GHCTargetVersion Nothing  v') = T.unpack ("ghc-" <> prettyVer v' <> T.pack exeExt)
-

lib/GHCup/Utils/Dirs.hs

@@ -16,7 +16,7 @@ Stability   : experimental
 Portability : portable
 -}
 module GHCup.Utils.Dirs
-  ( getAllDirs
+  ( getDirs
   , ghcupBaseDir
   , ghcupConfigFile
   , ghcupCacheDir
@@ -37,7 +37,6 @@ where
 import           GHCup.Errors
 import           GHCup.Types
 import           GHCup.Types.JSON               ( )
-import           GHCup.Types.Optics
 import           GHCup.Utils.MegaParsec
 import           GHCup.Utils.Prelude
 
@@ -191,23 +190,13 @@ ghcupLogsDir = do
 #endif
 
 
--- | Defaults to '~/.ghcup/tmp.
+getDirs :: IO Dirs
---
+getDirs = do
--- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
--- then uses 'XDG_DATA_HOME/ghcup/tmp' as per xdg spec.
-ghcupTmpDir :: IO FilePath
-ghcupTmpDir = ghcupBaseDir <&> (</> "tmp")
-
-
-
-getAllDirs :: IO Dirs
-getAllDirs = do
   baseDir  <- ghcupBaseDir
   binDir   <- ghcupBinDir
   cacheDir <- ghcupCacheDir
   logsDir  <- ghcupLogsDir
   confDir  <- ghcupConfigDir
-  tmpDir   <- ghcupTmpDir
   pure Dirs { .. }
 
 
@@ -237,9 +226,9 @@ ghcupConfigFile = do
 
 
 -- | ~/.ghcup/ghc by default.
-ghcupGHCBaseDir :: (MonadReader env m, HasDirs env) => m FilePath
+ghcupGHCBaseDir :: (MonadReader AppState m) => m FilePath
 ghcupGHCBaseDir = do
-  Dirs {..}  <- getDirs
+  AppState { dirs = Dirs {..} } <- ask
   pure (baseDir </> "ghc")
 
 
@@ -247,7 +236,7 @@ ghcupGHCBaseDir = do
 -- The dir may be of the form
 --   * armv7-unknown-linux-gnueabihf-8.8.3
 --   * 8.8.4
-ghcupGHCDir :: (MonadReader env m, HasDirs env, MonadThrow m)
+ghcupGHCDir :: (MonadReader AppState m, MonadThrow m)
             => GHCTargetVersion
             -> m FilePath
 ghcupGHCDir ver = do

lib/GHCup/Utils/File/Posix.hs

@@ -21,7 +21,6 @@ module GHCup.Utils.File.Posix where
 import           GHCup.Utils.File.Common
 import           GHCup.Utils.Prelude
 import           GHCup.Types
-import           GHCup.Types.Optics
 
 import           Control.Concurrent
 import           Control.Concurrent.Async
@@ -75,11 +74,7 @@ executeOut path args chdir = liftIO $ captureOutStreams $ do
   SPP.executeFile path True args Nothing
 
 
-execLogged :: ( MonadReader env m
+execLogged :: (MonadReader AppState m, MonadIO m, MonadThrow m)
-              , HasSettings env
-              , HasDirs env
-              , MonadIO m
-              , MonadThrow m)
            => FilePath         -- ^ thing to execute
            -> [String]         -- ^ args for the thing
            -> Maybe FilePath   -- ^ optionally chdir into this
@@ -87,8 +82,7 @@ execLogged :: ( MonadReader env m
            -> Maybe [(String, String)] -- ^ optional environment
            -> m (Either ProcessError ())
 execLogged exe args chdir lfile env = do
-  Settings {..} <- getSettings
+  AppState { settings = Settings {..}, dirs = Dirs {..} } <- ask
-  Dirs {..} <- getDirs
   let logfile = logsDir </> lfile <> ".log"
   liftIO $ bracket (openFd logfile WriteOnly (Just newFilePerms) defaultFileFlags{ append = True })
                    closeFd

lib/GHCup/Utils/File/Windows.hs

@@ -19,7 +19,6 @@ import {-# SOURCE #-} GHCup.Utils ( getLinkTarget, pathIsLink )
 import           GHCup.Utils.Dirs
 import           GHCup.Utils.File.Common
 import           GHCup.Types
-import           GHCup.Types.Optics
 
 import           Control.Concurrent
 import           Control.DeepSeq
@@ -147,11 +146,7 @@ executeOut path args chdir = do
   pure $ CapturedProcess exit out err
 
 
-execLogged :: ( MonadReader env m
+execLogged :: (MonadReader AppState m, MonadIO m, MonadThrow m)
-              , HasDirs env
-              , HasSettings env
-              , MonadIO m
-              , MonadThrow m)
            => FilePath         -- ^ thing to execute
            -> [String]         -- ^ args for the thing
            -> Maybe FilePath   -- ^ optionally chdir into this
@@ -159,7 +154,7 @@ execLogged :: ( MonadReader env m
            -> Maybe [(String, String)] -- ^ optional environment
            -> m (Either ProcessError ())
 execLogged exe args chdir lfile env = do
-  Dirs {..} <- getDirs
+  AppState { dirs = Dirs {..} } <- ask
   let stdoutLogfile = logsDir </> lfile <> ".stdout.log"
       stderrLogfile = logsDir </> lfile <> ".stderr.log"
   cp <- createProcessWithMingwPath ((proc exe args)

lib/GHCup/Utils/Logger.hs

@@ -20,7 +20,6 @@ import           GHCup.Utils.String.QQ
 import           Control.Monad
 import           Control.Monad.IO.Class
 import           Control.Monad.Logger
-import           Data.Char               ( ord )
 import           Prelude                 hiding ( appendFile )
 import           System.Console.Pretty
 import           System.FilePath
@@ -44,33 +43,20 @@ myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
   mylogger :: Loc -> LogSource -> LogLevel -> LogStr -> IO ()
   mylogger _ _ level str' = do
     -- color output
-    let style' = case level of
-          LevelDebug   -> style Bold . color Blue
-          LevelInfo    -> style Bold . color Green
-          LevelWarn    -> style Bold . color Yellow
-          LevelError   -> style Bold . color Red
-          LevelOther _ -> id
     let l = case level of
-          LevelDebug   -> toLogStr (style' "[ Debug ]")
+          LevelDebug   -> toLogStr (style Bold $ color Blue "[ Debug ]")
-          LevelInfo    -> toLogStr (style' "[ Info  ]")
+          LevelInfo    -> toLogStr (style Bold $ color Green "[ Info  ]")
-          LevelWarn    -> toLogStr (style' "[ Warn  ]")
+          LevelWarn    -> toLogStr (style Bold $ color Yellow "[ Warn  ]")
-          LevelError   -> toLogStr (style' "[ Error ]")
+          LevelError   -> toLogStr (style Bold $ color Red "[ Error ]")
           LevelOther t -> toLogStr "[ " <> toLogStr t <> toLogStr " ]"
-    let strs = fmap toLogStr . B.split (fromIntegral $ ord '\n') . fromLogStr $ str'
+    let out = fromLogStr (l <> toLogStr " " <> str' <> toLogStr "\n")
-    let out = case strs of
-                [] -> B.empty
-                (x:xs) -> fromLogStr
-                  . foldr (\a b -> a <> toLogStr "\n" <> b) mempty
-                  . ((l <> toLogStr " " <> x) :)
-                  . fmap (\line' -> toLogStr (style' "[ ...   ] ") <> line' )
-                  $ xs
 
     when (lcPrintDebug || (not lcPrintDebug && (level /= LevelDebug)))
       $ colorOutter out
 
     -- raw output
     let lr = case level of
-          LevelDebug   -> toLogStr "Debug:"
+          LevelDebug   -> toLogStr "Debug: "
           LevelInfo    -> toLogStr "Info:"
           LevelWarn    -> toLogStr "Warn:"
           LevelError   -> toLogStr "Error:"

lib/GHCup/Utils/Prelude.hs

@@ -26,7 +26,7 @@ import           Control.Monad.IO.Class
 import           Control.Monad.Trans.Class      ( lift )
 import           Data.Bifunctor
 import           Data.ByteString                ( ByteString )
-import           Data.List                      ( nub )
+import           Data.List                      ( nub, intercalate )
 import           Data.Foldable
 import           Data.String
 import           Data.Text                      ( Text )
@@ -47,6 +47,7 @@ import           GHC.IO.Exception
 import qualified Data.ByteString               as B
 import qualified Data.ByteString.Lazy          as L
 import qualified Data.Strict.Maybe             as S
+import qualified Data.List.Split               as Split
 import qualified Data.Text                     as T
 import qualified Data.Text.Encoding            as E
 import qualified Data.Text.Encoding.Error      as E
@@ -425,3 +426,19 @@ isNewLine w
   | w == _lf = True
   | w == _cr = True
   | otherwise = False
+
+
+-- | Split on a PVP suffix.
+--
+-- >>> splitOnPVP "-" "ghc-iserv-dyn-9.3.20210706" == ("ghc-iserv-dyn", "9.3.20210706")
+-- >>> splitOnPVP "-" "ghc-iserv-dyn"              == ("ghc-iserv-dyn", "")
+splitOnPVP :: String -> String -> (String, String)
+splitOnPVP c s = case Split.splitOn c s of
+  []  -> def
+  [_] -> def
+  xs
+    | let l = last xs
+    , (Right _) <- pvp (T.pack l) -> (intercalate c (init xs), l)
+    | otherwise -> def
+ where
+  def = (s, "")

refreeze.sh

@@ -1,27 +0,0 @@
-#!/bin/sh
-
-set -xue
-
-rm -f cabal.*.project
-rm -f cabal.*.project.freeze
-
-for ghc_ver in "$@" ; do
-	# shellcheck disable=SC3060
-	project_file=cabal.ghc${ghc_ver//./}.project
-
-	cp cabal.project "${project_file}"
-	case "$(uname -s)" in
-        MSYS*|MINGW*)
-			cabal freeze --project-file="${project_file}" -w "ghc-${ghc_ver}"
-			;;
-		*)
-			cabal freeze --project-file="${project_file}" -w "ghc-${ghc_ver}" -ftui -finternal-downloader
-			;;
-	esac
-
-
-	echo "" >> "${project_file}"
-	echo "with-compiler: ghc-${ghc_ver}" >> "${project_file}"
-
-	sed -i -e '/ghcup/d' "${project_file}".freeze
-done

scoop-better-shimexe/LICENSE-MIT

@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2019 Grégoire Geis
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

scoop-better-shimexe/LICENSE-UNLICENSE

@@ -1,10 +0,0 @@
-This is free and unencumbered software released into the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means.
-
-In jurisdictions that recognize copyright laws, the author or authors of this software dedicate any and all copyright interest in the software to the public domain. We make this dedication for the benefit of the public at large and to the detriment of our heirs and 
-successors. We intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights to this software under copyright law.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to <http://unlicense.org/>

scoop-better-shimexe/README.md

@@ -1,71 +0,0 @@
-# `shim.c`
-
-[`shim.c`](./shim.c) is a simple Windows program that, when started:
-1. Looks for a file with the exact same name as the running program, but with
-   the extension `shim` (e.g. `C:\bin\foo.exe` will read the file `C:\bin\foo.shim`).
-2. Reads and [parses](#shim-format) the files into a
-   [Scoop](https://github.com/lukesampson/scoop) shim format.
-3. Executes the target executable with the given arguments.
-
-`shim.c` was originally made to replace [Scoop](https://github.com/lukesampson/scoop)'s
-[`shim.cs`](https://github.com/lukesampson/scoop/blob/96de9c14bb483f9278e4b0a9e22b1923ee752901/supporting/shimexe/shim.cs)
-since it had several important flaws:
-1. [It was made in C#](https://github.com/lukesampson/scoop/tree/96de9c14bb483f9278e4b0a9e22b1923ee752901/supporting/shimexe),
-   and thus required an instantiation of a .NET command line app everytime it was started,
-   which can make a command run much slower than if it had been ran directly;
-2. [It](https://github.com/lukesampson/scoop/issues/2339) [did](https://github.com/lukesampson/scoop/issues/1896)
-   [not](https://github.com/felixse/FluentTerminal/issues/221) handle Ctrl+C and other
-   signals correctly, which could be quite infuriating (and essentially killing REPLs and long-running apps).
-
-[`shim.c`](./shim.c) is:
-- **Faster**, because it does not use the .NET Framework, and parses the `.shim` file in a simpler way.
-- **More efficient**, because by the time the target of the shim is started, all allocated memory will have been freed.
-- And more importantly, it **works better**:
-  - Signals originating from pressing `Ctrl+C` are ignored, and therefore handled directly by the spawned child.
-    Your processes and REPLs will no longer close when pressing `Ctrl+C`.
-  - Children are automatically killed when the shim process is killed. No more orphaned processes and weird behaviors.
-
-> **Note**: This project is not affiliated with [Scoop](https://github.com/lukesampson/scoop).
-
-
-## Installation for Scoop
-
-- In a Visual Studio command prompt, run `cl /O1 shim.c`.
-- Replace any `.exe` in `scoop\shims` by `shim.exe`.
-
-An additional script, `repshims.bat`, is provided. It will replace all `.exe`s in the user's Scoop directory
-by `shim.exe`.
-
-
-## Example
-
-Given the following shim `gs.shim`:
-```
-path = C:\Program Files\Git\git.exe
-args = status -u
-```
-
-In this directory, where `gs.exe` is the compiled `shim.c`:
-```
-C:\Bin\
-   gs.exe
-   gs.shim
-```
-
-Then calling `gs -s` will run the program `C:\Program Files\Git\git.exe status -u -s`.
-
-
-## Shim format
-
-Shims follow the same format as Scoop's shims: line-separated `key = value` pairs.
-```
-path = C:\Program Files\Git\git.exe
-args = status -uno
-```
-
-`path` is a required value, but `args` can be omitted. Also, do note that lines **must** end with a line feed.
-
-
-## License
-
-`SPDX-License-Identifier: MIT OR Unlicense`

scoop-better-shimexe/repshims.bat

@@ -1,15 +0,0 @@
-@echo off
-
-if not defined SCOOP set SCOOP=%USERPROFILE%\scoop
-
-for %%x in ("%SCOOP%\shims\*.exe") do (
-  echo Replacing %%x by new shim.
-  copy /B /Y shim.exe "%%~x" >NUL
-)
-
-if not defined SCOOP_GLOBAL set SCOOP_GLOBAL=%ProgramData%\scoop
-
-for %%x in ("%SCOOP_GLOBAL%\shims\*.exe") do (
-  echo Replacing %%x by new shim.
-  copy /B /Y shim.exe "%%~x" >NUL
-)

scoop-better-shimexe/shim.c

@@ -1,256 +0,0 @@
-#pragma comment(lib, "SHELL32.LIB")
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <wchar.h>
-#include <Windows.h>
-
-#ifndef ERROR_ELEVATION_REQUIRED
-#  define ERROR_ELEVATION_REQUIRED 740
-#endif
-
-#define MAX_FILENAME_SIZE 512
-
-BOOL WINAPI ctrlhandler(DWORD fdwCtrlType)
-{
-  switch (fdwCtrlType) {
-    // Ignore all events, and let the child process
-    // handle them.
-    case CTRL_C_EVENT:
-    case CTRL_CLOSE_EVENT:
-    case CTRL_LOGOFF_EVENT:
-    case CTRL_BREAK_EVENT:
-    case CTRL_SHUTDOWN_EVENT:
-      return TRUE;
-
-    default:
-      return FALSE;
-  }
-}
-
-int compute_program_length(const wchar_t* commandline)
-{
-  int i = 0;
-
-  if (commandline[0] == L'"') {
-    // Wait till end of string
-    i++;
-
-    for (;;) {
-      wchar_t c = commandline[i++];
-
-      if (c == 0)
-        return i - 1;
-      else if (c == L'\\')
-        i++;
-      else if (c == L'"')
-        return i;
-    }
-  } else {
-    for (;;) {
-      wchar_t c = commandline[i++];
-
-      if (c == 0)
-        return i - 1;
-      else if (c == L'\\')
-        i++;
-      else if (c == L' ')
-        return i;
-    }
-  }
-}
-
-int main()
-{
-  DWORD exit_code = 0;
-
-  wchar_t* path = NULL;
-  wchar_t* args = NULL;
-  wchar_t* cmd = NULL;
-
-  // Find filename of current executable.
-  wchar_t filename[MAX_FILENAME_SIZE + 2];
-  const unsigned int filename_size = GetModuleFileNameW(NULL, filename, MAX_FILENAME_SIZE);
-
-  if (filename_size >= MAX_FILENAME_SIZE) {
-    fprintf(stderr, "The filename of the program is too long to handle.\n");
-
-    exit_code = 1;
-    goto cleanup;
-  }
-
-  // Use filename of current executable to find .shim
-  filename[filename_size - 3] = L's';
-  filename[filename_size - 2] = L'h';
-  filename[filename_size - 1] = L'i';
-  filename[filename_size - 0] = L'm';
-  filename[filename_size + 1] =  0 ;
-
-  FILE* shim_file;
-
-  if ((shim_file = _wfsopen(filename, L"r,ccs=UTF-8", _SH_DENYNO)) == NULL) {
-    fprintf(stderr, "Cannot open shim file for read.\n");
-
-    exit_code = 1;
-    goto cleanup;
-  }
-
-  size_t command_length = 256;
-  size_t path_length;
-  size_t args_length;
-
-  // Read shim
-  wchar_t linebuf[8192];
-
-  for (;;) {
-    const wchar_t* line = fgetws(linebuf, 8192, shim_file);
-
-    if (line == NULL)
-      break;
-
-    if (line[4] != L' ' || line[5] != L'=' || line[6] != L' ')
-      continue;
-
-    const int linelen = wcslen(line);
-    const int len = linelen - 8 + (line[linelen - 1] != '\n');
-
-    if (line[0] == L'p' && line[1] == L'a' && line[2] == L't' && line[3] == L'h') {
-      // Reading path
-      path = calloc(len + 1, sizeof(wchar_t));
-      wmemcpy(path, line + 7, len);
-
-      command_length += len;
-      path_length = len;
-
-      continue;
-    }
-
-    if (line[0] == L'a' && line[1] == L'r' && line[2] == L'g' && line[3] == L's') {
-      // Reading args
-      args = calloc(len + 1, sizeof(wchar_t));
-      wmemcpy(args, line + 7, len);
-
-      command_length += len + 1;
-      args_length = len;
-
-      continue;
-    }
-
-    continue;
-  }
-
-  fclose(shim_file);
-
-  if (path == NULL) {
-    fprintf(stderr, "Could not read shim file.\n");
-
-    exit_code = 1;
-    goto cleanup;
-  }
-
-  // Find length of command to run
-  wchar_t* given_cmd = GetCommandLineW();
-  const int program_length = compute_program_length(given_cmd);
-
-  given_cmd += program_length;
-
-  const int given_length = wcslen(given_cmd);
-
-  command_length += given_length;
-
-  // Start building command to run, using '[path] [args]', as given by shim.
-  cmd = calloc(command_length, sizeof(wchar_t));
-  int cmd_i = 0;
-
-  wmemcpy(cmd, path, path_length);
-  cmd[path_length] = ' ';
-  cmd_i += path_length + 1;
-
-  if (args != NULL) {
-    wmemcpy(cmd + path_length + 1, args, args_length);
-    cmd[path_length + args_length + 1] = ' ';
-    cmd_i += args_length + 1;
-  }
-
-  // Copy all given arguments to command
-  wmemcpy(cmd + cmd_i, given_cmd, given_length);
-
-  // Find out if the target program is a console app
-  SHFILEINFOW sfi = {0};
-  const BOOL is_windows_app = HIWORD(SHGetFileInfoW(path, -1, &sfi, sizeof(sfi), SHGFI_EXETYPE));
-
-  if (is_windows_app)
-    // Unfortunately, this technique will still show a window for a fraction of time,
-    // but there's just no workaround.
-    FreeConsole();
-
-  // Create job object, which can be attached to child processes
-  // to make sure they terminate when the parent terminates as well.
-  JOBOBJECT_EXTENDED_LIMIT_INFORMATION jeli = {0};
-  HANDLE jobHandle = CreateJobObject(NULL, NULL);
-
-  jeli.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE | JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK;
-  SetInformationJobObject(jobHandle, JobObjectExtendedLimitInformation, &jeli, sizeof(jeli));
-
-  // Start subprocess
-  STARTUPINFOW si = {0};
-  PROCESS_INFORMATION pi = {0};
-
-  if (CreateProcessW(NULL, cmd, NULL, NULL, TRUE, CREATE_SUSPENDED, NULL, NULL, &si, &pi)) {
-    AssignProcessToJobObject(jobHandle, pi.hProcess);
-    ResumeThread(pi.hThread);
-  } else {
-    if (GetLastError() == ERROR_ELEVATION_REQUIRED) {
-      // We must elevate the process, which is (basically) impossible with
-      // CreateProcess, and therefore we fallback to ShellExecuteEx,
-      // which CAN create elevated processes, at the cost of opening a new separate
-      // window.
-      // Theorically, this could be fixed (or rather, worked around) using pipes
-      // and IPC, but... this is a question for another day.
-      SHELLEXECUTEINFOW sei = {0};
-
-      sei.cbSize       = sizeof(SHELLEXECUTEINFOW);
-      sei.fMask        = SEE_MASK_NOCLOSEPROCESS;
-      sei.lpFile       = path;
-      sei.lpParameters = cmd + path_length + 1;
-      sei.nShow        = SW_SHOW;
-
-      if (!ShellExecuteExW(&sei)) {
-        fprintf(stderr, "Unable to create elevated process: error %li.", GetLastError());
-
-        exit_code = 1;
-        goto cleanup;
-      }
-
-      pi.hProcess = sei.hProcess;
-    } else {
-      fprintf(stderr, "Could not create process with command '%ls'.\n", cmd);
-
-      exit_code = 1;
-      goto cleanup;
-    }
-  }
-
-  // Ignore Ctrl-C and other signals
-  if (!SetConsoleCtrlHandler(ctrlhandler, TRUE))
-    fprintf(stderr, "Could not set control handler; Ctrl-C behavior may be invalid.\n");
-
-  // Wait till end of process
-  WaitForSingleObject(pi.hProcess, INFINITE);
-
-  GetExitCodeProcess(pi.hProcess, &exit_code);
-
-  // Dispose of everything
-  CloseHandle(pi.hThread);
-  CloseHandle(pi.hProcess);
-  CloseHandle(jobHandle);
-
-cleanup:
-
-  // Free obsolete buffers
-  free(path);
-  free(args);
-  free(cmd);
-
-  return (int)exit_code;
-}

stack.yaml

@@ -1,4 +1,4 @@
-resolver: lts-18.2
+resolver: lts-17.11
 
 packages:
   - .
@@ -12,7 +12,6 @@ extra-deps:
 
   - IfElse-0.85@sha256:6939b94acc6a55f545f63a168a349dd2fbe4b9a7cca73bf60282db5cc6aa47d2,445
   - ascii-string-1.0.1.4@sha256:fa34f1d9ba57e8e89c0d4c9cef5e01ba32cb2d4373d13f92dcc0b531a6c6749b,2582
-  - base16-bytestring-0.1.1.7@sha256:0021256a9628971c08da95cb8f4d0d72192f3bb8a7b30b55c080562d17c43dd3,2231
   - brotli-0.0.0.0@sha256:2bf383a4cd308745740986be0b18381c5a0784393fe69b91456aacb2d603de46,2964
   - brotli-streams-0.0.0.0@sha256:1af1e22f67b8bfd6ad0d05e61825e7a178d738f689ebbb21c1aab5f1bbcae176,2331
   - chs-cabal-0.1.1.0@sha256:20ec6a9fb5ab6991f1a4adf157c537bd5d3b98d08d3c09c387c954c7c50bd011,1153
@@ -21,21 +20,17 @@ extra-deps:
   - haskus-utils-data-1.3@sha256:f62c4e49021b463185d043f7b69c727b63af641a71d7edd582d9f4f98e80e500,1466
   - haskus-utils-types-1.5.1@sha256:991c472f4e751e2f0d7aab6ad4220ef151d6160876dcf0511bbf876bbd432020,1298
   - haskus-utils-variant-3.0@sha256:8d51e45d3b664e61ccc25a58b37c0ccc4ee7537138b9fee21cd15c356906dd34,2159
+  - http-io-streams-0.1.6.0@sha256:53f5bab177efb52cd65ec396fd04ed59b93e5f919fb3700cd7dacd6cfce6f06d,3582
   - hpath-filepath-0.10.4@sha256:e9e44fb5fdbade7f30b5b5451257dbee15b6ef1aae4060034d73008bb3b5d878,1269
   - hpath-posix-0.13.3@sha256:abe472cf16bccd3a8b8814865ed3551a728fde0f3a2baea2acc03023bec6c565,1615
   - hspec-2.7.10@sha256:c9e82c90086acebac576552a06f3cabd249bba048edd1667c7fae0b1313d5bce,1712
   - hspec-core-2.7.10@sha256:2aba6ea126442b29e8183ab27f1c811706b19b1d83b02f193a896f6fc1589d13,4621
   - hspec-discover-2.7.10@sha256:d08bf5dd785629f589571477d9beb7cd91529471bd89f39517c1cb4b9b38160f,2184
   - hspec-golden-aeson-0.9.0.0@sha256:aa17274114026661ba4dfc9c60c230673c8f408bd86482fd611d2d5cb6aff996,2179
-  - http-io-streams-0.1.6.0@sha256:53f5bab177efb52cd65ec396fd04ed59b93e5f919fb3700cd7dacd6cfce6f06d,3582
   - libarchive-3.0.2.1@sha256:40ebf2a278e585802427bc58826867208bb33822f63d56107a1fcc3ca04d691d,10990
   - lzma-static-5.2.5.3@sha256:2758ee58c35992fcf7db78e98684c357a16a82fa2a4e7c352a6c210c08c555d8,7308
   - os-release-1.0.1@sha256:1281c62081f438fc3f0874d3bae6a4887d5964ac25261ba06e29d368ab173467,2716
-  - optics-0.4@sha256:9fb69bf0195b8d8f1f8cd0098000946868b8a3c3ffb51e5b64f79fc600c3eb4c,6568
+  - primitive-0.7.0.1@sha256:a381571c36edc7dca28b77fe8159b43c14c640087ec5946adacf949feec64231,3433
-  - optics-core-0.4@sha256:59e04aebca536bd011ae50c781937f45af4c1456af1eb9fb578f9a69eee293cd,4995
-  - optics-extra-0.4@sha256:b9914f38aa7d5c92f231060d9168447f9f5a367c07df9bf47a003e3e786d5e05,3432
-  - optics-th-0.4@sha256:7c838b5b1d6998133bf8f0641c36197ed6cb468dc69515e1952f33f0bbe8e11d,2009
-  - primitive-0.7.1.0@sha256:29de6bfd0cf8ba023ceb806203dfbec0e51e3524e75ffe41056f70b4229c6f0f,2728
   - regex-posix-clib-2.7
   - streamly-0.7.3@sha256:ad2a488fe802692ed47cab9fd0416c2904aac9e51cf2d8aafd1c3a40064c42f5,27421
   - streamly-bytestring-0.1.2@sha256:cc828f41d1c714c711d38fb213b4ed186febabba598ab080e13255f69c20b13c,2469

www/index.html

@@ -45,9 +45,9 @@
         <p>
             To install Haskell,<br/>run the following in a powershell session (as a non-admin user).
 			<div>
-			<div class="command-button"><pre><span class='ghcup-command' id="ghcup-command-powershell">Set-ExecutionPolicy Bypass -Scope Process -Force;[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;Invoke-Command -ScriptBlock ([ScriptBlock]::Create((Invoke-WebRequest https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1 -UseBasicParsing))) -ArgumentList $true</span></span></pre><button class="tooltip" onclick="copyToClipboardPowershell()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button>
+			<div class="command-button"><pre><span class='ghcup-command' id="ghcup-command-powershell">Set-ExecutionPolicy Bypass -Scope Process -Force;[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;Invoke-Command -ScriptBlock ([ScriptBlock]::Create((Invoke-WebRequest https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1 -UseBasicParsing))) -ArgumentList $false</span></span></pre><button class="tooltip" onclick="copyToClipboardPowershell()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button>
 			</div>
-				<p class="other-help">If you want to run a non-interactive installation, change <span class='code'>$true</span> to <span class='code'>$false</span> at the end of the script.</p>
+				<p class="other-help">If you want to run an interactive installation, change <span class='code'>$false</span> to <span class='code'>$true</span> at the end of the script.</p>
 			</div>
 		<p>If you're a Windows Subsystem 2 for Linux user run the following in your terminal, then follow the onscreen instructions to install Haskell.
 		</p>
@@ -65,9 +65,9 @@
         <p>
             To install Haskell,<br/>run the following in a powershell session (as a non-admin user).
 			<div>
-			<div class="command-button"><pre><span class='ghcup-command'>Set-ExecutionPolicy Bypass -Scope Process -Force;[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;Invoke-Command -ScriptBlock ([ScriptBlock]::Create((Invoke-WebRequest https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1 -UseBasicParsing))) -ArgumentList $true</span></span></pre><button class="tooltip" onclick="copyToClipboardPowershell()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button>
+			<div class="command-button"><pre><span class='ghcup-command'>Set-ExecutionPolicy Bypass -Scope Process -Force;[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072;Invoke-Command -ScriptBlock ([ScriptBlock]::Create((Invoke-WebRequest https://www.haskell.org/ghcup/sh/bootstrap-haskell.ps1 -UseBasicParsing))) -ArgumentList $false</span></span></pre><button class="tooltip" onclick="copyToClipboardPowershell()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button>
 			</div>
-				<p class="other-help">If you want to run an non-interactive installation, change <span class='code'>$true</span> to <span class='code'>$false</span> at the end of the script.</p>
+				<p class="other-help">If you want to run an interactive installation, change <span class='code'>$false</span> to <span class='code'>$true</span> at the end of the script.</p>
 			</div>
         </p>
 		<p>If you're a Windows Subsystem 2 for Linux user run the following in your terminal, then follow the onscreen instructions to install Haskell.