Update travis

Update CHANGELOG
Merge branch 'PR/issue-116'
2021-03-07 12:33:21 +01:00 · 2021-03-07 12:27:04 +01:00 · 2021-03-07 12:24:05 +01:00 · 2021-03-07 12:02:13 +01:00 · 2021-03-07 11:59:45 +01:00 · 2021-03-06 16:02:09 +01:00
33 changed files with 21157 additions and 10833 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,3 +1,7 @@
+stages:
+  - test
+  - release
+
 variables:
  GIT_SSL_NO_VERIFY: "1"

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

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

 .alpine:32bit:
  image: "i386/alpine:3.12"
@@ -30,21 +34,37 @@ variables:
    - x86_64-linux
  variables:
    OS: "LINUX"
-    BIT: "32"
+    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"

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

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

 .root_cleanup:
  after_script:
@@ -81,6 +101,20 @@ 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
@@ -106,10 +140,13 @@ 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:
@@ -120,12 +157,13 @@ 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.3"
+    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
  extends:
    - .debian
@@ -133,61 +171,83 @@ test:linux:bootstrap_script:
 ######## linux test ########

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

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

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

 test:linux:recommended:32bit:
+  stage: test
  extends: .test_ghcup_version:linux32
  variables:
-    GHC_VERSION: "8.10.2"
+    GHC_VERSION: "8.10.4"
    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.3"
+    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"

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


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

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

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


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

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


 release:linux:32bit:
+  stage: release
+  needs: ["test:linux:recommended:32bit"]
  extends:
    - .alpine:32bit
    - .release_ghcup
@@ -207,13 +269,40 @@ release:linux:32bit:
    - ./.gitlab/before_script/linux/alpine/install_deps.sh
  variables:
    ARTIFACT: "i386-linux-ghcup"
-    GHC_VERSION: "8.10.2"
+    GHC_VERSION: "8.10.4"
    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
@@ -222,7 +311,7 @@ release:darwin:
    - ./.gitlab/before_script/darwin/install_deps.sh
  variables:
    ARTIFACT: "x86_64-apple-darwin-ghcup"
-    GHC_VERSION: "8.10.3"
+    GHC_VERSION: "8.10.4"
    CABAL_VERSION: "3.4.0.0"
    MACOSX_DEPLOYMENT_TARGET: "10.7"

@@ -230,6 +319,8 @@ release:darwin:
 ######## freebsd release ########

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

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

-if [ "${BIT}" = "32" ] ; then
+if [ "${ARCH}" = "32" ] ; then
 	curl -sSfL https://downloads.haskell.org/ghcup/i386-linux-ghcup > ./ghcup-bin
 else
 	curl -sSfL https://downloads.haskell.org/ghcup/x86_64-linux-ghcup > ./ghcup-bin
--- a/.gitlab/before_script/linux/install_deps_manual.sh
+++ b/.gitlab/before_script/linux/install_deps_manual.sh
@@ -0,0 +1,64 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}"
+
+ednf() {
+	case "${ARCH}" in
+		"ARM")
+			sudo dnf -y --forcearch armv7hl "$@"
+			;;
+		"ARM64")
+			sudo dnf -y --forcearch aarch64 "$@"
+			;;
+		*) exit 1 ;;
+	esac
+}
+
+ednf update
+ednf install gcc gcc-c++ gmp gmp-devel make ncurses ncurses-devel xz xz-devel perl zlib zlib-devel openssl-devel openssl-libs openssl libffi libffi-devel
+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,10 +16,12 @@ git describe
 ecabal update

 if [ "${OS}" = "LINUX" ] ; then
