Lala

2021-02-06 13:30:11 +01:00
27 changed files with 8360 additions and 21016 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,7 +1,3 @@
-stages:
-  - test
-  - release
-
 variables:
  GIT_SSL_NO_VERIFY: "1"

@@ -18,7 +14,7 @@ variables:
    - x86_64-linux
  variables:
    OS: "LINUX"
-    ARCH: "64"
+    BIT: "64"

 .alpine:64bit:
  image: "alpine:3.12"
@@ -26,7 +22,7 @@ variables:
    - x86_64-linux
  variables:
    OS: "LINUX"
-    ARCH: "64"
+    BIT: "64"

 .alpine:32bit:
  image: "i386/alpine:3.12"
@@ -34,37 +30,21 @@ variables:
    - x86_64-linux
  variables:
    OS: "LINUX"
-    ARCH: "32"
-
-.linux:armv7:
-  image: "arm32v7/fedora"
-  tags:
-    - armv7-linux
-  variables:
-    OS: "LINUX"
-    ARCH: "ARM"
-
-.linux:aarch64:
-  image: "arm64v8/fedora"
-  tags:
-    - aarch64-linux
-  variables:
-    OS: "LINUX"
-    ARCH: "ARM64"
+    BIT: "32"

 .darwin:
  tags:
    - x86_64-darwin
  variables:
    OS: "DARWIN"
-    ARCH: "64"
+    BIT: "64"

 .freebsd:
  tags:
    - x86_64-freebsd
  variables:
    OS: "FREEBSD"
-    ARCH: "64"
+    BIT: "64"

 .root_cleanup:
  after_script:
@@ -101,20 +81,6 @@ variables:
  before_script:
    - ./.gitlab/before_script/linux/alpine/install_deps.sh

-.test_ghcup_version:armv7:
-  extends:
-    - .test_ghcup_version
-    - .linux:armv7
-  before_script:
-    - ./.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_manual.sh
-
 .test_ghcup_version:darwin:
  extends:
    - .test_ghcup_version
@@ -140,13 +106,10 @@ variables:
      - out
  only:
    - tags
-  variables:
-    JSON_VERSION: "0.0.4"

 ######## stack test ########

 test:linux:stack:
-  stage: test
  before_script:
    - ./.gitlab/before_script/linux/install_deps_minimal.sh
  script:
@@ -157,97 +120,74 @@ test:linux:stack:
 ######## bootstrap test ########

 test:linux:bootstrap_script:
-  stage: test
  before_script:
    - ./.gitlab/before_script/linux/install_deps_minimal.sh
  script:
    - ./.gitlab/script/ghcup_bootstrap.sh
  variables:
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
+    GHC_VERSION: "8.10.3"
+    CABAL_VERSION: "3.4.0.0-rc4"
  extends:
    - .debian

 ######## linux test ########

 test:linux:recommended:
-  stage: test
  extends: .test_ghcup_version:linux
  variables:
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
+    GHC_VERSION: "8.10.3"
+    CABAL_VERSION: "3.4.0.0-rc4"

 test:linux:latest:
-  stage: test
  extends: .test_ghcup_version:linux
  variables:
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
+    GHC_VERSION: "8.10.3"
+    CABAL_VERSION: "3.4.0.0-rc4"
+  allow_failure: true

 ######## linux 32bit test ########

 test:linux:recommended:32bit:
-  stage: test
  extends: .test_ghcup_version:linux32
  variables:
-    GHC_VERSION: "8.10.4"
+    GHC_VERSION: "8.10.2"
    CABAL_VERSION: "3.2.0.0"

-######## arm tests ########
-
-test:linux:recommended:armv7:
-  extends: .test_ghcup_version:armv7
-  variables:
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
-  when: manual
-
-test:linux:recommended:aarch64:
-  extends: .test_ghcup_version:aarch64
-  variables:
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
-  when: manual
-
 ######## darwin test ########

 test:mac:recommended:
-  stage: test
  extends: .test_ghcup_version:darwin
  variables:
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
+    GHC_VERSION: "8.10.3"
+    CABAL_VERSION: "3.4.0.0-rc4"

 test:mac:latest:
-  stage: test
  extends: .test_ghcup_version:darwin
  variables:
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
+    GHC_VERSION: "8.10.3"
+    CABAL_VERSION: "3.4.0.0-rc4"
+  allow_failure: true


 ######## freebsd test ########

 test:freebsd:recommended:
-  stage: test
  extends: .test_ghcup_version:freebsd
  variables:
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
+    GHC_VERSION: "8.10.3"
+    CABAL_VERSION: "3.4.0.0-rc4"

 test:freebsd:latest:
-  stage: test
  extends: .test_ghcup_version:freebsd
  variables:
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
+    GHC_VERSION: "8.10.3"
+    CABAL_VERSION: "3.4.0.0-rc4"
+  allow_failure: true


 ######## linux release ########

 release:linux:64bit:
-  stage: release
-  needs: ["test:linux:recommended", "test:linux:latest"]
  extends:
    - .alpine:64bit
    - .release_ghcup
@@ -255,13 +195,11 @@ release:linux:64bit:
    - ./.gitlab/before_script/linux/alpine/install_deps.sh
  variables:
    ARTIFACT: "x86_64-linux-ghcup"
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
+    GHC_VERSION: "8.10.3"
+    CABAL_VERSION: "3.4.0.0-rc4"


 release:linux:32bit:
-  stage: release
-  needs: ["test:linux:recommended:32bit"]
  extends:
    - .alpine:32bit
    - .release_ghcup
@@ -269,40 +207,13 @@ release:linux:32bit:
    - ./.gitlab/before_script/linux/alpine/install_deps.sh
  variables:
    ARTIFACT: "i386-linux-ghcup"
-    GHC_VERSION: "8.10.4"
+    GHC_VERSION: "8.10.2"
    CABAL_VERSION: "3.2.0.0"

-release:linux:armv7:
-  stage: release
-  needs: ["test:linux:recommended:armv7"]
-  extends:
-    - .linux:armv7
-    - .release_ghcup
-  before_script:
-    - ./.gitlab/before_script/linux/install_deps_manual.sh
-  variables:
-    ARTIFACT: "armv7-linux-ghcup"
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
-
-release:linux:aarch64:
-  stage: release
-  needs: ["test:linux:recommended:aarch64"]
-  extends:
-    - .linux:aarch64
-    - .release_ghcup
-  before_script:
-    - ./.gitlab/before_script/linux/install_deps_manual.sh
-  variables:
-    ARTIFACT: "aarch64-linux-ghcup"
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"

 ######## darwin release ########

 release:darwin:
-  stage: release
-  needs: ["test:mac:recommended", "test:mac:latest"]
  extends:
    - .darwin
    - .release_ghcup
@@ -311,16 +222,14 @@ release:darwin:
    - ./.gitlab/before_script/darwin/install_deps.sh
  variables:
    ARTIFACT: "x86_64-apple-darwin-ghcup"
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
+    GHC_VERSION: "8.10.3"
+    CABAL_VERSION: "3.4.0.0-rc4"
    MACOSX_DEPLOYMENT_TARGET: "10.7"


 ######## freebsd release ########

 release:freebsd:
-  stage: release
-  needs: ["test:freebsd:recommended", "test:freebsd:latest"]
  extends:
    - .freebsd
    - .release_ghcup
@@ -329,6 +238,6 @@ release:freebsd:
    - ./.gitlab/before_script/freebsd/install_deps.sh
  variables:
    ARTIFACT: "x86_64-portbld-freebsd-ghcup"
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
+    GHC_VERSION: "8.10.3"
+    CABAL_VERSION: "3.4.0.0-rc4"

--- a/.gitlab/before_script/darwin/install_deps.sh
+++ b/.gitlab/before_script/darwin/install_deps.sh
@@ -9,9 +9,8 @@ mkdir -p "${TMPDIR}"
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-apple-darwin-ghcup > ./ghcup-bin
 chmod +x ghcup-bin

-./ghcup-bin upgrade -i -f
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
+./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin install-cabal ${CABAL_VERSION}

 exit 0
--- a/.gitlab/before_script/freebsd/install_deps.sh
+++ b/.gitlab/before_script/freebsd/install_deps.sh
@@ -11,9 +11,8 @@ mkdir -p "${TMPDIR}"
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-portbld-freebsd-ghcup > ./ghcup-bin
 chmod +x ghcup-bin

-./ghcup-bin upgrade -i -f
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
+./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin set ${GHC_VERSION}

 exit 0
--- a/.gitlab/before_script/linux/alpine/install_deps.sh
+++ b/.gitlab/before_script/linux/alpine/install_deps.sh
@@ -10,9 +10,6 @@ apk add --no-cache \
 	curl \
 	gcc \
 	g++ \
-	binutils \
-	binutils-gold \
-	bsd-compat-headers \
 	gmp-dev \
 	ncurses-dev \
 	libffi-dev \
@@ -21,15 +18,14 @@ apk add --no-cache \
 	tar \
 	perl

-if [ "${ARCH}" = "32" ] ; then
+if [ "${BIT}" = "32" ] ; then
 	curl -sSfL https://downloads.haskell.org/ghcup/i386-linux-ghcup > ./ghcup-bin
 else
 	curl -sSfL https://downloads.haskell.org/ghcup/x86_64-linux-ghcup > ./ghcup-bin
 fi
 chmod +x ghcup-bin
-./ghcup-bin upgrade -i -f
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
+./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin install-cabal ${CABAL_VERSION}

 # utils
 apk add --no-cache \
--- a/.gitlab/before_script/linux/install_deps.sh
+++ b/.gitlab/before_script/linux/install_deps.sh
@@ -12,8 +12,7 @@ sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev li
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-linux-ghcup > ./ghcup-bin
 chmod +x ghcup-bin

-./ghcup-bin upgrade -i -f
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
-./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
+./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin install-cabal ${CABAL_VERSION}

--- a/.gitlab/before_script/linux/install_deps_manual.sh
+++ b/.gitlab/before_script/linux/install_deps_manual.sh
@@ -1,64 +0,0 @@
-#!/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
-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
--- a/.gitlab/script/ghcup_release.sh
+++ b/.gitlab/script/ghcup_release.sh
@@ -16,12 +16,10 @@ git describe
 ecabal update

 if [ "${OS}" = "LINUX" ] ; then
