Fix error messages and overhaul pretty printing

Fixes #115

.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,74 +157,97 @@ 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.8.4"
+    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
   extends:
     - .debian
 
 ######## linux test ########
 
 test:linux:recommended:
+  stage: test
   extends: .test_ghcup_version:linux
   variables:
-    GHC_VERSION: "8.8.4"
+    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
 
 test:linux:latest:
+  stage: test
   extends: .test_ghcup_version:linux
   variables:
-    GHC_VERSION: "8.10.2"
+    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.2.0.0"
+    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.8.4"
+    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.8.4"
+    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
 
 test:mac:latest:
+  stage: test
   extends: .test_ghcup_version:darwin
   variables:
-    GHC_VERSION: "8.10.2"
+    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.2.0.0"
+    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.8.4"
+    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
 
 test:freebsd:latest:
+  stage: test
   extends: .test_ghcup_version:freebsd
   variables:
-    GHC_VERSION: "8.10.2"
+    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.2.0.0"
+    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.8.4"
+    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.2.0.0"
+    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.8.4"
+    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,14 +311,16 @@ release:darwin:
     - ./.gitlab/before_script/darwin/install_deps.sh
   variables:
     ARTIFACT: "x86_64-apple-darwin-ghcup"
-    GHC_VERSION: "8.8.3"
+    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
     MACOSX_DEPLOYMENT_TARGET: "10.7"
 
 
 ######## 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.8.3"
+    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.2.0.0"
+    CABAL_VERSION: "3.4.0.0"
 

.gitlab/before_script/darwin/install_deps.sh

@@ -9,8 +9,9 @@ mkdir -p "${TMPDIR}"
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-apple-darwin-ghcup > ./ghcup-bin
 chmod +x ghcup-bin
 
-./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin upgrade -i -f
-./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
-./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
 
 exit 0

.gitlab/before_script/freebsd/install_deps.sh

@@ -11,8 +11,9 @@ mkdir -p "${TMPDIR}"
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-portbld-freebsd-ghcup > ./ghcup-bin
 chmod +x ghcup-bin
 
-./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin upgrade -i -f
-./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
-./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
 
 exit 0

.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,14 +21,15 @@ 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
 fi
 chmod +x ghcup-bin
-./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin upgrade -i -f
-./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
 
 # utils
 apk add --no-cache \

.gitlab/before_script/linux/install_deps.sh

@@ -12,7 +12,8 @@ sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev li
 curl -sSfL https://downloads.haskell.org/~ghcup/x86_64-linux-ghcup > ./ghcup-bin
 chmod +x ghcup-bin
 
-./ghcup-bin install ${GHC_VERSION}
+./ghcup-bin upgrade -i -f
-./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
-./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}
 

.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

.gitlab/script/ghcup_release.sh

@@ -16,15 +16,17 @@ 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
+	ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections' --constraint="zlib +static" -ftui
 else
-	ecabal build -w ghc-${GHC_VERSION} --constraint="zlib static" --constraint="lzma static" -ftui
+	ecabal build -w ghc-${GHC_VERSION} --constraint="zlib +static" --constraint="lzma +static" -ftui
 fi
 
 mkdir out

