Fix handling of stray versions wrt #116

Add test case for issue #116
Update ghcup in old yamls
2021-03-07 12:02:13 +01:00 · 2021-03-07 11:59:45 +01:00 · 2021-03-06 16:02:09 +01:00 · 2021-03-02 19:37:09 +01:00 · 2021-03-02 19:22:14 +01:00 · 2021-03-02 12:39:24 +01:00
38 changed files with 22132 additions and 11142 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,3 +1,7 @@
+stages:
+  - test
+  - release
+
 variables:
  GIT_SSL_NO_VERIFY: "1"

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

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

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

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

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

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

+.test_ghcup_version:armv7:
+  extends:
+    - .test_ghcup_version
+    - .linux:armv7
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
+
+.test_ghcup_version:aarch64:
+  extends:
+    - .test_ghcup_version
+    - .linux:aarch64
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_manual.sh
+
 .test_ghcup_version:darwin:
  extends:
    - .test_ghcup_version
@@ -106,10 +140,13 @@ variables:
      - out
  only:
    - tags
+  variables:
+    JSON_VERSION: "0.0.4"

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

 test:linux:stack:
+  stage: test
  before_script:
    - ./.gitlab/before_script/linux/install_deps_minimal.sh
  script:
@@ -120,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"
-    CABAL_VERSION: "3.2.0.0"
+    GHC_VERSION: "8.10.4"
+    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"
-    CABAL_VERSION: "3.2.0.0"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"

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

 ######## 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"
-    CABAL_VERSION: "3.2.0.0"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"

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


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

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

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


 ######## 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"
-    CABAL_VERSION: "3.2.0.0"
+    GHC_VERSION: "8.10.4"
+    CABAL_VERSION: "3.4.0.0"


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

--- a/.gitlab/before_script/darwin/install_deps.sh
+++ b/.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 set ${GHC_VERSION}
-./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin upgrade -i -f
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}

 exit 0
--- a/.gitlab/before_script/freebsd/install_deps.sh
+++ b/.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 install-cabal ${CABAL_VERSION}
-./ghcup-bin set ${GHC_VERSION}
+./ghcup-bin upgrade -i -f
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}

 exit 0
--- a/.gitlab/before_script/linux/alpine/install_deps.sh
+++ b/.gitlab/before_script/linux/alpine/install_deps.sh
@@ -10,6 +10,9 @@ apk add --no-cache \
 	curl \
 	gcc \
 	g++ \
+	binutils \
+	binutils-gold \
+	bsd-compat-headers \
 	gmp-dev \
 	ncurses-dev \
 	libffi-dev \
@@ -18,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 install-cabal ${CABAL_VERSION}
+./ghcup-bin upgrade -i -f
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}

 # utils
 apk add --no-cache \
--- a/.gitlab/before_script/linux/install_deps.sh
+++ b/.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 set ${GHC_VERSION}
-./ghcup-bin install-cabal ${CABAL_VERSION}
+./ghcup-bin upgrade -i -f
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml set ${GHC_VERSION}
+./ghcup-bin -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml install-cabal ${CABAL_VERSION}

--- a/.gitlab/before_script/linux/install_deps_manual.sh
+++ b/.gitlab/before_script/linux/install_deps_manual.sh
@@ -0,0 +1,64 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}"
+
+ednf() {
+	case "${ARCH}" in
+		"ARM")
+			sudo dnf -y --forcearch armv7hl "$@"
+			;;
+		"ARM64")
+			sudo dnf -y --forcearch aarch64 "$@"
+			;;
+		*) exit 1 ;;
+	esac
+}
+
+ednf update
+ednf install gcc gcc-c++ gmp gmp-devel make ncurses ncurses-devel xz xz-devel perl zlib zlib-devel openssl-devel openssl-libs openssl libffi libffi-devel
+if [ "${ARCH}" = "ARM64" ] ; then
+	ednf install numactl numactl-libs numactl-devel
+fi
+ednf install bash wget curl git tar
+ednf install llvm9.0 llvm9.0-devel llvm9.0-libs llvm9.0-static
+
+case "${ARCH}" in
+	"ARM")
+		ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-armv7-deb10-linux.tar.xz
+		cabal_url=home.smart-cactus.org/~ben/cabal-install-${CABAL_VERSION}-armv7-linux-bootstrapped.tar.xz
+		;;
+	"ARM64")
+		ghc_url=https://downloads.haskell.org/~ghc/${GHC_VERSION}/ghc-${GHC_VERSION}-aarch64-deb10-linux.tar.xz
+		cabal_url=https://downloads.haskell.org/~cabal/cabal-install-${CABAL_VERSION}/cabal-install-${CABAL_VERSION}-aarch64-ubuntu-18.04.tar.xz
+		;;
+	*) exit 1 ;;
+esac
+
+mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin
+
+curl -O "${ghc_url}"
+tar -xf ghc-*.tar.*
+cd ghc-${GHC_VERSION}
+./configure --prefix="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}
+make install
+for i in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/ghc/${GHC_VERSION}/bin/*-${GHC_VERSION} ; do
+	ln -s "${i}" "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/${i##*/}
+done
+for x in "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/*-${GHC_VERSION} ; do
+	ln -s ${x##*/} ${x%-${GHC_VERSION}}
+done
+cd ..
+rm -rf ghc-${GHC_VERSION} ghc-*.tar.*
+unset x i
+
+mkdir cabal-install
+cd cabal-install
+curl -O "${cabal_url}"
+tar -xf cabal-install-*
+mv cabal "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/cabal
+cd ..
+rm -rf cabal-install
--- a/.gitlab/script/ghcup_release.sh
+++ b/.gitlab/script/ghcup_release.sh
@@ -16,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
--- a/.gitlab/script/ghcup_version.sh
+++ b/.gitlab/script/ghcup_version.sh
@@ -26,7 +26,7 @@ if [ "${OS}" = "DARWIN" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} -ftui
 	ecabal test -w ghc-${GHC_VERSION} -ftui ghcup-test
 elif [ "${OS}" = "LINUX" ] ; then
-	if [ "${BIT}" = "32" ] ; then
+	if [ "${ARCH}" = "32" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar
 		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar ghcup-test
 	else
@@ -80,17 +80,17 @@ ghci-$(ghc --numeric-version) --version
 # test installing new ghc doesn't mess with currently set GHC
 # https://gitlab.haskell.org/haskell/ghcup-hs/issues/7
 if [ "${OS}" = "LINUX" ] ; then
-	eghcup --downloader=wget install 8.4.4
+	eghcup --downloader=wget install 8.10.3
 else # test wget a bit
-	eghcup install 8.4.4
+	eghcup install 8.10.3
 fi
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-eghcup set 8.4.4
-eghcup set 8.4.4
-[ "$(ghc --numeric-version)" = "8.4.4" ]
+eghcup set 8.10.3
+eghcup set 8.10.3
+[ "$(ghc --numeric-version)" = "8.10.3" ]
 eghcup set ${GHC_VERSION}
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-eghcup rm 8.4.4
+eghcup rm 8.10.3
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]

 # install hls
@@ -98,7 +98,7 @@ if [ "${OS}" = "DARWIN" ] ; then
 	eghcup install hls
 	haskell-language-server-wrapper --version
 elif [ "${OS}" = "LINUX" ] ; then
-	if [ "${BIT}" = "64" ] ; then
+	if [ "${ARCH}" = "64" ] ; then
 		eghcup install hls
 		haskell-language-server-wrapper --version
 	fi
@@ -107,6 +107,10 @@ fi

 eghcup rm $(ghc --numeric-version)

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

--- a/.travis/build.sh
+++ b/.travis/build.sh
@@ -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-cabal 3.2.0.0
-ghcup set 8.8.3
+ghcup install 8.10.3
+ghcup install-cabal 3.4.0.0-rc4
+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}"
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,22 @@
 # Revision history for ghcup

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

 * Fix disappearing HLS symlinks wrt #91
 * improve TUI:
--- a/HACKING.md
+++ b/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
-`GHCup.Data.GHCupDownloads`.
+Download information on where to fetch bindists from is in the appropriate
+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

--- a/README.md
+++ b/README.md
@@ -18,6 +18,7 @@ Similar in scope to [rustup](https://github.com/rust-lang-nursery/rustup.rs), [p
     * [Shell-completion](#shell-completion)
     * [Cross support](#cross-support)
     * [XDG support](#xdg-support)
+     * [Env variables](#env-variables)
     * [Installing custom bindists](#installing-custom-bindists)
   * [Design goals](#design-goals)
   * [How](#how)
@@ -119,9 +120,21 @@ 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_CACHE_HOME`: logs and download files will be stored in `ghcup` 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 (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`)
+
+### Env variables
+
+This is the complete list of env variables that change GHCup behavior:
+
+* `GHCUP_USE_XDG_DIRS`: see [XDG support](#xdg-support) above
+* `TMPDIR`: where ghcup does the work (unpacking, building, ...)
+* `GHCUP_INSTALL_BASE_PREFIX`: the base of ghcup (default: `$HOME`)
+* `GHCUP_CURL_OPTS`: additional options that can be passed to curl
+* `GHCUP_WGET_OPTS`: additional options that can be passed to wget
+* `CC`/`LD` etc.: full environment is passed to the build system when compiling GHC via GHCup

 ### Installing custom bindists

--- a/app/ghcup-gen/Main.hs
+++ b/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
-             (validateYAMLOpts <**> helper)
-             (progDesc "Validate all tarballs (download and checksum)")
-           )
+       (info
+         ((ValidateTarballs <$> validateYAMLOpts <*> tarballFilterP) <**> helper)
+         (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
--- a/app/ghcup-gen/Validate.hs
+++ b/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
-        Cabal | v > [vver|2.4.1.0|] -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
-        _     -> lift $ $(logWarn) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]
+        GHCup | arch `elem` [A_64, A_32] -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
+        Cabal | v > [vver|2.4.1.0|]
+              , arch `elem` [A_64, A_32] -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]) >> addError
+        GHC | Latest `elem` tags || Recommended `elem` tags
+            , arch `elem` [A_64, A_32] -> lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]
+        _ -> lift $ $(logWarn) [i|Linux Alpine missing for #{t} #{v'} #{arch'}|]

  checkUniqueTags tool = do
    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
-    let
-      dlbis = nub $ join $ (M.elems dls) <&> \versions ->
-        join $ (M.elems versions) <&> \vi ->
-          join $ (M.elems $ _viArch vi) <&> \pspecs ->
-            join $ (M.elems pspecs) <&> \pverspecs -> (M.elems pverspecs)
-    forM_ dlbis $ downloadAll
-
-    let dlsrc = nub $ join $ (M.elems dls) <&> \versions ->
-          join $ (M.elems versions) <&> maybe [] (: []) . _viSourceDL
-    forM_ dlsrc $ downloadAll
+     -- download/verify all tarballs
+    let dlis = nubOrd $ dls ^.. each
+          %& indices (maybe (const True) (==) tool) %> each
+          %& indices (matchTest versionRegex . T.unpack . prettyVer)
+          % (viSourceDL % _Just `summing` viArch % each % each % each)
+    when (null dlis) $ $(logError) [i|no tarballs selected by filter|] *> addError
+    forM_ dlis $ 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
--- a/app/ghcup/BrickMain.hs
+++ b/app/ghcup/BrickMain.hs
@@ -44,8 +44,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 +120,8 @@ showKey (Vty.KDown) = "↓"
 showKey key = tail (show key)


-ui :: BrickState -> Widget String
-ui BrickState { appSettings = as@(BrickSettings {}), ..}
+ui :: AttrMap -> BrickState -> Widget String
+ui dimAttrs BrickState { appSettings = as@(BrickSettings {}), ..}
  = ( padBottom Max
    $ ( withBorderStyle unicode
      $ borderWithLabel (str "GHCup")
@@ -150,9 +152,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
-          then updateAttrMap (const dimAttributes) . withAttr "no-bindist"
-          else id
+        dim
+          | lNoBindist && (not lInstalled)
+            && (not b) -- TODO: overloading dim and active ignores active
+                       --       so we hack around it here
+          = updateAttrMap (const dimAttrs) . withAttr "no-bindist"
+          | otherwise  = id
        hooray
          | elem Latest lTag && not lInstalled =
              withAttr "hooray"
@@ -239,39 +244,49 @@ minHSize :: Int -> Widget n -> Widget n
 minHSize s' = hLimit s' . vLimit 1 . (<+> fill ' ')


-app :: App BrickState e String
-app = App { appDraw         = \st -> [ui st]
-          , appHandleEvent  = eventHandler
-          , appStartEvent   = return
-          , appAttrMap      = const defaultAttributes
-          , appChooseCursor = neverShowCursor
-          }
+app :: AttrMap -> AttrMap -> App BrickState e String
+app attrs dimAttrs =
+  App { appDraw         = \st -> [ui dimAttrs st]
+  , appHandleEvent  = eventHandler
+  , appStartEvent   = return
+  , appAttrMap      = const attrs
+  , appChooseCursor = neverShowCursor
+  }

-defaultAttributes :: AttrMap
-defaultAttributes = attrMap
+defaultAttributes :: Bool -> AttrMap
+defaultAttributes no_color = attrMap
  Vty.defAttr
-  [ ("active"       , Vty.defAttr `Vty.withBackColor` Vty.blue)
-  , ("not-installed", Vty.defAttr `Vty.withForeColor` Vty.red)
-  , ("set"          , Vty.defAttr `Vty.withForeColor` Vty.green)
-  , ("installed"    , Vty.defAttr `Vty.withForeColor` Vty.green)
-  , ("recommended"  , Vty.defAttr `Vty.withForeColor` Vty.green)
-  , ("hls-powered"  , Vty.defAttr `Vty.withForeColor` Vty.green)
-  , ("latest"       , Vty.defAttr `Vty.withForeColor` Vty.yellow)
-  , ("prerelease"   , Vty.defAttr `Vty.withForeColor` Vty.red)
-  , ("compiled"     , Vty.defAttr `Vty.withForeColor` Vty.blue)
-  , ("stray"        , Vty.defAttr `Vty.withForeColor` Vty.blue)
-  , ("help"         , Vty.defAttr `Vty.withStyle` Vty.italic)
-  , ("hooray"       , Vty.defAttr `Vty.withForeColor` Vty.brightWhite)
+  [ ("active"       , Vty.defAttr `withBackColor` Vty.blue)
+  , ("not-installed", Vty.defAttr `withForeColor` Vty.red)
+  , ("set"          , Vty.defAttr `withForeColor` Vty.green)
+  , ("installed"    , Vty.defAttr `withForeColor` Vty.green)
+  , ("recommended"  , Vty.defAttr `withForeColor` Vty.green)
+  , ("hls-powered"  , Vty.defAttr `withForeColor` Vty.green)
+  , ("latest"       , Vty.defAttr `withForeColor` Vty.yellow)
+  , ("prerelease"   , Vty.defAttr `withForeColor` Vty.red)
+  , ("compiled"     , Vty.defAttr `withForeColor` Vty.blue)
+  , ("stray"        , Vty.defAttr `withForeColor` Vty.blue)
+  , ("help"         , Vty.defAttr `withStyle`     Vty.italic)
+  , ("hooray"       , Vty.defAttr `withForeColor` Vty.brightWhite)
  ]
+  where
+    withForeColor | no_color  = const
+                  | otherwise = Vty.withForeColor

+    withBackColor | no_color  = \attr _ -> attr `Vty.withStyle` Vty.reverseVideo
+                  | otherwise = Vty.withBackColor

-dimAttributes :: AttrMap
-dimAttributes = attrMap
+    withStyle                 = Vty.withStyle
+
+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
@@ -407,20 +422,27 @@ install' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do

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


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


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

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


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


 settings' :: IORef AppState
@@ -520,11 +546,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 +585,7 @@ getDownloads' = do

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


 getAppData :: Maybe GHCupDownloads
--- a/app/ghcup/Main.hs
+++ b/app/ghcup/Main.hs
@@ -32,6 +32,7 @@ import           GHCup.Version
 #if !defined(TAR)
 import           Codec.Archive
 #endif
+import           Control.Concurrent
 import           Control.Exception.Safe
 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
@@ -43,7 +44,7 @@ import           Data.Bifunctor
 import           Data.Char
 import           Data.Either
 import           Data.Functor
-import           Data.List                      ( intercalate, sort )
+import           Data.List                      ( intercalate, nub, sort, sortBy )
 import           Data.List.NonEmpty             (NonEmpty ((:|)))
 import           Data.Maybe
 import           Data.String.Interpolate
@@ -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 =
+installOpts :: Maybe Tool -> Parser InstallOptions
+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 = SetOptions <$> optional toolVersionArgument
+setOpts :: Maybe Tool -> Parser SetOptions
+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 = RmOptions <$> versionArgument
+rmOpts :: Maybe Tool -> Parser RmOptions
+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 =
-  argument (eitherReader toolVersionEither) (metavar "VERSION|TAG")
+toolVersionArgument :: Maybe ListCriteria -> Maybe Tool -> Parser ToolVersion
+toolVersionArgument criteria tool =
+  argument (eitherReader toolVersionEither)
+    (metavar "VERSION|TAG"
+    <> completer (tagCompleter (fromMaybe GHC tool) [])
+    <> foldMap (completer . versionCompleter criteria) tool)


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

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

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


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

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

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

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

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


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

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

@@ -1204,73 +1298,67 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
          let installCabal InstallOptions{..} =
                (case instBindist of
                   Nothing -> runInstTool $ do
-                     v <- liftE $ fromVersion dls instVer Cabal
+                     (v, vi) <- liftE $ fromVersion dls instVer Cabal
                     liftE $ installCabalBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
+                     pure vi
                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} $ do
-                     v <- liftE $ fromVersion dls instVer Cabal
+                     (v, vi) <- liftE $ fromVersion dls instVer Cabal
                     liftE $ installCabalBindist
                         (DownloadInfo uri Nothing "")
                         (_tvVersion v)
                         (fromMaybe pfreq instPlatform)
+                     pure vi
                  )
                  >>= \case
-                        VRight _ -> do
+                        VRight vi -> do
                          runLogger $ $(logInfo) ("Cabal installation successful")
+                          forM_ (join $ fmap _viPostInstall vi) $ \msg ->
+                            runLogger $ $(logInfo) msg
                          pure ExitSuccess
                        VLeft (V (AlreadyInstalled _ v)) -> do
                          runLogger $ $(logWarn)
-                            [i|Cabal ver #{prettyVer v} already installed, 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_ (join $ fmap _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 +1368,84 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                                [i|GHC #{prettyVer _tvVersion} successfully set as default version#{maybe "" (" for cross target " <>) _tvTarget}|]
                          pure ExitSuccess
                        VLeft e -> do
-                          runLogger ($(logError) [i|#{e}|])
+                          runLogger $ $(logError) $ T.pack $ prettyShow e
                          pure $ ExitFailure 5

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

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

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

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

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


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

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

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

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

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

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


@@ -1531,6 +1695,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 +1730,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 lStray then [color' Yellow "stray"] else mempty)
+                     ++ (if fromSrc then [color Blue "compiled"] else mempty)
+                     ++ (if lStray then [color Yellow "stray"] else mempty)
                     ++ (if lNoBindist
-                          then [color' Red "no-bindist"]
+                          then [color Red "no-bindist"]
                          else mempty
                        )
                     ]
@@ -1571,16 +1749,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 +1851,27 @@ checkForUpdates :: ( MonadReader AppState m
                -> PlatformRequest
                -> m ()
 checkForUpdates dls pfreq = do
-  forM_ (getLatest dls GHCup) $ \l -> do
+  forM_ (getLatest dls GHCup) $ \(l, _) -> do
    (Right ghc_ver) <- pure $ version $ prettyPVP ghcUpVer
    when (l > ghc_ver)
      $ $(logWarn)
          [i|New GHCup version available: #{prettyVer l}. To upgrade, run 'ghcup upgrade'|]

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

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

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

--- a/25
+++ b/25
@@ -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
--- a/cabal.ghc8104.project
+++ b/cabal.ghc8104.project
@@ -0,0 +1,43 @@
+packages: ./ghcup.cabal
+
+with-compiler: ghc-8.10.4
+
+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
+
+source-repository-package
+    type: git
+    location: https://github.com/hasufell/streamly.git
+    tag: f921e78236c6b44a6673b5e1a1803d2e7102d806
+
+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
--- a/cabal.ghc8104.project.freeze
+++ b/cabal.ghc8104.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.6.0,
+             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.3,
+             async -bench,
+             any.atomic-primops ==0.8.4,
+             atomic-primops -debug,
+             any.attoparsec ==0.13.2.5,
+             attoparsec -developer,
+             any.auto-update ==0.1.6,
+             any.base ==4.14.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.21,
+             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.1,
+             any.deepseq ==1.4.4.0,
+             any.deferred-folds ==0.9.16,
+             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.3,
+             any.filepath ==1.4.2.1,
+             any.focus ==1.0.2,
+             any.foldl ==1.4.11,
+             any.free ==5.1.6,
+             any.fusion-plugin-types ==0.1.0,
+             any.generic-arbitrary ==0.1.0,
+             any.generics-sop ==0.5.1.1,
+             any.ghc-boot-th ==8.10.4,
+             any.ghc-prim ==0.6.1,
+             ghcup -internal-downloader -tar -tui,
+             any.happy ==1.20.0,
+             any.hashable ==1.3.1.0,
+             hashable +integer-gmp,
+             any.haskell-src-exts ==1.23.1,
+             any.haskell-src-meta ==0.8.7,
+             any.haskus-utils-data ==1.3,
+             any.haskus-utils-types ==1.5,
+             any.haskus-utils-variant ==3.0,
+             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.indexed-traversable-instances ==0.1,
+             any.integer-gmp ==1.0.3.0,
+             any.integer-logarithms ==1.0.3.1,
+             integer-logarithms -check-bounds +integer-gmp,
+             any.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.12.0,
+             any.microlens-mtl ==0.2.0.1,
+             any.microlens-th ==0.4.3.9,
+             any.mmorph ==1.1.5,
+             any.monad-control ==1.0.2.3,
+             any.monad-logger ==0.3.36,
+             monad-logger +template_haskell,
+             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.4,
+             any.optics-core ==0.4,
+             optics-core -explicit-generic-labels,
+             any.optics-extra ==0.4,
+             any.optics-th ==0.4,
+             any.optics-vl ==0.2.1,
+             any.optparse-applicative ==0.16.1.0,
+             optparse-applicative +process,
+             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.3.0,
+             parser-combinators -dev,
+             any.pretty ==1.1.3.6,
+             any.pretty-terminal ==0.1.0.0,
+             any.primitive ==0.7.0.1,
+             any.primitive-extras ==0.8.2,
+             any.primitive-unlifted ==0.1.3.0,
+             any.process ==1.6.9.0,
+             any.profunctors ==5.6.2,
+             any.quickcheck-arbitrary-adt ==0.3.1.0,
+             any.quickcheck-io ==0.2.0,
+             any.random ==1.2.0,
+             any.recursion-schemes ==5.2.2,
+             recursion-schemes +template-haskell,
+             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.1.0,
+             string-interpolate -bytestring-builder -extended-benchmarks -text-builder,
+             any.syb ==0.7.2.1,
+             any.tagged ==0.8.6.1,
+             tagged +deepseq +transformers,
+             any.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.1,
+             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.4,
+             any.vector ==0.12.2.0,
+             vector +boundschecks -internalchecks -unsafechecks -wall,
+             any.vector-algorithms ==0.8.0.4,
+             vector-algorithms +bench +boundschecks -internalchecks -llvm +properties -unsafechecks,
+             any.versions ==4.0.3,
+             any.vty ==5.33,
+             any.wcwidth ==0.0.2,
+             wcwidth -cli +split-base,
+             any.word8 ==0.1.3,
+             any.yaml ==0.11.5.0,
+             yaml +no-examples +no-exe,
+             zlib -non-blocking-ffi -pkg-config -static
+index-state: hackage.haskell.org 2021-02-27T05:49:45Z
--- a/cabal.ghc884.project
+++ b/cabal.ghc884.project
@@ -1,14 +1,8 @@
-- Generated by stackage-to-hackage
-
-index-state: 2020-10-24T20:53:55Z
+packages: ./ghcup.cabal

 with-compiler: ghc-8.8.4

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

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

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

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

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

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

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

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

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

 package streamly
--- a/ghcup-0.0.2.yaml
+++ b/ghcup-0.0.2.yaml
@@ -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: []
@@ -1312,7 +1384,7 @@ ghcupDownloads:
              dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-freebsd-12.1-release.tar.xz
              dlHash: 9705e16d03497b46be4ad477e6c64d10890af853eafa8a9adf6dba89aa9e05f7
  GHCup:
-    0.1.11:
+    0.1.13:
      viTags:
      - Recommended
      - Latest
@@ -1322,22 +1394,22 @@ ghcupDownloads:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-linux-ghcup-0.1.11
-              dlHash: 99d97c9a1dce76892001e5cffd50cc23bf804f2282998c546d1b965aa2179699
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-linux-ghcup-0.1.13
+              dlHash: 674266bb9fa85bbafd3c620c68fae4b3cc62507bd6ad9b116603e860bdee1f5a
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-apple-darwin-ghcup-0.1.11
-              dlHash: 4b91dcd9bfdc40534156b8fadea3f317b3c44af1255169895f4911a221f819c6
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-apple-darwin-ghcup-0.1.13
+              dlHash: 5e45cb0b69cd8ee4f7793b84042d4bd121609fa59531ef760fc98fa10c466e4d
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-portbld-freebsd-ghcup-0.1.11
-              dlHash: 6f04ce98d3f3eb9299ce74f8264aa956f0dc38a64a3bd12ee048b7f146e9e1b4
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-portbld-freebsd-ghcup-0.1.13
+              dlHash: 79ce3143a100b60b5294fa831abf091b9699e0bf3addb6c9956de706fc954902
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/i386-linux-ghcup-0.1.11
-              dlHash: ec339e4c2b8b4d502f66a03c0d3f112cb68cd922dd3c4a6f66323628cf6a76c2
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/i386-linux-ghcup-0.1.13
+              dlHash: 4d7646027215b29384f1409399f66bd348421de8a6d53e47ae47c3b465e18fb0
          Linux_Alpine:
            unknown_versioning: *ghcup-32
--- a/ghcup-0.0.3.yaml
+++ b/ghcup-0.0.3.yaml
@@ -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
-        dlSubdir: ghc-9.0.0.20200925
-        dlHash: 142189a3a741af1deb40020c031f05aebfc2b6fd077ffd0c230cf405587cdbb0
+        dlUri: https://downloads.haskell.org/~ghc/9.0.1-rc1/ghc-9.0.0.20201227-src.tar.xz
+        dlSubdir: ghc-9.0.0.20201227
+        dlHash: de49a6d4c67bb8ef676c7e76ca48b3f174bb774a197794cf1518a7f7dd11e2cd
      viArch:
        A_64:
          Linux_Debian:
-            '9': &ghc-901a1-64-deb9
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-deb9-linux.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
-              dlHash: d44ab6f933292066d3f4bafc7e1a4209f8044069f9360bd60a97d2de05a73db2
-            '10': &ghc-901a1-64-deb10
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-deb10-linux-dwarf.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
-              dlHash: 958f98a97d244899d986168c89e4babe2b85ceaa4b0cf1c4631ea1dfa82ad75e
-            unknown_versioning: *ghc-901a1-64-deb9
+            '9': &ghc-901r1-64-deb9
+              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.20201227
+              dlHash: 53f1d9b1cd7cbac4f4e683b5bcf2d08dd45852bd55218c7c5e965b5a78704f15
+            '10': &ghc-901r1-64-deb10
+              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.20201227
+              dlHash: 646f3b91a4ea58be46545b493e08197a4345a71f74ec018be2b8fde496ffe1e4
+            unknown_versioning: *ghc-901r1-64-deb9
          Linux_Ubuntu:
-            unknown_versioning: &ghc-901a1-64-fedora
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-fedora27-linux.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
-              dlHash: 2711afabbaab7abd1b8fdf846802ce6ca8e531641d64bbf75780d4de64180dca
-            '16.04': *ghc-901a1-64-deb9
-            '18.04': *ghc-901a1-64-deb9
+            unknown_versioning: &ghc-901r1-64-fedora
+              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.20201227
+              dlHash: a6483262e5c999701b948107f5b9e77d705333f4b61b37b1c27b4abd28dd186c
+            '16.04': *ghc-901r1-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
-            unknown_versioning: *ghc-901a1-64-fedora
+            '27': *ghc-901r1-64-fedora
+            unknown_versioning: *ghc-901r1-64-fedora
          Linux_CentOS:
-            '7': &ghc-901a1-64-centos
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-x86_64-centos7-linux.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
-              dlHash: 5f6cd94e0d3917fa5c87031706e665f5d9b997f5c991c9c4c4e2900c39dc98ac
-            unknown_versioning: *ghc-901a1-64-centos
+            '7': &ghc-901r1-64-centos
+              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.20201227
+              dlHash: 563370553544c825b0f43427065af789c56ee7ec9cccd497b9dc28c13fc537c5
+            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
-              dlSubdir: ghc-9.0.0.20200925-x86_64-unknown-linux
-              dlHash: 05c0176e39cc89a95047060a589df0686ea1eb99b3de7f2cfadbe5e68bf93f68
+              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.20201227-x86_64-unknown-linux
+              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
-              dlSubdir: ghc-9.0.0.20200925
-              dlHash: fb85a78f2bdad53c591261e21c80f3f50fa2b68bbb22632d9be6960af7b27813
-          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
+              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.20201227
+              dlHash: e6e5bf34c002d52d7108b9d4c8621ae3d21059509f8868bb81b0ba4fda6320da
        A_32:
          Linux_Debian:
-            '9': &ghc-901a1-32-deb9
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200925-i386-deb9-linux.tar.xz
-              dlSubdir: ghc-9.0.0.20200925
-              dlHash: a533641720c33f953ca5d100bc7da219d4cf52eae081c94c97b9ac4cbd9c1d06
-            unknown_versioning: *ghc-901a1-32-deb9
+            '9': &ghc-901r1-32-deb9
+              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.20201227
+              dlHash: 1e3348e2288c60b763dc4e74e4a69b17ae261edb383a7a5220a879c35d530cda
+            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:
-        - old
+      viTags: []
      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:
-        - old
+      viTags: []
      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.13:
      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
-              dlHash: 99d97c9a1dce76892001e5cffd50cc23bf804f2282998c546d1b965aa2179699
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-linux-ghcup-0.1.13
+              dlHash: 674266bb9fa85bbafd3c620c68fae4b3cc62507bd6ad9b116603e860bdee1f5a
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-apple-darwin-ghcup-0.1.11
-              dlHash: 4b91dcd9bfdc40534156b8fadea3f317b3c44af1255169895f4911a221f819c6
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-apple-darwin-ghcup-0.1.13
+              dlHash: 5e45cb0b69cd8ee4f7793b84042d4bd121609fa59531ef760fc98fa10c466e4d
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-portbld-freebsd-ghcup-0.1.11
-              dlHash: 6f04ce98d3f3eb9299ce74f8264aa956f0dc38a64a3bd12ee048b7f146e9e1b4
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/x86_64-portbld-freebsd-ghcup-0.1.13
+              dlHash: 79ce3143a100b60b5294fa831abf091b9699e0bf3addb6c9956de706fc954902
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/i386-linux-ghcup-0.1.11
-              dlHash: ec339e4c2b8b4d502f66a03c0d3f112cb68cd922dd3c4a6f66323628cf6a76c2
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.13/i386-linux-ghcup-0.1.13
+              dlHash: 4d7646027215b29384f1409399f66bd348421de8a6d53e47ae47c3b465e18fb0
          Linux_Alpine:
            unknown_versioning: *ghcup-32
  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
-              dlHash: 5a3ed953f3cc4dac2c5712b0c1a4fc6848a91a301c2f692081fdb37985c23f61
+              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.8.0/haskell-language-server-Linux-0.8.0.tar.gz
+              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
-              dlHash: e5288935f5d8a38b56cfff1d0862d38b2749619b69b23923a814dc136ab7d307
+              dlUri: https://github.com/haskell/haskell-language-server/releases/download/0.8.0/haskell-language-server-macOS-0.8.0.tar.gz
+              dlHash: 1c1668bb455a5164df62774e6fb8f8f91a831ce527d9e5f89f453fb28ef54622
          Linux_Alpine:
            unknown_versioning: *hls-64
--- a/ghcup-0.0.4.yaml
+++ b/ghcup-0.0.4.yaml
--- a/ghcup.cabal
+++ b/ghcup.cabal
@@ -1,6 +1,6 @@
 cabal-version:      3.0
 name:               ghcup
-version:            0.1.12
+version:            0.1.14
 synopsis:           ghc toolchain installer as an exe/library
 description:
  A rewrite of the shell script ghcup, for providing
@@ -150,6 +150,9 @@ common optparse-applicative
 common parsec
  build-depends: parsec >=3.1

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

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

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

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

@@ -375,6 +381,7 @@ executable ghcup
    , monad-logger
    , mtl
    , optparse-applicative
+    , pretty
    , pretty-terminal
    , resourcet
    , safe
@@ -430,7 +437,9 @@ executable ghcup-gen
    , mtl
    , optics
    , optparse-applicative
+    , pretty
    , pretty-terminal
+    , regex-posix
    , resourcet
    , safe-exceptions
    , string-interpolate
--- a/golden/GHCupInfo.json
+++ b/golden/GHCupInfo.json
--- a/lib/GHCup.hs
+++ b/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
-  liftIO $ hideError NoSuchThing $ deleteFile fullDest
+  let destDir = dirname destFile
+      destFile = fromMaybe (binDir </> fn) mtarget
+  lift $ $(logDebug) [i|mkdir -p #{toFilePath destDir}|]
+  liftIO $ createDirRecursive' destDir
+  lift $ $(logDebug) [i|rm -f #{toFilePath destFile}|]
+  liftIO $ hideError NoSuchThing $ deleteFile destFile
+  lift $ $(logDebug) [i|cp #{toFilePath p} #{toFilePath destFile}|]
  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


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

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

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

+
+readFromCache :: (MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
+              => Excepts '[JSONError, FileDoesNotExistError] m GHCupInfo
+readFromCache = do
+  AppState {dirs = Dirs {..}} <- lift ask
+  lift $ $(logWarn)
+    [i|Could not get download info, trying cached version (this may not be recent!)|]
+  let path = view pathL' ghcupURL
+  yaml_file <- (cacheDir </>) <$> urlBaseName path
+  bs        <-
+    handleIO' NoSuchThing
+              (\_ -> throwE $ FileDoesNotExistError (toFilePath yaml_file))
+    $ liftIO
+    $ readFile yaml_file
+  lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bs)
+
+
+getBase :: (MonadFail m, MonadIO m, MonadCatch m, MonadLogger m, MonadReader AppState m)
+        => Excepts '[JSONError , FileDoesNotExistError] m GHCupInfo
+getBase =
+  handleIO (\_ -> readFromCache)
+  $ catchE @_ @'[JSONError, FileDoesNotExistError]
+      (\(DownloadFailed _) -> readFromCache)
+  $ ((reThrowAll @_ @_ @'[JSONError, DownloadFailed] DownloadFailed $ smartDl ghcupURL)
+    >>= (liftE . lE' @_ @_ @'[JSONError] JSONDecodeError . bimap show id . Y.decodeEither' . L.toStrict))
+    where
  -- First check if the json file is in the ~/.ghcup/cache dir
  -- and check it's access time. If it has been accessed within the
  -- last 5 minutes, just reuse it.
@@ -209,8 +213,8 @@ getDownloadsF urlSource = do
      then do
        accessTime <-
          PF.accessTimeHiRes
-            <$> (liftIO $ PF.getFileStatus (toFilePath json_file))
-        currentTime <- liftIO $ getPOSIXTime
+            <$> liftIO (PF.getFileStatus (toFilePath json_file))
+        currentTime <- liftIO getPOSIXTime

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

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

 import           GHCup.Types
+import           GHCup.Utils.Prelude

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



@@ -35,97 +49,203 @@ import           HPath
 data NoCompatiblePlatform = NoCompatiblePlatform String -- the platform we got
  deriving Show

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 deriving instance Show DownloadFailed

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

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


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

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


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

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


 data UnexpectedListLength = UnexpectedListLength String
  deriving Show

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

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

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

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

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

@@ -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
-  , _viChangeLog :: Maybe URI
-  , _viSourceDL  :: Maybe DownloadInfo -- ^ source tarball
-  , _viArch      :: ArchitectureSpec   -- ^ descend for binary downloads per arch
+  { _viTags        :: [Tag]              -- ^ version specific tag
+  , _viChangeLog   :: Maybe URI
+  , _viSourceDL    :: Maybe DownloadInfo -- ^ source tarball
+  , _viArch        :: ArchitectureSpec   -- ^ descend for binary downloads per arch
+  -- informative messages
+  , _viPostInstall :: Maybe Text
+  , _viPostRemove  :: Maybe Text
+  , _viPreCompile  :: Maybe Text
  }
  deriving (Eq, GHC.Generic, Show)

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

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

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

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

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

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

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

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


 -- | An encapsulation of a download. This can be used
@@ -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
-prettyPlatform PlatformResult { _platform = plat, _distroVersion = Just v' }
+platResToString :: PlatformResult -> String
+platResToString PlatformResult { _platform = plat, _distroVersion = Just v' }
  = show plat <> ", " <> T.unpack (prettyV v')
-prettyPlatform PlatformResult { _platform = plat, _distroVersion = Nothing }
+platResToString PlatformResult { _platform = plat, _distroVersion = Nothing }
  = show plat

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

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

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

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

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


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

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


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

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

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


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



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

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

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

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


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


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

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

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


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


-chmod_777 :: (MonadLogger m, MonadIO m) => Path a -> m ()
-chmod_777 (toFilePath -> fp) = do
+chmod_755 :: (MonadLogger m, MonadIO m) => Path a -> m ()
+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
-
--- a/lib/GHCup/Version.hs
+++ b/lib/GHCup/Version.hs
@@ -12,13 +12,15 @@ Portability : POSIX
 -}
 module GHCup.Version where

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

      <div id="platform-instructions-default" class="instructions">
        <div>
-          <p>To install Haskell, if you are running Linux, macOS, FreeBSD or Windows Subsystem for Linux, run the following
+          <p>To install Haskell, if you are running Linux, macOS (on Intel), FreeBSD or Windows Subsystem for Linux, run the following
          in your terminal (as a user other than root), then follow the onscreen instructions.</p>
 		  <pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | sh</span></pre>
+          <p>For macOS on Apple Silicon, run this instead:</p>
+          <div class="command-button"><pre><span class='ghcup-command'>curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | arch -x86_64 /bin/bash</span></pre><button class="tooltip" onclick="copyToClipboardSilicon()"><img src="copy.svg" alt="" /><span class="tooltiptext">Copy to clipboard</span></button></div>
          <p class="other-help">If you don't like curl | sh, see <a href="https://gitlab.haskell.org/haskell/ghcup-hs#manual-install">other installation methods</a>.</p>
        </div>
Author	SHA1	Message	Date
Julian Ospald	f6cc467e95	Fix handling of stray versions wrt #116	2021-03-07 12:02:13 +01:00
Julian Ospald	ef978c1230	Add test case for issue #116	2021-03-07 11:59:45 +01:00
Julian Ospald	52af598473	Update ghcup in old yamls	2021-03-06 16:02:09 +01:00
Julian Ospald	2acacd46c2	Bump stack.yaml	2021-03-02 19:37:09 +01:00
Julian Ospald	4b2f9ddb40	Update project files	2021-03-02 19:22:14 +01:00
Julian Ospald	0d3dc4eba2	Bump ghcup version	2021-03-02 12:39:24 +01:00
Julian Ospald	824faa8091	Update CHANGELOG	2021-03-02 12:38:11 +01:00
Julian Ospald	d10cdfdf57	Merge branch 'PR/issue-115'	2021-03-02 12:34:52 +01:00
Julian Ospald	5e911793ce	Document env variables wrt #95	2021-03-02 10:51:23 +01:00
Julian Ospald	8c87c9aeb7	Fix error messages and overhaul pretty printing Fixes #115	2021-03-02 10:35:31 +01:00
Julian Ospald	9da5998a5c	Add some fancy messages	2021-02-26 19:55:33 +01:00
Julian Ospald	08943dadca	Fix validation	2021-02-26 16:06:08 +01:00
Julian Ospald	7fac7226c5	Update ghcup	2021-02-26 15:38:35 +01:00
Julian Ospald	9686c8ebf9	Update changelog	2021-02-26 11:53:57 +01:00
Julian Ospald	4bf96d0ec9	Revert version bump in bootstrap script	2021-02-25 19:19:53 +01:00
Julian Ospald	34add82bee	Merge branch 'PR/issue-114'	2021-02-25 19:18:13 +01:00
Julian Ospald	f46e7e8c4b	Add "ghcup set ghc next" tag wrt #114	2021-02-25 19:10:55 +01:00
Julian Ospald	3baf254251	Improve tag completer	2021-02-25 16:13:00 +01:00
Julian Ospald	10ca9ea827	Reformat versionCompleter	2021-02-25 15:52:28 +01:00
Julian Ospald	4a50c8ecb7	Remove network call on shell completion	2021-02-25 15:46:08 +01:00
Julian Ospald	47d9766c78	Make sure forFold can properly inline	2021-02-25 15:40:52 +01:00
Julian Ospald	45ab69960f	Merge remote-tracking branch 'origin/merge-requests/70'	2021-02-25 15:36:37 +01:00
Julian Ospald	d3505d4ee6	Bump version to 0.1.13	2021-02-25 15:33:52 +01:00
Julian Ospald	9297d1a2f8	Merge branch 'arm'	2021-02-25 14:22:59 +01:00
Julian Ospald	56feb7c09e	Use stages in CI	2021-02-25 14:14:01 +01:00
Julian Ospald	bede4b8712	Merge branch 'www-fix-silicon-copy'	2021-02-25 13:33:11 +01:00
Julian Ospald	95c1c55f22	Fix copy button for apple silicon	2021-02-25 13:32:46 +01:00
Julian Ospald	f547a6eb68	Support ARM/AARCH	2021-02-25 11:53:36 +01:00
Huw campbell	453a29fdf7	Respect the user's configuration settings Only lookup user configuration before doing a search; implement version completion for Cabal and HLS removal	2021-02-25 16:31:40 +11:00
Huw campbell	1a5f0259f4	Just use the cache for commands which refer to locally stored objects. Setting a version of GHC will fail if provided with a version not installed, and we don't neede to check the most recent list of GHCs available to know that.	2021-02-25 10:19:16 +11:00
Huw campbell	d6fa61e223	Add command line completions for installed and available versions. When running `ghcup set ghc` and pressing tab, one should be able to autocomplete the currently installed GHCs we have available. Add an optparse applicative completer for install, rm, and set commands which shows tags and versions. For installation, all are shown; while for remove and set, only those installed are.	2021-02-25 00:42:16 +11:00
Julian Ospald	eab82b5d63	Update HLS to 1.0.0	2021-02-24 12:43:04 +01:00
Julian Ospald	c455b521a9	Fix ghcup-tui	2021-02-24 12:42:36 +01:00
Julian Ospald	b4f9e12293	Merge remote-tracking branch 'origin/merge-requests/54'	2021-02-24 10:13:46 +01:00
Julian Ospald	bbd353ea3a	Merge branch 'PR/issue-107'	2021-02-23 18:40:04 +01:00
Julian Ospald	4189c5de69	Update CHANGELOG	2021-02-23 17:11:45 +01:00
Julian Ospald	dee3218723	Fix item selection with unavailable versions Fixes #107	2021-02-23 17:10:48 +01:00
Julian Ospald	3c803a9f58	Merge branch 'PR/issue-104'	2021-02-23 12:52:19 +01:00
Julian Ospald	a9b0c0fbc9	Allow for dynamic post-install, post-remove and pre-compile msgs	2021-02-23 11:52:38 +01:00
Julian Ospald	38b6c918f9	Update CHANGELOG	2021-02-21 21:03:12 +01:00
Julian Ospald	6e584c96c4	Merge branch 'PR/issue-111'	2021-02-21 21:01:59 +01:00
Julian Ospald	20338f7d14	Alert user if upgraded ghcup is shadowed by old ghcup Also alerts if the binary is not in PATH at all. Fixes #111	2021-02-21 19:58:32 +01:00
Julian Ospald	1a995a5d63	Merge branch 'PR/cabal-3.4.0.0'	2021-02-21 16:34:18 +01:00
Julian Ospald	f964382175	Tighten checks, alpine 32bit bindists is 1st class	2021-02-21 15:37:05 +01:00
Julian Ospald	0c7f60fae6	Add more alpine 32bit bindists	2021-02-21 15:35:33 +01:00
Julian Ospald	413e63d1ca	Update hasufell.de hosted bindists to webhost.haskell.org	2021-02-21 15:34:55 +01:00
Julian Ospald	8b000f4e48	Add cabal-3.4.0.0 final release	2021-02-20 23:30:28 +01:00
Julian Ospald	b0522507be	Merge branch 'PR/ubunbu-20.10-update-reqs/110'	2021-02-16 16:40:03 +01:00
Julian Ospald	d4bcf7021e	Merge branch 'PR/fix-109'	2021-02-16 16:26:13 +01:00
Julian Ospald	48cf0b1f67	Update libffi req for ubuntu groovy Fixed #110	2021-02-16 14:41:49 +01:00
Julian Ospald	d82e189c01	Fix failed ghcup upgrade if destination dir doesn't exist Fixes #109	2021-02-16 14:37:17 +01:00
Julian Ospald	e5a60d1b9a	Merge branch 'ghc-8.10.4'	2021-02-06 22:39:52 +01:00
Julian Ospald	ff067351cb	Add GHC-8.10.4	2021-02-06 14:28:58 +01:00
Julian Ospald	345712a617	Add freeze/project file for ghc-8.10.3	2021-02-05 11:59:57 +01:00
Julian Ospald	118dac6907	Merge branch 'bump-GHC-CI'	2021-02-05 11:51:11 +01:00
Julian Ospald	5ca40caf81	Bump GHC/Cabal in CI	2021-02-05 11:02:45 +01:00
Julian Ospald	d858187fd4	Merge remote-tracking branch 'origin/merge-requests/61'	2021-02-05 10:49:39 +01:00
Julian Ospald	bd65517df1	Add changelog for ghc-9.0.1	2021-02-04 23:20:19 +01:00
Julian Ospald	b1acad6c95	Set 8.10.3 as recommended	2021-02-04 22:59:17 +01:00
Julian Ospald	a8333281ac	Bump to GHC-9.0.1	2021-02-04 22:49:49 +01:00
Julian Ospald	2fdb08ac00	Merge remote-tracking branch 'origin/merge-requests/59'	2021-01-31 11:19:22 +01:00
Javier Neira	bd4e5a2314	Update haskell-language-server to 0.9.0	2021-01-30 15:36:34 -05:00
Julian Ospald	34ed317b6b	Merge remote-tracking branch 'origin/merge-requests/58'	2021-01-13 10:13:40 +08:00
Enrico Maria De Angelis	14661502ab	#103 : Rewording of warning message	2021-01-11 07:12:19 +00:00
Julian Ospald	097754ffdf	Merge remote-tracking branch 'origin/merge-requests/57'	2021-01-05 08:24:30 +08:00
amesgen	f26ec6d295	update HLS to 0.8.0	2021-01-04 21:02:38 +01:00
Julian Ospald	858d430845	Add ghc-8.10.3 for alpine 32bit	2021-01-04 09:51:36 +08:00
Julian Ospald	5134eccbf8	Update HACKING.md	2021-01-02 16:07:41 +08:00
Julian Ospald	28b4737758	Merge remote-tracking branch 'origin/merge-requests/56'	2021-01-02 15:57:18 +08:00
amesgen	5c43ff4c9e	error if we check nothing	2021-01-02 08:51:57 +01:00
amesgen	53db68e39f	minor tarball filter format change	2021-01-02 07:58:08 +01:00
Julian Ospald	9e628e34dd	Merge remote-tracking branch 'origin/merge-requests/55'	2021-01-02 14:27:11 +08:00
amesgen	62d5d53232	filter tool and version instead of URL	2021-01-02 05:53:11 +01:00
amesgen	56569a0698	use regex instead of substring	2021-01-02 05:05:05 +01:00
amesgen	ef44f818d0	add GHC 9.0.1-rc1	2021-01-01 05:50:54 +01:00
amesgen	8944ed6e36	allow to filter tarball validation by a URL substring also, use nubOrd for linearithmic instead of quadratic complexity	2021-01-01 05:45:58 +01:00
Julian Ospald	51805b27aa	Update CHANGELOG	2020-12-30 17:01:45 +08:00
Julian Ospald	0ec64510b3	Update CHANGELOG	2020-12-30 16:52:46 +08:00
Julian Ospald	20152443da	Fix hash for 8.10.3 src dist	2020-12-30 11:47:26 +08:00
Ron Toland	7c8929fe9f	add default install instructions for apple silicon	2020-12-26 06:33:32 -08:00
Julian Ospald	5617516c93	Merge remote-tracking branch 'origin/merge-requests/52'	2020-12-25 01:26:08 +08:00
Julian Ospald	f6fe08367d	Fix cabal prerelease download URLs wrt #102	2020-12-24 04:46:05 +08:00
Julian Ospald	a5f02133e2	Merge remote-tracking branch 'origin/merge-requests/53'	2020-12-24 01:57:58 +08:00
Ron Toland	8ed9b4432d	Add install cmd for Apple Silicon wrt #101	2020-12-23 06:51:54 -08:00
amesgen	db1d05e8ad	add GHC 8.10.3	2020-12-21 00:52:00 +01:00
Julian Ospald	eae58137c8	Merge remote-tracking branch 'origin/merge-requests/47'	2020-12-20 01:45:49 +08:00
Julian Ospald	b0f90c096f	Fix chmod on executables, wrt #97	2020-12-20 01:27:27 +08:00
Julian Ospald	e8361c564a	Merge remote-tracking branch 'origin/merge-requests/51'	2020-12-19 03:30:40 +08:00
amesgen	54db9c9a92	update HLS to 0.7.1	2020-12-18 15:32:50 +01:00
amesgen	73db341dc8	update HLS to 0.7.0	2020-12-16 00:58:26 +01:00
Julian Ospald	5fd30b412b	Merge remote-tracking branch 'origin/merge-requests/49'	2020-11-28 12:46:16 +01:00
Anton-Latukha	bbe2e87640	CHANGELOG.md: add note about `ghcup` directory fix`	2020-11-28 12:34:58 +02:00
Anton-Latukha	67f59f6895	bootstrap-haskell: fx XDG GHCUP_DIR value	2020-11-28 01:41:43 +02:00
Anton-Latukha	3e2df2e111	bootstrap-haskell: create GHCUP_DIR	2020-11-28 01:27:35 +02:00
Julian Ospald	824d2149c6	Merge remote-tracking branch 'origin/merge-requests/48'	2020-11-27 20:26:33 +01:00
Anton-Latukha	c86dbe043b	bootstrap-haskell: mention the license Since script is served separately from the main source code (can be opened over https://get-ghcup.haskell.org) - mention the script license to the reciever.	2020-11-27 17:06:39 +02:00
Anton-Latukha	8043ac7f51	bootstrap-haskell: provide instructions for the main settings Provide some basic instructive information to someone who views the script.	2020-11-27 17:04:00 +02:00
Paolo Martini	ead9d31647	Apply NO_COLOR to dimAttributes as well to cover all tui colors	2020-11-26 20:22:32 +01:00
Paolo Martini	a08e624309	Respect NO_COLOR environment variable in list and tui	2020-11-25 11:41:53 +01:00
Julian Ospald	b20371c3ac	Add default values to all XDG_ variables documentation	2020-11-21 16:31:50 +01:00
Julian Ospald	0589a7cbcc	Document XDG_CONFIG_HOME wrt #85	2020-11-21 16:29:26 +01:00
Julian Ospald	cf48961063	Bump ghcup to 0.1.12	2020-11-21 14:23:37 +01:00
Julian Ospald	6046582b9c	Improve version ranges	2020-11-21 14:05:34 +01:00