-	if [ "${ARCH}" = "32" ] ; then
+	if [ "${BIT}" = "32" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui -ftar
-	elif [ "${ARCH}" = "64" ] ; then
-		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui
 	else
-		ecabal build -w ghc-${GHC_VERSION} -ftui
+		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui
 	fi
 elif [ "${OS}" = "FREEBSD" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections' --constraint="zlib +static" -ftui
--- a/.gitlab/script/ghcup_version.sh
+++ b/.gitlab/script/ghcup_version.sh
@@ -26,7 +26,7 @@ if [ "${OS}" = "DARWIN" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} -ftui
 	ecabal test -w ghc-${GHC_VERSION} -ftui ghcup-test
 elif [ "${OS}" = "LINUX" ] ; then
-	if [ "${ARCH}" = "32" ] ; then
+	if [ "${BIT}" = "32" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar
 		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar ghcup-test
 	else
@@ -80,17 +80,17 @@ ghci-$(ghc --numeric-version) --version
 # 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 install 8.10.3
+	eghcup --downloader=wget install 8.4.4
 else # test wget a bit
-	eghcup install 8.10.3
+	eghcup install 8.4.4
 fi
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-eghcup set 8.10.3
-eghcup set 8.10.3
-[ "$(ghc --numeric-version)" = "8.10.3" ]
+eghcup set 8.4.4
+eghcup set 8.4.4
+[ "$(ghc --numeric-version)" = "8.4.4" ]
 eghcup set ${GHC_VERSION}
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-eghcup rm 8.10.3
+eghcup rm 8.4.4
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]

 # install hls
@@ -98,7 +98,7 @@ if [ "${OS}" = "DARWIN" ] ; then
 	eghcup install hls
 	haskell-language-server-wrapper --version
 elif [ "${OS}" = "LINUX" ] ; then
-	if [ "${ARCH}" = "64" ] ; then
+	if [ "${BIT}" = "64" ] ; then
 		eghcup install hls
 		haskell-language-server-wrapper --version
 	fi
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,13 +1,7 @@
 # Revision history for ghcup

-## 0.1.13 -- 2021-02-26
+## 0.1.13 -- ????-??-??

-* Support ARMv7/AARCH64
-* Add command line completions for installed and available versions wrt [MR #70](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/70)
-* Allow to cycle through set tools wrt [#114](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/114)
-* Fix item selection with unavailable versions wrt [#107](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/107)
-* Allow for dynamic post-install, post-remove and pre-compile msgs wrt [MR #68](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/68)
-* Alert user if upgraded ghcup is shadowed by old ghcup wrt [#111](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/111)
 * Fix to `ghcup` directory creation and placement for the XDG install mode ([MR #49](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/49))
 * Do 755 permissions on executables, wrt #97
 * Add [NO_COLOR](https://no-color.org/) support wrt [MR #47](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/47)
--- a/app/ghcup-gen/Validate.hs
+++ b/app/ghcup-gen/Validate.hs
@@ -32,7 +32,6 @@ import           Optics
 import           System.Exit
 import           System.IO
 import           Text.ParserCombinators.ReadP
-import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           Text.Regex.Posix

 import qualified Data.ByteString               as B
@@ -68,7 +67,7 @@ validate dls = do
    forM_ (M.toList dls) $ \(t, versions) ->
      forM_ (M.toList versions) $ \(v, vi) ->
        forM_ (M.toList $ _viArch vi) $ \(arch, pspecs) -> do
-          checkHasRequiredPlatforms t v (_viTags vi) arch (M.keys pspecs)
+          checkHasRequiredPlatforms t v arch (M.keys pspecs)

    checkGHCVerIsValid
    forM_ (M.toList dls) $ \(t, _) -> checkMandatoryTags t
@@ -82,30 +81,26 @@ validate dls = do
        lift $ $(logInfo) [i|All good|]
        pure ExitSuccess
 where
-  checkHasRequiredPlatforms t v tags arch pspecs = do
+  checkHasRequiredPlatforms t v arch pspecs = do
    let v' = prettyVer v
-        arch' = prettyShow arch
    when (not $ any (== Linux UnknownLinux) pspecs) $ do
      lift $ $(logError)
-        [i|Linux UnknownLinux missing for for #{t} #{v'} #{arch'}|]
+        [i|Linux UnknownLinux missing for for #{t} #{v'} #{arch}|]
      addError
    when ((not $ any (== Darwin) pspecs) && arch == A_64) $ do
-      lift $ $(logError) [i|Darwin missing for #{t} #{v'} #{arch'}|]
+      lift $ $(logError) [i|Darwin missing for #{t} #{v'} #{arch}|]
      addError
    when ((not $ any (== FreeBSD) pspecs) && arch == A_64) $ lift $ $(logWarn)
-      [i|FreeBSD missing for #{t} #{v'} #{arch'}|]
+      [i|FreeBSD missing for #{t} #{v'} #{arch}|]

    -- alpine needs to be set explicitly, because
    -- we cannot assume that "Linux UnknownLinux" runs on Alpine
    -- (although it could be static)
    when (not $ any (== Linux Alpine) pspecs) $
      case t of
-        GHCup | arch `elem` [A_64, A_32] -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
-        Cabal | v > [vver|2.4.1.0|]
-              , arch `elem` [A_64, A_32] -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]) >> addError
-        GHC | Latest `elem` tags || Recommended `elem` tags
-            , arch `elem` [A_64, A_32] -> lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]
-        _ -> lift $ $(logWarn) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]
+        GHCup -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
+        Cabal | v > [vver|2.4.1.0|] -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
+        _     -> lift $ $(logWarn) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]

  checkUniqueTags tool = do
    let allTags = join $ M.elems $ availableToolVersions dls tool
--- a/app/ghcup/BrickMain.hs
+++ b/app/ghcup/BrickMain.hs
@@ -16,7 +16,6 @@ import           GHCup.Types
 import           GHCup.Utils
 import           GHCup.Utils.File
 import           GHCup.Utils.Logger
-import           GHCup.Utils.Prelude     hiding ((!?))

 import           Brick
 import           Brick.Widgets.Border
@@ -48,7 +47,6 @@ import           Prelude                 hiding ( appendFile )
 import           System.Environment
 import           System.Exit
 import           System.IO.Unsafe
-import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           URI.ByteString

 import qualified GHCup.Types                   as GT
@@ -154,10 +152,7 @@ ui dimAttrs BrickState { appSettings = as@(BrickSettings {}), ..}
          Nothing -> T.unpack . prettyVer $ lVer
          Just c  -> T.unpack (c <> "-" <> prettyVer lVer)
        dim
-          | lNoBindist && (not lInstalled)
-            && (not b) -- TODO: overloading dim and active ignores active
-                       --       so we hack around it here
-          = updateAttrMap (const dimAttrs) . withAttr "no-bindist"
+          | lNoBindist = updateAttrMap (const dimAttrs) . withAttr "no-bindist"
          | otherwise  = id
        hooray
          | elem Latest lTag && not lInstalled =
@@ -282,7 +277,7 @@ defaultAttributes no_color = attrMap
 dimAttributes :: Bool -> AttrMap
 dimAttributes no_color = attrMap
  (Vty.defAttr `Vty.withStyle` Vty.dim)
-  [ ("active"    , Vty.defAttr `withBackColor` Vty.blue) -- has no effect ??
+  [ ("active"    , Vty.defAttr `withBackColor` Vty.blue)
  , ("no-bindist", Vty.defAttr `Vty.withStyle` Vty.dim)
  ]
  where
@@ -419,35 +414,24 @@ install' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
              , DownloadFailed
              , NoUpdate
              , TarDirDoesNotExist
-              , VerNotFound
              ]

  (run $ do
      case lTool of
-        GHC   -> do
-          vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer GHC dls
-            ?? VerNotFound lVer GHC
-          liftE $ installGHCBin dls lVer pfreq $> vi
-        Cabal -> do
-          vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer Cabal dls
-            ?? VerNotFound lVer Cabal
-          liftE $ installCabalBin dls lVer pfreq $> vi
-        GHCup -> do
-          let vi = fromJust $ snd <$> getLatest dls GHCup
-          liftE $ upgradeGHCup dls Nothing False pfreq $> vi
-        HLS   -> do
-          vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer HLS dls
-            ?? VerNotFound lVer HLS
-          liftE $ installHLSBin dls lVer pfreq $> vi
+        GHC   -> liftE $ installGHCBin dls lVer pfreq
+        Cabal -> liftE $ installCabalBin dls lVer pfreq
+        GHCup -> liftE $ upgradeGHCup dls Nothing False pfreq $> ()
+        HLS   -> liftE $ installHLSBin dls lVer pfreq $> ()
    )
    >>= \case
-          VRight vi                         -> do
-            forM_ (_viPostInstall vi) $ \msg ->
-              runLogger $ $(logInfo) msg
-            pure $ Right ()
+          VRight _                          -> pure $ Right ()
          VLeft  (V (AlreadyInstalled _ _)) -> pure $ Right ()
+          VLeft (V (BuildFailed _ e)) ->
+            pure $ Left [i|Build failed with #{e}|]
+          VLeft (V NoDownload) ->
+            pure $ Left [i|No available version for #{prettyVer lVer}|]
          VLeft (V NoUpdate) -> pure $ Right ()
-          VLeft e -> pure $ Left [i|#{prettyShow e}
+          VLeft e -> pure $ Left [i|#{e}
 Also check the logs in ~/.ghcup/logs|]


@@ -471,33 +455,27 @@ set' _ (_, ListResult {..}) = do
    )
    >>= \case
          VRight _ -> pure $ Right ()
-          VLeft  e -> pure $ Left (prettyShow e)
+          VLeft  e -> pure $ Left [i|#{e}|]


 del' :: BrickState -> (Int, ListResult) -> IO (Either String ())
-del' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
+del' _ (_, ListResult {..}) = do
  settings <- readIORef settings'
  l        <- readIORef logger'
  let runLogger = myLoggerT l

-  let run = runLogger . flip runReaderT settings . runE @'[NotInstalled, VerNotFound]
+  let run = runLogger . flip runReaderT settings . runE @'[NotInstalled]

  (run $ do
-      vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer lTool dls
-        ?? VerNotFound lVer lTool
      case lTool of
-        GHC   -> liftE $ rmGHCVer (GHCTargetVersion lCross lVer) $> Just vi
-        Cabal -> liftE $ rmCabalVer lVer $> Just vi
-        HLS   -> liftE $ rmHLSVer lVer $> Just vi
-        GHCup -> pure Nothing
+        GHC   -> liftE $ rmGHCVer (GHCTargetVersion lCross lVer) $> ()
+        Cabal -> liftE $ rmCabalVer lVer $> ()
+        HLS   -> liftE $ rmHLSVer lVer $> ()
+        GHCup -> pure ()
    )
    >>= \case
-          VRight (Just vi) -> do
-            forM_ (_viPostRemove vi) $ \msg ->
-              runLogger $ $(logInfo) msg
-            pure $ Right ()
          VRight _ -> pure $ Right ()
-          VLeft  e -> pure $ Left (prettyShow e)
+          VLeft  e -> pure $ Left [i|#{e}|]


 changelog' :: BrickState -> (Int, ListResult) -> IO (Either String ())
@@ -512,7 +490,7 @@ changelog' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
            FreeBSD -> "xdg-open"
      exec cmd True [serializeURIRef' uri] Nothing Nothing >>= \case
        Right _ -> pure $ Right ()
-        Left  e -> pure $ Left $ prettyShow e
+        Left  e -> pure $ Left [i|#{e}|]


 settings' :: IORef AppState
@@ -592,7 +570,7 @@ getDownloads' = do

  case r of
    VRight a -> pure $ Right a
-    VLeft  e -> pure $ Left (prettyShow e)
+    VLeft  e -> pure $ Left [i|#{e}|]


 getAppData :: Maybe GHCupDownloads
--- a/app/ghcup/Main.hs
+++ b/app/ghcup/Main.hs
@@ -32,7 +32,6 @@ import           GHCup.Version
 #if !defined(TAR)
 import           Codec.Archive
 #endif
-import           Control.Concurrent
 import           Control.Exception.Safe
 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
@@ -44,7 +43,7 @@ import           Data.Bifunctor
 import           Data.Char
 import           Data.Either
 import           Data.Functor
-import           Data.List                      ( intercalate, nub, sort, sortBy )
+import           Data.List                      ( intercalate, sort )
 import           Data.List.NonEmpty             (NonEmpty ((:|)))
 import           Data.Maybe
 import           Data.String.Interpolate
@@ -66,12 +65,10 @@ import           System.Environment
 import           System.Exit
 import           System.IO               hiding ( appendFile )
 import           Text.Read               hiding ( lift )
-import           Text.PrettyPrint.HughesPJClass ( prettyShow )
 import           URI.ByteString

 import qualified Data.ByteString               as B
 import qualified Data.ByteString.UTF8          as UTF8
-import qualified Data.Map.Strict               as M
 import qualified Data.Text                     as T
 import qualified Data.Text.IO                  as T
 import qualified Data.Text.Encoding            as E
@@ -114,14 +111,9 @@ data ToolVersion = ToolVersion GHCTargetVersion -- target is ignored for cabal
                 | ToolTag Tag

 prettyToolVer :: ToolVersion -> String
-prettyToolVer (ToolVersion v') = T.unpack $ tVerToText v'
+prettyToolVer (ToolVersion v') = T.unpack $ prettyTVer v'
 prettyToolVer (ToolTag t) = show t

-toSetToolVer :: Maybe ToolVersion -> SetToolVersion
-toSetToolVer (Just (ToolVersion v')) = SetToolVersion v'
-toSetToolVer (Just (ToolTag t')) = SetToolTag t'
-toSetToolVer Nothing = SetRecommended
-

 data InstallCommand = InstallGHC InstallOptions
                    | InstallCabal InstallOptions
@@ -138,14 +130,8 @@ data SetCommand = SetGHC SetOptions
                | SetCabal SetOptions
                | SetHLS SetOptions

-- a superset of ToolVersion
-data SetToolVersion = SetToolVersion GHCTargetVersion
-                    | SetToolTag Tag
-                    | SetRecommended
-                    | SetNext
-
 data SetOptions = SetOptions
-  { sToolVer :: SetToolVersion
+  { sToolVer :: Maybe ToolVersion
  }

 data ListOptions = ListOptions
@@ -205,10 +191,10 @@ data ChangeLogOptions = ChangeLogOptions
 -- by default. For example:
 --
 -- > invertableSwitch "recursive" True (help "do not recurse into directories")
--
-- This example makes --recursive enabled by default, so
+-- 
+-- This example makes --recursive enabled by default, so 
 -- the help is shown only for --no-recursive.
-invertableSwitch
+invertableSwitch 
    :: String              -- ^ long option
    -> Char                -- ^ short option for the non-default option
    -> Bool                -- ^ is switch enabled by default?
@@ -376,7 +362,7 @@ com =
          (  command
              "install-cabal"
              ((info
-                 ((InstallCabalLegacy <$> installOpts (Just Cabal)) <**> helper)
+                 ((InstallCabalLegacy <$> installOpts) <**> helper)
                 (  progDesc "Install or update cabal"
                 <> footerDoc (Just $ text installCabalFooter)
                 )
@@ -426,7 +412,7 @@ installParser =
          "ghc"
          (   InstallGHC
          <$> (info
-                (installOpts (Just GHC) <**> helper)
+                (installOpts <**> helper)
                (  progDesc "Install GHC"
                <> footerDoc (Just $ text installGHCFooter)
                )
@@ -436,7 +422,7 @@ installParser =
           "cabal"
           (   InstallCabal
           <$> (info
-                 (installOpts (Just Cabal) <**> helper)
+                 (installOpts <**> helper)
                 (  progDesc "Install Cabal"
                 <> footerDoc (Just $ text installCabalFooter)
                 )
@@ -446,7 +432,7 @@ installParser =
           "hls"
           (   InstallHLS
           <$> (info
-                 (installOpts (Just HLS) <**> helper)
+                 (installOpts <**> helper)
                 (  progDesc "Install haskell-languge-server"
                 <> footerDoc (Just $ text installHLSFooter)
                 )
@@ -454,7 +440,7 @@ installParser =
           )
      )
    )
-    <|> (Right <$> installOpts Nothing)
+    <|> (Right <$> installOpts)
 where
  installHLSFooter :: String
  installHLSFooter = [s|Discussion:
@@ -485,8 +471,8 @@ Examples:
  ghcup install ghc -u https://gitlab.haskell.org/api/v4/projects/1/jobs/artifacts/master/raw/ghc-x86_64-fedora27-linux.tar.xz?job=validate-x86_64-linux-fedora27 head|]


-installOpts :: Maybe Tool -> Parser InstallOptions
-installOpts tool =
+installOpts :: Parser InstallOptions
+installOpts =
  (\p (u, v) b -> InstallOptions v p u b)
    <$> (optional
          (option
@@ -508,9 +494,9 @@ installOpts tool =
                    )
                  )
                )
-            <*> (Just <$> toolVersionArgument Nothing tool)
+            <*> (Just <$> toolVersionArgument)
            )
-        <|> (pure (Nothing, Nothing))
+        <|> ((,) <$> pure Nothing <*> optional toolVersionArgument)
        )
    <*> flag
          False
@@ -527,7 +513,7 @@ setParser =
          "ghc"
          (   SetGHC
          <$> (info
-                (setOpts (Just GHC) <**> helper)
+                (setOpts <**> helper)
                (  progDesc "Set GHC version"
                <> footerDoc (Just $ text setGHCFooter)
                )
@@ -537,7 +523,7 @@ setParser =
           "cabal"
           (   SetCabal
           <$> (info
-                 (setOpts (Just Cabal) <**> helper)
+                 (setOpts <**> helper)
                 (  progDesc "Set Cabal version"
                 <> footerDoc (Just $ text setCabalFooter)
                 )
@@ -547,7 +533,7 @@ setParser =
           "hls"
           (   SetHLS
           <$> (info
-                 (setOpts (Just HLS) <**> helper)
+                 (setOpts <**> helper)
                 (  progDesc "Set haskell-language-server version"
                 <> footerDoc (Just $ text setHLSFooter)
                 )
@@ -555,7 +541,7 @@ setParser =
           )
      )
    )
-    <|> (Right <$> setOpts Nothing)
+    <|> (Right <$> setOpts)
 where
  setGHCFooter :: String
  setGHCFooter = [s|Discussion:
@@ -572,10 +558,8 @@ setParser =
    Sets the the current haskell-language-server version.|]


-setOpts :: Maybe Tool -> Parser SetOptions
-setOpts tool = SetOptions <$>
-    (fromMaybe SetRecommended <$>
-      optional (setVersionArgument (Just ListInstalled) tool))
+setOpts :: Parser SetOptions
+setOpts = SetOptions <$> optional toolVersionArgument

 listOpts :: Parser ListOptions
 listOpts =
@@ -607,29 +591,29 @@ rmParser =
  (Left <$> subparser
      (  command
          "ghc"
-          (RmGHC <$> (info (rmOpts (Just GHC) <**> helper) (progDesc "Remove GHC version")))
+          (RmGHC <$> (info (rmOpts <**> helper) (progDesc "Remove GHC version")))
      <> command
           "cabal"
           (   RmCabal
-           <$> (info (versionParser' (Just ListInstalled) (Just Cabal) <**> helper)
+           <$> (info (versionParser' <**> helper)
                     (progDesc "Remove Cabal version")
               )
           )
      <> command
           "hls"
           (   RmHLS
-           <$> (info (versionParser' (Just ListInstalled) (Just HLS) <**> helper)
+           <$> (info (versionParser' <**> helper)
                     (progDesc "Remove haskell-language-server version")
               )
           )
      )
    )
-    <|> (Right <$> rmOpts Nothing)
+    <|> (Right <$> rmOpts)



-rmOpts :: Maybe Tool -> Parser RmOptions
-rmOpts tool = RmOptions <$> versionArgument (Just ListInstalled) tool
+rmOpts :: Parser RmOptions
+rmOpts = RmOptions <$> versionArgument


 changelogP :: Parser ChangeLogOptions
@@ -651,7 +635,7 @@ changelogP =
            )
          )
        )
-    <*> optional (toolVersionArgument Nothing Nothing)
+    <*> optional toolVersionArgument

 compileP :: Parser CompileCommand
 compileP = subparser
@@ -780,85 +764,13 @@ toolVersionParser = verP' <|> toolP
          )

 -- | same as toolVersionParser, except as an argument.
-toolVersionArgument :: Maybe ListCriteria -> Maybe Tool -> Parser ToolVersion
-toolVersionArgument criteria tool =
-  argument (eitherReader toolVersionEither)
-    (metavar "VERSION|TAG"
-    <> completer (tagCompleter (fromMaybe GHC tool) [])
-    <> foldMap (completer . versionCompleter criteria) tool)
+toolVersionArgument :: Parser ToolVersion
+toolVersionArgument =
+  argument (eitherReader toolVersionEither) (metavar "VERSION|TAG")


-setVersionArgument :: Maybe ListCriteria -> Maybe Tool -> Parser SetToolVersion
-setVersionArgument criteria tool =
-  argument (eitherReader setEither)
-    (metavar "VERSION|TAG|next"
-    <> completer (tagCompleter (fromMaybe GHC tool) ["next"])
-    <> foldMap (completer . versionCompleter criteria) tool)
- where
-  setEither s' =
-        parseSet s'
-    <|> bimap id SetToolTag (tagEither s')
-    <|> bimap id SetToolVersion (tVersionEither s')
-  parseSet s' = case fmap toLower s' of
-                  "next" -> Right SetNext
-                  other  -> Left [i|Unknown tag/version #{other}|]
-
-
-versionArgument :: Maybe ListCriteria -> Maybe Tool -> Parser GHCTargetVersion
-versionArgument criteria tool = argument (eitherReader tVersionEither) (metavar "VERSION" <> foldMap (completer . versionCompleter criteria) tool)
-
-
-tagCompleter :: Tool -> [String] -> Completer
-tagCompleter tool add = listIOCompleter $ do
-  let loggerConfig = LoggerConfig
-        { lcPrintDebug = False
-        , colorOutter  = mempty
-        , rawOutter    = mempty
-        }
-
-      runLogger = myLoggerT loggerConfig
-
-  dirs <- getDirs
-  let simpleSettings = Settings False False Never Curl False GHCupURL
-      simpleAppState = AppState simpleSettings dirs defaultKeyBindings
-      runEnv = runLogger . flip runReaderT simpleAppState
-
-  mGhcUpInfo <- runEnv . runE $ readFromCache
-
-  case mGhcUpInfo of
-    VRight dls -> do
-      let allTags = filter (\t -> t /= Old)
-            $ join
-            $ M.elems
-            $ availableToolVersions (_ghcupDownloads dls) tool
-      pure $ nub $ (add ++) $ fmap tagToString allTags
-    VLeft _ -> pure  (nub $ ["recommended", "latest"] ++ add)
-
-
-versionCompleter :: Maybe ListCriteria -> Tool -> Completer
-versionCompleter criteria tool = listIOCompleter $ do
-  let loggerConfig = LoggerConfig
-        { lcPrintDebug = False
-        , colorOutter  = mempty
-        , rawOutter    = mempty
-        }
-
-      runLogger = myLoggerT loggerConfig
-
-  mpFreq <- runLogger . runE $ platformRequest
-
-  forFold mpFreq $ \pfreq -> do
-    dirs <- getDirs
-    let simpleSettings = Settings False False Never Curl False GHCupURL
-        simpleAppState = AppState simpleSettings dirs defaultKeyBindings
-        runEnv = runLogger . flip runReaderT simpleAppState
-
-    mGhcUpInfo <- runEnv . runE $ readFromCache
-
-    forFold mGhcUpInfo $ \(GHCupInfo _ dls) -> do
-      installedVersions <- runEnv $ listVersions dls (Just tool) criteria pfreq
-      return $ T.unpack . prettyVer . lVer <$> installedVersions
-
+versionArgument :: Parser GHCTargetVersion
+versionArgument = argument (eitherReader tVersionEither) (metavar "VERSION")

 versionParser :: Parser GHCTargetVersion
 versionParser = option
@@ -866,10 +778,10 @@ versionParser = option
  (short 'v' <> long "version" <> metavar "VERSION" <> help "The target version"
  )

-versionParser' :: Maybe ListCriteria -> Maybe Tool -> Parser Version
-versionParser' criteria tool = argument
-  (eitherReader (first show . version . T.pack))
-  (metavar "VERSION"  <> foldMap (completer . versionCompleter criteria) tool)
+versionParser' :: Parser Version
+versionParser' = argument
+  (eitherReader (bimap show id . version . T.pack))
+  (metavar "VERSION")


 tagEither :: String -> Either String Tag
@@ -879,7 +791,7 @@ tagEither s' = case fmap toLower s' of
  ('b':'a':'s':'e':'-':ver') -> case pvp (T.pack ver') of
                                  Right x -> Right (Base x)
                                  Left  _ -> Left [i|Invalid PVP version for base #{ver'}|]
-  other         -> Left [i|Unknown tag #{other}|]
+  other         -> Left ([i|Unknown tag #{other}|])


 tVersionEither :: String -> Either String GHCTargetVersion
@@ -1128,12 +1040,9 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                      , NotInstalled
                      , BuildFailed
                      , TagNotFound
-                      , VerNotFound
                      , DigestError
                      , DownloadFailed
                      , TarDirDoesNotExist
-                      , NextVerNotFound
-                      , NoToolVersionSet
                      ]

          let runInstTool = runInstTool' appstate
@@ -1146,9 +1055,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                  @'[ FileDoesNotExistError
                    , NotInstalled
                    , TagNotFound
-                    , VerNotFound
-                    , NextVerNotFound
-                    , NoToolVersionSet
                    ]

          let
@@ -1158,9 +1064,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                . runE
                  @'[ NotInstalled
                    , TagNotFound
-                    , VerNotFound
-                    , NextVerNotFound
-                    , NoToolVersionSet
                    ]

          let
@@ -1170,15 +1073,12 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                . runE
                  @'[ NotInstalled
                    , TagNotFound
-                    , VerNotFound
-                    , NextVerNotFound
-                    , NoToolVersionSet
                    ]

          let runListGHC = runLogger . flip runReaderT appstate

          let runRm =
-                runLogger . flip runReaderT appstate . runE @'[NotInstalled, VerNotFound]
+                runLogger . flip runReaderT appstate . runE @'[NotInstalled]

          let runDebugInfo =
                runLogger
@@ -1202,7 +1102,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                      , UnknownArchive
                      , TarDirDoesNotExist
                      , NotInstalled
-                      , VerNotFound
 #if !defined(TAR)
                      , ArchiveResult
 #endif
@@ -1232,7 +1131,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                    VRight r -> pure r
                    VLeft e -> do
                      runLogger
-                        ($(logError) $ T.pack $ prettyShow e)
+                        ($(logError) [i|Error determining Platform: #{e}|])
                      exitWith (ExitFailure 2)


@@ -1247,7 +1146,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                    VRight r -> pure r
                    VLeft  e -> do
                      runLogger
-                        ($(logError) $ T.pack $ prettyShow e)
+                        ($(logError) [i|Error fetching download info: #{e}|])
                      exitWith (ExitFailure 2)

          case optCommand of
@@ -1263,39 +1162,42 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
          let installGHC InstallOptions{..} =
                  (case instBindist of
                     Nothing -> runInstTool $ do
-                       (v, vi) <- liftE $ fromVersion dls instVer GHC
+                       v <- liftE $ fromVersion dls instVer GHC
                       liftE $ installGHCBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
                       when instSet $ void $ liftE $ setGHC v SetGHCOnly
-                       pure vi
                     Just uri -> runInstTool' appstate{ settings = settings {noVerify = True}} $ do
-                       (v, vi) <- liftE $ fromVersion dls instVer GHC
+                       v <- liftE $ fromVersion dls instVer GHC
                       liftE $ installGHCBindist
                         (DownloadInfo uri (Just $ RegexDir "ghc-.*") "")
                         (_tvVersion v)
                         (fromMaybe pfreq instPlatform)
                       when instSet $ void $ liftE $ setGHC v SetGHCOnly
-                       pure vi
                    )
                    >>= \case
-                          VRight vi -> do
+                          VRight _ -> do
                            runLogger $ $(logInfo) ("GHC installation successful")
-                            forM_ (_viPostInstall vi) $ \msg ->
-                              runLogger $ $(logInfo) msg
                            pure ExitSuccess
                          VLeft (V (AlreadyInstalled _ v)) -> do
                            runLogger $ $(logWarn)
                              [i|GHC ver #{prettyVer v} already installed; if you really want to reinstall it, you may want to run 'ghcup rm ghc #{prettyVer v}' first|]
                            pure ExitSuccess
-                          VLeft err@(V (BuildFailed tmpdir _)) -> do
+                          VLeft (V (BuildFailed tmpdir e)) -> do
                            case keepDirs settings of
-                              Never -> runLogger ($(logError) $ T.pack $ prettyShow err)
-                              _ -> runLogger ($(logError) [i|#{prettyShow err}
+                              Never -> runLogger ($(logError) [i|Build failed with #{e}|])
+                              _ -> runLogger ($(logError) [i|Build failed with #{e}
    Check the logs at #{logsDir} and the build directory #{tmpdir} for more clues.
    Make sure to clean up #{tmpdir} afterwards.|])
                            pure $ ExitFailure 3
+                          VLeft (V NoDownload) -> do
+
+                            runLogger $ do
+                              case instVer of
+                                Just iver -> $(logError) [i|No available GHC version for #{prettyToolVer iver}|]
+                                Nothing -> $(logError) [i|No available recommended GHC version|]
+                            pure $ ExitFailure 3
                          VLeft e -> do
                            runLogger $ do
-                              $(logError) $ T.pack $ prettyShow e
+                              $(logError) [i|#{e}|]
                              $(logError) [i|Also check the logs in #{logsDir}|]
                            pure $ ExitFailure 3

@@ -1303,67 +1205,73 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
          let installCabal InstallOptions{..} =
                (case instBindist of
                   Nothing -> runInstTool $ do
-                     (v, vi) <- liftE $ fromVersion dls instVer Cabal
+                     v <- liftE $ fromVersion dls instVer Cabal
                     liftE $ installCabalBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
-                     pure vi
                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} $ do
-                     (v, vi) <- liftE $ fromVersion dls instVer Cabal
+                     v <- liftE $ fromVersion dls instVer Cabal
                     liftE $ installCabalBindist
                         (DownloadInfo uri Nothing "")
                         (_tvVersion v)
                         (fromMaybe pfreq instPlatform)
-                     pure vi
                  )
                  >>= \case
-                        VRight vi -> do
+                        VRight _ -> do
                          runLogger $ $(logInfo) ("Cabal installation successful")
-                          forM_ (_viPostInstall vi) $ \msg ->
-                            runLogger $ $(logInfo) msg
                          pure ExitSuccess
                        VLeft (V (AlreadyInstalled _ v)) -> do
                          runLogger $ $(logWarn)
                            [i|Cabal ver #{prettyVer v} already installed; if you really want to reinstall it, you may want to run 'ghcup rm cabal #{prettyVer v}' first|]
                          pure ExitSuccess
+                        VLeft (V NoDownload) -> do
+
+                          runLogger $ do
+                            case instVer of
+                              Just iver -> $(logError) [i|No available Cabal version for #{prettyToolVer iver}|]
+                              Nothing -> $(logError) [i|No available recommended Cabal version|]
+                          pure $ ExitFailure 4
                        VLeft e -> do
                          runLogger $ do
-                            $(logError) $ T.pack $ prettyShow e
+                            $(logError) [i|#{e}|]
                            $(logError) [i|Also check the logs in #{logsDir}|]
                          pure $ ExitFailure 4

          let installHLS InstallOptions{..} =
                (case instBindist of
                   Nothing -> runInstTool $ do
-                     (v, vi) <- liftE $ fromVersion dls instVer HLS
+                     v <- liftE $ fromVersion dls instVer HLS
                     liftE $ installHLSBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
-                     pure vi
                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} $ do
-                     (v, vi) <- liftE $ fromVersion dls instVer HLS
+                     v <- liftE $ fromVersion dls instVer HLS
                     liftE $ installHLSBindist
                         (DownloadInfo uri Nothing "")
                         (_tvVersion v)
                         (fromMaybe pfreq instPlatform)
-                     pure vi
                  )
                  >>= \case
-                        VRight vi -> do
+                        VRight _ -> do
                          runLogger $ $(logInfo) ("HLS installation successful")
-                          forM_ (_viPostInstall vi) $ \msg ->
-                            runLogger $ $(logInfo) msg
                          pure ExitSuccess
                        VLeft (V (AlreadyInstalled _ v)) -> do
                          runLogger $ $(logWarn)
                            [i|HLS ver #{prettyVer v} already installed; if you really want to reinstall it, you may want to run 'ghcup rm hls #{prettyVer v}' first|]
                          pure ExitSuccess
+                        VLeft (V NoDownload) -> do
+
+                          runLogger $ do
+                            case instVer of
+                              Just iver -> $(logError) [i|No available HLS version for #{prettyToolVer iver}|]
+                              Nothing -> $(logError) [i|No available recommended HLS version|]
+                          pure $ ExitFailure 4
                        VLeft e -> do
                          runLogger $ do
-                            $(logError) $ T.pack $ prettyShow e
+                            $(logError) [i|#{e}|]
                            $(logError) [i|Also check the logs in #{logsDir}|]
                          pure $ ExitFailure 4


          let setGHC' SetOptions{..} =
                (runSetGHC $ do
-                    v <- liftE $ fst <$> fromVersion' dls sToolVer GHC
+                    v <- liftE $ fromVersion dls sToolVer GHC
                    liftE $ setGHC v SetGHCOnly
                  )
                  >>= \case
@@ -1373,90 +1281,59 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                                [i|GHC #{prettyVer _tvVersion} successfully set as default version#{maybe "" (" for cross target " <>) _tvTarget}|]
                          pure ExitSuccess
                        VLeft e -> do
-                          runLogger $ $(logError) $ T.pack $ prettyShow e
+                          runLogger ($(logError) [i|#{e}|])
                          pure $ ExitFailure 5

          let setCabal' SetOptions{..} =
                (runSetCabal $ do
-                    v <- liftE $ fst <$> fromVersion' dls sToolVer Cabal
+                    v <- liftE $ fromVersion dls sToolVer Cabal
                    liftE $ setCabal (_tvVersion v)
-                    pure v
                  )
                  >>= \case
-                        VRight (GHCTargetVersion{..}) -> do
-                          runLogger
-                            $ $(logInfo)
-                                [i|Cabal #{prettyVer _tvVersion} successfully set as default version|]
-                          pure ExitSuccess
+                        VRight _ -> pure ExitSuccess
                        VLeft  e -> do
-                          runLogger $ $(logError) $ T.pack $ prettyShow e
+                          runLogger ($(logError) [i|#{e}|])
                          pure $ ExitFailure 14

          let setHLS' SetOptions{..} =
                (runSetHLS $ do
-                    v <- liftE $ fst <$> fromVersion' dls sToolVer HLS
+                    v <- liftE $ fromVersion dls sToolVer HLS
                    liftE $ setHLS (_tvVersion v)
-                    pure v
                  )
                  >>= \case
-                        VRight (GHCTargetVersion{..}) -> do
-                          runLogger
-                            $ $(logInfo)
-                                [i|HLS #{prettyVer _tvVersion} successfully set as default version|]
-                          pure ExitSuccess
+                        VRight _ -> pure ExitSuccess
                        VLeft  e -> do
-                          runLogger $ $(logError) $ T.pack $ prettyShow e
+                          runLogger ($(logError) [i|#{e}|])
                          pure $ ExitFailure 14

          let rmGHC' RmOptions{..} =
                (runRm $ do
-                    liftE $
-                      rmGHCVer ghcVer
-                    vi <- liftE @_ @'[VerNotFound] $ getVersionInfo (_tvVersion ghcVer) GHC dls
-                      ?? VerNotFound (_tvVersion ghcVer) GHC
-                    pure vi
+                    liftE $ rmGHCVer ghcVer
                  )
                  >>= \case
-                        VRight vi -> do
-                          forM_ (_viPostRemove vi) $ \msg ->
-                            runLogger $ $(logInfo) msg
-                          pure ExitSuccess
+                        VRight _ -> pure ExitSuccess
                        VLeft  e -> do
-                          runLogger $ $(logError) $ T.pack $ prettyShow e
+                          runLogger ($(logError) [i|#{e}|])
                          pure $ ExitFailure 7

          let rmCabal' tv =
                (runRm $ do
-                    liftE $
-                      rmCabalVer tv
-                    vi <- liftE @_ @'[VerNotFound] $ getVersionInfo tv Cabal dls
-                      ?? VerNotFound tv Cabal
-                    pure vi
+                    liftE $ rmCabalVer tv
                  )
                  >>= \case
-                        VRight vi -> do
-                          forM_ (_viPostRemove vi) $ \msg ->
-                            runLogger $ $(logInfo) msg
-                          pure ExitSuccess
+                        VRight _ -> pure ExitSuccess
                        VLeft  e -> do
-                          runLogger $ $(logError) $ T.pack $ prettyShow e
+                          runLogger ($(logError) [i|#{e}|])
                          pure $ ExitFailure 15

          let rmHLS' tv =
                (runRm $ do
-                    liftE $
-                      rmHLSVer tv
-                    vi <- liftE @_ @'[VerNotFound] $ getVersionInfo tv HLS dls
-                      ?? VerNotFound tv HLS
-                    pure vi
+                    liftE $ rmHLSVer tv
                  )
                  >>= \case
-                        VRight vi -> do
-                          forM_ (_viPostRemove vi) $ \msg ->
-                            runLogger $ $(logInfo) msg
-                          pure ExitSuccess
+                        VRight _ -> pure ExitSuccess
                        VLeft  e -> do
-                          runLogger $ $(logError) $ T.pack $ prettyShow e
+                          runLogger ($(logError) [i|#{e}|])
                          pure $ ExitFailure 15


@@ -1503,18 +1380,11 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                        putStrLn $ prettyDebugInfo dinfo
                        pure ExitSuccess
                      VLeft e -> do
-                        runLogger $ $(logError) $ T.pack $ prettyShow e
+                        runLogger ($(logError) [i|#{e}|])
                        pure $ ExitFailure 8

            Compile (CompileGHC GHCCompileOptions {..}) ->
              (runCompileGHC $ do
-                vi <- liftE @_ @'[VerNotFound] $ getVersionInfo targetVer GHC dls
-                  ?? VerNotFound targetVer GHC
-                forM_ (_viPreCompile vi) $ \msg -> do
-                  lift $ $(logInfo) msg
-                  lift $ $(logInfo)
-                    ("...waiting for 5 seconds, you can still abort...")
-                  liftIO $ threadDelay 5000000 -- for compilation, give the user a sec to intervene
                liftE $ compileGHC dls
                            (GHCTargetVersion crossTarget targetVer)
                            bootstrapGhc
@@ -1523,30 +1393,28 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                            patchDir
                            addConfArgs
                            pfreq
-                when setCompile $ void $ liftE $
-                  setGHC (GHCTargetVersion crossTarget targetVer) SetGHCOnly
-                pure vi
+                when setCompile $ void $ liftE
+                  $ setGHC (GHCTargetVersion crossTarget targetVer) SetGHCOnly
                )
                >>= \case
-                      VRight vi -> do
+                      VRight _ -> do
                        runLogger $ $(logInfo)
                          ("GHC successfully compiled and installed")
-                        forM_ (_viPostInstall vi) $ \msg ->
-                          runLogger $ $(logInfo) msg
                        pure ExitSuccess
                      VLeft (V (AlreadyInstalled _ v)) -> do
                        runLogger $ $(logWarn)
                          [i|GHC ver #{prettyVer v} already installed; if you really want to reinstall it, you may want to run 'ghcup rm ghc #{prettyVer v}' first|]
                        pure ExitSuccess
-                      VLeft err@(V (BuildFailed tmpdir _)) -> do
+                      VLeft (V (BuildFailed tmpdir e)) -> do
                        case keepDirs settings of
-                          Never -> runLogger $ $(logError) $ T.pack $ prettyShow err
-                          _ -> runLogger ($(logError) [i|#{prettyShow err}
+                          Never -> runLogger ($(logError) [i|Build failed with #{e}
+Check the logs at #{logsDir}|])
+                          _ -> runLogger ($(logError) [i|Build failed with #{e}
 Check the logs at #{logsDir} and the build directory #{tmpdir} for more clues.
 Make sure to clean up #{tmpdir} afterwards.|])
                        pure $ ExitFailure 9
                      VLeft e -> do
-                        runLogger $ $(logError) $ T.pack $ prettyShow e
+                        runLogger ($(logError) [i|#{e}|])
                        pure $ ExitFailure 9

            Upgrade (uOpts) force -> do
@@ -1561,17 +1429,14 @@ Make sure to clean up #{tmpdir} afterwards.|])
              (runUpgrade $ (liftE $ upgradeGHCup dls target force pfreq)) >>= \case
                VRight v' -> do
                  let pretty_v = prettyVer v'
-                  let vi = fromJust $ snd <$> getLatest dls GHCup
                  runLogger $ $(logInfo)
                    [i|Successfully upgraded GHCup to version #{pretty_v}|]
-                  forM_ (_viPostInstall vi) $ \msg ->
-                    runLogger $ $(logInfo) msg
                  pure ExitSuccess
                VLeft (V NoUpdate) -> do
                  runLogger $ $(logWarn) [i|No GHCup update available|]
                  pure ExitSuccess
                VLeft e -> do
-                  runLogger $ $(logError) $ T.pack $ prettyShow e
+                  runLogger ($(logError) [i|#{e}|])
                  pure $ ExitFailure 11

            ToolRequirements ->
@@ -1588,7 +1453,10 @@ Make sure to clean up #{tmpdir} afterwards.|])
                >>= \case
                      VRight _ -> pure ExitSuccess
                      VLeft  e -> do
-                        runLogger $ $(logError) $ T.pack $ prettyShow e
+                        runLogger
+                          ($(logError)
+                            [i|Error getting tool requirements: #{e}|]
+                          )
                        pure $ ExitFailure 12

            ChangeLog (ChangeLogOptions {..}) -> do
@@ -1633,72 +1501,29 @@ Make sure to clean up #{tmpdir} afterwards.|])
            ef@(ExitFailure _) -> exitWith ef
  pure ()

-fromVersion :: (MonadFail m, MonadReader AppState m, MonadThrow m, MonadIO m, MonadCatch m)
+
+fromVersion :: Monad m
            => GHCupDownloads
            -> Maybe ToolVersion
            -> Tool
-            -> Excepts '[TagNotFound, VerNotFound, NextVerNotFound, NoToolVersionSet] m (GHCTargetVersion, VersionInfo)
-fromVersion av tv tool = fromVersion' av (toSetToolVer tv) tool
-
-fromVersion' :: (MonadFail m, MonadReader AppState m, MonadThrow m, MonadIO m, MonadCatch m)
-             => GHCupDownloads
-             -> SetToolVersion
-             -> Tool
-             -> Excepts '[TagNotFound, VerNotFound, NextVerNotFound, NoToolVersionSet] m (GHCTargetVersion, VersionInfo)
-fromVersion' av SetRecommended tool =
-  (\(x, y) -> (mkTVer x, y)) <$> getRecommended av tool
-    ?? TagNotFound Recommended tool
-fromVersion' av (SetToolVersion v) tool = do
-  vi <- getVersionInfo (_tvVersion v) tool av ?? VerNotFound (_tvVersion v) tool
+            -> Excepts '[TagNotFound] m GHCTargetVersion
+fromVersion av Nothing tool =
+  mkTVer <$> getRecommended av tool ?? TagNotFound Recommended tool
+fromVersion av (Just (ToolVersion v)) _ = do
  case pvp $ prettyVer (_tvVersion v) of
-    Left _ -> pure (v, vi)
+    Left _ -> pure v
    Right (PVP (major' :|[minor'])) ->
      case getLatestGHCFor (fromIntegral major') (fromIntegral minor') av of
-        Just (v', vi') -> pure (GHCTargetVersion (_tvTarget v) v', vi')
-        Nothing -> pure (v, vi)
-    Right _ -> pure (v, vi)
-fromVersion' av  (SetToolTag Latest) tool =
-  (\(x, y) -> (mkTVer x, y)) <$> getLatest av tool ?? TagNotFound Latest tool
-fromVersion' av (SetToolTag Recommended) tool =
-  (\(x, y) -> (mkTVer x, y)) <$> getRecommended av tool ?? TagNotFound Recommended tool
-fromVersion' av (SetToolTag (Base pvp'')) GHC =
-  (\(x, y) -> (mkTVer x, y)) <$> getLatestBaseVersion av pvp'' ?? TagNotFound (Base pvp'') GHC
-fromVersion' av SetNext tool = do
-  next <- case tool of
-    GHC -> do
-      set <- fmap _tvVersion $ ghcSet Nothing !? NoToolVersionSet tool
-      ghcs <- rights <$> lift getInstalledGHCs
-      (headMay
-        . tail
-        . dropWhile (\GHCTargetVersion {..} -> _tvVersion /= set)
-        . cycle
-        . sortBy (\x y -> compare (_tvVersion x) (_tvVersion y))
-        . filter (\GHCTargetVersion {..} -> _tvTarget == Nothing)
-        $ ghcs) ?? NoToolVersionSet tool
-    Cabal -> do
-      set <- cabalSet !? NoToolVersionSet tool
-      cabals <- rights <$> lift getInstalledCabals
-      (fmap (GHCTargetVersion Nothing)
-        . headMay
-        . tail
-        . dropWhile (/= set)
-        . cycle
-        . sort
-        $ cabals) ?? NoToolVersionSet tool
-    HLS -> do
-      set <- hlsSet !? NoToolVersionSet tool
-      hlses <- rights <$> lift getInstalledHLSs
-      (fmap (GHCTargetVersion Nothing)
-        . headMay
-        . tail
-        . dropWhile (/= set)
-        . cycle
-        . sort
-        $ hlses) ?? NoToolVersionSet tool
-    GHCup -> fail "GHCup cannot be set"
-  vi <- getVersionInfo (_tvVersion next) tool av ?? VerNotFound (_tvVersion next) tool
-  pure (next, vi)
-fromVersion' _ (SetToolTag t') tool =
+        Just v' -> pure $ GHCTargetVersion (_tvTarget v) v'
+        Nothing -> pure v
+    Right _ -> pure v
+fromVersion av (Just (ToolTag Latest)) tool =
+  mkTVer <$> getLatest av tool ?? TagNotFound Latest tool
+fromVersion av (Just (ToolTag Recommended)) tool =
+  mkTVer <$> getRecommended av tool ?? TagNotFound Recommended tool
+fromVersion av (Just (ToolTag (Base pvp''))) GHC =
+  mkTVer <$> getLatestBaseVersion av pvp'' ?? TagNotFound (Base pvp'') GHC
+fromVersion _ (Just (ToolTag t')) tool =
  throwE $ TagNotFound t' tool


@@ -1863,27 +1688,27 @@ checkForUpdates :: ( MonadReader AppState m
                -> PlatformRequest
                -> m ()
 checkForUpdates dls pfreq = do
-  forM_ (getLatest dls GHCup) $ \(l, _) -> do
+  forM_ (getLatest dls GHCup) $ \l -> do
    (Right ghc_ver) <- pure $ version $ prettyPVP ghcUpVer
    when (l > ghc_ver)
      $ $(logWarn)
          [i|New GHCup version available: #{prettyVer l}. To upgrade, run 'ghcup upgrade'|]

-  forM_ (getLatest dls GHC) $ \(l, _) -> do
+  forM_ (getLatest dls GHC) $ \l -> do
    mghc_ver <- latestInstalled GHC
    forM mghc_ver $ \ghc_ver ->
      when (l > ghc_ver)
        $ $(logWarn)
            [i|New GHC version available: #{prettyVer l}. To upgrade, run 'ghcup install ghc #{prettyVer l}'|]

-  forM_ (getLatest dls Cabal) $ \(l, _) -> do
+  forM_ (getLatest dls Cabal) $ \l -> do
    mcabal_ver <- latestInstalled Cabal
    forM mcabal_ver $ \cabal_ver ->
      when (l > cabal_ver)
        $ $(logWarn)
            [i|New Cabal version available: #{prettyVer l}. To upgrade, run 'ghcup install cabal #{prettyVer l}'|]

-  forM_ (getLatest dls HLS) $ \(l, _) -> do
+  forM_ (getLatest dls HLS) $ \l -> do
    mcabal_ver <- latestInstalled HLS
    forM mcabal_ver $ \cabal_ver ->
      when (l > cabal_ver)
@@ -1902,7 +1727,7 @@ GHCup base dir: #{toFilePath diBaseDir}
 GHCup bin dir: #{toFilePath diBinDir}
 GHCup GHC directory: #{toFilePath diGHCDir}
 GHCup cache directory: #{toFilePath diCacheDir}
-Architecture: #{prettyShow diArch}
-Platform: #{prettyShow diPlatform}
+Architecture: #{prettyArch diArch}
+Platform: #{prettyPlatform diPlatform}
 Version: #{describe_result}|]

--- a/8
+++ b/8
@@ -69,7 +69,7 @@ _done() {
 download_ghcup() {
 	_plat="$(uname -s)"
 	_arch=$(uname -m)
-	_ghver="0.1.13"
+	_ghver="0.1.12"
 	_base_url="https://downloads.haskell.org/~ghcup"

    case "${_plat}" in
@@ -89,12 +89,6 @@ download_ghcup() {
 				i*86)
 					_url=${_base_url}/${_ghver}/i386-linux-ghcup-${_ghver}
 					;;
-				armv7*)
-					_url=${_base_url}/${_ghver}/armv7-linux-ghcup-${_ghver}
-					;;
-				aarch64|arm64|armv8l)
-					_url=${_base_url}/${_ghver}/aarch64-linux-ghcup-${_ghver}
-					;;
 				*) die "Unknown architecture: ${_arch}"
 					;;
 			esac
--- a/cabal.project
+++ b/cabal.project
@@ -22,8 +22,39 @@ source-repository-package

 source-repository-package
    type: git
-    location: https://github.com/hasufell/streamly.git
-    tag: f921e78236c6b44a6673b5e1a1803d2e7102d806
+    location: https://github.com/well-typed/optics.git
+    tag: a21d34612bfe5a9552ff35df98d7dc6b87e57e28
+    subdir: optics-th
+
+source-repository-package
+    type: git
+    location: https://github.com/well-typed/optics.git
+    tag: a21d34612bfe5a9552ff35df98d7dc6b87e57e28
+    subdir: optics-extra
+
+source-repository-package
+    type: git
+    location: https://github.com/well-typed/optics.git
+    tag: a21d34612bfe5a9552ff35df98d7dc6b87e57e28
+    subdir: optics-core
+
+source-repository-package
+    type: git
+    location: https://github.com/well-typed/optics.git
+    tag: a21d34612bfe5a9552ff35df98d7dc6b87e57e28
+    subdir: optics
+
+source-repository-package
+    type: git
+    location: https://github.com/well-typed/generics-sop.git
+    tag: dcac01495c377bd29cf8f6dcf714f23a47edde9d
+    subdir: generics-sop
+
+source-repository-package
+    type: git
+    location: https://github.com/well-typed/generics-sop.git
+    tag: dcac01495c377bd29cf8f6dcf714f23a47edde9d
+    subdir: sop-core

 optimization: 2

@@ -38,4 +69,4 @@ constraints: http-io-streams -brotli
 package libarchive
  flags: -system-libarchive

-allow-newer: base, ghc-prim, template-haskell
+allow-newer: base, ghc-prim, template-haskell, Cabal
--- a/ghcup-0.0.4.yaml
+++ b/ghcup-0.0.4.yaml
@@ -28,7 +28,7 @@ toolRequirements:
          - libncurses5
          - libtinfo5
          notes: ''
-        "( >= 20.04 && < 20.10 )":
+        ">= 20.04":
          distroPKGs:
          - build-essential
          - curl
@@ -40,18 +40,6 @@ toolRequirements:
          - libncurses5
          - libtinfo5
          notes: ''
-        "( >= 20.10 )":
-          distroPKGs:
-          - build-essential
-          - curl
-          - libffi-dev
-          - libffi8ubuntu1
-          - libgmp-dev
-          - libgmp10
-          - libncurses-dev
-          - libncurses5
-          - libtinfo5
-          notes: ''
      Linux_CentOS:
        '( >= 7 && < 8 )':
          distroPKGs:
@@ -76,19 +64,6 @@ toolRequirements:
          - xz
          - perl
          notes: ''
-      Linux_Fedora:
-        unknown_versioning:
-          distroPKGs:
-          - gcc
-          - gcc-c++
-          - gmp
-          - gmp-devel
-          - make
-          - ncurses
-          - ncurses-compat-libs
-          - xz
-          - perl
-          notes: ''
      Linux_Alpine:
        unknown_versioning:
          distroPKGs:
@@ -138,7 +113,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/7.10.3/ghc-7.10.3-src.tar.xz
        dlSubdir: ghc-7.10.3
        dlHash: cf90cedce1c28fd0e2b9e72fe8a938756668d18ea1fcc884a19f698658ac4fef
-      viPostRemove: &ghc-post-remove "After removing GHC you might also want to clean up your cabal store at: ~/.cabal/store/ghc-<ghcver>"
      viArch:
        A_64:
          Linux_Debian:
@@ -202,7 +176,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.0.2/ghc-8.0.2-src.tar.xz
        dlSubdir: ghc-8.0.2
        dlHash: 11625453e1d0686b3fa6739988f70ecac836cadc30b9f0c8b49ef9091d6118b1
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -220,7 +193,7 @@ ghcupDownloads:
            unknown_versioning: *ghc-802-64-deb8
          Linux_Alpine:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.0.2/ghc-8.0.2-x86_64-alpine-linux.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.0.2-x86_64-alpine-linux.tar.xz
              dlSubdir: ghc-8.0.2
              dlHash: 517783b660a27ebf95b2568d47292fd633d5f9a4de4c80ad1ccf05e1b9d7313f
          Linux_UnknownLinux:
@@ -247,7 +220,7 @@ ghcupDownloads:
              dlHash: 818621342a2161b8afcc995a0765816bb40aefbfa1db2c8a7d59c04d8b18228a
          Linux_Alpine:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.0.2/ghc-8.0.2-i386-alpine-linux.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.0.2-i386-alpine-linux.tar.xz
              dlSubdir: ghc-8.0.2
              dlHash: b4cd12a1048b2fff2f23c9eec0dd3a1174d54d017f8d79ec79af4534118e6881
          Linux_UnknownLinux:
@@ -261,7 +234,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.2.2/ghc-8.2.2-src.tar.xz
        dlSubdir: ghc-8.2.2
        dlHash: bb8ec3634aa132d09faa270bbd604b82dfa61f04855655af6f9d14a9eedc05fc
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -279,7 +251,7 @@ ghcupDownloads:
            unknown_versioning: *ghc-822-64-deb8
          Linux_Alpine:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.2.2/ghc-8.2.2-x86_64-alpine-linux.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.2.2-x86_64-alpine-linux.tar.xz
              dlSubdir: ghc-8.2.2
              dlHash: adcf3a320a3c402aba07ae9586990dc3c0b550e96aeffb1b9e194313d3ba716d
          Linux_UnknownLinux:
@@ -315,7 +287,7 @@ ghcupDownloads:
            unknown_versioning: *ghc-822-32-deb8
          Linux_Alpine:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.2.2/ghc-8.2.2-i386-alpine-linux.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.2.2-i386-alpine-linux.tar.xz
              dlSubdir: ghc-8.2.2
              dlHash: 467534c32552cfd318753112dbc70af003693aad4b0081f2a07e61f5b5ea2c22
          Linux_UnknownLinux:
@@ -329,7 +301,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.4.1/ghc-8.4.1-src.tar.xz
        dlSubdir: ghc-8.4.1
        dlHash: 39ae2f25192408f355693e5a3c8b6ff613ddb7c4da998fdf26210143a61839d2
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -379,7 +350,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.4.2/ghc-8.4.2-src.tar.xz
        dlSubdir: ghc-8.4.2
        dlHash: 01cc32f24a06bf3b2428351b6d7fec791e82d042426d29ad9e5a245b35f0047b
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -434,7 +404,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.4.3/ghc-8.4.3-src.tar.xz
        dlSubdir: ghc-8.4.3
        dlHash: ae47afda985830de8811243255aa3744dfb9207cb980af74393298b2b62160d6
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -483,7 +452,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.4.4/ghc-8.4.4-src.tar.xz
        dlSubdir: ghc-8.4.4
        dlHash: 11117735a58e507c481c09f3f39ae5a314e9fbf49fc3109528f99ea7959004b2
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -514,7 +482,7 @@ ghcupDownloads:
            unknown_versioning: *ghc-844-64-centos
          Linux_Alpine:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.4.4/ghc-8.4.4-x86_64-alpine-linux.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.4.4-x86_64-alpine-linux.tar.xz
              dlSubdir: ghc-8.4.4
              dlHash: 336affff8314d3dc5e85d9c09015ae2ba8a7658b459c8c8ae77ecaa551a56ae7
          Linux_AmazonLinux:
@@ -543,7 +511,7 @@ ghcupDownloads:
            unknown_versioning: *ghc-844-32-deb8
          Linux_Alpine:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.4.4/ghc-8.4.4-i386-alpine-linux.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.4.4-i386-alpine-linux.tar.xz
              dlSubdir: ghc-8.4.4
              dlHash: 892888d388ef5c9cadf5cfba1146d62237c25b9b066fb62fee940b2b285fd308
          Linux_UnknownLinux:
@@ -557,7 +525,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.6.1/ghc-8.6.1-src.tar.xz
        dlSubdir: ghc-8.6.1
        dlHash: 2c25c26d1e5c47c7cbb2a1d8e6456524033e7a71409184dd3125e3fc5a3c7036
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -612,7 +579,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.6.2/ghc-8.6.2-src.tar.xz
        dlSubdir: ghc-8.6.2
        dlHash: caaa819d21280ecde90a4773143dee188711e9ff175a27cfbaee56eb851d76d5
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -658,7 +624,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.6.3/ghc-8.6.3-src.tar.xz
        dlSubdir: ghc-8.6.3
        dlHash: 9f9e37b7971935d88ba80426c36af14b1e0b3ec1d9c860f44a4391771bc07f23
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -722,7 +687,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.6.4/ghc-8.6.4-src.tar.xz
        dlSubdir: ghc-8.6.4
        dlHash: 5b5d07e4463203a433c3ed3df461ba6cce11b6d2b9b264db31f3429075d0303a
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -771,7 +735,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.6.5/ghc-8.6.5-src.tar.xz
        dlSubdir: ghc-8.6.5
        dlHash: 4d4aa1e96f4001b934ac6193ab09af5d6172f41f5a5d39d8e43393b9aafee361
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -802,7 +765,7 @@ ghcupDownloads:
            unknown_versioning: *ghc-865-64-centos
          Linux_Alpine:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.6.5/ghc-8.6.5-x86_64-alpine-linux.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.6.5-x86_64-alpine-linux.tar.xz
              dlSubdir: ghc-8.6.5
              dlHash: b9d3ed7f7aa24ef2d58bb579252289caa0b8877adee3685e3af2fb73d440afdc
          Linux_AmazonLinux:
@@ -816,7 +779,7 @@ ghcupDownloads:
              dlHash: dfc1bdb1d303a87a8552aa17f5b080e61351f2823c2b99071ec23d0837422169
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.6.5/ghc-8.6.5-x86_64-portbld-freebsd.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.6.5-x86_64-portbld-freebsd.tar.xz
              dlSubdir: ghc-8.6.5
              dlHash: 83a3059a630d40a98e26cb5b520354e12094a96e36ba2f5ab002dad94cf2fb37
        A_32:
@@ -831,17 +794,11 @@ ghcupDownloads:
            unknown_versioning: *ghc-865-32-deb9
          Linux_Alpine:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.6.5/ghc-8.6.5-i386-alpine-linux.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.6.5-i386-alpine-linux.tar.xz
              dlSubdir: ghc-8.6.5
              dlHash: 3737837550d9b177acfe150e3a3cd4545427ded020487c2ed5194d7b8f116349
          Linux_UnknownLinux:
            unknown_versioning: *ghc-865-32-deb9
-        A_ARM64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.6.5/ghc-8.6.5-aarch64-ubuntu18.04-linux.tar.xz
-              dlSubdir: ghc-8.6.5
-              dlHash: 1852589037e4b2805ab517bc430e25a3125c4a118a1674ffefbb443394a0c786
    8.8.1:
      viTags:
      - base-4.13.0.0
@@ -851,7 +808,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.8.1/ghc-8.8.1-src.tar.xz
        dlSubdir: ghc-8.8.1
        dlHash: 908a83d9b814da74585de9d39687189e6260ec3848131f9d9236cab8a123721a
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -910,7 +866,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.8.2/ghc-8.8.2-src.tar.xz
        dlSubdir: ghc-8.8.2
        dlHash: 01cea54d90686b97bcc9960b108beaffccd4336dee930dcf9beaf52b1f370a0b
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -969,7 +924,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.8.3/ghc-8.8.3-src.tar.xz
        dlSubdir: ghc-8.8.3
        dlHash: e0dcc0aaf3e234c5978f29e6df62947e97720ab404ec0158343df211c5480f89
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -1009,7 +963,7 @@ ghcupDownloads:
              dlHash: 7016de90dd226b06fc79d0759c5d4c83c2ab01d8c678905442c28bd948dbb782
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.8.3/ghc-8.8.3-x86_64-portbld-freebsd.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.8.3-x86_64-portbld-freebsd.tar.xz
              dlSubdir: ghc-8.8.3
              dlHash: 569719075b4d14b3875a899df522090ae31e6fe085e6dffe518e875b09a2f0be
        A_32:
@@ -1024,12 +978,6 @@ ghcupDownloads:
            unknown_versioning: *ghc-883-32-deb9
          Linux_UnknownLinux:
            unknown_versioning: *ghc-883-32-deb9
-        A_ARM64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.8.3/ghc-8.8.3-aarch64-deb9-linux.tar.xz
-              dlSubdir: ghc-8.8.3
-              dlHash: 2a6821d0e7326cfa7670851702924bbab3b092415ba41247c37419158327eed9
    8.8.4:
      viTags:
      - base-4.13.0.0
@@ -1038,7 +986,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.8.4/ghc-8.8.4-src.tar.xz
        dlSubdir: ghc-8.8.4
        dlHash: f0505e38b2235ff9f1090b51f44d6c8efd371068e5a6bb42a2a6d8b67b5ffc2d
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -1069,7 +1016,7 @@ ghcupDownloads:
            unknown_versioning: *ghc-884-64-centos
          Linux_Alpine:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.8.4/ghc-8.8.4-x86_64-alpine-linux.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.8.4-x86_64-alpine-linux.tar.xz
              dlSubdir: ghc-8.8.4
              dlHash: 90c6a1661de7f20c7d169cd6270125035b3332063e45103ce028df0beecf434e
          Linux_AmazonLinux:
@@ -1083,7 +1030,7 @@ ghcupDownloads:
              dlHash: e80a789e9d8cfb41dd87f3284b75432427c4461c1731d220d04ead8733ccdb5e
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.8.4/ghc-8.8.4-x86_64-portbld-freebsd.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.8.4-x86_64-portbld-freebsd.tar.xz
              dlSubdir: ghc-8.8.4
              dlHash: 8cebe5ccf454e82acd1ff52ca57590d1ab0f3f44a981b46257ec12158c8c447e
        A_32:
@@ -1098,7 +1045,7 @@ ghcupDownloads:
            unknown_versioning: *ghc-884-32-deb9
          Linux_Alpine:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.8.4/ghc-8.8.4-i386-alpine-linux.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.8.4-i386-alpine-linux.tar.xz
              dlSubdir: ghc-8.8.4
              dlHash: 1d18e89ee031197e55c48683e78a7ffc67601ac5fd9f73aac555eb064b3859a2
          Linux_UnknownLinux:
@@ -1112,7 +1059,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/8.10.1/ghc-8.10.1-src.tar.xz
        dlSubdir: ghc-8.10.1
        dlHash: 4e3b07f83a266b3198310f19f71e371ebce97c769b14f0d688f4cbf2a2a1edf5
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -1160,7 +1106,7 @@ ghcupDownloads:
              dlHash: 65b1ca361093de4804a7e40b3e68178e1ef720f84f743641ec8d95e56a45b3a8
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.10.1/ghc-8.10.1-x86_64-portbld-freebsd.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.10.1-x86_64-portbld-freebsd.tar.xz
              dlSubdir: ghc-8.10.1
              dlHash: e8646ec9b60fd40aa9505ee055f22f04601290ab7a1342c2cf37c34de9d3f142
        A_32:
@@ -1176,33 +1122,19 @@ ghcupDownloads:
            unknown_versioning: *ghc-8101-32-deb9
          Linux_Alpine:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.10.1/ghc-8.10.1-i386-alpine-linux.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.10.1-i386-alpine-linux.tar.xz
              dlSubdir: ghc-8.10.1
              dlHash: 7360cc6b29e9b4ab08f6ea5bc3bcca6f5c216933e81ef1620dcdd700f1fdb289
          Linux_UnknownLinux:
            unknown_versioning: *ghc-8101-32-deb9
-        A_ARM64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.1/ghc-8.10.1-aarch64-deb9-linux.tar.xz
-              dlSubdir: ghc-8.10.1
-              dlHash: c099011e07999db917e797fb5d89c31f075a562556ab99be8ab0accbf2a94db7
-        A_ARM:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.1/ghc-8.10.1-armv7-deb9-linux.tar.xz
-              dlSubdir: ghc-8.10.1
-              dlHash: afe1bde2b0d6deb0320b9460fffe5d9427e302df85aec866b9c1458777d52b28
    8.10.2:
      viTags:
-      - old
      - base-4.14.1.0
      viChangeLog: https://downloads.haskell.org/~ghc/8.10.2/docs/html/users_guide/8.10.2-notes.html
      viSourceDL:
        dlUri: https://downloads.haskell.org/~ghc/8.10.2/ghc-8.10.2-src.tar.xz
        dlSubdir: ghc-8.10.2
        dlHash: 9c573a4621a78723950617c223559bdc325ea6a3409264aedf68f05510b0880b
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -1268,30 +1200,18 @@ ghcupDownloads:
            unknown_versioning: *ghc-8102-32-deb9
          Linux_Alpine:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.10.2/ghc-8.10.2-i386-alpine-linux.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.10.2-i386-alpine-linux.tar.xz
              dlSubdir: ghc-8.10.2
              dlHash: 9ee1cf1e85e9536088b3c9e80e975074e525ea378cd4eb156071bbc4b7b38327
-        A_ARM64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.2/ghc-8.10.2-aarch64-deb10-linux.tar.xz
-              dlSubdir: ghc-8.10.2
-              dlHash: 5cf24189077e6e2dce2aa16367ad8a53f603e751a15010dfb23d067206e55593
-        A_ARM:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.2/ghc-8.10.2-armv7-deb10-linux.tar.xz
-              dlSubdir: ghc-8.10.2
-              dlHash: bb9c97826b1f4d7a8ef8bce0616b612f1ded10480ef10fcf7fb4e6d10a6681c8
    8.10.3:
      viTags:
+      - Recommended
      - base-4.14.1.0
      viChangeLog: https://downloads.haskell.org/~ghc/8.10.3/docs/html/users_guide/8.10.3-notes.html
      viSourceDL:
        dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-src.tar.xz
        dlSubdir: ghc-8.10.3
        dlHash: ccdc8319549028a708d7163e2967382677b1a5a379ff94d948195b5cf46eb931
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -1357,112 +1277,9 @@ ghcupDownloads:
            unknown_versioning: *ghc-8103-32-deb9
          Linux_Alpine:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.10.3/ghc-8.10.3-i386-alpine-linux.tar.xz
+              dlUri: https://files.hasufell.de/ghc/ghc-8.10.3-i386-alpine-linux.tar.xz
              dlSubdir: ghc-8.10.3
              dlHash: 309201cdefd2d13b8b3fd09c26c6137048c490d219a0a9c7407c3ce1d011f60c
-        A_ARM64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-aarch64-deb10-linux.tar.xz
-              dlSubdir: ghc-8.10.3
-              dlHash: a531432d505a1fe886cdc8639d168eb1c92d76464c1270713e01ce81891bbadb
-        A_ARM:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-armv7-deb10-linux.tar.xz
-              dlSubdir: ghc-8.10.3
-              dlHash: b823b58cae36fbac0741680ca7605180fa4cf4c6ae439123d282184b94d32fd6
-    8.10.4:
-      viTags:
-      - Recommended
-      - base-4.14.1.0
-      viChangeLog: https://downloads.haskell.org/~ghc/8.10.4/docs/html/users_guide/8.10.4-notes.html
-      viSourceDL:
-        dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-src.tar.xz
-        dlSubdir: ghc-8.10.4
-        dlHash: 52af871b4e08550257d720c2944ac85727d0b948407cef1bebfe7508c224910e
-      viPostRemove: *ghc-post-remove
-      viPreCompile: "If you have autoconf >= 2.70 you'll need this patch https://gitlab.haskell.org/ghc/ghc/-/snippets/2040 (see the --patchdir option)"
-      viArch:
-        A_64:
-          Linux_Debian:
-            '( >= 9 && < 10 )': &ghc-8104-64-deb9
-              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-x86_64-deb9-linux.tar.xz
-              dlSubdir: ghc-8.10.4
-              dlHash: 5694200a5c38f22c142baf850b1d2f3784211d2ec9302e11693259a1ae8e38b7
-            '( >= 10 && < 11 )': &ghc-8104-64-deb10
-              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-x86_64-deb10-linux.tar.xz
-              dlSubdir: ghc-8.10.4
-              dlHash: 816365565e9927459b035515a7db6a0db62f9796f327389b6f8a0035d12fbda0
-            unknown_versioning: *ghc-8104-64-deb9
-          Linux_Ubuntu:
-            unknown_versioning: &ghc-8104-64-fedora
-              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-x86_64-fedora27-linux.tar.xz
-              dlSubdir: ghc-8.10.4
-              dlHash: a189eed900a8717d6d7906bafd10b9a9a9688ad942d1c75e19df480376dff9ea
-            '( >= 16 && < 19 )': *ghc-8104-64-deb9
-          Linux_Mint:
-            unknown_versioning: *ghc-8104-64-deb10
-          Linux_Fedora:
-            '( >= 27 && < 28 )': *ghc-8104-64-fedora
-            unknown_versioning: *ghc-8104-64-fedora
-          Linux_CentOS:
-            '( >= 7 && < 8 )': &ghc-8104-64-centos
-              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-x86_64-centos7-linux.tar.xz
-              dlSubdir: ghc-8.10.4
-              dlHash: fb8a91f0cf06594172aff46c2f6f7486179e1c3760855c79fbdd3012598cc2cd
-            unknown_versioning: *ghc-8104-64-centos
-          Linux_RedHat:
-            unknown_versioning: *ghc-8104-64-centos
-          Linux_Alpine:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-x86_64-alpine3.10-linux-integer-simple.tar.xz
-              dlSubdir: ghc-8.10.4-x86_64-unknown-linux
-              dlHash: 74c2c07537832708502716ef4ec40019f8e552ddda13c8eadf8f7c4b03a79359
-          Linux_AmazonLinux:
-            unknown_versioning: *ghc-8104-64-centos
-          Linux_UnknownLinux:
-            unknown_versioning: *ghc-8104-64-fedora
-          Darwin:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-x86_64-apple-darwin.tar.xz
-              dlSubdir: ghc-8.10.4
-              dlHash: 725ecf6543e63b81a3581fb8c97afd21a08ae11bc0fa4f8ee25d45f0362ef6d5
-          FreeBSD:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-x86_64-portbld-freebsd.tar.xz
-              dlSubdir: ghc-8.10.4
-              dlHash: c9776a2ccf9629b03e967206a507fcdcb6c5189800a626e9461ababf6733c357
-        A_32:
-          Linux_Debian:
-            '( >= 9 && < 10 )': &ghc-8104-32-deb9
-              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-i386-deb9-linux.tar.xz
-              dlSubdir: ghc-8.10.4
-              dlHash: 0022c5b9ac22825bb7b4745af3d92cef0ba1ecd01fab3ef387ddbd47146569ad
-            unknown_versioning: *ghc-8104-32-deb9
-          Linux_Ubuntu:
-            unknown_versioning: *ghc-8104-32-deb9
-          Linux_Mint:
-            unknown_versioning: *ghc-8104-32-deb9
-          Linux_UnknownLinux:
-            unknown_versioning: *ghc-8104-32-deb9
-          Linux_Alpine:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.10.4/ghc-8.10.4-i386-alpine-linux.tar.xz
-              dlSubdir: ghc-8.10.4
-              dlHash: 9161a98bed763692101854d83af69c1316030cfe5ee6f6acde283d04ef139735
-        A_ARM64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-aarch64-deb10-linux.tar.xz
-              dlSubdir: ghc-8.10.4
-              dlHash: 249da6310be799a5eefe0579b6dae1701eb984afb980fe08309d19cf704038ed
-        A_ARM:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/8.10.4/ghc-8.10.4-armv7-deb10-linux.tar.xz
-              dlSubdir: ghc-8.10.4
-              dlHash: 0d18ef83593272f6196a41cc3abdc48dfe5e14372db75d71ea19fe35320c4e81
    9.0.1:
      viTags:
      - Latest
@@ -1472,7 +1289,6 @@ ghcupDownloads:
        dlUri: https://downloads.haskell.org/~ghc/9.0.1/ghc-9.0.1-src.tar.xz
        dlSubdir: ghc-9.0.1
        dlHash: a5230314e4065f9fcc371dfe519748fd85c825b279abf72a24e09b83578a35f9
-      viPostRemove: *ghc-post-remove
      viArch:
        A_64:
          Linux_Debian:
@@ -1536,23 +1352,6 @@ ghcupDownloads:
            unknown_versioning: *ghc-901-32-deb9
          Linux_UnknownLinux:
            unknown_versioning: *ghc-901-32-deb9
-          Linux_Alpine:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/9.0.1/ghc-9.0.1-i386-alpine-linux.tar.xz
-              dlSubdir: ghc-9.0.1
-              dlHash: ebfeb3b91e6f2bb5a49fd3376746f7fd1b89e62e9838bf5b1530a8756ff1e6aa
-        A_ARM64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1/ghc-9.0.1-aarch64-deb9-linux.tar.xz
-              dlSubdir: ghc-9.0.1
-              dlHash: fac7a0bdfc83c05df94024a2d67b8f00a9cd2733b9cb41fb8ad76be399014906
-        A_ARM:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1/ghc-9.0.1-armv7-deb9-linux.tar.xz
-              dlSubdir: ghc-9.0.1
-              dlHash: 6f404f9b88468407b3a9ec5800bcc2d01dd453ef3d63414853b4fbbd4d8df496
  Cabal:
    2.4.1.0:
      viTags:
@@ -1619,7 +1418,8 @@ ghcupDownloads:
              dlHash: 6898ccd6e6dc0872999c06daaf61d546164e12f60a1880d09852c9f0c59c5cf6
    3.2.0.0:
      viTags:
-      - old
+      - Recommended
+      - Latest
      viChangeLog: https://downloads.haskell.org/~cabal/cabal-install-3.2.0.0/changelog
      viArch:
        A_64:
@@ -1648,52 +1448,32 @@ ghcupDownloads:
            unknown_versioning:
              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.2.0.0/cabal-install-3.2.0.0-i386-unknown-linux.tar.xz
              dlHash: 2b3ac28549916de5f3379241797eaf60e84b6c001f2abbe73d9fadbbaf768e93
-    3.4.0.0:
+    3.4.0.0-rc4:
      viTags:
-      - Recommended
-      - Latest
+      - Prerelease
      viChangeLog: https://github.com/haskell/cabal/blob/master/release-notes/cabal-install-3.4.0.0.md
      viArch:
        A_64:
          Linux_Ubuntu:
-            unknown_versioning: &cabal-3400-ubuntu
-              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.4.0.0/cabal-install-3.4.0.0-x86_64-ubuntu-16.04.tar.xz
-              dlHash: cf28f9ffd763476aa2b1730d85cbf155d366fac541f78ee3951e8cb2d6de63e6
+            unknown_versioning: &cabal-3400rc4-ubuntu
+              dlUri: http://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-ubuntu-16.04.tar.xz
+              dlHash: a1be168876816a624b206c55596d9bb5f442541c889ee2438d664698122b9ffe
          Linux_Alpine:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.4.0.0/cabal-install-3.4.0.0-x86_64-alpine-3.11.6-static-noofd.tar.xz
-              dlHash: c74073fe79110946182e522fcadc8dcabf07c87583e8cf7801ed4e0c327241f6
+              dlUri: http://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-alpine-3.11.6-static-noofd.tar.xz
+              dlHash: 49dab6684483594e4c7c3e561ec477268002605253ad34701b471277efbe91bc
          Linux_UnknownLinux:
-            unknown_versioning: *cabal-3400-ubuntu
+            unknown_versioning: *cabal-3400rc4-ubuntu
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.4.0.0/cabal-install-3.4.0.0-x86_64-darwin-sierra.tar.xz
-              dlHash: cb10be9a53e856aa2d852fd88fb6944f138783ffe0ea84d93c9a69244e34ea91
+              dlUri: http://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-darwin-sierra.tar.xz
+              dlHash: a3f809a3388e90b9fdf52444e30ea9aad3894e2cbe53c37fc3311ceb106eda9e
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.4.0.0/cabal-install-3.4.0.0-x86_64-freebsd-12.1-release.tar.xz
-              dlHash: a1e2db664ec00e42a1e071a4181f6476f6e0bad321f1ddc0cf27831119f4c6d4
-        A_32:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.4.0.0/cabal-install-3.4.0.0-i386-debian-9.tar.xz
-              dlHash: ef3750644a53f7b1fad141b2ad02d4c7a3b239ec0cbfa7f0528fb02c1dfcebce
-          Linux_Alpine:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/cabal/3.4.0.0/cabal-install-3.4.0.0-i386-alpine-linux-musl.tar.gz
-              dlHash: 95adb65f3a72aa8d9ce83685bc06e1eee5b801f56e204e27e957e8a35abd9cf8
-        A_ARM64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~cabal/cabal-install-3.4.0.0/cabal-install-3.4.0.0-aarch64-ubuntu-18.04.tar.xz
-              dlHash: 04d378347896dfdc3510b192b97489815cfa5d692f46e2758da0f789e682b8f0
-        A_ARM:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/unofficial-bindists/cabal/3.4.0.0/cabal-install-3.4.0.0-armv7-linux-bootstrapped.tar.xz
-              dlHash: 16c0d1eaba24bed14f3e152970179a45d9f9bb5cc839b2c210ad06eb7d4826ed
+              dlUri: http://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-freebsd-12.1-release.tar.xz
+              dlHash: 9705e16d03497b46be4ad477e6c64d10890af853eafa8a9adf6dba89aa9e05f7
  GHCup:
-    0.1.13:
+    0.1.12:
      viTags:
      - Recommended
      - Latest
@@ -1703,51 +1483,40 @@ ghcupDownloads:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-linux-ghcup-0.1.13
-              dlHash: 674266bb9fa85bbafd3c620c68fae4b3cc62507bd6ad9b116603e860bdee1f5a
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-linux-ghcup-0.1.12
+              dlHash: 83088569ddf2d35df494f440dedd9c8eb2a53276d665f7de731f6554986c2ddb
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-apple-darwin-ghcup-0.1.13
-              dlHash: 5e45cb0b69cd8ee4f7793b84042d4bd121609fa59531ef760fc98fa10c466e4d
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-apple-darwin-ghcup-0.1.12
+              dlHash: 1336efb0851e1ed267838f97f6c36cbceb5363ad0ae359f04f1bc43d0c5f2cef
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-portbld-freebsd-ghcup-0.1.13
-              dlHash: 79ce3143a100b60b5294fa831abf091b9699e0bf3addb6c9956de706fc954902
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-portbld-freebsd-ghcup-0.1.12
+              dlHash: a72123e972a53d667574c7d276a81842701a07fce2b434e4d856e561c34772fe
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/i386-linux-ghcup-0.1.13
-              dlHash: 4d7646027215b29384f1409399f66bd348421de8a6d53e47ae47c3b465e18fb0
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/i386-linux-ghcup-0.1.12
+              dlHash: 4bc79a272dfcd16143f08d9f8e33f2fef66dc53f3a0659bdab56ac3cbecf9e84
          Linux_Alpine:
            unknown_versioning: *ghcup-32
-        A_ARM64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/aarch64-linux-ghcup-0.1.13
-              dlHash: c60be7ca13454a9ea5cfe1aacd57809a01605c9533f40a433543d443ac16e439
-        A_ARM:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/armv7-linux-ghcup-0.1.13
-              dlHash: d0d047dce694a43ce2872c28ad05b22541c43d6e222eed172b9f909f5dbadb8c
  HLS:
-    1.0.0:
+    0.9.0:
      viTags:
        - Recommended
        - Latest
-      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#100
-      viPostInstall: "This is just the server part of your LSP configuration. Consult the README on how to configure HLS, your project and your LSP client in your editor: https://github.com/haskell/haskell-language-server/blob/master/README.md"
+      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#090
      viArch:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &hls-64
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.0.0/haskell-language-server-Linux-1.0.0.tar.gz
-              dlHash: 4fab18998c5f67118a26b75b059f3b3e2ad345b6325515a552d1a24cdf87ed3f
+              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.9.0/haskell-language-server-Linux-0.9.0.tar.gz
+              dlHash: 6933216e2fcdc51a32a828f7880403d83433b6585ff393da196f6db1d4e1e53f
          Darwin:
            unknown_versioning:
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.0.0/haskell-language-server-macOS-1.0.0.tar.gz
-              dlHash: 74e7624c889c0235f0b02d7e7f164d5eb95b611d584fc8602f0b3a099b73f8be
+              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.9.0/haskell-language-server-macOS-0.9.0.tar.gz
+              dlHash: f6197977941e803e128889f1170bebca97a80c1b62234bf5c7b1032ab3df68f4
          Linux_Alpine:
            unknown_versioning: *hls-64
--- a/ghcup.cabal
+++ b/ghcup.cabal
@@ -1,6 +1,6 @@
 cabal-version:      3.0
 name:               ghcup
-version:            0.1.13
+version:            0.1.12
 synopsis:           ghc toolchain installer as an exe/library
 description:
  A rewrite of the shell script ghcup, for providing
@@ -150,9 +150,6 @@ common optparse-applicative
 common parsec
  build-depends: parsec >=3.1

-common pretty
-  build-depends: pretty >=1.1.3.1
-
 common pretty-terminal
  build-depends: pretty-terminal >=0.1.0.0

@@ -291,7 +288,6 @@ library
    , optics
    , optics-vl
    , parsec
-    , pretty
    , pretty-terminal
    , regex-posix
    , resourcet
@@ -340,13 +336,11 @@ library
    GHCup.Utils.Version.QQ
    GHCup.Version

-  other-modules:
-    Paths_ghcup
-
  default-extensions:
    Strict
    StrictData

+  -- other-modules:
  -- other-extensions:
  hs-source-dirs:  lib

@@ -381,7 +375,6 @@ executable ghcup
    , monad-logger
    , mtl
    , optparse-applicative
-    , pretty
    , pretty-terminal
    , resourcet
    , safe
@@ -437,7 +430,6 @@ executable ghcup-gen
    , mtl
    , optics
    , optparse-applicative
-    , pretty
    , pretty-terminal
    , regex-posix
    , resourcet
--- a/golden/GHCupInfo.json
+++ b/golden/GHCupInfo.json
--- a/lib/GHCup.hs
+++ b/lib/GHCup.hs
@@ -525,7 +525,7 @@ setGHC ver sghc = do
  let verBS = verToBS (_tvVersion ver)
  ghcdir                        <- lift $ ghcupGHCDir ver

-  whenM (lift $ fmap not $ ghcInstalled ver) (throwE (NotInstalled GHC ver))
+  whenM (lift $ fmap not $ ghcInstalled ver) (throwE (NotInstalled GHC (ver ^. tvVersion % to prettyVer)))

  -- symlink destination
  AppState { dirs = Dirs {..} } <- lift ask
@@ -605,7 +605,7 @@ setCabal ver = do

  whenM (liftIO $ fmap not $ doesFileExist (binDir </> targetFile))
    $ throwE
-    $ NotInstalled Cabal (GHCTargetVersion Nothing ver)
+    $ NotInstalled Cabal (prettyVer ver)

  let cabalbin = binDir </> [rel|cabal|]

@@ -647,7 +647,7 @@ setHLS ver = do

  -- set haskell-language-server-<ghcver> symlinks
  bins <- lift $ hlsServerBinaries ver
-  when (bins == []) $ throwE $ NotInstalled HLS (GHCTargetVersion Nothing ver)
+  when (bins == []) $ throwE $ NotInstalled HLS (prettyVer ver)

  forM_ bins $ \f -> do
    let destL = toFilePath f
@@ -929,7 +929,7 @@ rmGHCVer :: ( MonadReader AppState m
 rmGHCVer ver = do
  isSetGHC <- lift $ fmap (maybe False (== ver)) $ ghcSet (_tvTarget ver)

-  whenM (lift $ fmap not $ ghcInstalled ver) (throwE (NotInstalled GHC ver))
+  whenM (lift $ fmap not $ ghcInstalled ver) (throwE (NotInstalled GHC (ver ^. tvVersion % to prettyVer)))
  dir <- lift $ ghcupGHCDir ver

  -- this isn't atomic, order matters
@@ -970,7 +970,7 @@ rmCabalVer :: (MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m, M
           => Version
           -> Excepts '[NotInstalled] m ()
 rmCabalVer ver = do
-  whenM (lift $ fmap not $ cabalInstalled ver) $ throwE (NotInstalled Cabal (GHCTargetVersion Nothing ver))
+  whenM (lift $ fmap not $ cabalInstalled ver) $ throwE (NotInstalled Cabal (prettyVer ver))

  cSet      <- lift $ cabalSet

@@ -993,7 +993,7 @@ rmHLSVer :: (MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m, Mon
         => Version
         -> Excepts '[NotInstalled] m ()
 rmHLSVer ver = do
-  whenM (lift $ fmap not $ hlsInstalled ver) $ throwE (NotInstalled HLS (GHCTargetVersion Nothing ver))
+  whenM (lift $ fmap not $ hlsInstalled ver) $ throwE (NotInstalled HLS (prettyVer ver))

  isHlsSet      <- lift $ hlsSet

@@ -1240,7 +1240,7 @@ Stage1Only = YES|]
      $ c
    tarName <-
      parseRel
-        [i|ghc-#{tVerToText tver}-#{pfReqToString pfreq}-#{cDigest}.tar#{takeExtension (toFilePath tar)}|]
+        [i|ghc-#{prettyTVer tver}-#{prettyPfReq pfreq}-#{cDigest}.tar#{takeExtension (toFilePath tar)}|]
    let tarPath = cacheDir </> tarName
    handleIO (throwE . CopyError . show) $ liftIO $ copyFile (workdir </> tar)
                                                             tarPath
@@ -1308,30 +1308,18 @@ upgradeGHCup :: ( MonadMask m
 upgradeGHCup dls mtarget force pfreq = do
  AppState {dirs = Dirs {..}} <- lift ask
  lift $ $(logInfo) [i|Upgrading GHCup...|]
-  let latestVer = fromJust $ fst <$> getLatest dls GHCup
+  let latestVer = fromJust $ getLatest dls GHCup
  when (not force && (latestVer <= pvpToVersion ghcUpVer)) $ throwE NoUpdate
  dli   <- lE $ getDownloadInfo GHCup latestVer pfreq dls
  tmp   <- lift withGHCupTmpDir
  let fn = [rel|ghcup|]
  p <- liftE $ download dli tmp (Just fn)
-  let destDir = dirname destFile
-      destFile = fromMaybe (binDir </> fn) mtarget
-  lift $ $(logDebug) [i|mkdir -p #{toFilePath destDir}|]
-  liftIO $ createDirRecursive' destDir
-  lift $ $(logDebug) [i|rm -f #{toFilePath destFile}|]
-  liftIO $ hideError NoSuchThing $ deleteFile destFile
-  lift $ $(logDebug) [i|cp #{toFilePath p} #{toFilePath destFile}|]
+  let fullDest = fromMaybe (binDir </> fn) mtarget
+  liftIO $ hideError NoSuchThing $ deleteFile fullDest
  handleIO (throwE . CopyError . show) $ liftIO $ copyFile p
-                                                           destFile
+                                                           fullDest
                                                           Overwrite
-  lift $ chmod_755 destFile
-
-  liftIO (isInPath destFile) >>= \b -> when (not b) $
-    lift $ $(logWarn) [i|"#{toFilePath (dirname destFile)}" is not in PATH! You have to add it in order to use ghcup.|]
-  liftIO (isShadowed destFile) >>= \case
-    Nothing -> pure ()
-    Just pa -> lift $ $(logWarn) [i|ghcup is shadowed by "#{toFilePath pa}". The upgrade will not be in effect, unless you remove "#{toFilePath pa}" or make sure "#{toFilePath destDir}" comes before "#{toFilePath (dirname pa)}" in PATH.|]
-
+  lift $ chmod_755 fullDest
  pure latestVer


--- a/lib/GHCup/Download.hs
+++ b/lib/GHCup/Download.hs
@@ -137,8 +137,30 @@ getDownloadsF urlSource = do
      bsExt <- reThrowAll DownloadFailed $ downloadBS uri
      ext <- lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bsExt)
      pure (mergeGhcupInfo base ext)
+ where
+  readFromCache :: (MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
+                => Excepts '[JSONError, FileDoesNotExistError] m GHCupInfo
+  readFromCache = do
+    AppState {dirs = Dirs {..}} <- lift ask
+    lift $ $(logWarn)
+      [i|Could not get download info, trying cached version (this may not be recent!)|]
+    let path = view pathL' ghcupURL
+    yaml_file <- (cacheDir </>) <$> urlBaseName path
+    bs        <-
+      handleIO' NoSuchThing
+                (\_ -> throwE $ FileDoesNotExistError (toFilePath yaml_file))
+      $ liftIO
+      $ readFile yaml_file
+    lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bs)

-    where
+  getBase :: (MonadFail m, MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
+          => Excepts '[JSONError , FileDoesNotExistError] m GHCupInfo
+  getBase =
+    handleIO (\_ -> readFromCache)
+    $ catchE @_ @'[JSONError, FileDoesNotExistError]
+        (\(DownloadFailed _) -> readFromCache)
+    $ ((reThrowAll @_ @_ @'[JSONError, DownloadFailed] DownloadFailed $ smartDl ghcupURL)
+      >>= (liftE . lE' @_ @_ @'[JSONError] JSONDecodeError . bimap show id . Y.decodeEither' . L.toStrict))

  mergeGhcupInfo :: GHCupInfo -- ^ base to merge with
                 -> GHCupInfo -- ^ extension overwriting the base
@@ -150,32 +172,6 @@ getDownloadsF urlSource = do
                           ) base
    in GHCupInfo tr new

-
-readFromCache :: (MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
-              => Excepts '[JSONError, FileDoesNotExistError] m GHCupInfo
-readFromCache = do
-  AppState {dirs = Dirs {..}} <- lift ask
-  lift $ $(logWarn)
-    [i|Could not get download info, trying cached version (this may not be recent!)|]
-  let path = view pathL' ghcupURL
-  yaml_file <- (cacheDir </>) <$> urlBaseName path
-  bs        <-
-    handleIO' NoSuchThing
-              (\_ -> throwE $ FileDoesNotExistError (toFilePath yaml_file))
-    $ liftIO
-    $ readFile yaml_file
-  lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bs)
-
-
-getBase :: (MonadFail m, MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
-        => Excepts '[JSONError , FileDoesNotExistError] m GHCupInfo
-getBase =
-  handleIO (\_ -> readFromCache)
-  $ catchE @_ @'[JSONError, FileDoesNotExistError]
-      (\(DownloadFailed _) -> readFromCache)
-  $ ((reThrowAll @_ @_ @'[JSONError, DownloadFailed] DownloadFailed $ smartDl ghcupURL)
-    >>= (liftE . lE' @_ @_ @'[JSONError] JSONDecodeError . bimap show id . 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.
@@ -213,8 +209,8 @@ getBase =
      then do
        accessTime <-
          PF.accessTimeHiRes
-            <$> liftIO (PF.getFileStatus (toFilePath json_file))
-        currentTime <- liftIO getPOSIXTime
+            <$> (liftIO $ PF.getFileStatus (toFilePath json_file))
+        currentTime <- liftIO $ getPOSIXTime

        -- access time won't work on most linuxes, but we can try regardless
        if (currentTime - accessTime) > 300
--- a/lib/GHCup/Errors.hs
+++ b/lib/GHCup/Errors.hs
@@ -1,13 +1,7 @@
-{-# OPTIONS_GHC -Wno-orphans #-}
-{-# LANGUAGE CPP               #-}
 {-# LANGUAGE ExistentialQuantification #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE DataKinds #-}
-{-# LANGUAGE QuasiQuotes           #-}
-{-# LANGUAGE TypeOperators           #-}
-{-# LANGUAGE DataKinds           #-}
-{-# LANGUAGE FlexibleInstances           #-}

 {-|
 Module      : GHCup.Errors
@@ -21,21 +15,13 @@ Portability : POSIX
 module GHCup.Errors where

 import           GHCup.Types
-import           GHCup.Utils.Prelude

-#if !defined(TAR)
-import           Codec.Archive
-#endif
 import           Control.Exception.Safe
 import           Data.ByteString                ( ByteString )
-import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
-import           HPath
 import           Haskus.Utils.Variant
-import           Text.PrettyPrint
-import           Text.PrettyPrint.HughesPJClass
-import           URI.ByteString
+import           HPath



@@ -49,211 +35,97 @@ import           URI.ByteString
 data NoCompatiblePlatform = NoCompatiblePlatform String -- the platform we got
  deriving Show

-instance Pretty NoCompatiblePlatform where
-  pPrint (NoCompatiblePlatform str') =
-    text ("Could not find a compatible platform. Got: " ++ str')
-
 -- | Unable to find a download for the requested versio/distro.
 data NoDownload = NoDownload
  deriving Show

-instance Pretty NoDownload where
-  pPrint NoDownload =
-    text "Unable to find a download for the requested version/distro."
-
 -- | No update available or necessary.
 data NoUpdate = NoUpdate
  deriving Show

-instance Pretty NoUpdate where
-  pPrint NoUpdate = text "No update available or necessary."
-
 -- | The Architecture is unknown and unsupported.
 data NoCompatibleArch = NoCompatibleArch String
  deriving Show

-instance Pretty NoCompatibleArch where
-  pPrint (NoCompatibleArch arch) =
-    text ("The Architecture is unknown or unsupported. Got: " ++ arch)
-
 -- | Unable to figure out the distribution of the host.
 data DistroNotFound = DistroNotFound
  deriving Show

-instance Pretty DistroNotFound where
-  pPrint DistroNotFound =
-    text "Unable to figure out the distribution of the host."
-
 -- | The archive format is unknown. We don't know how to extract it.
 data UnknownArchive = UnknownArchive ByteString
  deriving Show

-instance Pretty UnknownArchive where
-  pPrint (UnknownArchive file) =
-    text [i|The archive format is unknown. We don't know how to extract the file "#{decUTF8Safe file}"|]
-
 -- | The scheme is not supported (such as ftp).
 data UnsupportedScheme = UnsupportedScheme
  deriving Show

-instance Pretty UnsupportedScheme where
-  pPrint UnsupportedScheme = text "The scheme is not supported (such as ftp)."
-
 -- | Unable to copy a file.
 data CopyError = CopyError String
  deriving Show

-instance Pretty CopyError where
-  pPrint (CopyError reason) =
-    text ("Unable to copy a file. Reason was: " ++ reason)
-
 -- | Unable to find a tag of a tool.
 data TagNotFound = TagNotFound Tag Tool
  deriving Show

-instance Pretty TagNotFound where
-  pPrint (TagNotFound tag tool) =
-    text "Unable to find tag" <+> pPrint tag <+> text [i|of tool "#{tool}"|]
-
-- | Unable to find a version of a tool.
-data VerNotFound = VerNotFound Version Tool
-  deriving Show
-
-instance Pretty VerNotFound where
-  pPrint (VerNotFound ver' tool) =
-    text [i|Unable to find version "#{prettyShow ver'}" of tool "#{tool}"|]
-
-- | Unable to find the next version of a tool (the one after the currently
-- set one).
-data NextVerNotFound = NextVerNotFound Tool
-  deriving Show
-
-instance Pretty NextVerNotFound where
-  pPrint (NextVerNotFound tool) =
-    text [i|Unable to find next (the one after the currently set one) version of tool "#{tool}"|]
-
 -- | The tool (such as GHC) is already installed with that version.
 data AlreadyInstalled = AlreadyInstalled Tool Version
  deriving Show

-instance Pretty AlreadyInstalled where
-  pPrint (AlreadyInstalled tool ver') =
-    text [i|#{tool}-#{prettyShow ver'} is already installed|]
-
 -- | The tool is not installed. Some operations rely on a tool
 -- to be installed (such as setting the current GHC version).
-data NotInstalled = NotInstalled Tool GHCTargetVersion
+data NotInstalled = NotInstalled Tool Text
  deriving Show

-instance Pretty NotInstalled where
-  pPrint (NotInstalled tool ver) =
-    text [i|The version "#{prettyShow ver}" of the tool "#{tool}" is not installed.|]
-
 -- | An executable was expected to be in PATH, but was not found.
 data NotFoundInPATH = NotFoundInPATH (Path Rel)
  deriving Show

-instance Pretty NotFoundInPATH where
-  pPrint (NotFoundInPATH exe) =
-    text [i|The exe "#{decUTF8Safe . toFilePath $ exe}" was not found in PATH.|]
-
 -- | JSON decoding failed.
 data JSONError = JSONDecodeError String
  deriving Show

-instance Pretty JSONError where
-  pPrint (JSONDecodeError err) =
-    text [i|JSON decoding failed with: #{err}|]
-
 -- | A file that is supposed to exist does not exist
 -- (e.g. when we use file scheme to "download" something).
 data FileDoesNotExistError = FileDoesNotExistError ByteString
  deriving Show

-instance Pretty FileDoesNotExistError where
-  pPrint (FileDoesNotExistError file) =
-    text [i|File "#{decUTF8Safe file}" does not exist.|]
-
 data TarDirDoesNotExist = TarDirDoesNotExist TarDir
  deriving Show

-instance Pretty TarDirDoesNotExist where
-  pPrint (TarDirDoesNotExist dir) =
-    text "Tar directory does not exist:" <+> pPrint dir
-
 -- | File digest verification failed.
 data DigestError = DigestError Text Text
  deriving Show

-instance Pretty DigestError where
-  pPrint (DigestError currentDigest expectedDigest) =
-    text [i|Digest error: expected "#{expectedDigest}", but got "#{currentDigest}"|]
-
 -- | Unexpected HTTP status.
 data HTTPStatusError = HTTPStatusError Int
  deriving Show

-instance Pretty HTTPStatusError where
-  pPrint (HTTPStatusError status) =
-    text [i|Unexpected HTTP status: #{status}|]
-
 -- | The 'Location' header was expected during a 3xx redirect, but not found.
 data NoLocationHeader = NoLocationHeader
  deriving Show

-instance Pretty NoLocationHeader where
-  pPrint NoLocationHeader =
-    text [i|The 'Location' header was expected during a 3xx redirect, but not found.|]
-
 -- | Too many redirects.
 data TooManyRedirs = TooManyRedirs
  deriving Show

-instance Pretty TooManyRedirs where
-  pPrint TooManyRedirs =
-    text [i|Too many redirections.|]
-
 -- | A patch could not be applied.
 data PatchFailed = PatchFailed
  deriving Show

-instance Pretty PatchFailed where
-  pPrint PatchFailed =
-    text [i|A patch could not be applied.|]
-
 -- | The tool requirements could not be found.
 data NoToolRequirements = NoToolRequirements
  deriving Show

-instance Pretty NoToolRequirements where
-  pPrint NoToolRequirements =
-    text [i|The Tool requirements could not be found.|]
-
 data InvalidBuildConfig = InvalidBuildConfig Text
  deriving Show

-instance Pretty InvalidBuildConfig where
-  pPrint (InvalidBuildConfig reason) =
-    text [i|The build config is invalid. Reason was: #{reason}|]
-
-data NoToolVersionSet = NoToolVersionSet Tool
-  deriving Show
-
-instance Pretty NoToolVersionSet where
-  pPrint (NoToolVersionSet tool) =
-    text [i|No version is set for tool "#{tool}".|]
-

    -------------------------
    --[ High-level errors ]--
    -------------------------

 -- | A download failed. The underlying error is encapsulated.
-data DownloadFailed = forall x xs . (Show x, Show (V xs), Pretty x, Pretty (V xs)) => DownloadFailed (V (x ': xs))
-
-instance Pretty DownloadFailed where
-  pPrint (DownloadFailed reason) =
-    text "Download failed:" <+> pPrint reason
+data DownloadFailed = forall es . Show (V es) => DownloadFailed (V es)

 deriving instance Show DownloadFailed

@@ -261,20 +133,12 @@ deriving instance Show DownloadFailed
 -- | A build failed.
 data BuildFailed = forall es . Show (V es) => BuildFailed (Path Abs) (V es)

-instance Pretty BuildFailed where
-  pPrint (BuildFailed path reason) =
-    text [i|BuildFailed failed in dir "#{decUTF8Safe . toFilePath $ path}": #{reason}|]
-
 deriving instance Show BuildFailed


 -- | Setting the current GHC version failed.
 data GHCupSetError = forall es . Show (V es) => GHCupSetError (V es)

-instance Pretty GHCupSetError where
-  pPrint (GHCupSetError reason) =
-    text [i|Setting the current GHC version failed: #{reason}|]
-
 deriving instance Show GHCupSetError


@@ -287,65 +151,11 @@ deriving instance Show GHCupSetError
 data ParseError = ParseError String
  deriving Show

-instance Pretty ParseError where
-  pPrint (ParseError reason) =
-    text [i|Parsing failed: #{reason}|]
-
 instance Exception ParseError


 data UnexpectedListLength = UnexpectedListLength String
  deriving Show

-instance Pretty UnexpectedListLength where
-  pPrint (UnexpectedListLength reason) =
-    text [i|List length unexpected: #{reason}|]
-
 instance Exception UnexpectedListLength

-
-
-    ------------------------
-    --[ orphan instances ]--
-    ------------------------
-
-instance Pretty (V '[]) where
-   {-# INLINABLE pPrint #-}
-   pPrint _ = undefined
-
-instance
-   ( Pretty x
-   , Pretty (V xs)
-   ) => Pretty (V (x ': xs))
-   where
-      pPrint v = case popVariantHead v of
-         Right x -> pPrint x
-         Left xs -> pPrint xs
-
-instance Pretty URIParseError where
-  pPrint (MalformedScheme reason) =
-    text [i|Failed to parse URI. Malformed scheme: #{reason}|]
-  pPrint MalformedUserInfo =
-    text [i|Failed to parse URI. Malformed user info.|]
-  pPrint MalformedQuery =
-    text [i|Failed to parse URI. Malformed query.|]
-  pPrint MalformedFragment =
-    text [i|Failed to parse URI. Malformed fragment.|]
-  pPrint MalformedHost =
-    text [i|Failed to parse URI. Malformed host.|]
-  pPrint MalformedPort =
-    text [i|Failed to parse URI. Malformed port.|]
-  pPrint MalformedPath =
-    text [i|Failed to parse URI. Malformed path.|]
-  pPrint (OtherError err) =
-    text [i|Failed to parse URI: #{err}|]
-
-#if !defined(TAR)
-instance Pretty ArchiveResult where
-  pPrint ArchiveFatal = text "Archive result: fatal"
-  pPrint ArchiveFailed = text "Archive result: failed"
-  pPrint ArchiveWarn = text "Archive result: warning"
-  pPrint ArchiveRetry = text "Archive result: retry"
-  pPrint ArchiveOk = text "Archive result: Ok"
-  pPrint ArchiveEOF = text "Archive result: EOF"
-#endif
--- a/lib/GHCup/Types.hs
+++ b/lib/GHCup/Types.hs
@@ -1,8 +1,6 @@
-{-# OPTIONS_GHC -Wno-orphans #-}
 {-# LANGUAGE CPP               #-}
 {-# LANGUAGE DeriveGeneric     #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes           #-}

 {-|
 Module      : GHCup.Types
@@ -17,16 +15,12 @@ module GHCup.Types where

 import           Data.Map.Strict                ( Map )
 import           Data.List.NonEmpty             ( NonEmpty (..) )
-import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Versions
 import           HPath
-import           Text.PrettyPrint.HughesPJClass (Pretty, pPrint, text)
 import           URI.ByteString

 import qualified Data.Text                     as T
-import qualified Data.Text.Encoding            as E
-import qualified Data.Text.Encoding.Error      as E
 import qualified GHC.Generics                  as GHC
 import qualified Graphics.Vty                  as Vty

@@ -91,14 +85,10 @@ data Tool = GHC
 -- | All necessary information of a tool version, including
 -- source download and per-architecture downloads.
 data VersionInfo = VersionInfo
-  { _viTags        :: [Tag]              -- ^ version specific tag
-  , _viChangeLog   :: Maybe URI
-  , _viSourceDL    :: Maybe DownloadInfo -- ^ source tarball
-  , _viArch        :: ArchitectureSpec   -- ^ descend for binary downloads per arch
-  -- informative messages
-  , _viPostInstall :: Maybe Text
-  , _viPostRemove  :: Maybe Text
-  , _viPreCompile  :: Maybe Text
+  { _viTags      :: [Tag]              -- ^ version specific tag
+  , _viChangeLog :: Maybe URI
+  , _viSourceDL  :: Maybe DownloadInfo -- ^ source tarball
+  , _viArch      :: ArchitectureSpec   -- ^ descend for binary downloads per arch
  }
  deriving (Eq, GHC.Generic, Show)

@@ -112,21 +102,6 @@ data Tag = Latest
         | UnknownTag String  -- ^ used for upwardscompat
         deriving (Ord, Eq, GHC.Generic, Show) -- FIXME: manual JSON instance

-tagToString :: Tag -> String
-tagToString Recommended        = "recommended"
-tagToString Latest             = "latest"
-tagToString Prerelease         = "prerelease"
-tagToString (Base       pvp'') = "base-" ++ T.unpack (prettyPVP pvp'')
-tagToString (UnknownTag t    ) = t
-tagToString Old                = ""
-
-instance Pretty Tag where
-  pPrint Recommended        = text "recommended"
-  pPrint Latest             = text "latest"
-  pPrint Prerelease         = text "prerelease"
-  pPrint (Base       pvp'') = text ("base-" ++ T.unpack (prettyPVP pvp''))
-  pPrint (UnknownTag t    ) = text t
-  pPrint Old                = mempty

 data Architecture = A_64
                  | A_32
@@ -138,18 +113,15 @@ data Architecture = A_64
                  | A_ARM64
  deriving (Eq, GHC.Generic, Ord, Show)

-archToString :: Architecture -> String
-archToString A_64 = "x86_64"
-archToString A_32 = "i386"
-archToString A_PowerPC = "powerpc"
-archToString A_PowerPC64 = "powerpc64"
-archToString A_Sparc = "sparc"
-archToString A_Sparc64 = "sparc64"
-archToString A_ARM = "arm"
-archToString A_ARM64 = "aarch64"
-
-instance Pretty Architecture where
-  pPrint = text . archToString
+prettyArch :: Architecture -> String
+prettyArch A_64 = "x86_64"
+prettyArch A_32 = "i386"
+prettyArch A_PowerPC = "powerpc"
+prettyArch A_PowerPC64 = "powerpc64"
+prettyArch A_Sparc = "sparc"
+prettyArch A_Sparc64 = "sparc64"
+prettyArch A_ARM = "arm"
+prettyArch A_ARM64 = "aarch64"

 data Platform = Linux LinuxDistro
              -- ^ must exit
@@ -158,13 +130,10 @@ data Platform = Linux LinuxDistro
              | FreeBSD
  deriving (Eq, GHC.Generic, Ord, Show)

-platformToString :: Platform -> String
-platformToString (Linux distro) = "linux-" ++ distroToString distro
-platformToString Darwin = "darwin"
-platformToString FreeBSD = "freebsd"
-
-instance Pretty Platform where
-  pPrint = text . platformToString
+prettyPlatfrom :: Platform -> String
+prettyPlatfrom (Linux distro) = "linux-" ++ prettyDistro distro
+prettyPlatfrom Darwin = "darwin"
+prettyPlatfrom FreeBSD = "freebsd"

 data LinuxDistro = Debian
                 | Ubuntu
@@ -182,21 +151,18 @@ data LinuxDistro = Debian
                 -- ^ must exit
  deriving (Eq, GHC.Generic, Ord, Show)

-distroToString :: LinuxDistro -> String
-distroToString Debian = "debian"
-distroToString Ubuntu = "ubuntu"
-distroToString Mint= "mint"
-distroToString Fedora = "fedora"
-distroToString CentOS = "centos"
-distroToString RedHat = "redhat"
-distroToString Alpine = "alpine"
-distroToString AmazonLinux = "amazon"
-distroToString Gentoo = "gentoo"
-distroToString Exherbo = "exherbo"
-distroToString UnknownLinux = "unknown"
-
-instance Pretty LinuxDistro where
-  pPrint = text . distroToString
+prettyDistro :: LinuxDistro -> String
+prettyDistro Debian = "debian"
+prettyDistro Ubuntu = "ubuntu"
+prettyDistro Mint= "mint"
+prettyDistro Fedora = "fedora"
+prettyDistro CentOS = "centos"
+prettyDistro RedHat = "redhat"
+prettyDistro Alpine = "alpine"
+prettyDistro AmazonLinux = "amazon"
+prettyDistro Gentoo = "gentoo"
+prettyDistro Exherbo = "exherbo"
+prettyDistro UnknownLinux = "unknown"


 -- | An encapsulation of a download. This can be used
@@ -221,10 +187,6 @@ data TarDir = RealDir (Path Rel)
            | RegexDir String     -- ^ will be compiled to regex, the first match will "win"
            deriving (Eq, Ord, GHC.Generic, Show)

-instance Pretty TarDir where
-  pPrint (RealDir path) = text [i|#{E.decodeUtf8With E.lenientDecode . toFilePath $ path}|]
-  pPrint (RegexDir regex) = text regex
-

 -- | Where to fetch GHCupDownloads from.
 data URLSource = GHCupURL
@@ -344,15 +306,12 @@ data PlatformResult = PlatformResult
  }
  deriving (Eq, Show)

-platResToString :: PlatformResult -> String
-platResToString PlatformResult { _platform = plat, _distroVersion = Just v' }
+prettyPlatform :: PlatformResult -> String
+prettyPlatform PlatformResult { _platform = plat, _distroVersion = Just v' }
  = show plat <> ", " <> T.unpack (prettyV v')
-platResToString PlatformResult { _platform = plat, _distroVersion = Nothing }
+prettyPlatform PlatformResult { _platform = plat, _distroVersion = Nothing }
  = show plat

-instance Pretty PlatformResult where
-  pPrint = text . platResToString
-
 data PlatformRequest = PlatformRequest
  { _rArch     :: Architecture
  , _rPlatform :: Platform
@@ -360,17 +319,14 @@ data PlatformRequest = PlatformRequest
  }
  deriving (Eq, Show)

-pfReqToString :: PlatformRequest -> String
-pfReqToString (PlatformRequest arch plat ver) =
-  archToString arch ++ "-" ++ platformToString plat ++ pver
+prettyPfReq :: PlatformRequest -> String
+prettyPfReq (PlatformRequest arch plat ver) =
+  prettyArch arch ++ "-" ++ prettyPlatfrom plat ++ pver
 where
  pver = case ver of
           Just v' -> "-" ++ (T.unpack $ prettyV v')
           Nothing -> ""

-instance Pretty PlatformRequest where
-  pPrint = text . pfReqToString
-
 -- | A GHC identified by the target platform triple
 -- and the version.
 data GHCTargetVersion = GHCTargetVersion
@@ -383,13 +339,11 @@ data GHCTargetVersion = GHCTargetVersion
 mkTVer :: Version -> GHCTargetVersion
 mkTVer = GHCTargetVersion Nothing

-tVerToText :: GHCTargetVersion -> Text
-tVerToText (GHCTargetVersion (Just t) v') = t <> "-" <> prettyVer v'
-tVerToText (GHCTargetVersion Nothing  v') = prettyVer v'

 -- | Assembles a path of the form: <target-triple>-<version>
-instance Pretty GHCTargetVersion where
-  pPrint = text . T.unpack . tVerToText
+prettyTVer :: GHCTargetVersion -> Text
+prettyTVer (GHCTargetVersion (Just t) v') = t <> "-" <> prettyVer v'
+prettyTVer (GHCTargetVersion Nothing  v') = prettyVer v'


 -- | A comparator and a version.
@@ -407,9 +361,3 @@ data VersionRange = SimpleRange (NonEmpty VersionCmp) -- And
                  | OrRange (NonEmpty VersionCmp) VersionRange
  deriving (Eq, GHC.Generic, Ord, Show)

-
-instance Pretty Versioning where
-  pPrint = text . T.unpack . prettyV
-
-instance Pretty Version where
-  pPrint = text . T.unpack . prettyVer
--- a/lib/GHCup/Utils.hs
+++ b/lib/GHCup/Utils.hs
@@ -497,11 +497,11 @@ getGHCForMajor major' minor' mt = do
 getLatestGHCFor :: Int -- ^ major version component
                -> Int -- ^ minor version component
                -> GHCupDownloads
-                -> Maybe (Version, VersionInfo)
+                -> Maybe Version
 getLatestGHCFor major' minor' dls = do
  join
-    . fmap (lastMay . filter (\(v, _) -> matchMajor v major' minor'))
-    . preview (ix GHC % to Map.toDescList)
+    . fmap (lastMay . filter (\v -> matchMajor v major' minor'))
+    . preview (ix GHC % to Map.keys)
    $ dls


@@ -596,17 +596,17 @@ getTagged tag =
  % _head
  )

-getLatest :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
-getLatest av tool = headOf (ix tool % getTagged Latest) $ av
+getLatest :: GHCupDownloads -> Tool -> Maybe Version
+getLatest av tool = headOf (ix tool % getTagged Latest % to fst) $ av

-getRecommended :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
-getRecommended av tool = headOf (ix tool % getTagged Recommended) $ av
+getRecommended :: GHCupDownloads -> Tool -> Maybe Version
+getRecommended av tool = headOf (ix tool % getTagged Recommended % to fst) $ av


 -- | Gets the latest GHC with a given base version.
-getLatestBaseVersion :: GHCupDownloads -> PVP -> Maybe (Version, VersionInfo)
+getLatestBaseVersion :: GHCupDownloads -> PVP -> Maybe Version
 getLatestBaseVersion av pvpVer =
-  headOf (ix GHC % getTagged (Base pvpVer)) av
+  headOf (ix GHC % getTagged (Base pvpVer) % to fst) av



@@ -650,7 +650,7 @@ ghcToolFiles ver = do

  -- fail if ghc is not installed
  whenM (fmap not $ liftIO $ doesDirectoryExist ghcdir)
-        (throwE (NotInstalled GHC ver))
+        (throwE (NotInstalled GHC (prettyTVer ver)))

  files    <- liftIO $ getDirsFiles' bindir
  -- figure out the <ver> suffix, because this might not be `Version` for
@@ -795,25 +795,3 @@ createDirRecursive' p =
          _ -> throwIO e
      _ -> throwIO e

-
-getVersionInfo :: Version
-               -> Tool
-               -> GHCupDownloads
-               -> Maybe VersionInfo
-getVersionInfo v' tool dls =
-  headOf
-    ( ix tool
-    % to (Map.filterWithKey (\k _ -> k == v'))
-    % to Map.elems
-    % _head
-    )
-    dls
-
-
-- Gathering monoidal values
-traverseFold :: (Foldable t, Applicative m, Monoid b) => (a -> m b) -> t a -> m b
-traverseFold f = foldl (\mb a -> (<>) <$> mb <*> f a) (pure mempty)
-
-- | Gathering monoidal values
-forFold :: (Foldable t, Applicative m, Monoid b) => t a -> (a -> m b) -> m b
-forFold = \t -> \f -> traverseFold f t
--- a/lib/GHCup/Utils/Dirs.hs
+++ b/lib/GHCup/Utils/Dirs.hs
@@ -185,9 +185,9 @@ getDirs = do
 ghcupConfigFile :: (MonadIO m)
                => Excepts '[JSONError] m UserSettings
 ghcupConfigFile = do
-  confDir <- liftIO ghcupConfigDir
+  confDir <- liftIO $ ghcupConfigDir
  let file = confDir </> [rel|config.yaml|]
-  bs <- liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ Just <$> readFile file
+  bs <- liftIO $ handleIO' NoSuchThing (\_ -> pure $ Nothing) $ fmap Just $ readFile file 
  case bs of
      Nothing -> pure defaultUserSettings
      Just bs' -> lE' JSONDecodeError . bimap show id . Y.decodeEither' . L.toStrict $ bs'
@@ -214,7 +214,7 @@ ghcupGHCDir :: (MonadReader AppState m, MonadThrow m)
            -> m (Path Abs)
 ghcupGHCDir ver = do
  ghcbasedir    <- ghcupGHCBaseDir
-  verdir        <- parseRel $ E.encodeUtf8 (tVerToText ver)
+  verdir        <- parseRel $ E.encodeUtf8 (prettyTVer ver)
  pure (ghcbasedir </> verdir)


--- a/lib/GHCup/Utils/File.hs
+++ b/lib/GHCup/Utils/File.hs
@@ -43,7 +43,7 @@ import           GHC.IO.Exception
 import           HPath
 import           HPath.IO                hiding ( hideError )
 import           Optics                  hiding ((<|), (|>))
-import           System.Console.Pretty   hiding ( Pretty )
+import           System.Console.Pretty
 import           System.Console.Regions
 import           System.IO.Error
 import           System.Posix.Directory.ByteString
@@ -55,7 +55,6 @@ import "unix"    System.Posix.IO.ByteString
                                         hiding ( openFd )
 import           System.Posix.Process           ( ProcessStatus(..) )
 import           System.Posix.Types
-import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
 import           Text.Regex.Posix


@@ -80,15 +79,6 @@ data ProcessError = NonZeroExit Int ByteString [ByteString]
                  | NoSuchPid ByteString [ByteString]
                  deriving Show

-instance Pretty ProcessError where
-  pPrint (NonZeroExit e exe args) =
-    text [i|Process "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args} failed with exit code #{e}.|]
-  pPrint (PTerminated exe args) =
-    text [i|Process "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args} terminated.|]
-  pPrint (PStopped exe args) =
-    text [i|Process "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args} stopped.|]
-  pPrint (NoSuchPid exe args) =
-    text [i|Could not find PID for process running "#{decUTF8Safe exe}" with arguments #{fmap decUTF8Safe args}.|]

 data CapturedProcess = CapturedProcess
  { _exitCode :: ExitCode
@@ -417,32 +407,6 @@ searchPath paths needle = go paths
      else pure False


-- | Check wether a binary is shadowed by another one that comes before
-- it in PATH. Returns the path to said binary, if any.
-isShadowed :: Path Abs -> IO (Maybe (Path Abs))
-isShadowed p = do
-  let dir = dirname p
-  fn <- basename p
-  spaths <- catMaybes . fmap parseAbs <$> (liftIO getSearchPath)
-  if dir `elem` spaths
-  then do
-    let shadowPaths = takeWhile (/= dir) spaths
-    searchPath shadowPaths fn
-  else pure Nothing
-
-
-- | Check whether the binary is in PATH. This returns only `True`
-- if the directory containing the binary is part of PATH.
-isInPath :: Path Abs -> IO Bool
-isInPath p = do
-  let dir = dirname p
-  fn <- basename p
-  spaths <- catMaybes . fmap parseAbs <$> (liftIO getSearchPath)
-  if dir `elem` spaths
-  then isJust <$> searchPath [dir] fn
-  else pure False
-
-
 findFiles :: Path Abs -> Regex -> IO [Path Rel]
 findFiles path regex = do
  dirStream <- openDirStream (toFilePath path)
--- a/lib/GHCup/Version.hs
+++ b/lib/GHCup/Version.hs
@@ -12,15 +12,13 @@ Portability : POSIX
 -}
 module GHCup.Version where

+import           GHCup.Utils.Version.QQ
 import           GHCup.Types
-import           Paths_ghcup (version)

-import           Data.Version (Version(versionBranch))
-import           Data.Versions hiding (version)
+import           Data.Versions
 import           URI.ByteString
 import           URI.ByteString.QQ

-import qualified Data.List.NonEmpty            as NE
 import qualified Data.Text                     as T

 -- | This reflects the API version of the YAML.
@@ -29,7 +27,7 @@ ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.4.yaml|]

 -- | The current ghcup version.
 ghcUpVer :: PVP
-ghcUpVer = PVP . NE.fromList . fmap fromIntegral $ versionBranch version
+ghcUpVer = [pver|0.1.12|]

 -- | ghcup version as numeric string.
 numericVer :: String
--- a/www/ghcup.js
+++ b/www/ghcup.js
@@ -149,17 +149,7 @@ function fill_in_bug_report_values() {
 }

 function copyToClipboard() {
-  const text = document.getElementById("ghcup-command-normal").innerText;
-  const el = document.createElement('textarea');
-  el.value = text;
-  document.body.appendChild(el);
-  el.select();
-  document.execCommand('copy');
-  document.body.removeChild(el);
-}
-
-function copyToClipboardSilicon() {
-  const text = document.getElementById("ghcup-command-silicon").innerText;
+  const text = document.getElementsByClassName("ghcup-command").item(0).innerText;
  const el = document.createElement('textarea');
  el.value = text;
  document.body.appendChild(el);
--- a/www/index.html
+++ b/www/index.html
@@ -32,10 +32,7 @@

      <div id="platform-instructions-mac" class="instructions" style="display: none;">
        <p>Run the following in your terminal (as a user other than root), then follow the onscreen instructions.</p>
-		<p>On Intel:</p>
-		<div class="command-button"><pre><span class='ghcup-command' id="ghcup-command-normal">curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
-        <p>On Apple Silicon:</p>
-		<div class="command-button"><pre><span class='ghcup-command' id="ghcup-command-silicon">curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | arch -x86_64 /bin/bash</span></pre><button class="tooltip" onclick="copyToClipboardSilicon()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
+		<div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
        <p class="other-help">If you don't like curl | sh, see <a href="https://gitlab.haskell.org/haskell/ghcup-hs#manual-install">other installation methods</a>.<br/>You appear to be running macOS. If not, <a class="default-platform-button" href="#">display all supported installers</a>.</p>
      </div>

@@ -104,11 +101,9 @@

      <div id="platform-instructions-default" class="instructions">
        <div>
-          <p>To install Haskell, if you are running Linux, macOS (on Intel), FreeBSD or Windows Subsystem for Linux, run the following
+          <p>To install Haskell, if you are running Linux, macOS, FreeBSD or Windows Subsystem for Linux, run the following
          in your terminal (as a user other than root), then follow the onscreen instructions.</p>
 		  <div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre><button class="tooltip" onclick="copyToClipboard()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
-          <p>For macOS on Apple Silicon, run this instead:</p>
-          <div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | arch -x86_64 /bin/bash</span></pre><button class="tooltip" onclick="copyToClipboardSilicon()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
          <p class="other-help">If you don't like curl | sh, see <a href="https://gitlab.haskell.org/haskell/ghcup-hs#manual-install">other installation methods</a>.</p>
        </div>

@@ -151,11 +146,9 @@

      <div id="platform-instructions-default" class="instructions">
        <div>
-          <p>To install Haskell, if you are running Linux, macOS (on Intel), FreeBSD or Windows Subsystem for Linux, run the following
+          <p>To install Haskell, if you are running Linux, macOS, FreeBSD or Windows Subsystem for Linux, run the following
          in your terminal (as a user other than root), then follow the onscreen instructions.</p>
 		  <pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre>
-          <p>For macOS on Apple Silicon, run this instead:</p>
-          <div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | arch -x86_64 /bin/bash</span></pre><button class="tooltip" onclick="copyToClipboardSilicon()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
          <p class="other-help">If you don't like curl | sh, see <a href="https://gitlab.haskell.org/haskell/ghcup-hs#manual-install">other installation methods</a>.</p>
        </div>