.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.10.3
-eghcup set 8.4.4
+eghcup set 8.10.3
-[ "$(ghc --numeric-version)" = "8.4.4" ]
+[ "$(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

.travis/build.sh

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

CHANGELOG.md

@@ -1,6 +1,18 @@
 # Revision history for ghcup
 
-## 0.1.12 -- ????-??-??
+## 0.1.13 -- 2021-02-26
+
+* Support ARMv7/AARCH64
+* Add command line completions for installed and available versions wrt [MR #70](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/70)
+* Allow to cycle through set tools wrt [#114](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/114)
+* Fix item selection with unavailable versions wrt [#107](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/107)
+* Allow for dynamic post-install, post-remove and pre-compile msgs wrt [MR #68](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/68)
+* Alert user if upgraded ghcup is shadowed by old ghcup wrt [#111](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/111)
+* Fix to `ghcup` directory creation and placement for the XDG install mode ([MR #49](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/49))
+* Do 755 permissions on executables, wrt #97
+* Add [NO_COLOR](https://no-color.org/) support wrt [MR #47](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/47)
+
+## 0.1.12 -- 2020-11-21
 
 * Fix disappearing HLS symlinks wrt #91
 * improve TUI:

HACKING.md

@@ -52,8 +52,19 @@ organised tree-ish in `GHCup.Utils` and `GHCup.Utils.*`.
 Anything dealing with ghcup specific directories is in
 `GHCup.Utils.Dirs`.
 
-Download information on where to fetch bindists from is in
+Download information on where to fetch bindists from is in the appropriate
-`GHCup.Data.GHCupDownloads`.
+yaml files: `ghcup-<yaml-ver>.yaml`.
+
+## Common Tasks
+
+### Adding a new GHC version
+
+1. open the latest `ghcup-<yaml-ver>.yaml`
+2. find the latest ghc version (in yaml tree e.g. `ghcupDownloads -> GHC -> 8.10.3`)
+3. copy-paste it
+4. adjust the version, tags, changelog, source url
+5. adjust the various bindist urls (make sure to also change the yaml anchors)
+6. run `cabal run exe:ghcup-gen -- check-tarballs -f ghcup-<yaml-ver>.yaml -u 'ghc-8\.10\.4'`
 
 ## Major refactors
 

README.md

@@ -119,9 +119,10 @@ To enable XDG style directories, set the environment variable `GHCUP_USE_XDG_DIR
 
 Then you can control the locations via XDG environment variables as such:
 
-* `XDG_DATA_HOME`: GHCs will be unpacked in `ghcup/ghc` subdir
+* `XDG_DATA_HOME`: GHCs will be unpacked in `ghcup/ghc` subdir (default: `~/.local/share`)
-* `XDG_CACHE_HOME`: logs and download files will be stored in `ghcup` subdir
+* `XDG_CACHE_HOME`: logs and download files will be stored in `ghcup` subdir (default: `~/.cache`)
 * `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`)
 
 ### Installing custom bindists
 

app/ghcup-gen/Main.hs

@@ -14,6 +14,7 @@ import           GHCup.Types
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.Logger
 
+import           Data.Char                      ( toLower )
 #if !MIN_VERSION_base(4,13,0)
 import           Data.Semigroup                 ( (<>) )
 #endif
@@ -21,6 +22,7 @@ import           Options.Applicative     hiding ( style )
 import           System.Console.Pretty
 import           System.Exit
 import           System.IO                      ( stdout )
+import           Text.Regex.Posix
 import           Validate
 
 import qualified Data.ByteString               as B
@@ -32,7 +34,7 @@ data Options = Options
   }
 
 data Command = ValidateYAML ValidateYAMLOpts
-             | ValidateTarballs ValidateYAMLOpts
+             | ValidateTarballs ValidateYAMLOpts TarballFilter
 
 
 data Input
@@ -63,6 +65,22 @@ data ValidateYAMLOpts = ValidateYAMLOpts
 validateYAMLOpts :: Parser ValidateYAMLOpts
 validateYAMLOpts = ValidateYAMLOpts <$> optional inputP
 
+tarballFilterP :: Parser TarballFilter
+tarballFilterP = option readm $
+  long "tarball-filter" <> short 'u' <> metavar "<tool>-<version>" <> value def
+    <> help "Only check certain tarballs (format: <tool>-<version>)"
+  where
+    def = TarballFilter Nothing (makeRegex ("" :: String))
+    readm = do
+      s <- str
+      case span (/= '-') s of
+        (_, []) -> fail "invalid format, missing '-' after the tool name"
+        (t, v) | [tool] <- [ tool | tool <- [minBound..maxBound], low (show tool) == low t ] ->
+          TarballFilter <$> pure (Just tool) <*> makeRegexOptsM compIgnoreCase execBlank (drop 1 v)
+        _ -> fail "invalid tool"
+    low = fmap toLower
+
+
 opts :: Parser Options
 opts = Options <$> com
 
@@ -78,11 +96,9 @@ com = subparser
      )
   <> (command
        "check-tarballs"
-       (   ValidateTarballs
+       (info
-       <$> (info
+         ((ValidateTarballs <$> validateYAMLOpts <*> tarballFilterP) <**> helper)
-             (validateYAMLOpts <**> helper)
+         (progDesc "Validate all tarballs (download and checksum)")
-             (progDesc "Validate all tarballs (download and checksum)")
-           )
        )
      )
   )
@@ -100,13 +116,13 @@ main = do
               B.getContents >>= valAndExit validate
             ValidateYAMLOpts { vInput = Just (FileInput file) } ->
               B.readFile file >>= valAndExit validate
-          ValidateTarballs vopts -> case vopts of
+          ValidateTarballs vopts tarballFilter -> case vopts of
             ValidateYAMLOpts { vInput = Nothing } ->
-              B.getContents >>= valAndExit validateTarballs
+              B.getContents >>= valAndExit (validateTarballs tarballFilter)
             ValidateYAMLOpts { vInput = Just StdInput } ->
-              B.getContents >>= valAndExit validateTarballs
+              B.getContents >>= valAndExit (validateTarballs tarballFilter)
             ValidateYAMLOpts { vInput = Just (FileInput file) } ->
-              B.readFile file >>= valAndExit validateTarballs
+              B.readFile file >>= valAndExit (validateTarballs tarballFilter)
   pure ()
 
  where

app/ghcup-gen/Validate.hs

@@ -7,6 +7,7 @@ module Validate where
 import           GHCup
 import           GHCup.Download
 import           GHCup.Types
+import           GHCup.Types.Optics
 import           GHCup.Utils.Dirs
 import           GHCup.Utils.Logger
 import           GHCup.Utils.Version.QQ
@@ -21,6 +22,7 @@ import           Control.Monad.Trans.Reader     ( runReaderT )
 import           Control.Monad.Trans.Resource   ( runResourceT
                                                 , MonadUnliftIO
                                                 )
+import           Data.Containers.ListUtils      ( nubOrd )
 import           Data.IORef
 import           Data.List
 import           Data.String.Interpolate
@@ -30,6 +32,8 @@ 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
 import qualified Data.Map.Strict               as M
@@ -64,7 +68,7 @@ validate dls = do
     forM_ (M.toList dls) $ \(t, versions) ->
       forM_ (M.toList versions) $ \(v, vi) ->
         forM_ (M.toList $ _viArch vi) $ \(arch, pspecs) -> do
-          checkHasRequiredPlatforms t v arch (M.keys pspecs)
+          checkHasRequiredPlatforms t v (_viTags vi) arch (M.keys pspecs)
 
     checkGHCVerIsValid
     forM_ (M.toList dls) $ \(t, _) -> checkMandatoryTags t
@@ -78,26 +82,30 @@ validate dls = do
         lift $ $(logInfo) [i|All good|]
         pure ExitSuccess
  where
-  checkHasRequiredPlatforms t v arch pspecs = do
+  checkHasRequiredPlatforms t v tags arch pspecs = do
     let v' = prettyVer v
+        arch' = prettyShow arch
     when (not $ any (== Linux UnknownLinux) pspecs) $ do
       lift $ $(logError)
-        [i|Linux UnknownLinux missing for for #{t} #{v'} #{arch}|]
+        [i|Linux UnknownLinux missing for for #{t} #{v'} #{arch'}|]
       addError
     when ((not $ any (== Darwin) pspecs) && arch == A_64) $ do
-      lift $ $(logError) [i|Darwin missing for #{t} #{v'} #{arch}|]
+      lift $ $(logError) [i|Darwin missing for #{t} #{v'} #{arch'}|]
       addError
     when ((not $ any (== FreeBSD) pspecs) && arch == A_64) $ lift $ $(logWarn)
-      [i|FreeBSD missing for #{t} #{v'} #{arch}|]
+      [i|FreeBSD missing for #{t} #{v'} #{arch'}|]
 
     -- alpine needs to be set explicitly, because
     -- we cannot assume that "Linux UnknownLinux" runs on Alpine
     -- (although it could be static)
     when (not $ any (== Linux Alpine) pspecs) $
       case t of
-        GHCup -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
+        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|] -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
+        Cabal | v > [vver|2.4.1.0|]
-        _     -> lift $ $(logWarn) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]
+              , 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
     let allTags = join $ M.elems $ availableToolVersions dls tool
@@ -157,6 +165,11 @@ validate dls = do
   isBase (Base _) = True
   isBase _        = False
 
+data TarballFilter = TarballFilter
+  { tfTool    :: Maybe Tool
+  , tfVersion :: Regex
+  }
+
 validateTarballs :: ( Monad m
                     , MonadLogger m
                     , MonadThrow m
@@ -164,23 +177,20 @@ validateTarballs :: ( Monad m
                     , MonadUnliftIO m
                     , MonadMask m
                     )
-                 => GHCupDownloads
+                 => TarballFilter
+                 -> GHCupDownloads
                  -> m ExitCode
-validateTarballs dls = do
+validateTarballs (TarballFilter tool versionRegex) dls = do
   ref <- liftIO $ newIORef 0
 
   flip runReaderT ref $ do
-     -- download/verify all binary tarballs
+     -- download/verify all tarballs
-    let
+    let dlis = nubOrd $ dls ^.. each
-      dlbis = nub $ join $ (M.elems dls) <&> \versions ->
+          %& indices (maybe (const True) (==) tool) %> each
-        join $ (M.elems versions) <&> \vi ->
+          %& indices (matchTest versionRegex . T.unpack . prettyVer)
-          join $ (M.elems $ _viArch vi) <&> \pspecs ->
+          % (viSourceDL % _Just `summing` viArch % each % each % each)
-            join $ (M.elems pspecs) <&> \pverspecs -> (M.elems pverspecs)
+    when (null dlis) $ $(logError) [i|no tarballs selected by filter|] *> addError
-    forM_ dlbis $ downloadAll
+    forM_ dlis $ downloadAll
-
-    let dlsrc = nub $ join $ (M.elems dls) <&> \versions ->
-          join $ (M.elems versions) <&> maybe [] (: []) . _viSourceDL
-    forM_ dlsrc $ downloadAll
 
     -- exit
     e <- liftIO $ readIORef ref
@@ -191,13 +201,13 @@ validateTarballs dls = do
         pure ExitSuccess
 
  where
+  runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
+                                     , colorOutter  = B.hPut stderr
+                                     , rawOutter    = (\_ -> pure ())
+                                     }
   downloadAll dli = do
     dirs <- liftIO getDirs
     let settings = AppState (Settings True False Never Curl False GHCupURL) dirs defaultKeyBindings
-    let runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
-                                           , colorOutter  = B.hPut stderr
-                                           , rawOutter    = (\_ -> pure ())
-                                           }
 
     r <-
       runLogger

app/ghcup/BrickMain.hs

@@ -16,6 +16,7 @@ import           GHCup.Types
 import           GHCup.Utils
 import           GHCup.Utils.File
 import           GHCup.Utils.Logger
+import           GHCup.Utils.Prelude     hiding ((!?))
 
 import           Brick
 import           Brick.Widgets.Border
@@ -44,8 +45,10 @@ import           Data.Vector                    ( Vector
 import           Data.Versions           hiding ( str )
 import           Haskus.Utils.Variant.Excepts
 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
@@ -118,8 +121,8 @@ showKey (Vty.KDown) = "↓"
 showKey key = tail (show key)
 
 
-ui :: BrickState -> Widget String
+ui :: AttrMap -> BrickState -> Widget String
-ui BrickState { appSettings = as@(BrickSettings {}), ..}
+ui dimAttrs BrickState { appSettings = as@(BrickSettings {}), ..}
   = ( padBottom Max
     $ ( withBorderStyle unicode
       $ borderWithLabel (str "GHCup")
@@ -150,9 +153,12 @@ ui BrickState { appSettings = as@(BrickSettings {}), ..}
         ver = case lCross of
           Nothing -> T.unpack . prettyVer $ lVer
           Just c  -> T.unpack (c <> "-" <> prettyVer lVer)
-        dim = if lNoBindist
+        dim
-          then updateAttrMap (const dimAttributes) . withAttr "no-bindist"
+          | lNoBindist && (not lInstalled)
-          else id
+            && (not b) -- TODO: overloading dim and active ignores active
+                       --       so we hack around it here
+          = updateAttrMap (const dimAttrs) . withAttr "no-bindist"
+          | otherwise  = id
         hooray
           | elem Latest lTag && not lInstalled =
               withAttr "hooray"
@@ -239,39 +245,49 @@ minHSize :: Int -> Widget n -> Widget n
 minHSize s' = hLimit s' . vLimit 1 . (<+> fill ' ')
 
 
-app :: App BrickState e String
+app :: AttrMap -> AttrMap -> App BrickState e String
-app = App { appDraw         = \st -> [ui st]
+app attrs dimAttrs =
-          , appHandleEvent  = eventHandler
+  App { appDraw         = \st -> [ui dimAttrs st]
-          , appStartEvent   = return
+  , appHandleEvent  = eventHandler
-          , appAttrMap      = const defaultAttributes
+  , appStartEvent   = return
-          , appChooseCursor = neverShowCursor
+  , appAttrMap      = const attrs
-          }
+  , appChooseCursor = neverShowCursor
+  }
 
-defaultAttributes :: AttrMap
+defaultAttributes :: Bool -> AttrMap
-defaultAttributes = attrMap
+defaultAttributes no_color = attrMap
   Vty.defAttr
-  [ ("active"       , Vty.defAttr `Vty.withBackColor` Vty.blue)
+  [ ("active"       , Vty.defAttr `withBackColor` Vty.blue)
-  , ("not-installed", Vty.defAttr `Vty.withForeColor` Vty.red)
+  , ("not-installed", Vty.defAttr `withForeColor` Vty.red)
-  , ("set"          , Vty.defAttr `Vty.withForeColor` Vty.green)
+  , ("set"          , Vty.defAttr `withForeColor` Vty.green)
-  , ("installed"    , Vty.defAttr `Vty.withForeColor` Vty.green)
+  , ("installed"    , Vty.defAttr `withForeColor` Vty.green)
-  , ("recommended"  , Vty.defAttr `Vty.withForeColor` Vty.green)
+  , ("recommended"  , Vty.defAttr `withForeColor` Vty.green)
-  , ("hls-powered"  , Vty.defAttr `Vty.withForeColor` Vty.green)
+  , ("hls-powered"  , Vty.defAttr `withForeColor` Vty.green)
-  , ("latest"       , Vty.defAttr `Vty.withForeColor` Vty.yellow)
+  , ("latest"       , Vty.defAttr `withForeColor` Vty.yellow)
-  , ("prerelease"   , Vty.defAttr `Vty.withForeColor` Vty.red)
+  , ("prerelease"   , Vty.defAttr `withForeColor` Vty.red)
-  , ("compiled"     , Vty.defAttr `Vty.withForeColor` Vty.blue)
+  , ("compiled"     , Vty.defAttr `withForeColor` Vty.blue)
-  , ("stray"        , Vty.defAttr `Vty.withForeColor` Vty.blue)
+  , ("stray"        , Vty.defAttr `withForeColor` Vty.blue)
-  , ("help"         , Vty.defAttr `Vty.withStyle` Vty.italic)
+  , ("help"         , Vty.defAttr `withStyle`     Vty.italic)
-  , ("hooray"       , Vty.defAttr `Vty.withForeColor` Vty.brightWhite)
+  , ("hooray"       , Vty.defAttr `withForeColor` Vty.brightWhite)
   ]
+  where
+    withForeColor | no_color  = const
+                  | otherwise = Vty.withForeColor
 
+    withBackColor | no_color  = \attr _ -> attr `Vty.withStyle` Vty.reverseVideo
+                  | otherwise = Vty.withBackColor
 
-dimAttributes :: AttrMap
+    withStyle                 = Vty.withStyle
-dimAttributes = attrMap
+
+dimAttributes :: Bool -> AttrMap
+dimAttributes no_color = attrMap
   (Vty.defAttr `Vty.withStyle` Vty.dim)
-  [ ("active"    , Vty.defAttr `Vty.withBackColor` Vty.blue)
+  [ ("active"    , Vty.defAttr `withBackColor` Vty.blue) -- has no effect ??
   , ("no-bindist", Vty.defAttr `Vty.withStyle` Vty.dim)
   ]
-
+  where
+    withBackColor | no_color  = \attr _ -> attr `Vty.withStyle` Vty.reverseVideo
+                  | otherwise = Vty.withBackColor
 
 eventHandler :: BrickState -> BrickEvent n e -> EventM n (Next BrickState)
 eventHandler st@(BrickState {..}) ev = do
@@ -403,24 +419,35 @@ install' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
               , DownloadFailed
               , NoUpdate
               , TarDirDoesNotExist
+              , VerNotFound
               ]
 
   (run $ do
       case lTool of
-        GHC   -> liftE $ installGHCBin dls lVer pfreq
+        GHC   -> do
-        Cabal -> liftE $ installCabalBin dls lVer pfreq
+          vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer GHC dls
-        GHCup -> liftE $ upgradeGHCup dls Nothing False pfreq $> ()
+            ?? VerNotFound lVer GHC
-        HLS   -> liftE $ installHLSBin dls lVer pfreq $> ()
+          liftE $ installGHCBin dls lVer pfreq $> vi
+        Cabal -> do
+          vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer Cabal dls
+            ?? VerNotFound lVer Cabal
+          liftE $ installCabalBin dls lVer pfreq $> vi
+        GHCup -> do
+          let vi = fromJust $ snd <$> getLatest dls GHCup
+          liftE $ upgradeGHCup dls Nothing False pfreq $> vi
+        HLS   -> do
+          vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer HLS dls
+            ?? VerNotFound lVer HLS
+          liftE $ installHLSBin dls lVer pfreq $> vi
     )
     >>= \case
-          VRight _                          -> pure $ Right ()
+          VRight vi                         -> do
+            forM_ (_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|]
 
 
@@ -444,27 +471,33 @@ 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
 
-  let run = runLogger . flip runReaderT settings . runE @'[NotInstalled]
+  let run = runLogger . flip runReaderT settings . runE @'[NotInstalled, VerNotFound]
 
   (run $ do
+      vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer lTool dls
+        ?? VerNotFound lVer lTool
       case lTool of
-        GHC   -> liftE $ rmGHCVer (GHCTargetVersion lCross lVer) $> ()
+        GHC   -> liftE $ rmGHCVer (GHCTargetVersion lCross lVer) $> Just vi
-        Cabal -> liftE $ rmCabalVer lVer $> ()
+        Cabal -> liftE $ rmCabalVer lVer $> Just vi
-        HLS   -> liftE $ rmHLSVer lVer $> ()
+        HLS   -> liftE $ rmHLSVer lVer $> Just vi
-        GHCup -> pure ()
+        GHCup -> pure Nothing
     )
     >>= \case
+          VRight (Just vi) -> do
+            forM_ (_viPostRemove vi) $ \msg ->
+              runLogger $ $(logInfo) msg
+            pure $ Right ()
           VRight _ -> pure $ Right ()
-          VLeft  e -> pure $ Left [i|#{e}|]
+          VLeft  e -> pure $ Left (prettyShow e)
 
 
 changelog' :: BrickState -> (Int, ListResult) -> IO (Either String ())
@@ -479,7 +512,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
@@ -520,11 +553,13 @@ brickMain s l av pfreq' = do
   writeIORef logger'   l
   let runLogger = myLoggerT l
 
+  no_color <- isJust <$> lookupEnv "NO_COLOR"
+
   eAppData <- getAppData (Just av) pfreq'
   case eAppData of
     Right ad ->
       defaultMain
-          app
+          (app (defaultAttributes no_color) (dimAttributes no_color))
           (BrickState ad
                     defaultAppSettings
                     (constructList ad defaultAppSettings Nothing)
@@ -557,7 +592,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

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
@@ -59,15 +60,18 @@ import           Options.Applicative     hiding ( style )
 import           Options.Applicative.Help.Pretty ( text )
 import           Prelude                 hiding ( appendFile )
 import           Safe
-import           System.Console.Pretty
+import           System.Console.Pretty   hiding ( color )
+import qualified System.Console.Pretty         as Pretty
 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
@@ -110,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
@@ -129,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
@@ -190,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?
@@ -361,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)
                  )
@@ -411,7 +426,7 @@ installParser =
           "ghc"
           (   InstallGHC
           <$> (info
-                (installOpts <**> helper)
+                (installOpts (Just GHC) <**> helper)
                 (  progDesc "Install GHC"
                 <> footerDoc (Just $ text installGHCFooter)
                 )
@@ -421,7 +436,7 @@ installParser =
            "cabal"
            (   InstallCabal
            <$> (info
-                 (installOpts <**> helper)
+                 (installOpts (Just Cabal) <**> helper)
                  (  progDesc "Install Cabal"
                  <> footerDoc (Just $ text installCabalFooter)
                  )
@@ -431,7 +446,7 @@ installParser =
            "hls"
            (   InstallHLS
            <$> (info
-                 (installOpts <**> helper)
+                 (installOpts (Just HLS) <**> helper)
                  (  progDesc "Install haskell-languge-server"
                  <> footerDoc (Just $ text installHLSFooter)
                  )
@@ -439,7 +454,7 @@ installParser =
            )
       )
     )
-    <|> (Right <$> installOpts)
+    <|> (Right <$> installOpts Nothing)
  where
   installHLSFooter :: String
   installHLSFooter = [s|Discussion:
@@ -470,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 :: Maybe Tool -> Parser InstallOptions
-installOpts =
+installOpts tool =
   (\p (u, v) b -> InstallOptions v p u b)
     <$> (optional
           (option
@@ -493,9 +508,9 @@ installOpts =
                     )
                   )
                 )
-            <*> (Just <$> toolVersionArgument)
+            <*> (Just <$> toolVersionArgument Nothing tool)
             )
-        <|> ((,) <$> pure Nothing <*> optional toolVersionArgument)
+        <|> (pure (Nothing, Nothing))
         )
     <*> flag
           False
@@ -512,7 +527,7 @@ setParser =
           "ghc"
           (   SetGHC
           <$> (info
-                (setOpts <**> helper)
+                (setOpts (Just GHC) <**> helper)
                 (  progDesc "Set GHC version"
                 <> footerDoc (Just $ text setGHCFooter)
                 )
@@ -522,7 +537,7 @@ setParser =
            "cabal"
            (   SetCabal
            <$> (info
-                 (setOpts <**> helper)
+                 (setOpts (Just Cabal) <**> helper)
                  (  progDesc "Set Cabal version"
                  <> footerDoc (Just $ text setCabalFooter)
                  )
@@ -532,7 +547,7 @@ setParser =
            "hls"
            (   SetHLS
            <$> (info
-                 (setOpts <**> helper)
+                 (setOpts (Just HLS) <**> helper)
                  (  progDesc "Set haskell-language-server version"
                  <> footerDoc (Just $ text setHLSFooter)
                  )
@@ -540,7 +555,7 @@ setParser =
            )
       )
     )
-    <|> (Right <$> setOpts)
+    <|> (Right <$> setOpts Nothing)
  where
   setGHCFooter :: String
   setGHCFooter = [s|Discussion:
@@ -557,8 +572,10 @@ setParser =
     Sets the the current haskell-language-server version.|]
 
 
-setOpts :: Parser SetOptions
+setOpts :: Maybe Tool -> Parser SetOptions
-setOpts = SetOptions <$> optional toolVersionArgument
+setOpts tool = SetOptions <$>
+    (fromMaybe SetRecommended <$>
+      optional (setVersionArgument (Just ListInstalled) tool))
 
 listOpts :: Parser ListOptions
 listOpts =
@@ -590,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 :: Maybe Tool -> Parser RmOptions
-rmOpts = RmOptions <$> versionArgument
+rmOpts tool = RmOptions <$> versionArgument (Just ListInstalled) tool
 
 
 changelogP :: Parser ChangeLogOptions
@@ -634,7 +651,7 @@ changelogP =
             )
           )
         )
-    <*> optional toolVersionArgument
+    <*> optional (toolVersionArgument Nothing Nothing)
 
 compileP :: Parser CompileCommand
 compileP = subparser
@@ -763,13 +780,85 @@ toolVersionParser = verP' <|> toolP
           )
 
 -- | same as toolVersionParser, except as an argument.
-toolVersionArgument :: Parser ToolVersion
+toolVersionArgument :: Maybe ListCriteria -> Maybe Tool -> Parser ToolVersion
-toolVersionArgument =
+toolVersionArgument criteria tool =
-  argument (eitherReader toolVersionEither) (metavar "VERSION|TAG")
+  argument (eitherReader toolVersionEither)
+    (metavar "VERSION|TAG"
+    <> completer (tagCompleter (fromMaybe GHC tool) [])
+    <> foldMap (completer . versionCompleter criteria) tool)
 
 
-versionArgument :: Parser GHCTargetVersion
+setVersionArgument :: Maybe ListCriteria -> Maybe Tool -> Parser SetToolVersion
-versionArgument = argument (eitherReader tVersionEither) (metavar "VERSION")
+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
@@ -777,10 +866,10 @@ versionParser = option
   (short 'v' <> long "version" <> metavar "VERSION" <> help "The target version"
   )
 
-versionParser' :: Parser Version
+versionParser' :: Maybe ListCriteria -> Maybe Tool -> Parser Version
-versionParser' = argument
+versionParser' criteria tool = argument
-  (eitherReader (bimap show id . version . T.pack))
+  (eitherReader (first show . version . T.pack))
-  (metavar "VERSION")
+  (metavar "VERSION"  <> foldMap (completer . versionCompleter criteria) tool)
 
 
 tagEither :: String -> Either String Tag
@@ -790,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
@@ -1039,9 +1128,12 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                       , NotInstalled
                       , BuildFailed
                       , TagNotFound
+                      , VerNotFound
                       , DigestError
                       , DownloadFailed
                       , TarDirDoesNotExist
+                      , NextVerNotFound
+                      , NoToolVersionSet
                       ]
 
           let runInstTool = runInstTool' appstate
@@ -1054,6 +1146,9 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                   @'[ FileDoesNotExistError
                     , NotInstalled
                     , TagNotFound
+                    , VerNotFound
+                    , NextVerNotFound
+                    , NoToolVersionSet
                     ]
 
           let
@@ -1063,6 +1158,9 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                 . runE
                   @'[ NotInstalled
                     , TagNotFound
+                    , VerNotFound
+                    , NextVerNotFound
+                    , NoToolVersionSet
                     ]
 
           let
@@ -1072,12 +1170,15 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                 . runE
                   @'[ NotInstalled
                     , TagNotFound
+                    , VerNotFound
+                    , NextVerNotFound
+                    , NoToolVersionSet
                     ]
 
           let runListGHC = runLogger . flip runReaderT appstate
 
           let runRm =
-                runLogger . flip runReaderT appstate . runE @'[NotInstalled]
+                runLogger . flip runReaderT appstate . runE @'[NotInstalled, VerNotFound]
 
           let runDebugInfo =
                 runLogger
@@ -1101,6 +1202,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                       , UnknownArchive
                       , TarDirDoesNotExist
                       , NotInstalled
+                      , VerNotFound
 #if !defined(TAR)
                       , ArchiveResult
 #endif
@@ -1130,7 +1232,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)
 
 
@@ -1145,7 +1247,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
@@ -1161,42 +1263,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_ (_viPostInstall vi) $ \msg ->
+                              runLogger $ $(logInfo) msg
                             pure ExitSuccess
                           VLeft (V (AlreadyInstalled _ v)) -> do
                             runLogger $ $(logWarn)
-                              [i|GHC ver #{prettyVer v} already installed, you may want to run 'ghcup rm ghc #{prettyVer v}' first|]
+                              [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}|])
+                              Never -> runLogger ($(logError) $ T.pack $ prettyShow err)
-                              _ -> runLogger ($(logError) [i|Build failed with #{e}
+                              _ -> 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
 
@@ -1204,73 +1303,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_ (_viPostInstall vi) $ \msg ->
+                            runLogger $ $(logInfo) msg
                           pure ExitSuccess
                         VLeft (V (AlreadyInstalled _ v)) -> do
                           runLogger $ $(logWarn)
-                            [i|Cabal ver #{prettyVer v} already installed, you may want to run 'ghcup rm cabal #{prettyVer v}' first|]
+                            [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_ (_viPostInstall vi) $ \msg ->
+                            runLogger $ $(logInfo) msg
                           pure ExitSuccess
                         VLeft (V (AlreadyInstalled _ v)) -> do
                           runLogger $ $(logWarn)
-                            [i|HLS ver #{prettyVer v} already installed, you may want to run 'ghcup rm hls #{prettyVer v}' first|]
+                            [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
@@ -1280,59 +1373,90 @@ 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
+                    vi <- liftE @_ @'[VerNotFound] $ getVersionInfo (_tvVersion ghcVer) GHC dls
+                      ?? VerNotFound (_tvVersion ghcVer) GHC
+                    pure vi
                   )
                   >>= \case
-                        VRight _ -> pure ExitSuccess
+                        VRight vi -> do
+                          forM_ (_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
+                    vi <- liftE @_ @'[VerNotFound] $ getVersionInfo tv Cabal dls
+                      ?? VerNotFound tv Cabal
+                    pure vi
                   )
                   >>= \case
-                        VRight _ -> pure ExitSuccess
+                        VRight vi -> do
+                          forM_ (_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
+                    vi <- liftE @_ @'[VerNotFound] $ getVersionInfo tv HLS dls
+                      ?? VerNotFound tv HLS
+                    pure vi
                   )
                   >>= \case
-                        VRight _ -> pure ExitSuccess
+                        VRight vi -> do
+                          forM_ (_viPostRemove vi) $ \msg ->
+                            runLogger $ $(logInfo) msg
+                          pure ExitSuccess
                         VLeft  e -> do
-                          runLogger ($(logError) [i|#{e}|])
+                          runLogger $ $(logError) $ T.pack $ prettyShow e
                           pure $ ExitFailure 15
 
 
@@ -1379,11 +1503,18 @@ 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
+                vi <- liftE @_ @'[VerNotFound] $ getVersionInfo targetVer GHC dls
+                  ?? VerNotFound targetVer GHC
+                forM_ (_viPreCompile vi) $ \msg -> do
+                  lift $ $(logInfo) msg
+                  lift $ $(logInfo)
+                    ("...waiting for 5 seconds, you can still abort...")
+                  liftIO $ threadDelay 5000000 -- for compilation, give the user a sec to intervene
                 liftE $ compileGHC dls
                             (GHCTargetVersion crossTarget targetVer)
                             bootstrapGhc
@@ -1392,28 +1523,30 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                             patchDir
                             addConfArgs
                             pfreq
-                when setCompile $ void $ liftE
+                when setCompile $ void $ liftE $
-                  $ setGHC (GHCTargetVersion crossTarget targetVer) SetGHCOnly
+                  setGHC (GHCTargetVersion crossTarget targetVer) SetGHCOnly
+                pure vi
                 )
                 >>= \case
-                      VRight _ -> do
+                      VRight vi -> do
                         runLogger $ $(logInfo)
                           ("GHC successfully compiled and installed")
+                        forM_ (_viPostInstall vi) $ \msg ->
+                          runLogger $ $(logInfo) msg
                         pure ExitSuccess
                       VLeft (V (AlreadyInstalled _ v)) -> do
                         runLogger $ $(logWarn)
-                          [i|GHC ver #{prettyVer v} already installed, you may want to run 'ghcup rm ghc #{prettyVer v}' first|]
+                          [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}
+                          Never -> runLogger $ $(logError) $ T.pack $ prettyShow err
-Check the logs at #{logsDir}|])
+                          _ -> runLogger ($(logError) [i|#{prettyShow err}
-                          _ -> runLogger ($(logError) [i|Build failed with #{e}
 Check the logs at #{logsDir} and the build directory #{tmpdir} for more clues.
 Make sure to clean up #{tmpdir} afterwards.|])
                         pure $ ExitFailure 9
                       VLeft e -> do
-                        runLogger ($(logError) [i|#{e}|])
+                        runLogger $ $(logError) $ T.pack $ prettyShow e
                         pure $ ExitFailure 9
 
             Upgrade (uOpts) force -> do
@@ -1428,14 +1561,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 ->
@@ -1452,10 +1588,7 @@ Make sure to clean up #{tmpdir} afterwards.|])
                 >>= \case
                       VRight _ -> pure ExitSuccess
                       VLeft  e -> do
-                        runLogger
+                        runLogger $ $(logError) $ T.pack $ prettyShow e
-                          ($(logError)
-                            [i|Error getting tool requirements: #{e}|]
-                          )
                         pure $ ExitFailure 12
 
             ChangeLog (ChangeLogOptions {..}) -> do
@@ -1500,29 +1633,72 @@ Make sure to clean up #{tmpdir} afterwards.|])
             ef@(ExitFailure _) -> exitWith ef
   pure ()
 
-
+fromVersion :: (MonadFail m, MonadReader AppState m, MonadThrow m, MonadIO m, MonadCatch m)
-fromVersion :: Monad m
             => GHCupDownloads
             -> Maybe ToolVersion
             -> Tool
-            -> Excepts '[TagNotFound] m GHCTargetVersion
+            -> Excepts '[TagNotFound, VerNotFound, NextVerNotFound, NoToolVersionSet] m (GHCTargetVersion, VersionInfo)
-fromVersion av Nothing tool =
+fromVersion av tv tool = fromVersion' av (toSetToolVer tv) tool
-  mkTVer <$> getRecommended av tool ?? TagNotFound Recommended tool
+
-fromVersion av (Just (ToolVersion v)) _ = do
+fromVersion' :: (MonadFail m, MonadReader AppState m, MonadThrow m, MonadIO m, MonadCatch m)
+             => GHCupDownloads
+             -> SetToolVersion
+             -> Tool
+             -> Excepts '[TagNotFound, VerNotFound, NextVerNotFound, NoToolVersionSet] m (GHCTargetVersion, VersionInfo)
+fromVersion' av SetRecommended tool =
+  (\(x, y) -> (mkTVer x, y)) <$> getRecommended av tool
+    ?? TagNotFound Recommended tool
+fromVersion' av (SetToolVersion v) tool = do
+  vi <- getVersionInfo (_tvVersion v) tool av ?? VerNotFound (_tvVersion v) tool
   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'
+        Just (v', vi') -> pure (GHCTargetVersion (_tvTarget v) v', vi')
-        Nothing -> pure v
+        Nothing -> pure (v, vi)
-    Right _ -> pure v
+    Right _ -> pure (v, vi)
-fromVersion av (Just (ToolTag Latest)) tool =
+fromVersion' av  (SetToolTag Latest) tool =
-  mkTVer <$> getLatest av tool ?? TagNotFound Latest tool
+  (\(x, y) -> (mkTVer x, y)) <$> getLatest av tool ?? TagNotFound Latest tool
-fromVersion av (Just (ToolTag Recommended)) tool =
+fromVersion' av (SetToolTag Recommended) tool =
-  mkTVer <$> getRecommended av tool ?? TagNotFound Recommended tool
+  (\(x, y) -> (mkTVer x, y)) <$> getRecommended av tool ?? TagNotFound Recommended tool
-fromVersion av (Just (ToolTag (Base pvp''))) GHC =
+fromVersion' av (SetToolTag (Base pvp'')) GHC =
-  mkTVer <$> getLatestBaseVersion av pvp'' ?? TagNotFound (Base pvp'') GHC
+  (\(x, y) -> (mkTVer x, y)) <$> getLatestBaseVersion av pvp'' ?? TagNotFound (Base pvp'') GHC
-fromVersion _ (Just (ToolTag t')) tool =
+fromVersion' av SetNext tool = do
+  next <- case tool of
+    GHC -> do
+      set <- fmap _tvVersion $ ghcSet Nothing !? NoToolVersionSet tool
+      ghcs <- rights <$> lift getInstalledGHCs
+      (headMay
+        . tail
+        . dropWhile (\GHCTargetVersion {..} -> _tvVersion /= set)
+        . cycle
+        . sortBy (\x y -> compare (_tvVersion x) (_tvVersion y))
+        . filter (\GHCTargetVersion {..} -> _tvTarget == Nothing)
+        $ ghcs) ?? NoToolVersionSet tool
+    Cabal -> do
+      set <- cabalSet !? NoToolVersionSet tool
+      cabals <- rights <$> lift getInstalledCabals
+      (fmap (GHCTargetVersion Nothing)
+        . headMay
+        . tail
+        . dropWhile (/= set)
+        . cycle
+        . sort
+        $ cabals) ?? NoToolVersionSet tool
+    HLS -> do
+      set <- hlsSet !? NoToolVersionSet tool
+      hlses <- rights <$> lift getInstalledHLSs
+      (fmap (GHCTargetVersion Nothing)
+        . headMay
+        . tail
+        . dropWhile (/= set)
+        . cycle
+        . sort
+        $ hlses) ?? NoToolVersionSet tool
+    GHCup -> fail "GHCup cannot be set"
+  vi <- getVersionInfo (_tvVersion next) tool av ?? VerNotFound (_tvVersion next) tool
+  pure (next, vi)
+fromVersion' _ (SetToolTag t') tool =
   throwE $ TagNotFound t' tool
 
 
@@ -1531,6 +1707,20 @@ printListResult raw lr = do
   -- https://gitlab.haskell.org/ghc/ghc/issues/8118
   setLocaleEncoding utf8
 
+  no_color <- isJust <$> lookupEnv "NO_COLOR"
+
+  let
+    color | raw || no_color = flip const
+          | otherwise       = Pretty.color
+
+  let
+    printTag Recommended        = color Green "recommended"
+    printTag Latest             = color Yellow "latest"
+    printTag Prerelease         = color Red "prerelease"
+    printTag (Base       pvp'') = "base-" ++ T.unpack (prettyPVP pvp'')
+    printTag (UnknownTag t    ) = t
+    printTag Old                = ""
+
   let
     rows =
       (\x -> if raw
@@ -1552,13 +1742,13 @@ printListResult raw lr = do
                      , intercalate "," $ (filter (/= "") . fmap printTag $ sort lTag)
                      , intercalate ","
                      $  (if hlsPowered
-                          then [color' Green "hls-powered"]
+                          then [color Green "hls-powered"]
                           else mempty
                         )
-                     ++ (if fromSrc then [color' Blue "compiled"] else mempty)
+                     ++ (if fromSrc then [color Blue "compiled"] else mempty)
-                     ++ (if lStray then [color' Yellow "stray"] else mempty)
+                     ++ (if lStray then [color Yellow "stray"] else mempty)
                      ++ (if lNoBindist
-                          then [color' Red "no-bindist"]
+                          then [color Red "no-bindist"]
                           else mempty
                         )
                      ]
@@ -1571,16 +1761,6 @@ printListResult raw lr = do
 
   forM_ padded $ \row -> putStrLn $ intercalate " " row
  where
-  printTag Recommended        = color' Green "recommended"
-  printTag Latest             = color' Yellow "latest"
-  printTag Prerelease         = color' Red "prerelease"
-  printTag (Base       pvp'') = "base-" ++ T.unpack (prettyPVP pvp'')
-  printTag (UnknownTag t    ) = t
-  printTag Old                = ""
-
-  color' = case raw of
-    True  -> flip const
-    False -> color
 
   padTo str' x =
     let lstr = strWidth str'
@@ -1683,27 +1863,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)
@@ -1722,7 +1902,7 @@ GHCup base dir: #{toFilePath diBaseDir}
 GHCup bin dir: #{toFilePath diBinDir}
 GHCup GHC directory: #{toFilePath diGHCDir}
 GHCup cache directory: #{toFilePath diCacheDir}
-Architecture: #{prettyArch diArch}
+Architecture: #{prettyShow diArch}
-Platform: #{prettyPlatform diPlatform}
+Platform: #{prettyShow diPlatform}
 Version: #{describe_result}|]
 

bootstrap-haskell

@@ -1,5 +1,16 @@
 #!/bin/sh
 
+# Main settings:
+#   * BOOTSTRAP_HASKELL_NONINTERACTIVE - any nonzero value for noninteractive installation
+#   * BOOTSTRAP_HASKELL_NO_UPGRADE - any nonzero value to not trigger the upgrade
+#   * GHCUP_USE_XDG_DIRS - any nonzero value to respect The XDG Base Directory Specification
+#   * BOOTSTRAP_HASKELL_VERBOSE - any nonzero value for more verbose installation
+#   * BOOTSTRAP_HASKELL_GHC_VERSION
+#   * BOOTSTRAP_HASKELL_CABAL_VERSION
+
+# License: LGPL-3.0
+
+
 # safety subshell to avoid executing anything in case this script is not downloaded properly
 (
 
@@ -8,7 +19,7 @@
 export GHCUP_USE_XDG_DIRS
 
 if [ -n "${GHCUP_USE_XDG_DIRS}" ] ; then
-	GHCUP_DIR=${XDG_DATA_HOME:=$HOME/.local}/ghcup
+	GHCUP_DIR=${XDG_DATA_HOME:=$HOME/.local/share}/ghcup
 	GHCUP_BIN=${XDG_BIN_HOME:=$HOME/.local/bin}
 else
 	GHCUP_DIR=${GHCUP_INSTALL_BASE_PREFIX}/.ghcup
@@ -23,8 +34,7 @@ die() {
     exit 2
 }
 
-edo()
+edo() {
-{
     "$@" || die "\"$*\" failed!"
 }
 
@@ -59,7 +69,7 @@ _done() {
 download_ghcup() {
 	_plat="$(uname -s)"
 	_arch=$(uname -m)
-	_ghver="0.1.11"
+	_ghver="0.1.13"
 	_base_url="https://downloads.haskell.org/~ghcup"
 
     case "${_plat}" in
@@ -79,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
@@ -114,6 +130,7 @@ download_ghcup() {
 
     edo chmod +x "${GHCUP_BIN}"/ghcup
 
+  edo mkdir -p "${GHCUP_DIR}"
 	cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
 		export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
 		EOF

cabal.ghc8103.project

@@ -0,0 +1,38 @@
+with-compiler: ghc-8.10.3
+
+packages: ./ghcup.cabal
+
+optional-packages: ./3rdparty/*/*.cabal
+
+source-repository-package
+    type: git
+    location: https://github.com/haskus/packages.git
+    tag: 80a1c5fc07f7226c424250ec17f674cd4d618f42
+    subdir: haskus-utils-types
+
+source-repository-package
+    type: git
+    location: https://github.com/hasufell/hpath.git
+    tag: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
+    subdir: hpath-io
+
+source-repository-package
+    type: git
+    location: https://github.com/hasufell/hpath.git
+    tag: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
+    subdir: hpath-directory
+
+optimization: 2
+
+package streamly
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+package ghcup
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+constraints: http-io-streams -brotli
+
+package libarchive
+  flags: -system-libarchive
+
+allow-newer: base, ghc-prim, template-haskell

cabal.ghc8103.project.freeze

@@ -0,0 +1,261 @@
+active-repositories: hackage.haskell.org:merge
+constraints: any.Cabal ==3.2.1.0,
+             any.HUnit ==1.6.2.0,
+             any.IfElse ==0.85,
+             any.QuickCheck ==2.14.2,
+             QuickCheck -old-random +templatehaskell,
+             any.StateVar ==1.2.1,
+             any.abstract-deque ==0.3,
+             abstract-deque -usecas,
+             any.aeson ==1.5.5.1,
+             aeson -bytestring-builder -cffi -developer -fast,
+             any.aeson-pretty ==0.8.8,
+             aeson-pretty -lib-only,
+             any.alex ==3.2.6,
+             alex +small_base,
+             any.ansi-terminal ==0.11,
+             ansi-terminal -example,
+             any.ansi-wl-pprint ==0.6.9,
+             ansi-wl-pprint -example,
+             any.array ==0.5.4.0,
+             any.ascii-string ==1.0.1.4,
+             any.assoc ==1.0.2,
+             any.async ==2.2.2,
+             async -bench,
+             any.atomic-primops ==0.8.4,
+             atomic-primops -debug,
+             any.attoparsec ==0.13.2.4,
+             attoparsec -developer,
+             any.auto-update ==0.1.6,
+             any.base ==4.14.1.0,
+             any.base-compat ==0.11.2,
+             any.base-compat-batteries ==0.11.2,
+             any.base-orphans ==0.8.4,
+             any.base16-bytestring ==1.0.1.0,
+             any.base64-bytestring ==1.2.0.1,
+             any.bifunctors ==5.5.10,
+             bifunctors +semigroups +tagged,
+             any.binary ==0.8.8.0,
+             any.blaze-builder ==0.4.2.1,
+             any.bytestring ==0.10.12.0,
+             any.bz2 ==1.0.1.0,
+             bz2 -cross +with-bzlib,
+             any.c2hs ==0.28.7,
+             c2hs +base3 -regression,
+             any.call-stack ==0.3.0,
+             any.case-insensitive ==1.2.1.0,
+             any.casing ==0.1.4.1,
+             any.cereal ==0.5.8.1,
+             cereal -bytestring-builder,
+             any.chs-cabal ==0.1.1.0,
+             any.chs-deps ==0.1.0.0,
+             chs-deps -cross,
+             any.clock ==0.8.2,
+             clock -llvm,
+             any.cmdargs ==0.10.20,
+             cmdargs +quotation -testprog,
+             any.colour ==2.3.5,
+             any.comonad ==5.0.8,
+             comonad +containers +distributive +indexed-traversable,
+             any.composition-prelude ==3.0.0.2,
+             composition-prelude -development,
+             any.concurrent-output ==1.10.12,
+             any.conduit ==1.3.4,
+             any.conduit-extra ==1.3.5,
+             any.containers ==0.6.2.1,
+             any.contravariant ==1.5.3,
+             contravariant +semigroups +statevar +tagged,
+             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.deepseq ==1.4.4.0,
+             any.deferred-folds ==0.9.15,
+             any.directory ==1.3.6.0,
+             any.distributive ==0.6.2.1,
+             distributive +semigroups +tagged,
+             any.dlist ==1.0,
+             dlist -werror,
+             any.easy-file ==0.2.2,
+             any.errors ==2.3.0,
+             any.exceptions ==0.10.4,
+             any.fast-logger ==3.0.2,
+             any.filepath ==1.4.2.1,
+             any.focus ==1.0.2,
+             any.foldl ==1.4.10,
+             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.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.haskell-src-exts ==1.23.1,
+             any.haskell-src-meta ==0.8.5,
+             any.haskus-utils-data ==1.3,
+             any.haskus-utils-types ==1.5,
+             any.haskus-utils-variant ==3.0,
+             any.heaps ==0.3.6.1,
+             any.hpath ==0.11.0,
+             any.hpath-directory ==0.14.1,
+             any.hpath-filepath ==0.10.4,
+             any.hpath-io ==0.14.1,
+             any.hpath-posix ==0.13.2,
+             any.hsc2hs ==0.68.7,
+             hsc2hs -in-ghc-tree,
+             any.hspec ==2.7.8,
+             any.hspec-core ==2.7.8,
+             any.hspec-discover ==2.7.8,
+             any.hspec-expectations ==0.8.2,
+             any.hspec-golden-aeson ==0.7.0.0,
+             any.indexed-profunctors ==0.1,
+             any.indexed-traversable ==0.1.1,
+             any.integer-gmp ==1.0.3.0,
+             any.integer-logarithms ==1.0.3.1,
+             integer-logarithms -check-bounds +integer-gmp,
+             any.language-c ==0.8.3,
+             language-c -allwarnings +iecfpextension +separatesyb +usebytestrings,
+             any.libarchive ==3.0.2.1,
+             libarchive -cross -low-memory -system-libarchive,
+             any.libyaml ==0.1.2,
+             libyaml -no-unicode -system-libyaml,
+             any.lifted-base ==0.2.3.12,
+             any.list-t ==1.0.4,
+             any.lockfree-queue ==0.2.3.1,
+             lzma -static,
+             any.math-functions ==0.3.4.1,
+             math-functions +system-erf +system-expm1,
+             any.megaparsec ==9.0.1,
+             megaparsec -dev,
+             any.microlens ==0.4.11.2,
+             any.microlens-mtl ==0.2.0.1,
+             any.microlens-th ==0.4.3.9,
+             any.mmorph ==1.1.4,
+             any.monad-control ==1.0.2.3,
+             any.monad-logger ==0.3.36,
+             monad-logger +template_haskell,
+             any.monad-loops ==0.4.3,
+             monad-loops +base4,
+             any.mono-traversable ==1.0.15.1,
+             any.mtl ==2.2.2,
+             any.mwc-random ==0.15.0.1,
+             any.network ==3.1.2.1,
+             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-vl ==0.2.1,
+             any.optparse-applicative ==0.16.1.0,
+             optparse-applicative +process,
+             any.os-release ==1.0.1,
+             os-release -devel,
+             any.parallel ==3.2.2.0,
+             any.parsec ==3.1.14.0,
+             any.parser-combinators ==1.2.1,
+             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-unlifted ==0.1.3.0,
+             any.process ==1.6.9.0,
+             any.profunctors ==5.6.1,
+             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,
+             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,
+             any.rts ==1.0,
+             any.safe ==0.3.19,
+             any.safe-exceptions ==0.1.7.1,
+             any.scientific ==0.3.6.2,
+             scientific -bytestring-builder -integer-simple,
+             any.semigroupoids ==5.3.5,
+             semigroupoids +comonad +containers +contravariant +distributive +tagged +unordered-containers,
+             any.setenv ==0.1.1.3,
+             any.sop-core ==0.5.0.1,
+             any.split ==0.2.3.4,
+             any.splitmix ==0.1.0.3,
+             splitmix -optimised-mixer,
+             any.stm ==2.5.0.0,
+             any.stm-chans ==3.0.0.4,
+             any.streaming-commons ==0.2.2.1,
+             streaming-commons -use-bytestring-builder,
+             any.streamly ==0.7.2,
+             streamly -debug -dev -examples -examples-sdl -fusion-plugin -has-llvm -inspection -no-fusion -streamk,
+             any.streamly-bytestring ==0.1.2,
+             any.streamly-posix ==0.1.0.1,
+             any.strict ==0.4.0.1,
+             strict +assoc,
+             any.strict-base ==0.4.0.0,
+             any.string-interpolate ==0.3.0.2,
+             string-interpolate -bytestring-builder -extended-benchmarks -text-builder,
+             any.syb ==0.7.2.1,
+             any.tagged ==0.8.6.1,
+             tagged +deepseq +transformers,
+             any.tasty ==1.3.1,
+             tasty +clock,
+             any.tasty-hunit ==0.10.0.3,
+             any.tasty-quickcheck ==0.10.1.2,
+             any.template-haskell ==2.16.0.0,
+             any.terminal-size ==0.3.2.1,
+             any.terminfo ==0.4.1.4,
+             any.text ==1.2.4.1,
+             any.text-conversions ==0.3.1,
+             any.text-short ==0.1.3,
+             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-lift ==0.8.2,
+             any.th-lift-instances ==0.1.18,
+             any.th-orphans ==0.13.11,
+             any.th-reify-many ==0.1.9,
+             any.these ==1.1.1.1,
+             these +assoc,
+             any.time ==1.9.3,
+             any.time-compat ==1.9.5,
+             time-compat -old-locale,
+             any.transformers ==0.5.6.2,
+             any.transformers-base ==0.4.5.2,
+             transformers-base +orphaninstances,
+             any.transformers-compat ==0.6.6,
+             transformers-compat -five +five-three -four +generic-deriving +mtl -three -two,
+             any.typed-process ==0.2.6.0,
+             any.unbounded-delays ==0.1.1.1,
+             any.unix ==2.7.2.2,
+             any.unix-bytestring ==0.3.7.3,
+             any.unix-compat ==0.5.3,
+             unix-compat -old-time,
+             any.unix-time ==0.4.7,
+             any.unliftio-core ==0.2.0.1,
+             any.unordered-containers ==0.2.13.0,
+             unordered-containers -debug,
+             any.uri-bytestring ==0.3.3.0,
+             uri-bytestring -lib-werror,
+             any.utf8-string ==1.0.2,
+             any.uuid-types ==1.0.3,
+             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.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

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

ghcup-0.0.2.yaml

@@ -1117,7 +1117,6 @@ ghcupDownloads:
             unknown_versioning: *ghc-8101-32-deb9
     8.10.2:
       viTags:
-      - Latest
       - base-4.14.1.0
       viChangeLog: https://downloads.haskell.org/~ghc/8.10.2/docs/html/users_guide/8.10.2-notes.html
       viSourceDL:
@@ -1193,6 +1192,79 @@ ghcupDownloads:
               dlUri: https://files.hasufell.de/ghc/ghc-8.10.2-i386-alpine-linux.tar.xz
               dlSubdir: ghc-8.10.2
               dlHash: 9ee1cf1e85e9536088b3c9e80e975074e525ea378cd4eb156071bbc4b7b38327
+    8.10.3:
+      viTags:
+      - Latest
+      - base-4.14.1.0
+      viChangeLog: https://downloads.haskell.org/~ghc/8.10.3/docs/html/users_guide/8.10.3-notes.html
+      viSourceDL:
+        dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-src.tar.xz
+        dlSubdir: ghc-8.10.3
+        dlHash: 9c573a4621a78723950617c223559bdc325ea6a3409264aedf68f05510b0880b
+      viArch:
+        A_64:
+          Linux_Debian:
+            '9': &ghc-8103-64-deb9
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-deb9-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: 95e4aadea30701fe5ab84d15f757926d843ded7115e11c4cd827809ca830718d
+            '10': &ghc-8103-64-deb10
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-deb10-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: c8f3d9f0e61a89eaba1d3ad8fb2eced1af0e81576811261b887993bee12538ac
+            unknown_versioning: *ghc-8103-64-deb9
+          Linux_Ubuntu:
+            unknown_versioning: &ghc-8103-64-fedora
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-fedora27-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: f8739b12008712d6b6a9ffc6c39f9d05af77ef3bcb932c9aff20fa0893c8c159
+            '16.04': *ghc-8103-64-deb9
+            '18.04': *ghc-8103-64-deb9
+          Linux_Mint:
+            unknown_versioning: *ghc-8103-64-deb10
+          Linux_Fedora:
+            '27': *ghc-8103-64-fedora
+            unknown_versioning: *ghc-8103-64-fedora
+          Linux_CentOS:
+            '7': &ghc-8103-64-centos
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-centos7-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: f562ca61979ff1d21e34e69e59028cb742a8eff8d84e46bbd3a750f2ac7d8ed1
+            unknown_versioning: *ghc-8103-64-centos
+          Linux_RedHat:
+            unknown_versioning: *ghc-8103-64-centos
+          Linux_Alpine:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-alpine3.10-linux-integer-simple.tar.xz
+              dlSubdir: ghc-8.10.3-x86_64-unknown-linux
+              dlHash: 8506c478ebbfb5441c3c36c07c36fc8532cacb2b3e13c6733bd44cb17b3ce96c
+          Linux_AmazonLinux:
+            unknown_versioning: *ghc-8103-64-centos
+          Linux_UnknownLinux:
+            unknown_versioning: *ghc-8103-64-fedora
+          Darwin:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-apple-darwin.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: 2635f35d76e44e69afdfd37cae89d211975cc20f71f784363b72003e59f22015
+          FreeBSD:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-portbld-freebsd.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: 749007e995104db05cf6e3ad5bc36238cab8afac8055145661e5730e8f8af040
+        A_32:
+          Linux_Debian:
+            '9': &ghc-8103-32-deb9
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-i386-deb9-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: f0addd2a16b705f58ff9e8702c3ddf3e2d6bd0d3555707b5b5095e51bafee7b1
+            unknown_versioning: *ghc-8103-32-deb9
+          Linux_Ubuntu:
+            unknown_versioning: *ghc-8103-32-deb9
+          Linux_Mint:
+            unknown_versioning: *ghc-8103-32-deb9
+          Linux_UnknownLinux:
+            unknown_versioning: *ghc-8103-32-deb9
   Cabal:
     2.4.1.0:
       viTags: []

ghcup-0.0.3.yaml

@@ -95,7 +95,6 @@ ghcupDownloads:
     7.10.3:
       viTags:
       - base-4.8.2.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/7.10.3/docs/html/users_guide/release-7-10-1.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/7.10.3/ghc-7.10.3-src.tar.xz
@@ -158,7 +157,6 @@ ghcupDownloads:
     8.0.2:
       viTags:
       - base-4.9.1.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.0.2/docs/html/users_guide/8.0.1-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.0.2/ghc-8.0.2-src.tar.xz
@@ -216,7 +214,6 @@ ghcupDownloads:
     8.2.2:
       viTags:
       - base-4.10.1.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.2.2/docs/html/users_guide/8.2.2-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.2.2/ghc-8.2.2-src.tar.xz
@@ -283,7 +280,6 @@ ghcupDownloads:
     8.4.1:
       viTags:
       - base-4.11.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.4.1/docs/html/users_guide/8.4.1-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.4.1/ghc-8.4.1-src.tar.xz
@@ -332,7 +328,6 @@ ghcupDownloads:
     8.4.2:
       viTags:
       - base-4.11.1.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.4.2/docs/html/users_guide/8.4.2-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.4.2/ghc-8.4.2-src.tar.xz
@@ -387,7 +382,6 @@ ghcupDownloads:
     8.4.3:
       viTags:
       - base-4.11.1.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.4.3/docs/html/users_guide/8.4.3-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.4.3/ghc-8.4.3-src.tar.xz
@@ -510,7 +504,6 @@ ghcupDownloads:
     8.6.1:
       viTags:
       - base-4.12.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.6.1/docs/html/users_guide/8.6.1-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.6.1/ghc-8.6.1-src.tar.xz
@@ -565,7 +558,6 @@ ghcupDownloads:
     8.6.2:
       viTags:
       - base-4.12.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.6.2/docs/html/users_guide/8.6.2-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.6.2/ghc-8.6.2-src.tar.xz
@@ -611,7 +603,6 @@ ghcupDownloads:
     8.6.3:
       viTags:
       - base-4.12.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.6.3/docs/html/users_guide/8.6.3-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.6.3/ghc-8.6.3-src.tar.xz
@@ -675,7 +666,6 @@ ghcupDownloads:
     8.6.4:
       viTags:
       - base-4.12.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.6.4/docs/html/users_guide/8.6.4-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.6.4/ghc-8.6.4-src.tar.xz
@@ -798,7 +788,6 @@ ghcupDownloads:
     8.8.1:
       viTags:
       - base-4.13.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.8.1/docs/html/users_guide/8.8.1-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.8.1/ghc-8.8.1-src.tar.xz
@@ -857,7 +846,6 @@ ghcupDownloads:
     8.8.2:
       viTags:
       - base-4.13.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.8.2/docs/html/users_guide/8.8.2-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.8.2/ghc-8.8.2-src.tar.xz
@@ -916,7 +904,6 @@ ghcupDownloads:
     8.8.3:
       viTags:
       - base-4.13.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.8.3/docs/html/users_guide/8.8.3-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.8.3/ghc-8.8.3-src.tar.xz
@@ -1054,7 +1041,6 @@ ghcupDownloads:
     8.10.1:
       viTags:
       - base-4.14.0.0
-      - old
       viChangeLog: https://downloads.haskell.org/~ghc/8.10.1/docs/html/users_guide/8.10.1-notes.html
       viSourceDL:
         dlUri: https://downloads.haskell.org/~ghc/8.10.1/ghc-8.10.1-src.tar.xz
@@ -1131,7 +1117,6 @@ ghcupDownloads:
             unknown_versioning: *ghc-8101-32-deb9
     8.10.2:
       viTags:
-      - Latest
       - base-4.14.1.0
       viChangeLog: https://downloads.haskell.org/~ghc/8.10.2/docs/html/users_guide/8.10.2-notes.html
       viSourceDL:
@@ -1207,82 +1192,149 @@ ghcupDownloads:
               dlUri: https://files.hasufell.de/ghc/ghc-8.10.2-i386-alpine-linux.tar.xz
               dlSubdir: ghc-8.10.2
               dlHash: 9ee1cf1e85e9536088b3c9e80e975074e525ea378cd4eb156071bbc4b7b38327
-    9.0.0.20200925:
+    8.10.3:
+      viTags:
+      - Latest
+      - base-4.14.1.0
+      viChangeLog: https://downloads.haskell.org/~ghc/8.10.3/docs/html/users_guide/8.10.3-notes.html
+      viSourceDL:
+        dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-src.tar.xz
+        dlSubdir: ghc-8.10.3
+        dlHash: 9c573a4621a78723950617c223559bdc325ea6a3409264aedf68f05510b0880b
+      viArch:
+        A_64:
+          Linux_Debian:
+            '9': &ghc-8103-64-deb9
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-deb9-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: 95e4aadea30701fe5ab84d15f757926d843ded7115e11c4cd827809ca830718d
+            '10': &ghc-8103-64-deb10
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-deb10-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: c8f3d9f0e61a89eaba1d3ad8fb2eced1af0e81576811261b887993bee12538ac
+            unknown_versioning: *ghc-8103-64-deb9
+          Linux_Ubuntu:
+            unknown_versioning: &ghc-8103-64-fedora
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-fedora27-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: f8739b12008712d6b6a9ffc6c39f9d05af77ef3bcb932c9aff20fa0893c8c159
+            '16.04': *ghc-8103-64-deb9
+            '18.04': *ghc-8103-64-deb9
+          Linux_Mint:
+            unknown_versioning: *ghc-8103-64-deb10
+          Linux_Fedora:
+            '27': *ghc-8103-64-fedora
+            unknown_versioning: *ghc-8103-64-fedora
+          Linux_CentOS:
+            '7': &ghc-8103-64-centos
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-centos7-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: f562ca61979ff1d21e34e69e59028cb742a8eff8d84e46bbd3a750f2ac7d8ed1
+            unknown_versioning: *ghc-8103-64-centos
+          Linux_RedHat:
+            unknown_versioning: *ghc-8103-64-centos
+          Linux_Alpine:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-alpine3.10-linux-integer-simple.tar.xz
+              dlSubdir: ghc-8.10.3-x86_64-unknown-linux
+              dlHash: 8506c478ebbfb5441c3c36c07c36fc8532cacb2b3e13c6733bd44cb17b3ce96c
+          Linux_AmazonLinux:
+            unknown_versioning: *ghc-8103-64-centos
+          Linux_UnknownLinux:
+            unknown_versioning: *ghc-8103-64-fedora
+          Darwin:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-apple-darwin.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: 2635f35d76e44e69afdfd37cae89d211975cc20f71f784363b72003e59f22015
+          FreeBSD:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-x86_64-portbld-freebsd.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: 749007e995104db05cf6e3ad5bc36238cab8afac8055145661e5730e8f8af040
+        A_32:
+          Linux_Debian:
+            '9': &ghc-8103-32-deb9
+              dlUri: https://downloads.haskell.org/~ghc/8.10.3/ghc-8.10.3-i386-deb9-linux.tar.xz
+              dlSubdir: ghc-8.10.3
+              dlHash: f0addd2a16b705f58ff9e8702c3ddf3e2d6bd0d3555707b5b5095e51bafee7b1
+            unknown_versioning: *ghc-8103-32-deb9
+          Linux_Ubuntu:
+            unknown_versioning: *ghc-8103-32-deb9
+          Linux_Mint:
+            unknown_versioning: *ghc-8103-32-deb9
+          Linux_UnknownLinux:
+            unknown_versioning: *ghc-8103-32-deb9
+    9.0.0.20201227:
       viTags:
       - Prerelease
       - base-4.15.0.0
       viSourceDL:
-        dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-src.tar.xz
+        dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-src.tar.xz
-        dlSubdir: ghc-9.0.0.20200925
+        dlSubdir: ghc-9.0.0.20201227
-        dlHash: 142189a3a741af1deb40020c031f05aebfc2b6fd077ffd0c230cf405587cdbb0
+        dlHash: de49a6d4c67bb8ef676c7e76ca48b3f174bb774a197794cf1518a7f7dd11e2cd
       viArch:
         A_64:
           Linux_Debian:
-            '9': &ghc-901a1-64-deb9
+            '9': &ghc-901r1-64-deb9
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-deb9-linux.tar.xz
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-x86_64-deb9-linux.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
+              dlSubdir: ghc-9.0.0.20201227
-              dlHash: d44ab6f933292066d3f4bafc7e1a4209f8044069f9360bd60a97d2de05a73db2
+              dlHash: 53f1d9b1cd7cbac4f4e683b5bcf2d08dd45852bd55218c7c5e965b5a78704f15
-            '10': &ghc-901a1-64-deb10
+            '10': &ghc-901r1-64-deb10
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-deb10-linux-dwarf.tar.xz
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-x86_64-deb10-linux-dwarf.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
+              dlSubdir: ghc-9.0.0.20201227
-              dlHash: 958f98a97d244899d986168c89e4babe2b85ceaa4b0cf1c4631ea1dfa82ad75e
+              dlHash: 646f3b91a4ea58be46545b493e08197a4345a71f74ec018be2b8fde496ffe1e4
-            unknown_versioning: *ghc-901a1-64-deb9
+            unknown_versioning: *ghc-901r1-64-deb9
           Linux_Ubuntu:
-            unknown_versioning: &ghc-901a1-64-fedora
+            unknown_versioning: &ghc-901r1-64-fedora
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-fedora27-linux.tar.xz
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-x86_64-fedora27-linux.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
+              dlSubdir: ghc-9.0.0.20201227
-              dlHash: 2711afabbaab7abd1b8fdf846802ce6ca8e531641d64bbf75780d4de64180dca
+              dlHash: a6483262e5c999701b948107f5b9e77d705333f4b61b37b1c27b4abd28dd186c
-            '16.04': *ghc-901a1-64-deb9
+            '16.04': *ghc-901r1-64-deb9
-            '18.04': *ghc-901a1-64-deb9
+            '18.04': *ghc-901r1-64-deb9
           Linux_Mint:
-            unknown_versioning: *ghc-901a1-64-deb10
+            unknown_versioning: *ghc-901r1-64-deb10
           Linux_Fedora:
-            '27': *ghc-901a1-64-fedora
+            '27': *ghc-901r1-64-fedora
-            unknown_versioning: *ghc-901a1-64-fedora
+            unknown_versioning: *ghc-901r1-64-fedora
           Linux_CentOS:
-            '7': &ghc-901a1-64-centos
+            '7': &ghc-901r1-64-centos
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-centos7-linux.tar.xz
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-x86_64-centos7-linux.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
+              dlSubdir: ghc-9.0.0.20201227
-              dlHash: 5f6cd94e0d3917fa5c87031706e665f5d9b997f5c991c9c4c4e2900c39dc98ac
+              dlHash: 563370553544c825b0f43427065af789c56ee7ec9cccd497b9dc28c13fc537c5
-            unknown_versioning: *ghc-901a1-64-centos
+            unknown_versioning: *ghc-901r1-64-centos
           Linux_RedHat:
-            unknown_versioning: *ghc-901a1-64-centos
+            unknown_versioning: *ghc-901r1-64-centos
           Linux_Alpine:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-alpine3.10-linux-integer-simple.tar.xz
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-x86_64-alpine3.10-linux-integer-simple.tar.xz
-              dlSubdir: ghc-9.0.0.20200925-x86_64-unknown-linux
+              dlSubdir: ghc-9.0.0.20201227-x86_64-unknown-linux
-              dlHash: 05c0176e39cc89a95047060a589df0686ea1eb99b3de7f2cfadbe5e68bf93f68
+              dlHash: 21d1ffce74032a8f2e808c9160624a41d9d7a129e4e376845d7dd422b290fba2
           Linux_AmazonLinux:
-            unknown_versioning: *ghc-901a1-64-centos
+            unknown_versioning: *ghc-901r1-64-centos
           Linux_UnknownLinux:
-            unknown_versioning: *ghc-901a1-64-fedora
+            unknown_versioning: *ghc-901r1-64-fedora
           Darwin:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-apple-darwin.tar.xz
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-x86_64-apple-darwin.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
+              dlSubdir: ghc-9.0.0.20201227
-              dlHash: fb85a78f2bdad53c591261e21c80f3f50fa2b68bbb22632d9be6960af7b27813
+              dlHash: e6e5bf34c002d52d7108b9d4c8621ae3d21059509f8868bb81b0ba4fda6320da
-          FreeBSD:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-unknown-freebsd.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
-              dlHash: 1e094cbbf9636b1f231bc99e44197fe7a05f570cf46f079bba1a0ca796c3c30c
         A_32:
           Linux_Debian:
-            '9': &ghc-901a1-32-deb9
+            '9': &ghc-901r1-32-deb9
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-i386-deb9-linux.tar.xz
+              dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-i386-deb9-linux.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
+              dlSubdir: ghc-9.0.0.20201227
-              dlHash: a533641720c33f953ca5d100bc7da219d4cf52eae081c94c97b9ac4cbd9c1d06
+              dlHash: 1e3348e2288c60b763dc4e74e4a69b17ae261edb383a7a5220a879c35d530cda
-            unknown_versioning: *ghc-901a1-32-deb9
+            unknown_versioning: *ghc-901r1-32-deb9
           Linux_Ubuntu:
-            unknown_versioning: *ghc-901a1-32-deb9
+            unknown_versioning: *ghc-901r1-32-deb9
           Linux_Mint:
-            unknown_versioning: *ghc-901a1-32-deb9
+            unknown_versioning: *ghc-901r1-32-deb9
           Linux_UnknownLinux:
-            unknown_versioning: *ghc-901a1-32-deb9
+            unknown_versioning: *ghc-901r1-32-deb9
   Cabal:
     2.4.1.0:
-      viTags:
+      viTags: []
-        - old
       viChangeLog: https://downloads.haskell.org/~cabal/cabal-install-2.4.1.0/changelog
       viArch:
         A_64:
@@ -1313,8 +1365,7 @@ ghcupDownloads:
               dlSubdir:
               dlHash: b2da736cc27609442b10f77fc1a687aba603a7a33045b722dbf1a0066fade198
     3.0.0.0:
-      viTags:
+      viTags: []
-        - old
       viChangeLog: https://downloads.haskell.org/~cabal/cabal-install-3.0.0.0/changelog
       viArch:
         A_64:
@@ -1400,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.11:
+    0.1.12:
       viTags:
       - Recommended
       - Latest
@@ -1410,40 +1461,40 @@ 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
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-linux-ghcup-0.1.12
-              dlHash: 99d97c9a1dce76892001e5cffd50cc23bf804f2282998c546d1b965aa2179699
+              dlHash: 83088569ddf2d35df494f440dedd9c8eb2a53276d665f7de731f6554986c2ddb
           Darwin:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-apple-darwin-ghcup-0.1.11
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-apple-darwin-ghcup-0.1.12
-              dlHash: 4b91dcd9bfdc40534156b8fadea3f317b3c44af1255169895f4911a221f819c6
+              dlHash: 1336efb0851e1ed267838f97f6c36cbceb5363ad0ae359f04f1bc43d0c5f2cef
           FreeBSD:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-portbld-freebsd-ghcup-0.1.11
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/x86_64-portbld-freebsd-ghcup-0.1.12
-              dlHash: 6f04ce98d3f3eb9299ce74f8264aa956f0dc38a64a3bd12ee048b7f146e9e1b4
+              dlHash: a72123e972a53d667574c7d276a81842701a07fce2b434e4d856e561c34772fe
           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
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.12/i386-linux-ghcup-0.1.12
-              dlHash: ec339e4c2b8b4d502f66a03c0d3f112cb68cd922dd3c4a6f66323628cf6a76c2
+              dlHash: 4bc79a272dfcd16143f08d9f8e33f2fef66dc53f3a0659bdab56ac3cbecf9e84
           Linux_Alpine:
             unknown_versioning: *ghcup-32
   HLS:
-    0.6.0:
+    0.8.0:
       viTags:
         - Recommended
         - Latest
-      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#060
+      viChangeLog: https://github.com/haskell/haskell-language-server/blob/master/ChangeLog.md#080
       viArch:
         A_64:
           Linux_UnknownLinux:
             unknown_versioning: &hls-64
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.6.0/haskell-language-server-Linux-0.6.0.tar.gz
+              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.8.0/haskell-language-server-Linux-0.8.0.tar.gz
-              dlHash: 5a3ed953f3cc4dac2c5712b0c1a4fc6848a91a301c2f692081fdb37985c23f61
+              dlHash: ba1306ab1af7a5fa1174b19bc3aa8904f5b238d9d6eac04d07fd692db9af4534
           Darwin:
             unknown_versioning:
-              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.6.0/haskell-language-server-macOS-0.6.0.tar.gz
+              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.8.0/haskell-language-server-macOS-0.8.0.tar.gz
-              dlHash: e5288935f5d8a38b56cfff1d0862d38b2749619b69b23923a814dc136ab7d307
+              dlHash: 1c1668bb455a5164df62774e6fb8f8f91a831ce527d9e5f89f453fb28ef54622
           Linux_Alpine:
             unknown_versioning: *hls-64

ghcup.cabal

@@ -1,6 +1,6 @@
 cabal-version:      3.0
 name:               ghcup
-version:            0.1.12
+version:            0.1.13
 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,7 +437,9 @@ executable ghcup-gen
     , mtl
     , optics
     , optparse-applicative
+    , pretty
     , pretty-terminal
+    , regex-posix
     , resourcet
     , safe-exceptions
     , string-interpolate

lib/GHCup.hs

@@ -333,7 +333,7 @@ installCabalBindist dlinfo ver (PlatformRequest {..}) = do
       (path </> cabalFile)
       (destPath)
       Overwrite
-    lift $ chmod_777 destPath
+    lift $ chmod_755 destPath
 
 
 -- | Installs cabal into @~\/.ghcup\/bin/cabal-\<ver\>@ and
@@ -449,7 +449,7 @@ installHLSBindist dlinfo ver (PlatformRequest {..}) = do
         (path </> f)
         (inst </> toF)
         Overwrite
-      lift $ chmod_777 (inst </> toF)
+      lift $ chmod_755 (inst </> toF)
 
     -- install haskell-language-server-wrapper
     let wrapper = [rel|haskell-language-server-wrapper|]
@@ -458,7 +458,7 @@ installHLSBindist dlinfo ver (PlatformRequest {..}) = do
       (path </> wrapper)
       (inst </> toF)
       Overwrite
-    lift $ chmod_777 (inst </> toF)
+    lift $ chmod_755 (inst </> toF)
 
 
 -- | Installs hls binaries @haskell-language-server-\<ghcver\>@
@@ -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,18 +1308,30 @@ 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
   let fn = [rel|ghcup|]
   p <- liftE $ download dli tmp (Just fn)
-  let fullDest = fromMaybe (binDir </> fn) mtarget
+  let destDir = dirname destFile
-  liftIO $ hideError NoSuchThing $ deleteFile fullDest
+      destFile = fromMaybe (binDir </> fn) mtarget
+  lift $ $(logDebug) [i|mkdir -p #{toFilePath destDir}|]
+  liftIO $ createDirRecursive' destDir
+  lift $ $(logDebug) [i|rm -f #{toFilePath destFile}|]
+  liftIO $ hideError NoSuchThing $ deleteFile destFile
+  lift $ $(logDebug) [i|cp #{toFilePath p} #{toFilePath destFile}|]
   handleIO (throwE . CopyError . show) $ liftIO $ copyFile p
-                                                           fullDest
+                                                           destFile
                                                            Overwrite
-  lift $ chmod_777 fullDest
+  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
 
 

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)
+    where
-          => Excepts '[JSONError , FileDoesNotExistError] m GHCupInfo
-  getBase =
-    handleIO (\_ -> readFromCache)
-    $ catchE @_ @'[JSONError, FileDoesNotExistError]
-        (\(DownloadFailed _) -> readFromCache)
-    $ ((reThrowAll @_ @_ @'[JSONError, DownloadFailed] DownloadFailed $ smartDl ghcupURL)
-      >>= (liftE . lE' @_ @_ @'[JSONError] JSONDecodeError . bimap show id . Y.decodeEither' . L.toStrict))
 
   mergeGhcupInfo :: GHCupInfo -- ^ base to merge with
                  -> GHCupInfo -- ^ extension overwriting the base
@@ -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))
+            <$> liftIO (PF.getFileStatus (toFilePath json_file))
-        currentTime <- liftIO $ getPOSIXTime
+        currentTime <- liftIO getPOSIXTime
 
         -- access time won't work on most linuxes, but we can try regardless
         if (currentTime - accessTime) > 300

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,211 @@ 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 a version of a tool.
+data VerNotFound = VerNotFound Version Tool
+  deriving Show
+
+instance Pretty VerNotFound where
+  pPrint (VerNotFound ver' tool) =
+    text [i|Unable to find version "#{prettyShow ver'}" of tool "#{tool}"|]
+
+-- | Unable to find the next version of a tool (the one after the currently
+-- set one).
+data NextVerNotFound = NextVerNotFound Tool
+  deriving Show
+
+instance Pretty NextVerNotFound where
+  pPrint (NextVerNotFound tool) =
+    text [i|Unable to find next (the one after the currently set one) version of tool "#{tool}"|]
+
 -- | The tool (such as GHC) is already installed with that version.
 data AlreadyInstalled = AlreadyInstalled Tool Version
   deriving Show
 
+instance Pretty AlreadyInstalled where
+  pPrint (AlreadyInstalled tool ver') =
+    text [i|#{tool}-#{prettyShow ver'} is already installed|]
+
 -- | The tool is not installed. Some operations rely on a tool
 -- to be installed (such as setting the current GHC version).
-data NotInstalled = NotInstalled Tool 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 +261,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 +287,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

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
 
@@ -79,16 +85,20 @@ data Tool = GHC
           | Cabal
           | GHCup
           | HLS
-  deriving (Eq, GHC.Generic, Ord, Show)
+  deriving (Eq, GHC.Generic, Ord, Show, Enum, Bounded)
 
 
 -- | All necessary information of a tool version, including
 -- source download and per-architecture downloads.
 data VersionInfo = VersionInfo
-  { _viTags      :: [Tag]              -- ^ version specific tag
+  { _viTags        :: [Tag]              -- ^ version specific tag
-  , _viChangeLog :: Maybe URI
+  , _viChangeLog   :: Maybe URI
-  , _viSourceDL  :: Maybe DownloadInfo -- ^ source tarball
+  , _viSourceDL    :: Maybe DownloadInfo -- ^ source tarball
-  , _viArch      :: ArchitectureSpec   -- ^ descend for binary downloads per arch
+  , _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
+archToString :: Architecture -> String
-prettyArch A_64 = "x86_64"
+archToString A_64 = "x86_64"
-prettyArch A_32 = "i386"
+archToString A_32 = "i386"
-prettyArch A_PowerPC = "powerpc"
+archToString A_PowerPC = "powerpc"
-prettyArch A_PowerPC64 = "powerpc64"
+archToString A_PowerPC64 = "powerpc64"
-prettyArch A_Sparc = "sparc"
+archToString A_Sparc = "sparc"
-prettyArch A_Sparc64 = "sparc64"
+archToString A_Sparc64 = "sparc64"
-prettyArch A_ARM = "arm"
+archToString A_ARM = "arm"
-prettyArch A_ARM64 = "aarch64"
+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
+platformToString :: Platform -> String
-prettyPlatfrom (Linux distro) = "linux-" ++ prettyDistro distro
+platformToString (Linux distro) = "linux-" ++ distroToString distro
-prettyPlatfrom Darwin = "darwin"
+platformToString Darwin = "darwin"
-prettyPlatfrom FreeBSD = "freebsd"
+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
+distroToString :: LinuxDistro -> String
-prettyDistro Debian = "debian"
+distroToString Debian = "debian"
-prettyDistro Ubuntu = "ubuntu"
+distroToString Ubuntu = "ubuntu"
-prettyDistro Mint= "mint"
+distroToString Mint= "mint"
-prettyDistro Fedora = "fedora"
+distroToString Fedora = "fedora"
-prettyDistro CentOS = "centos"
+distroToString CentOS = "centos"
-prettyDistro RedHat = "redhat"
+distroToString RedHat = "redhat"
-prettyDistro Alpine = "alpine"
+distroToString Alpine = "alpine"
-prettyDistro AmazonLinux = "amazon"
+distroToString AmazonLinux = "amazon"
-prettyDistro Gentoo = "gentoo"
+distroToString Gentoo = "gentoo"
-prettyDistro Exherbo = "exherbo"
+distroToString Exherbo = "exherbo"
-prettyDistro UnknownLinux = "unknown"
+distroToString UnknownLinux = "unknown"
+
+instance Pretty LinuxDistro where
+  pPrint = text . distroToString
 
 
 -- | An encapsulation of a download. This can be used
@@ -172,7 +206,7 @@ data DownloadInfo = DownloadInfo
   , _dlSubdir :: Maybe TarDir
   , _dlHash   :: Text
   }
-  deriving (Eq, GHC.Generic, Show)
+  deriving (Eq, Ord, GHC.Generic, Show)
 
 
 
@@ -185,7 +219,11 @@ data DownloadInfo = DownloadInfo
 -- | How to descend into a tar archive.
 data TarDir = RealDir (Path Rel)
             | RegexDir String     -- ^ will be compiled to regex, the first match will "win"
-            deriving (Eq, GHC.Generic, Show)
+            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.
@@ -306,12 +344,15 @@ data PlatformResult = PlatformResult
   }
   deriving (Eq, Show)
 
-prettyPlatform :: PlatformResult -> String
+platResToString :: PlatformResult -> String
-prettyPlatform PlatformResult { _platform = plat, _distroVersion = Just v' }
+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
+pfReqToString :: PlatformRequest -> String
-prettyPfReq (PlatformRequest arch plat ver) =
+pfReqToString (PlatformRequest arch plat ver) =
-  prettyArch arch ++ "-" ++ prettyPlatfrom plat ++ pver
+  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
+instance Pretty GHCTargetVersion where
-prettyTVer (GHCTargetVersion (Just t) v') = t <> "-" <> prettyVer v'
+  pPrint = text . T.unpack . tVerToText
-prettyTVer (GHCTargetVersion Nothing  v') = prettyVer v'
 
 
 -- | 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

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'))
+    . fmap (lastMay . filter (\(v, _) -> matchMajor v major' minor'))
-    . preview (ix GHC % to Map.keys)
+    . preview (ix GHC % to Map.toDescList)
     $ dls
 
 
@@ -596,17 +596,17 @@ getTagged tag =
   % _head
   )
 
-getLatest :: GHCupDownloads -> Tool -> Maybe Version
+getLatest :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
-getLatest av tool = headOf (ix tool % getTagged Latest % to fst) $ av
+getLatest av tool = headOf (ix tool % getTagged Latest) $ av
 
-getRecommended :: GHCupDownloads -> Tool -> Maybe Version
+getRecommended :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
-getRecommended av tool = headOf (ix tool % getTagged Recommended % to fst) $ av
+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

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)
 
 

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)
@@ -440,13 +476,16 @@ isBrokenSymlink p =
         pure False
 
 
-chmod_777 :: (MonadLogger m, MonadIO m) => Path a -> m ()
+chmod_755 :: (MonadLogger m, MonadIO m) => Path a -> m ()
-chmod_777 (toFilePath -> fp) = do
+chmod_755 (toFilePath -> fp) = do
   let exe_mode =
-          newFilePerms
+          nullFileMode
             `unionFileModes` ownerExecuteMode
+            `unionFileModes` ownerReadMode
+            `unionFileModes` ownerWriteMode
             `unionFileModes` groupExecuteMode
+            `unionFileModes` groupReadMode
             `unionFileModes` otherExecuteMode
-  $(logDebug) [i|chmod 777 #{fp}|]
+            `unionFileModes` otherReadMode
+  $(logDebug) [i|chmod 755 #{fp}|]
   liftIO $ setFileMode fp exe_mode
-

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

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

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>