-	if [ "${BIT}" = "32" ] ; then
+	if [ "${ARCH}" = "32" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui -ftar
-	else
+	elif [ "${ARCH}" = "64" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui
+	else
+		ecabal build -w ghc-${GHC_VERSION} -ftui
 	fi
 elif [ "${OS}" = "FREEBSD" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections' --constraint="zlib +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 [ "${BIT}" = "32" ] ; then
+	if [ "${ARCH}" = "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.4.4
+	eghcup --downloader=wget install 8.10.3
 else # test wget a bit
-	eghcup install 8.4.4
+	eghcup install 8.10.3
 fi
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-eghcup set 8.4.4
-eghcup set 8.4.4
-[ "$(ghc --numeric-version)" = "8.4.4" ]
+eghcup set 8.10.3
+eghcup set 8.10.3
+[ "$(ghc --numeric-version)" = "8.10.3" ]
 eghcup set ${GHC_VERSION}
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-eghcup rm 8.4.4
+eghcup rm 8.10.3
 [ "$(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 [ "${BIT}" = "64" ] ; then
+	if [ "${ARCH}" = "64" ] ; then
 		eghcup install hls
 		haskell-language-server-wrapper --version
 	fi
@@ -107,6 +107,10 @@ fi

 eghcup rm $(ghc --numeric-version)

+# https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/116
+eghcup install cabal -u https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-ubuntu-16.04.tar.xz 3.4.0.0-rc4
+eghcup rm cabal 3.4.0.0-rc4
+
 eghcup upgrade
 eghcup upgrade -f

--- a/.travis/build.sh
+++ b/.travis/build.sh
@@ -8,9 +8,9 @@ chmod +x ~/.ghcup/bin/ghcup

 export PATH="$HOME/.ghcup/bin:$PATH"

-ghcup install 8.10.3
-ghcup install-cabal 3.4.0.0-rc4
-ghcup set 8.10.3
+ghcup install 8.10.4
+ghcup install-cabal 3.4.0.0
+ghcup set 8.10.4


 ## install ghcup
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,18 @@
 # Revision history for ghcup

-## 0.1.13 -- ????-??-??
+## 0.1.14 -- 2021-03-07

+* Major bugfix: fix handling of stray versions wrt [#116](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/116)
+* Fix error messages and overhaul pretty printing wrt [#115](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/115)
+
+## 0.1.13 -- 2021-02-26
+
+* Support ARMv7/AARCH64
+* Add command line completions for installed and available versions wrt [MR #70](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/70)
+* Allow to cycle through set tools wrt [#114](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/114)
+* Fix item selection with unavailable versions wrt [#107](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/107)
+* Allow for dynamic post-install, post-remove and pre-compile msgs wrt [MR #68](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/68)
+* Alert user if upgraded ghcup is shadowed by old ghcup wrt [#111](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/111)
 * Fix to `ghcup` directory creation and placement for the XDG install mode ([MR #49](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/49))
 * Do 755 permissions on executables, wrt #97
 * Add [NO_COLOR](https://no-color.org/) support wrt [MR #47](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/47)
--- a/README.md
+++ b/README.md
@@ -18,6 +18,7 @@ Similar in scope to [rustup](https://github.com/rust-lang-nursery/rustup.rs), [p
     * [Shell-completion](#shell-completion)
     * [Cross support](#cross-support)
     * [XDG support](#xdg-support)
+     * [Env variables](#env-variables)
     * [Installing custom bindists](#installing-custom-bindists)
   * [Design goals](#design-goals)
   * [How](#how)
@@ -124,6 +125,17 @@ Then you can control the locations via XDG environment variables as such:
 * `XDG_BIN_HOME`: binaries end up here (default: `~/.local/bin`)
 * `XDG_CONFIG_HOME`: the config file is stored in `ghcup` subdir as `config.yaml` (default: `~/.config`)

+### Env variables
+
+This is the complete list of env variables that change GHCup behavior:
+
+* `GHCUP_USE_XDG_DIRS`: see [XDG support](#xdg-support) above
+* `TMPDIR`: where ghcup does the work (unpacking, building, ...)
+* `GHCUP_INSTALL_BASE_PREFIX`: the base of ghcup (default: `$HOME`)
+* `GHCUP_CURL_OPTS`: additional options that can be passed to curl
+* `GHCUP_WGET_OPTS`: additional options that can be passed to wget
+* `CC`/`LD` etc.: full environment is passed to the build system when compiling GHC via GHCup
+
 ### Installing custom bindists

 There are a couple of good use cases to install custom bindists:
--- a/app/ghcup-gen/Validate.hs
+++ b/app/ghcup-gen/Validate.hs
@@ -32,6 +32,7 @@ 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
@@ -83,7 +84,7 @@ validate dls = do
 where
  checkHasRequiredPlatforms t v tags arch pspecs = do
    let v' = prettyVer v
-        arch' = prettyArch arch
+        arch' = prettyShow arch
    when (not $ any (== Linux UnknownLinux) pspecs) $ do
      lift $ $(logError)
        [i|Linux UnknownLinux missing for for #{t} #{v'} #{arch'}|]
@@ -99,9 +100,11 @@ validate dls = do
    -- (although it could be static)
    when (not $ any (== Linux Alpine) pspecs) $
      case t of
-        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
-        GHC | Latest `elem` tags || Recommended `elem` tags -> lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]
+        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'}|]

  checkUniqueTags tool = do
--- a/app/ghcup/BrickMain.hs
+++ b/app/ghcup/BrickMain.hs
@@ -47,6 +47,7 @@ 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
@@ -152,7 +153,10 @@ ui dimAttrs BrickState { appSettings = as@(BrickSettings {}), ..}
          Nothing -> T.unpack . prettyVer $ lVer
          Just c  -> T.unpack (c <> "-" <> prettyVer lVer)
        dim
-          | lNoBindist = updateAttrMap (const dimAttrs) . withAttr "no-bindist"
+          | lNoBindist && (not lInstalled)
+            && (not b) -- TODO: overloading dim and active ignores active
+                       --       so we hack around it here
+          = updateAttrMap (const dimAttrs) . withAttr "no-bindist"
          | otherwise  = id
        hooray
          | elem Latest lTag && not lInstalled =
@@ -277,7 +281,7 @@ defaultAttributes no_color = attrMap
 dimAttributes :: Bool -> AttrMap
 dimAttributes no_color = attrMap
  (Vty.defAttr `Vty.withStyle` Vty.dim)
-  [ ("active"    , Vty.defAttr `withBackColor` Vty.blue)
+  [ ("active"    , Vty.defAttr `withBackColor` Vty.blue) -- has no effect ??
  , ("no-bindist", Vty.defAttr `Vty.withStyle` Vty.dim)
  ]
  where
@@ -418,20 +422,27 @@ install' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do

  (run $ do
      case lTool of
-        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 $> ()
+        GHC   -> do
+          let vi = getVersionInfo lVer GHC dls
+          liftE $ installGHCBin dls lVer pfreq $> vi
+        Cabal -> do
+          let vi = getVersionInfo lVer Cabal dls
+          liftE $ installCabalBin dls lVer pfreq $> vi
+        GHCup -> do
+          let vi = snd <$> getLatest dls GHCup
+          liftE $ upgradeGHCup dls Nothing False pfreq $> vi
+        HLS   -> do
+          let vi = getVersionInfo lVer HLS dls
+          liftE $ installHLSBin dls lVer pfreq $> vi
    )
    >>= \case
-          VRight _                          -> pure $ Right ()
+          VRight vi                         -> do
+            forM_ (join $ fmap _viPostInstall vi) $ \msg ->
+              runLogger $ $(logInfo) msg
+            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|#{e}
+          VLeft e -> pure $ Left [i|#{prettyShow e}
 Also check the logs in ~/.ghcup/logs|]


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


 del' :: BrickState -> (Int, ListResult) -> IO (Either String ())
-del' _ (_, ListResult {..}) = do
+del' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
  settings <- readIORef settings'
  l        <- readIORef logger'
  let runLogger = myLoggerT l
@@ -467,15 +478,19 @@ del' _ (_, ListResult {..}) = do
  let run = runLogger . flip runReaderT settings . runE @'[NotInstalled]

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


 changelog' :: BrickState -> (Int, ListResult) -> IO (Either String ())
@@ -490,7 +505,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 [i|#{e}|]
+        Left  e -> pure $ Left $ prettyShow e


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

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


 getAppData :: Maybe GHCupDownloads
--- a/app/ghcup/Main.hs
+++ b/app/ghcup/Main.hs
@@ -32,6 +32,7 @@ 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 )
@@ -43,7 +44,7 @@ import           Data.Bifunctor
 import           Data.Char
 import           Data.Either
 import           Data.Functor
-import           Data.List                      ( intercalate, sort )
+import           Data.List                      ( intercalate, nub, sort, sortBy )
 import           Data.List.NonEmpty             (NonEmpty ((:|)))
 import           Data.Maybe
 import           Data.String.Interpolate
@@ -65,10 +66,12 @@ 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
@@ -111,9 +114,14 @@ data ToolVersion = ToolVersion GHCTargetVersion -- target is ignored for cabal
                 | ToolTag Tag

 prettyToolVer :: ToolVersion -> String
-prettyToolVer (ToolVersion v') = T.unpack $ prettyTVer v'
+prettyToolVer (ToolVersion v') = T.unpack $ tVerToText 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
@@ -130,8 +138,14 @@ data SetCommand = SetGHC SetOptions
                | SetCabal SetOptions
                | SetHLS SetOptions

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

 data ListOptions = ListOptions
@@ -191,10 +205,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?
@@ -362,7 +376,7 @@ com =
          (  command
              "install-cabal"
              ((info
-                 ((InstallCabalLegacy <$> installOpts) <**> helper)
+                 ((InstallCabalLegacy <$> installOpts (Just Cabal)) <**> helper)
                 (  progDesc "Install or update cabal"
                 <> footerDoc (Just $ text installCabalFooter)
                 )
@@ -412,7 +426,7 @@ installParser =
          "ghc"
          (   InstallGHC
          <$> (info
-                (installOpts <**> helper)
+                (installOpts (Just GHC) <**> helper)
                (  progDesc "Install GHC"
                <> footerDoc (Just $ text installGHCFooter)
                )
@@ -422,7 +436,7 @@ installParser =
           "cabal"
           (   InstallCabal
           <$> (info
-                 (installOpts <**> helper)
+                 (installOpts (Just Cabal) <**> helper)
                 (  progDesc "Install Cabal"
                 <> footerDoc (Just $ text installCabalFooter)
                 )
@@ -432,7 +446,7 @@ installParser =
           "hls"
           (   InstallHLS
           <$> (info
-                 (installOpts <**> helper)
+                 (installOpts (Just HLS) <**> helper)
                 (  progDesc "Install haskell-languge-server"
                 <> footerDoc (Just $ text installHLSFooter)
                 )
@@ -440,7 +454,7 @@ installParser =
           )
      )
    )
-    <|> (Right <$> installOpts)
+    <|> (Right <$> installOpts Nothing)
 where
  installHLSFooter :: String
  installHLSFooter = [s|Discussion:
@@ -471,8 +485,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 :: Parser InstallOptions
-installOpts =
+installOpts :: Maybe Tool -> Parser InstallOptions
+installOpts tool =
  (\p (u, v) b -> InstallOptions v p u b)
    <$> (optional
          (option
@@ -494,9 +508,9 @@ installOpts =
                    )
                  )
                )
-            <*> (Just <$> toolVersionArgument)
+            <*> (Just <$> toolVersionArgument Nothing tool)
            )
-        <|> ((,) <$> pure Nothing <*> optional toolVersionArgument)
+        <|> (pure (Nothing, Nothing))
        )
    <*> flag
          False
@@ -513,7 +527,7 @@ setParser =
          "ghc"
          (   SetGHC
          <$> (info
-                (setOpts <**> helper)
+                (setOpts (Just GHC) <**> helper)
                (  progDesc "Set GHC version"
                <> footerDoc (Just $ text setGHCFooter)
                )
@@ -523,7 +537,7 @@ setParser =
           "cabal"
           (   SetCabal
           <$> (info
-                 (setOpts <**> helper)
+                 (setOpts (Just Cabal) <**> helper)
                 (  progDesc "Set Cabal version"
                 <> footerDoc (Just $ text setCabalFooter)
                 )
@@ -533,7 +547,7 @@ setParser =
           "hls"
           (   SetHLS
           <$> (info
-                 (setOpts <**> helper)
+                 (setOpts (Just HLS) <**> helper)
                 (  progDesc "Set haskell-language-server version"
                 <> footerDoc (Just $ text setHLSFooter)
                 )
@@ -541,7 +555,7 @@ setParser =
           )
      )
    )
-    <|> (Right <$> setOpts)
+    <|> (Right <$> setOpts Nothing)
 where
  setGHCFooter :: String
  setGHCFooter = [s|Discussion:
@@ -558,8 +572,10 @@ setParser =
    Sets the the current haskell-language-server version.|]


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

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



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


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

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

 -- | same as toolVersionParser, except as an argument.
-toolVersionArgument :: Parser ToolVersion
-toolVersionArgument =
-  argument (eitherReader toolVersionEither) (metavar "VERSION|TAG")
+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)


-versionArgument :: Parser GHCTargetVersion
-versionArgument = argument (eitherReader tVersionEither) (metavar "VERSION")
+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
+

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

-versionParser' :: Parser Version
-versionParser' = argument
-  (eitherReader (bimap show id . version . T.pack))
-  (metavar "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)


 tagEither :: String -> Either String Tag
@@ -791,7 +879,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
@@ -1043,6 +1131,8 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                      , DigestError
                      , DownloadFailed
                      , TarDirDoesNotExist
+                      , NextVerNotFound
+                      , NoToolVersionSet
                      ]

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

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

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

          let runListGHC = runLogger . flip runReaderT appstate
@@ -1131,7 +1227,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                    VRight r -> pure r
                    VLeft e -> do
                      runLogger
-                        ($(logError) [i|Error determining Platform: #{e}|])
+                        ($(logError) $ T.pack $ prettyShow e)
                      exitWith (ExitFailure 2)


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

          case optCommand of
@@ -1162,42 +1258,39 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
          let installGHC InstallOptions{..} =
                  (case instBindist of
                     Nothing -> runInstTool $ do
-                       v <- liftE $ fromVersion dls instVer GHC
+                       (v, vi) <- 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 <- liftE $ fromVersion dls instVer GHC
+                       (v, vi) <- 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 _ -> do
+                          VRight vi -> do
                            runLogger $ $(logInfo) ("GHC installation successful")
+                            forM_ (join $ fmap _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 (V (BuildFailed tmpdir e)) -> do
+                          VLeft err@(V (BuildFailed tmpdir _)) -> do
                            case keepDirs settings of
-                              Never -> runLogger ($(logError) [i|Build failed with #{e}|])
-                              _ -> runLogger ($(logError) [i|Build failed with #{e}
+                              Never -> runLogger ($(logError) $ T.pack $ prettyShow err)
+                              _ -> runLogger ($(logError) [i|#{prettyShow err}
    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) [i|#{e}|]
+                              $(logError) $ T.pack $ prettyShow e
                              $(logError) [i|Also check the logs in #{logsDir}|]
                            pure $ ExitFailure 3

@@ -1205,73 +1298,67 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
          let installCabal InstallOptions{..} =
                (case instBindist of
                   Nothing -> runInstTool $ do
-                     v <- liftE $ fromVersion dls instVer Cabal
+                     (v, vi) <- 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 <- liftE $ fromVersion dls instVer Cabal
+                     (v, vi) <- liftE $ fromVersion dls instVer Cabal
                     liftE $ installCabalBindist
                         (DownloadInfo uri Nothing "")
                         (_tvVersion v)
                         (fromMaybe pfreq instPlatform)
+                     pure vi
                  )
                  >>= \case
-                        VRight _ -> do
+                        VRight vi -> do
                          runLogger $ $(logInfo) ("Cabal installation successful")
+                          forM_ (join $ fmap _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) [i|#{e}|]
+                            $(logError) $ T.pack $ prettyShow e
                            $(logError) [i|Also check the logs in #{logsDir}|]
                          pure $ ExitFailure 4

          let installHLS InstallOptions{..} =
                (case instBindist of
                   Nothing -> runInstTool $ do
-                     v <- liftE $ fromVersion dls instVer HLS
+                     (v, vi) <- 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 <- liftE $ fromVersion dls instVer HLS
+                     (v, vi) <- liftE $ fromVersion dls instVer HLS
                     liftE $ installHLSBindist
                         (DownloadInfo uri Nothing "")
                         (_tvVersion v)
                         (fromMaybe pfreq instPlatform)
+                     pure vi
                  )
                  >>= \case
-                        VRight _ -> do
+                        VRight vi -> do
                          runLogger $ $(logInfo) ("HLS installation successful")
+                          forM_ (join $ fmap _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) [i|#{e}|]
+                            $(logError) $ T.pack $ prettyShow e
                            $(logError) [i|Also check the logs in #{logsDir}|]
                          pure $ ExitFailure 4


          let setGHC' SetOptions{..} =
                (runSetGHC $ do
-                    v <- liftE $ fromVersion dls sToolVer GHC
+                    v <- liftE $ fst <$> fromVersion' dls sToolVer GHC
                    liftE $ setGHC v SetGHCOnly
                  )
                  >>= \case
@@ -1281,59 +1368,84 @@ 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) [i|#{e}|])
+                          runLogger $ $(logError) $ T.pack $ prettyShow e
                          pure $ ExitFailure 5

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

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

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

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

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


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

            Compile (CompileGHC GHCCompileOptions {..}) ->
              (runCompileGHC $ do
+                let vi = getVersionInfo targetVer GHC dls
+                forM_ (join $ fmap _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
@@ -1393,28 +1511,30 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                            patchDir
                            addConfArgs
                            pfreq
-                when setCompile $ void $ liftE
-                  $ setGHC (GHCTargetVersion crossTarget targetVer) SetGHCOnly
+                when setCompile $ void $ liftE $
+                  setGHC (GHCTargetVersion crossTarget targetVer) SetGHCOnly
+                pure vi
                )
                >>= \case
-                      VRight _ -> do
+                      VRight vi -> do
                        runLogger $ $(logInfo)
                          ("GHC successfully compiled and installed")
+                        forM_ (join $ fmap _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 (V (BuildFailed tmpdir e)) -> do
+                      VLeft err@(V (BuildFailed tmpdir _)) -> do
                        case keepDirs settings of
-                          Never -> runLogger ($(logError) [i|Build failed with #{e}
-Check the logs at #{logsDir}|])
-                          _ -> runLogger ($(logError) [i|Build failed with #{e}
+                          Never -> runLogger $ $(logError) $ T.pack $ prettyShow err
+                          _ -> runLogger ($(logError) [i|#{prettyShow err}
 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) [i|#{e}|])
+                        runLogger $ $(logError) $ T.pack $ prettyShow e
                        pure $ ExitFailure 9

            Upgrade (uOpts) force -> do
@@ -1429,14 +1549,17 @@ 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) [i|#{e}|])
+                  runLogger $ $(logError) $ T.pack $ prettyShow e
                  pure $ ExitFailure 11

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

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

-
-fromVersion :: Monad m
+fromVersion :: (MonadFail m, MonadReader AppState m, MonadThrow m, MonadIO m, MonadCatch m)
            => GHCupDownloads
            -> Maybe ToolVersion
            -> Tool
-            -> Excepts '[TagNotFound] m GHCTargetVersion
-fromVersion av Nothing tool =
-  mkTVer <$> getRecommended av tool ?? TagNotFound Recommended tool
-fromVersion av (Just (ToolVersion v)) _ = do
+            -> Excepts '[TagNotFound, NextVerNotFound, NoToolVersionSet] m (GHCTargetVersion, Maybe 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, NextVerNotFound, NoToolVersionSet] m (GHCTargetVersion, Maybe VersionInfo)
+fromVersion' av SetRecommended tool =
+  (\(x, y) -> (mkTVer x, Just y)) <$> getRecommended av tool
+    ?? TagNotFound Recommended tool
+fromVersion' av (SetToolVersion v) tool = do
+  let vi = getVersionInfo (_tvVersion v) tool av
  case pvp $ prettyVer (_tvVersion v) of
-    Left _ -> pure v
+    Left _ -> pure (v, vi)
    Right (PVP (major' :|[minor'])) ->
      case getLatestGHCFor (fromIntegral major') (fromIntegral minor') av of
-        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 =
+        Just (v', vi') -> pure (GHCTargetVersion (_tvTarget v) v', Just vi')
+        Nothing -> pure (v, vi)
+    Right _ -> pure (v, vi)
+fromVersion' av  (SetToolTag Latest) tool =
+  (\(x, y) -> (mkTVer x, Just y)) <$> getLatest av tool ?? TagNotFound Latest tool
+fromVersion' av (SetToolTag Recommended) tool =
+  (\(x, y) -> (mkTVer x, Just y)) <$> getRecommended av tool ?? TagNotFound Recommended tool
+fromVersion' av (SetToolTag (Base pvp'')) GHC =
+  (\(x, y) -> (mkTVer x, Just 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"
+  let vi = getVersionInfo (_tvVersion next) tool av
+  pure (next, vi)
+fromVersion' _ (SetToolTag t') tool =
  throwE $ TagNotFound t' tool


@@ -1688,27 +1851,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)
@@ -1727,7 +1890,7 @@ GHCup base dir: #{toFilePath diBaseDir}
 GHCup bin dir: #{toFilePath diBinDir}
 GHCup GHC directory: #{toFilePath diGHCDir}
 GHCup cache directory: #{toFilePath diCacheDir}
-Architecture: #{prettyArch diArch}
-Platform: #{prettyPlatform diPlatform}
+Architecture: #{prettyShow diArch}
+Platform: #{prettyShow diPlatform}
 Version: #{describe_result}|]

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

    case "${_plat}" in
@@ -89,6 +89,12 @@ 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.ghc8104.project
+++ b/cabal.ghc8104.project
@@ -1,7 +1,7 @@
-with-compiler: ghc-8.10.3
-
 packages: ./ghcup.cabal

+with-compiler: ghc-8.10.4
+
 optional-packages: ./3rdparty/*/*.cabal

 source-repository-package
@@ -22,6 +22,11 @@ source-repository-package
    tag: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
    subdir: hpath-directory

+source-repository-package
+    type: git
+    location: https://github.com/hasufell/streamly.git
+    tag: f921e78236c6b44a6673b5e1a1803d2e7102d806
+
 optimization: 2

 package streamly
--- a/cabal.ghc8104.project.freeze
+++ b/cabal.ghc8104.project.freeze
@@ -7,7 +7,7 @@ constraints: any.Cabal ==3.2.1.0,
             any.StateVar ==1.2.1,
             any.abstract-deque ==0.3,
             abstract-deque -usecas,
-             any.aeson ==1.5.5.1,
+             any.aeson ==1.5.6.0,
             aeson -bytestring-builder -cffi -developer -fast,
             any.aeson-pretty ==0.8.8,
             aeson-pretty -lib-only,
@@ -20,11 +20,11 @@ constraints: any.Cabal ==3.2.1.0,
             any.array ==0.5.4.0,
             any.ascii-string ==1.0.1.4,
             any.assoc ==1.0.2,
-             any.async ==2.2.2,
+             any.async ==2.2.3,
             async -bench,
             any.atomic-primops ==0.8.4,
             atomic-primops -debug,
-             any.attoparsec ==0.13.2.4,
+             any.attoparsec ==0.13.2.5,
             attoparsec -developer,
             any.auto-update ==0.1.6,
             any.base ==4.14.1.0,
@@ -52,7 +52,7 @@ constraints: any.Cabal ==3.2.1.0,
             chs-deps -cross,
             any.clock ==0.8.2,
             clock -llvm,
-             any.cmdargs ==0.10.20,
+             any.cmdargs ==0.10.21,
             cmdargs +quotation -testprog,
             any.colour ==2.3.5,
             any.comonad ==5.0.8,
@@ -68,9 +68,9 @@ constraints: any.Cabal ==3.2.1.0,
             any.cryptohash-sha256 ==0.11.102.0,
             cryptohash-sha256 -exe +use-cbits,
             any.data-default-class ==0.1.2.0,
-             any.data-fix ==0.3.0,
+             any.data-fix ==0.3.1,
             any.deepseq ==1.4.4.0,
-             any.deferred-folds ==0.9.15,
+             any.deferred-folds ==0.9.16,
             any.directory ==1.3.6.0,
             any.distributive ==0.6.2.1,
             distributive +semigroups +tagged,
@@ -79,22 +79,22 @@ constraints: any.Cabal ==3.2.1.0,
             any.easy-file ==0.2.2,
             any.errors ==2.3.0,
             any.exceptions ==0.10.4,
-             any.fast-logger ==3.0.2,
+             any.fast-logger ==3.0.3,
             any.filepath ==1.4.2.1,
             any.focus ==1.0.2,
-             any.foldl ==1.4.10,
+             any.foldl ==1.4.11,
             any.free ==5.1.6,
             any.fusion-plugin-types ==0.1.0,
             any.generic-arbitrary ==0.1.0,
-             any.generics-sop ==0.5.1.0,
-             any.ghc-boot-th ==8.10.3,
+             any.generics-sop ==0.5.1.1,
+             any.ghc-boot-th ==8.10.4,
             any.ghc-prim ==0.6.1,
             ghcup -internal-downloader -tar -tui,
             any.happy ==1.20.0,
-             any.hashable ==1.3.0.0,
-             hashable -examples +integer-gmp +sse2 -sse41,
+             any.hashable ==1.3.1.0,
+             hashable +integer-gmp,
             any.haskell-src-exts ==1.23.1,
-             any.haskell-src-meta ==0.8.5,
+             any.haskell-src-meta ==0.8.7,
             any.haskus-utils-data ==1.3,
             any.haskus-utils-types ==1.5,
             any.haskus-utils-variant ==3.0,
@@ -113,6 +113,7 @@ constraints: any.Cabal ==3.2.1.0,
             any.hspec-golden-aeson ==0.7.0.0,
             any.indexed-profunctors ==0.1,
             any.indexed-traversable ==0.1.1,
+             any.indexed-traversable-instances ==0.1,
             any.integer-gmp ==1.0.3.0,
             any.integer-logarithms ==1.0.3.1,
             integer-logarithms -check-bounds +integer-gmp,
@@ -130,10 +131,10 @@ constraints: any.Cabal ==3.2.1.0,
             math-functions +system-erf +system-expm1,
             any.megaparsec ==9.0.1,
             megaparsec -dev,
-             any.microlens ==0.4.11.2,
+             any.microlens ==0.4.12.0,
             any.microlens-mtl ==0.2.0.1,
             any.microlens-th ==0.4.3.9,
-             any.mmorph ==1.1.4,
+             any.mmorph ==1.1.5,
             any.monad-control ==1.0.2.3,
             any.monad-logger ==0.3.36,
             monad-logger +template_haskell,
@@ -146,10 +147,11 @@ constraints: any.Cabal ==3.2.1.0,
             network -devel,
             any.old-locale ==1.0.0.7,
             any.old-time ==1.1.0.3,
-             any.optics ==0.3,
-             any.optics-core ==0.3.0.1,
-             any.optics-extra ==0.3,
-             any.optics-th ==0.3.0.2,
+             any.optics ==0.4,
+             any.optics-core ==0.4,
+             optics-core -explicit-generic-labels,
+             any.optics-extra ==0.4,
+             any.optics-th ==0.4,
             any.optics-vl ==0.2.1,
             any.optparse-applicative ==0.16.1.0,
             optparse-applicative +process,
@@ -157,21 +159,20 @@ constraints: any.Cabal ==3.2.1.0,
             os-release -devel,
             any.parallel ==3.2.2.0,
             any.parsec ==3.1.14.0,
-             any.parser-combinators ==1.2.1,
+             any.parser-combinators ==1.3.0,
             parser-combinators -dev,
             any.pretty ==1.1.3.6,
             any.pretty-terminal ==0.1.0.0,
             any.primitive ==0.7.0.1,
-             any.primitive-extras ==0.8,
+             any.primitive-extras ==0.8.2,
             any.primitive-unlifted ==0.1.3.0,
             any.process ==1.6.9.0,
-             any.profunctors ==5.6.1,
+             any.profunctors ==5.6.2,
             any.quickcheck-arbitrary-adt ==0.3.1.0,
             any.quickcheck-io ==0.2.0,
             any.random ==1.2.0,
-             any.recursion-schemes ==5.2.1,
+             any.recursion-schemes ==5.2.2,
             recursion-schemes +template-haskell,
-             any.regex-base ==0.94.0.0,
             any.regex-posix ==0.96.0.0,
             regex-posix -_regex-posix-clib,
             any.resourcet ==1.2.4.2,
@@ -198,7 +199,7 @@ constraints: any.Cabal ==3.2.1.0,
             any.strict ==0.4.0.1,
             strict +assoc,
             any.strict-base ==0.4.0.0,
-             any.string-interpolate ==0.3.0.2,
+             any.string-interpolate ==0.3.1.0,
             string-interpolate -bytestring-builder -extended-benchmarks -text-builder,
             any.syb ==0.7.2.1,
             any.tagged ==0.8.6.1,
@@ -216,8 +217,7 @@ constraints: any.Cabal ==3.2.1.0,
             text-short -asserts,
             any.tf-random ==0.5,
             any.th-abstraction ==0.4.2.0,
-             any.th-compat ==0.1,
-             any.th-expand-syns ==0.4.6.0,
+             any.th-compat ==0.1.1,
             any.th-lift ==0.8.2,
             any.th-lift-instances ==0.1.18,
             any.th-orphans ==0.13.11,
@@ -245,17 +245,17 @@ constraints: any.Cabal ==3.2.1.0,
             any.uri-bytestring ==0.3.3.0,
             uri-bytestring -lib-werror,
             any.utf8-string ==1.0.2,
-             any.uuid-types ==1.0.3,
+             any.uuid-types ==1.0.4,
             any.vector ==0.12.2.0,
             vector +boundschecks -internalchecks -unsafechecks -wall,
             any.vector-algorithms ==0.8.0.4,
             vector-algorithms +bench +boundschecks -internalchecks -llvm +properties -unsafechecks,
-             any.versions ==4.0.2,
-             any.vty ==5.32,
+             any.versions ==4.0.3,
+             any.vty ==5.33,
             any.wcwidth ==0.0.2,
             wcwidth -cli +split-base,
             any.word8 ==0.1.3,
             any.yaml ==0.11.5.0,
             yaml +no-examples +no-exe,
             zlib -non-blocking-ffi -pkg-config -static
-index-state: hackage.haskell.org 2021-02-04T20:08:20Z
+index-state: hackage.haskell.org 2021-02-27T05:49:45Z
--- a/cabal.ghc884.project
+++ b/cabal.ghc884.project
@@ -1,14 +1,8 @@
-- Generated by stackage-to-hackage
-
-index-state: 2020-10-24T20:53:55Z
+packages: ./ghcup.cabal

 with-compiler: ghc-8.8.4

-packages:
-    ./
-  , 3rdparty/lzma/
-  , 3rdparty/lzma-clib/
-  , 3rdparty/zlib/
+optional-packages: ./3rdparty/*/*.cabal

 source-repository-package
    type: git
@@ -20,28 +14,30 @@ source-repository-package
    type: git
    location: https://github.com/hasufell/hpath.git
    tag: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
-    subdir: hpath-directory
-            hpath-io
+    subdir: hpath-io

 source-repository-package
    type: git
-    location: https://github.com/hasufell/text-conversions.git
-    tag: 9abf0e5e5664a3178367597c32db19880477a53c
+    location: https://github.com/hasufell/hpath.git
+    tag: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
+    subdir: hpath-directory

-allow-older: *
-allow-newer: *
+source-repository-package
+    type: git
+    location: https://github.com/hasufell/streamly.git
+    tag: f921e78236c6b44a6673b5e1a1803d2e7102d806

-package lzma
-    ghc-options: -O2
+optimization: 2

-package lzma-clib
-    ghc-options: -O2
-
-package zlib
-    ghc-options: -O2
+package streamly
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16

 package ghcup
    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16

-package streamly
-    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+constraints: http-io-streams -brotli
+
+package libarchive
+  flags: -system-libarchive
+
+allow-newer: base, ghc-prim, template-haskell
--- a/cabal.ghc884.project.freeze
+++ b/cabal.ghc884.project.freeze
--- a/cabal.project
+++ b/cabal.project
@@ -20,6 +20,11 @@ source-repository-package
    tag: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
    subdir: hpath-directory

+source-repository-package
+    type: git
+    location: https://github.com/hasufell/streamly.git
+    tag: f921e78236c6b44a6673b5e1a1803d2e7102d806
+
 optimization: 2

 package streamly
--- a/ghcup-0.0.2.yaml
+++ b/ghcup-0.0.2.yaml
@@ -1384,7 +1384,7 @@ ghcupDownloads:
              dlUri: https://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.11:
+    0.1.13:
      viTags:
      - Recommended
      - Latest
@@ -1394,22 +1394,22 @@ ghcupDownloads:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-linux-ghcup-0.1.11
-              dlHash: 99d97c9a1dce76892001e5cffd50cc23bf804f2282998c546d1b965aa2179699
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-linux-ghcup-0.1.13
+              dlHash: 674266bb9fa85bbafd3c620c68fae4b3cc62507bd6ad9b116603e860bdee1f5a
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-apple-darwin-ghcup-0.1.11
-              dlHash: 4b91dcd9bfdc40534156b8fadea3f317b3c44af1255169895f4911a221f819c6
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-apple-darwin-ghcup-0.1.13
+              dlHash: 5e45cb0b69cd8ee4f7793b84042d4bd121609fa59531ef760fc98fa10c466e4d
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-portbld-freebsd-ghcup-0.1.11
-              dlHash: 6f04ce98d3f3eb9299ce74f8264aa956f0dc38a64a3bd12ee048b7f146e9e1b4
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-portbld-freebsd-ghcup-0.1.13
+              dlHash: 79ce3143a100b60b5294fa831abf091b9699e0bf3addb6c9956de706fc954902
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/i386-linux-ghcup-0.1.11
-              dlHash: ec339e4c2b8b4d502f66a03c0d3f112cb68cd922dd3c4a6f66323628cf6a76c2
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/i386-linux-ghcup-0.1.13
+              dlHash: 4d7646027215b29384f1409399f66bd348421de8a6d53e47ae47c3b465e18fb0
          Linux_Alpine:
            unknown_versioning: *ghcup-32
--- a/ghcup-0.0.3.yaml
+++ b/ghcup-0.0.3.yaml
@@ -1451,7 +1451,7 @@ ghcupDownloads:
              dlUri: https://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.12:
+    0.1.13:
      viTags:
      - Recommended
      - Latest
@@ -1461,23 +1461,23 @@ ghcupDownloads:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-linux-ghcup-0.1.12
-              dlHash: 83088569ddf2d35df494f440dedd9c8eb2a53276d665f7de731f6554986c2ddb
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-linux-ghcup-0.1.13
+              dlHash: 674266bb9fa85bbafd3c620c68fae4b3cc62507bd6ad9b116603e860bdee1f5a
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-apple-darwin-ghcup-0.1.12
-              dlHash: 1336efb0851e1ed267838f97f6c36cbceb5363ad0ae359f04f1bc43d0c5f2cef
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-apple-darwin-ghcup-0.1.13
+              dlHash: 5e45cb0b69cd8ee4f7793b84042d4bd121609fa59531ef760fc98fa10c466e4d
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-portbld-freebsd-ghcup-0.1.12
-              dlHash: a72123e972a53d667574c7d276a81842701a07fce2b434e4d856e561c34772fe
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-portbld-freebsd-ghcup-0.1.13
+              dlHash: 79ce3143a100b60b5294fa831abf091b9699e0bf3addb6c9956de706fc954902
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/i386-linux-ghcup-0.1.12
-              dlHash: 4bc79a272dfcd16143f08d9f8e33f2fef66dc53f3a0659bdab56ac3cbecf9e84
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/i386-linux-ghcup-0.1.13
+              dlHash: 4d7646027215b29384f1409399f66bd348421de8a6d53e47ae47c3b465e18fb0
          Linux_Alpine:
            unknown_versioning: *ghcup-32
  HLS:
--- a/ghcup-0.0.4.yaml
+++ b/ghcup-0.0.4.yaml
@@ -76,6 +76,19 @@ 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:
@@ -125,6 +138,7 @@ 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:
@@ -188,6 +202,7 @@ 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:
@@ -246,6 +261,7 @@ 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:
@@ -313,6 +329,7 @@ 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:
@@ -362,6 +379,7 @@ 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:
@@ -416,6 +434,7 @@ 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:
@@ -464,6 +483,7 @@ 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:
@@ -537,6 +557,7 @@ 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:
@@ -591,6 +612,7 @@ 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:
@@ -636,6 +658,7 @@ 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:
@@ -699,6 +722,7 @@ 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:
@@ -747,6 +771,7 @@ 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:
@@ -811,6 +836,12 @@ ghcupDownloads:
              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
@@ -820,6 +851,7 @@ 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:
@@ -878,6 +910,7 @@ 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:
@@ -936,6 +969,7 @@ 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:
@@ -990,6 +1024,12 @@ 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
@@ -998,6 +1038,7 @@ 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:
@@ -1071,6 +1112,7 @@ 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:
@@ -1139,6 +1181,18 @@ ghcupDownloads:
              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
@@ -1148,6 +1202,7 @@ ghcupDownloads:
        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:
@@ -1216,6 +1271,18 @@ ghcupDownloads:
              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.10.2/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:
      - base-4.14.1.0
@@ -1224,6 +1291,7 @@ ghcupDownloads:
        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:
@@ -1292,6 +1360,18 @@ ghcupDownloads:
              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/ghc/8.10.3/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
@@ -1301,6 +1381,8 @@ ghcupDownloads:
        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:
@@ -1369,6 +1451,18 @@ ghcupDownloads:
              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
@@ -1378,6 +1472,7 @@ 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:
@@ -1446,6 +1541,18 @@ ghcupDownloads:
              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:
@@ -1575,8 +1682,18 @@ ghcupDownloads:
            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
  GHCup:
-    0.1.12:
+    0.1.13:
      viTags:
      - Recommended
      - Latest
@@ -1586,40 +1703,51 @@ ghcupDownloads:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-linux-ghcup-0.1.12
-              dlHash: 83088569ddf2d35df494f440dedd9c8eb2a53276d665f7de731f6554986c2ddb
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-linux-ghcup-0.1.13
+              dlHash: 674266bb9fa85bbafd3c620c68fae4b3cc62507bd6ad9b116603e860bdee1f5a
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-apple-darwin-ghcup-0.1.12
-              dlHash: 1336efb0851e1ed267838f97f6c36cbceb5363ad0ae359f04f1bc43d0c5f2cef
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-apple-darwin-ghcup-0.1.13
+              dlHash: 5e45cb0b69cd8ee4f7793b84042d4bd121609fa59531ef760fc98fa10c466e4d
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-portbld-freebsd-ghcup-0.1.12
-              dlHash: a72123e972a53d667574c7d276a81842701a07fce2b434e4d856e561c34772fe
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-portbld-freebsd-ghcup-0.1.13
+              dlHash: 79ce3143a100b60b5294fa831abf091b9699e0bf3addb6c9956de706fc954902
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/i386-linux-ghcup-0.1.12
-              dlHash: 4bc79a272dfcd16143f08d9f8e33f2fef66dc53f3a0659bdab56ac3cbecf9e84
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/i386-linux-ghcup-0.1.13
+              dlHash: 4d7646027215b29384f1409399f66bd348421de8a6d53e47ae47c3b465e18fb0
          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:
-    0.9.0:
+    1.0.0:
      viTags:
        - Recommended
        - Latest
-      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#090
+      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"
      viArch:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &hls-64
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.9.0/haskell-language-server-Linux-0.9.0.tar.gz
-              dlHash: 6933216e2fcdc51a32a828f7880403d83433b6585ff393da196f6db1d4e1e53f
+              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.0.0/haskell-language-server-Linux-1.0.0.tar.gz
+              dlHash: 4fab18998c5f67118a26b75b059f3b3e2ad345b6325515a552d1a24cdf87ed3f
          Darwin:
            unknown_versioning:
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.9.0/haskell-language-server-macOS-0.9.0.tar.gz
-              dlHash: f6197977941e803e128889f1170bebca97a80c1b62234bf5c7b1032ab3df68f4
+              dlUri: https://github.com/haskell/haskell-language-server/releases/download/1.0.0/haskell-language-server-macOS-1.0.0.tar.gz
+              dlHash: 74e7624c889c0235f0b02d7e7f164d5eb95b611d584fc8602f0b3a099b73f8be
          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.12
+version:            0.1.14
 synopsis:           ghc toolchain installer as an exe/library
 description:
  A rewrite of the shell script ghcup, for providing
@@ -150,6 +150,9 @@ 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

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

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

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

@@ -375,6 +381,7 @@ executable ghcup
    , monad-logger
    , mtl
    , optparse-applicative
+    , pretty
    , pretty-terminal
    , resourcet
    , safe
@@ -430,6 +437,7 @@ 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 ^. tvVersion % to prettyVer)))
+  whenM (lift $ fmap not $ ghcInstalled ver) (throwE (NotInstalled GHC ver))

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

  whenM (liftIO $ fmap not $ doesFileExist (binDir </> targetFile))
    $ throwE
-    $ NotInstalled Cabal (prettyVer ver)
+    $ NotInstalled Cabal (GHCTargetVersion Nothing 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 (prettyVer ver)
+  when (bins == []) $ throwE $ NotInstalled HLS (GHCTargetVersion Nothing 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 ^. tvVersion % to prettyVer)))
+  whenM (lift $ fmap not $ ghcInstalled ver) (throwE (NotInstalled GHC ver))
  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 (prettyVer ver))
+  whenM (lift $ fmap not $ cabalInstalled ver) $ throwE (NotInstalled Cabal (GHCTargetVersion Nothing 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 (prettyVer ver))
+  whenM (lift $ fmap not $ hlsInstalled ver) $ throwE (NotInstalled HLS (GHCTargetVersion Nothing ver))

  isHlsSet      <- lift $ hlsSet

@@ -1240,7 +1240,7 @@ Stage1Only = YES|]
      $ c
    tarName <-
      parseRel
-        [i|ghc-#{prettyTVer tver}-#{prettyPfReq pfreq}-#{cDigest}.tar#{takeExtension (toFilePath tar)}|]
+        [i|ghc-#{tVerToText tver}-#{pfReqToString pfreq}-#{cDigest}.tar#{takeExtension (toFilePath tar)}|]
    let tarPath = cacheDir </> tarName
    handleIO (throwE . CopyError . show) $ liftIO $ copyFile (workdir </> tar)
                                                             tarPath
@@ -1308,7 +1308,7 @@ upgradeGHCup :: ( MonadMask m
 upgradeGHCup dls mtarget force pfreq = do
  AppState {dirs = Dirs {..}} <- lift ask
  lift $ $(logInfo) [i|Upgrading GHCup...|]
-  let latestVer = fromJust $ getLatest dls GHCup
+  let latestVer = fromJust $ fst <$> getLatest dls GHCup
  when (not force && (latestVer <= pvpToVersion ghcUpVer)) $ throwE NoUpdate
  dli   <- lE $ getDownloadInfo GHCup latestVer pfreq dls
  tmp   <- lift withGHCupTmpDir
@@ -1325,6 +1325,13 @@ upgradeGHCup dls mtarget force pfreq = do
                                                           destFile
                                                           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.|]
+
  pure latestVer


--- a/lib/GHCup/Download.hs
+++ b/lib/GHCup/Download.hs
@@ -137,30 +137,8 @@ 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)

-  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

  mergeGhcupInfo :: GHCupInfo -- ^ base to merge with
                 -> GHCupInfo -- ^ extension overwriting the base
@@ -172,6 +150,32 @@ 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.
@@ -209,8 +213,8 @@ getDownloadsF urlSource = do
      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,7 +1,13 @@
+{-# 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
@@ -15,13 +21,21 @@ 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           Haskus.Utils.Variant
 import           HPath
+import           Haskus.Utils.Variant
+import           Text.PrettyPrint
+import           Text.PrettyPrint.HughesPJClass
+import           URI.ByteString



@@ -35,97 +49,203 @@ import           HPath
 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 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 Text
+data NotInstalled = NotInstalled Tool GHCTargetVersion
  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 es . Show (V es) => DownloadFailed (V es)
+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

 deriving instance Show DownloadFailed

@@ -133,12 +253,20 @@ 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


@@ -151,11 +279,65 @@ 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,6 +1,8 @@
+{-# OPTIONS_GHC -Wno-orphans #-}
 {-# LANGUAGE CPP               #-}
 {-# LANGUAGE DeriveGeneric     #-}
 {-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes           #-}

 {-|
 Module      : GHCup.Types
@@ -15,12 +17,16 @@ 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

@@ -85,10 +91,14 @@ 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
+  { _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
  }
  deriving (Eq, GHC.Generic, Show)

@@ -102,6 +112,21 @@ 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
@@ -113,15 +138,18 @@ data Architecture = A_64
                  | A_ARM64
  deriving (Eq, GHC.Generic, Ord, Show)

-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"
+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

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

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

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

-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"
+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


 -- | An encapsulation of a download. This can be used
@@ -187,6 +221,10 @@ 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
@@ -306,12 +344,15 @@ data PlatformResult = PlatformResult
  }
  deriving (Eq, Show)

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

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

-prettyPfReq :: PlatformRequest -> String
-prettyPfReq (PlatformRequest arch plat ver) =
-  prettyArch arch ++ "-" ++ prettyPlatfrom plat ++ pver
+pfReqToString :: PlatformRequest -> String
+pfReqToString (PlatformRequest arch plat ver) =
+  archToString arch ++ "-" ++ platformToString 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
@@ -339,11 +383,13 @@ 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>
-prettyTVer :: GHCTargetVersion -> Text
-prettyTVer (GHCTargetVersion (Just t) v') = t <> "-" <> prettyVer v'
-prettyTVer (GHCTargetVersion Nothing  v') = prettyVer v'
+instance Pretty GHCTargetVersion where
+  pPrint = text . T.unpack . tVerToText


 -- | A comparator and a version.
@@ -361,3 +407,9 @@ 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
+                -> Maybe (Version, VersionInfo)
 getLatestGHCFor major' minor' dls = do
  join
-    . fmap (lastMay . filter (\v -> matchMajor v major' minor'))
-    . preview (ix GHC % to Map.keys)
+    . fmap (lastMay . filter (\(v, _) -> matchMajor v major' minor'))
+    . preview (ix GHC % to Map.toDescList)
    $ dls


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

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

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


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



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

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

  files    <- liftIO $ getDirsFiles' bindir
  -- figure out the <ver> suffix, because this might not be `Version` for
@@ -795,3 +795,25 @@ 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) $ fmap Just $ readFile file 
+  bs <- liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ 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 (prettyTVer ver)
+  verdir        <- parseRel $ E.encodeUtf8 (tVerToText 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
+import           System.Console.Pretty   hiding ( Pretty )
 import           System.Console.Regions
 import           System.IO.Error
 import           System.Posix.Directory.ByteString
@@ -55,6 +55,7 @@ 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


@@ -79,6 +80,15 @@ 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
@@ -407,6 +417,32 @@ 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,13 +12,15 @@ Portability : POSIX
 -}
 module GHCup.Version where

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

-import           Data.Versions
+import           Data.Version (Version(versionBranch))
+import           Data.Versions hiding (version)
 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.
@@ -27,7 +29,7 @@ ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.4.yaml|]

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

 -- | ghcup version as numeric string.
 numericVer :: String
--- a/stack.yaml
+++ b/stack.yaml
@@ -1,4 +1,4 @@
-resolver: lts-16.17
+resolver: lts-17.4

 packages:
  - .
@@ -22,33 +22,28 @@ extra-deps:
  - git: https://github.com/hasufell/text-conversions.git
    commit: 9abf0e5e5664a3178367597c32db19880477a53c

+  - git: https://github.com/hasufell/streamly.git
+    commit: f921e78236c6b44a6673b5e1a1803d2e7102d806
+
  - IfElse-0.85@sha256:6939b94acc6a55f545f63a168a349dd2fbe4b9a7cca73bf60282db5cc6aa47d2,445
-  - QuickCheck-2.14.1@sha256:01e46d7b0a8d3148288ec977625f62d5516ebb5031a50c63f0453863301b4a79,7736
  - ascii-string-1.0.1.4@sha256:fa34f1d9ba57e8e89c0d4c9cef5e01ba32cb2d4373d13f92dcc0b531a6c6749b,2582
-  - base64-bytestring-1.1.0.0@sha256:190264fef9e65d9085f00ccda419137096d1dc94777c58272bc96821dc7f37c3,2334
-  - brick-0.55@sha256:f98736eca0cd694837062e06da4655eed969d53b789dfd919716e9b6f5b4c5ce,15858
  - brotli-0.0.0.0@sha256:2bf383a4cd308745740986be0b18381c5a0784393fe69b91456aacb2d603de46,2964
  - brotli-streams-0.0.0.0@sha256:1af1e22f67b8bfd6ad0d05e61825e7a178d738f689ebbb21c1aab5f1bbcae176,2331
  - chs-cabal-0.1.1.0@sha256:20ec6a9fb5ab6991f1a4adf157c537bd5d3b98d08d3c09c387c954c7c50bd011,1153
  - chs-deps-0.1.0.0@sha256:0cdada6d2c682c41b20331b8c63c2ecfc7e806928585195fd544c9d41f3074fd,2496
-  - composition-prelude-3.0.0.0@sha256:7407835ce8c1e0e2fd6febd25391b12989b216773e685e3cf95bd89072af0ecc,1149
+  - composition-prelude-3.0.0.2@sha256:1ffed216bd28d810fce0b5be83a661e2a892696d73b3f8de5c0f5edb9b5f0090,1216
  - haskus-utils-data-1.3@sha256:f62c4e49021b463185d043f7b69c727b63af641a71d7edd582d9f4f98e80e500,1466
  - haskus-utils-variant-3.0@sha256:8d51e45d3b664e61ccc25a58b37c0ccc4ee7537138b9fee21cd15c356906dd34,2159
  - hpath-0.11.0@sha256:12b8405bee13d0007d644a888ef8407069ce7bbbd76970f8746b801447124ade,1440
  - hpath-filepath-0.10.4@sha256:e9e44fb5fdbade7f30b5b5451257dbee15b6ef1aae4060034d73008bb3b5d878,1269
  - hpath-posix-0.13.2@sha256:eec4ff2b00dc86be847aca0f409fc8f6212ffd2170ec36a17dc9a52b46562392,1615
-  - http-io-streams-0.1.4.0@sha256:9a74a059daeddf7a41d361919190b9f4d4292f05e0e4bdf156e2098a116a8145,3582
-  - libarchive-3.0.0.0@sha256:e4157b307acf16cca0ec3d398ac5093cc06f092b33a9743be559ef0f6c6ae52f,11204
+  - http-io-streams-0.1.6.0@sha256:53f5bab177efb52cd65ec396fd04ed59b93e5f919fb3700cd7dacd6cfce6f06d,3582
+  - libarchive-3.0.2.1@sha256:40ebf2a278e585802427bc58826867208bb33822f63d56107a1fcc3ca04d691d,10990
  - os-release-1.0.1@sha256:1281c62081f438fc3f0874d3bae6a4887d5964ac25261ba06e29d368ab173467,2716
-  - primitive-extras-0.8@sha256:fca0310150496867f5b9421fe1541ecda87fae17eae44885a29f9c52dd00c8ff,2963
-  - primitive-unlifted-0.1.3.0@sha256:a98f827740f5dcf097d885b3a47c32f4462204449620abc9d51b8c4f8619f9e6,1427
-  - random-1.2.0@sha256:4321209c8faedc034810ea8ed0dbc4a36f1a1df97b75af024219f2f533da57de,6094
-  - splitmix-0.1.0.1@sha256:22f9662e7e8b173421872241edd39350078a9ed4bb9e9f503948c5b483c79276,5253
+  - primitive-0.7.0.1@sha256:a381571c36edc7dca28b77fe8159b43c14c640087ec5946adacf949feec64231,3433
+  - streamly-bytestring-0.1.2@sha256:cc828f41d1c714c711d38fb213b4ed186febabba598ab080e13255f69c20b13c,2469
  - streamly-posix-0.1.0.1@sha256:5d89b806281035d34020387ed99dde1ddab282c7ed66df3b7cd010b38fd3517b,2138
  - strict-base-0.4.0.0@sha256:2ff4e43cb95eedf2995558d7fc34d19362846413dd39e6aa6a5b3ea8228fef9f,1248
-  - tar-bytestring-0.6.3.2@sha256:88f29bed56b688c543a4cb3986402d64b360f76b3fd9b88ac618b8344f8da712,5715
-  - versions-4.0.1@sha256:0f644c1587d38f0eb3c3fe364bf1822424db43cbd4d618d0e21473b062c45239,1936
-  - vty-5.30@sha256:4af3938d7b9e6096e222bf52d0ea5d39873bc6fe19febd34106906306af13730,20857
  - xor-0.0.1.0@sha256:f8362b4a68562b9afbcd727ff64c1a303970df3a032e0033d2f4c094c3501df3,2243

 flags:
@@ -63,7 +58,7 @@ flags:
    internal-downloader: true

 system-ghc: true
-compiler: ghc-8.8.4
+compiler: ghc-8.10.4
 compiler-check: match-exact

 ghc-options:
--- a/www/ghcup.js
+++ b/www/ghcup.js
@@ -149,7 +149,17 @@ function fill_in_bug_report_values() {
 }

 function copyToClipboard() {
-  const text = document.getElementsByClassName("ghcup-command").item(0).innerText;
+  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 el = document.createElement('textarea');
  el.value = text;
  document.body.appendChild(el);
--- a/www/index.html
+++ b/www/index.html
@@ -32,7 +32,10 @@

      <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>
-		<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>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>
        <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>

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

      <div id="platform-instructions-default" class="instructions">
        <div>
-          <p>To install Haskell, if you are running Linux, macOS, FreeBSD or Windows Subsystem for Linux, run the following
+          <p>To install Haskell, if you are running Linux, macOS (on Intel), 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>

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

      <div id="platform-instructions-default" class="instructions">
        <div>
-          <p>To install Haskell, if you are running Linux, macOS, FreeBSD or Windows Subsystem for Linux, run the following
+          <p>To install Haskell, if you are running Linux, macOS (on Intel), 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>
Author	SHA1	Message	Date
Julian Ospald	561b6684ce	Update travis	2021-03-07 12:33:21 +01:00
Julian Ospald	a13bb3154d	Update CHANGELOG	2021-03-07 12:27:04 +01:00
Julian Ospald	fd9d3faf9f	Merge branch 'PR/issue-116'	2021-03-07 12:24:05 +01:00
Julian Ospald	f6cc467e95	Fix handling of stray versions wrt #116	2021-03-07 12:02:13 +01:00
Julian Ospald	ef978c1230	Add test case for issue #116	2021-03-07 11:59:45 +01:00
Julian Ospald	52af598473	Update ghcup in old yamls	2021-03-06 16:02:09 +01:00
Julian Ospald	2acacd46c2	Bump stack.yaml	2021-03-02 19:37:09 +01:00
Julian Ospald	4b2f9ddb40	Update project files	2021-03-02 19:22:14 +01:00
Julian Ospald	0d3dc4eba2	Bump ghcup version	2021-03-02 12:39:24 +01:00
Julian Ospald	824faa8091	Update CHANGELOG	2021-03-02 12:38:11 +01:00
Julian Ospald	d10cdfdf57	Merge branch 'PR/issue-115'	2021-03-02 12:34:52 +01:00
Julian Ospald	5e911793ce	Document env variables wrt #95	2021-03-02 10:51:23 +01:00
Julian Ospald	8c87c9aeb7	Fix error messages and overhaul pretty printing Fixes #115	2021-03-02 10:35:31 +01:00
Julian Ospald	9da5998a5c	Add some fancy messages	2021-02-26 19:55:33 +01:00
Julian Ospald	08943dadca	Fix validation	2021-02-26 16:06:08 +01:00
Julian Ospald	7fac7226c5	Update ghcup	2021-02-26 15:38:35 +01:00
Julian Ospald	9686c8ebf9	Update changelog	2021-02-26 11:53:57 +01:00
Julian Ospald	4bf96d0ec9	Revert version bump in bootstrap script	2021-02-25 19:19:53 +01:00
Julian Ospald	34add82bee	Merge branch 'PR/issue-114'	2021-02-25 19:18:13 +01:00
Julian Ospald	f46e7e8c4b	Add "ghcup set ghc next" tag wrt #114	2021-02-25 19:10:55 +01:00
Julian Ospald	3baf254251	Improve tag completer	2021-02-25 16:13:00 +01:00
Julian Ospald	10ca9ea827	Reformat versionCompleter	2021-02-25 15:52:28 +01:00
Julian Ospald	4a50c8ecb7	Remove network call on shell completion	2021-02-25 15:46:08 +01:00
Julian Ospald	47d9766c78	Make sure forFold can properly inline	2021-02-25 15:40:52 +01:00
Julian Ospald	45ab69960f	Merge remote-tracking branch 'origin/merge-requests/70'	2021-02-25 15:36:37 +01:00
Julian Ospald	d3505d4ee6	Bump version to 0.1.13	2021-02-25 15:33:52 +01:00
Julian Ospald	9297d1a2f8	Merge branch 'arm'	2021-02-25 14:22:59 +01:00
Julian Ospald	56feb7c09e	Use stages in CI	2021-02-25 14:14:01 +01:00
Julian Ospald	bede4b8712	Merge branch 'www-fix-silicon-copy'	2021-02-25 13:33:11 +01:00
Julian Ospald	95c1c55f22	Fix copy button for apple silicon	2021-02-25 13:32:46 +01:00
Julian Ospald	f547a6eb68	Support ARM/AARCH	2021-02-25 11:53:36 +01:00
Huw campbell	453a29fdf7	Respect the user's configuration settings Only lookup user configuration before doing a search; implement version completion for Cabal and HLS removal	2021-02-25 16:31:40 +11:00
Huw campbell	1a5f0259f4	Just use the cache for commands which refer to locally stored objects. Setting a version of GHC will fail if provided with a version not installed, and we don't neede to check the most recent list of GHCs available to know that.	2021-02-25 10:19:16 +11:00
Huw campbell	d6fa61e223	Add command line completions for installed and available versions. When running `ghcup set ghc` and pressing tab, one should be able to autocomplete the currently installed GHCs we have available. Add an optparse applicative completer for install, rm, and set commands which shows tags and versions. For installation, all are shown; while for remove and set, only those installed are.	2021-02-25 00:42:16 +11:00
Julian Ospald	eab82b5d63	Update HLS to 1.0.0	2021-02-24 12:43:04 +01:00
Julian Ospald	c455b521a9	Fix ghcup-tui	2021-02-24 12:42:36 +01:00
Julian Ospald	b4f9e12293	Merge remote-tracking branch 'origin/merge-requests/54'	2021-02-24 10:13:46 +01:00
Julian Ospald	bbd353ea3a	Merge branch 'PR/issue-107'	2021-02-23 18:40:04 +01:00
Julian Ospald	4189c5de69	Update CHANGELOG	2021-02-23 17:11:45 +01:00
Julian Ospald	dee3218723	Fix item selection with unavailable versions Fixes #107	2021-02-23 17:10:48 +01:00
Julian Ospald	3c803a9f58	Merge branch 'PR/issue-104'	2021-02-23 12:52:19 +01:00
Julian Ospald	a9b0c0fbc9	Allow for dynamic post-install, post-remove and pre-compile msgs	2021-02-23 11:52:38 +01:00
Julian Ospald	38b6c918f9	Update CHANGELOG	2021-02-21 21:03:12 +01:00
Julian Ospald	6e584c96c4	Merge branch 'PR/issue-111'	2021-02-21 21:01:59 +01:00
Julian Ospald	20338f7d14	Alert user if upgraded ghcup is shadowed by old ghcup Also alerts if the binary is not in PATH at all. Fixes #111	2021-02-21 19:58:32 +01:00
Julian Ospald	1a995a5d63	Merge branch 'PR/cabal-3.4.0.0'	2021-02-21 16:34:18 +01:00
Ron Toland	7c8929fe9f	add default install instructions for apple silicon	2020-12-26 06:33:32 -08:00
Ron Toland	8ed9b4432d	Add install cmd for Apple Silicon wrt #101	2020-12-23 06:51:54 -08:00