Update recommended GHC in CI

Update latest in CI
2021-02-06 22:42:15 +01:00 · 2021-02-06 22:42:15 +01:00
28 changed files with 8221 additions and 20632 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,7 +1,3 @@
-stages:
-  - test
-  - release
-
 variables:
  GIT_SSL_NO_VERIFY: "1"

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

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

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

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

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

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

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

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

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

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

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

 test:linux:recommended:
-  stage: test
  extends: .test_ghcup_version:linux
-  variables:
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
-
-test:linux:latest:
-  stage: test
-  extends: .test_ghcup_version:linux
-  variables:
-    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.10.4"
    CABAL_VERSION: "3.2.0.0"

-######## arm tests ########
-
-test:linux:recommended:armv7:
-  extends: .test_ghcup_version:armv7
+test:linux:latest:
+  extends: .test_ghcup_version:linux
  variables:
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
-  when: manual
+    GHC_VERSION: "9.0.1"
+    CABAL_VERSION: "3.4.0.0-rc4"
+  allow_failure: true

-test:linux:recommended:aarch64:
-  extends: .test_ghcup_version:aarch64
+######## linux 32bit test ########
+
+test:linux:recommended:32bit:
+  extends: .test_ghcup_version:linux32
  variables:
-    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
-  when: manual
+    GHC_VERSION: "8.10.2"
+    CABAL_VERSION: "3.2.0.0"

 ######## darwin test ########

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

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


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

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

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


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

 release:linux:64bit:
-  stage: release
-  needs: ["test:linux:recommended", "test:linux:latest"]
  extends:
    - .alpine:64bit
    - .release_ghcup
@@ -256,12 +196,10 @@ release:linux:64bit:
  variables:
    ARTIFACT: "x86_64-linux-ghcup"
    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
+    CABAL_VERSION: "3.4.0.0-rc4"


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

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

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

 release:darwin:
-  stage: release
-  needs: ["test:mac:recommended", "test:mac:latest"]
  extends:
    - .darwin
    - .release_ghcup
@@ -312,15 +223,13 @@ release:darwin:
  variables:
    ARTIFACT: "x86_64-apple-darwin-ghcup"
    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
+    CABAL_VERSION: "3.4.0.0-rc4"
    MACOSX_DEPLOYMENT_TARGET: "10.7"


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

 release:freebsd:
-  stage: release
-  needs: ["test:freebsd:recommended", "test:freebsd:latest"]
  extends:
    - .freebsd
    - .release_ghcup
@@ -330,5 +239,5 @@ release:freebsd:
  variables:
    ARTIFACT: "x86_64-portbld-freebsd-ghcup"
    GHC_VERSION: "8.10.4"
-    CABAL_VERSION: "3.4.0.0"
+    CABAL_VERSION: "3.4.0.0-rc4"

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

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

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

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

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

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

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

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

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

 if [ "${OS}" = "LINUX" ] ; then
-	if [ "${ARCH}" = "32" ] ; then
+	if [ "${BIT}" = "32" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui -ftar
-	elif [ "${ARCH}" = "64" ] ; then
-		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui
 	else
-		ecabal build -w ghc-${GHC_VERSION} -ftui
+		ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections -optl-static' -ftui
 	fi
 elif [ "${OS}" = "FREEBSD" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} --ghc-options='-split-sections' --constraint="zlib +static" -ftui
--- a/.gitlab/script/ghcup_version.sh
+++ b/.gitlab/script/ghcup_version.sh
@@ -26,7 +26,7 @@ if [ "${OS}" = "DARWIN" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} -ftui
 	ecabal test -w ghc-${GHC_VERSION} -ftui ghcup-test
 elif [ "${OS}" = "LINUX" ] ; then
-	if [ "${ARCH}" = "32" ] ; then
+	if [ "${BIT}" = "32" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar
 		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar ghcup-test
 	else
@@ -80,17 +80,17 @@ ghci-$(ghc --numeric-version) --version
 # test installing new ghc doesn't mess with currently set GHC
 # https://gitlab.haskell.org/haskell/ghcup-hs/issues/7
 if [ "${OS}" = "LINUX" ] ; then
-	eghcup --downloader=wget install 8.10.3
+	eghcup --downloader=wget install 8.4.4
 else # test wget a bit
-	eghcup install 8.10.3
+	eghcup install 8.4.4
 fi
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-eghcup set 8.10.3
-eghcup set 8.10.3
-[ "$(ghc --numeric-version)" = "8.10.3" ]
+eghcup set 8.4.4
+eghcup set 8.4.4
+[ "$(ghc --numeric-version)" = "8.4.4" ]
 eghcup set ${GHC_VERSION}
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]
-eghcup rm 8.10.3
+eghcup rm 8.4.4
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]

 # install hls
@@ -98,7 +98,7 @@ if [ "${OS}" = "DARWIN" ] ; then
 	eghcup install hls
 	haskell-language-server-wrapper --version
 elif [ "${OS}" = "LINUX" ] ; then
-	if [ "${ARCH}" = "64" ] ; then
+	if [ "${BIT}" = "64" ] ; then
 		eghcup install hls
 		haskell-language-server-wrapper --version
 	fi
--- a/.travis/build.sh
+++ b/.travis/build.sh
@@ -8,9 +8,9 @@ chmod +x ~/.ghcup/bin/ghcup

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

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


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

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

-* Support ARMv7/AARCH64
-* Add command line completions for installed and available versions wrt [MR #70](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/70)
-* Allow to cycle through set tools wrt [#114](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/114)
-* Fix item selection with unavailable versions wrt [#107](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/107)
-* Allow for dynamic post-install, post-remove and pre-compile msgs wrt [MR #68](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/68)
-* Alert user if upgraded ghcup is shadowed by old ghcup wrt [#111](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/111)
 * Fix to `ghcup` directory creation and placement for the XDG install mode ([MR #49](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/49))
 * Do 755 permissions on executables, wrt #97
 * Add [NO_COLOR](https://no-color.org/) support wrt [MR #47](https://gitlab.haskell.org/haskell/ghcup-hs/-/merge_requests/47)
--- a/app/ghcup-gen/Validate.hs
+++ b/app/ghcup-gen/Validate.hs
@@ -67,7 +67,7 @@ validate dls = do
    forM_ (M.toList dls) $ \(t, versions) ->
      forM_ (M.toList versions) $ \(v, vi) ->
        forM_ (M.toList $ _viArch vi) $ \(arch, pspecs) -> do
-          checkHasRequiredPlatforms t v (_viTags vi) arch (M.keys pspecs)
+          checkHasRequiredPlatforms t v arch (M.keys pspecs)

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

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

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

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

  (run $ do
      case lTool of
-        GHC   -> do
-          vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer GHC dls
-            ?? VerNotFound lVer GHC
-          liftE $ installGHCBin dls lVer pfreq $> vi
-        Cabal -> do
-          vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer Cabal dls
-            ?? VerNotFound lVer Cabal
-          liftE $ installCabalBin dls lVer pfreq $> vi
-        GHCup -> do
-          let vi = fromJust $ snd <$> getLatest dls GHCup
-          liftE $ upgradeGHCup dls Nothing False pfreq $> vi
-        HLS   -> do
-          vi <- liftE @_ @'[VerNotFound] $ getVersionInfo lVer HLS dls
-            ?? VerNotFound lVer HLS
-          liftE $ installHLSBin dls lVer pfreq $> vi
+        GHC   -> liftE $ installGHCBin dls lVer pfreq
+        Cabal -> liftE $ installCabalBin dls lVer pfreq
+        GHCup -> liftE $ upgradeGHCup dls Nothing False pfreq $> ()
+        HLS   -> liftE $ installHLSBin dls lVer pfreq $> ()
    )
    >>= \case
-          VRight vi                         -> do
-            forM_ (_viPostInstall vi) $ \msg ->
-              runLogger $ $(logInfo) msg
-            pure $ Right ()
+          VRight _                          -> pure $ Right ()
          VLeft  (V (AlreadyInstalled _ _)) -> pure $ Right ()
          VLeft (V (BuildFailed _ e)) ->
            pure $ Left [i|Build failed with #{e}|]
@@ -478,27 +459,21 @@ set' _ (_, ListResult {..}) = do


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

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

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

--- a/app/ghcup/Main.hs
+++ b/app/ghcup/Main.hs
@@ -32,7 +32,6 @@ import           GHCup.Version
 #if !defined(TAR)
 import           Codec.Archive
 #endif
-import           Control.Concurrent
 import           Control.Exception.Safe
 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
@@ -44,7 +43,7 @@ import           Data.Bifunctor
 import           Data.Char
 import           Data.Either
 import           Data.Functor
-import           Data.List                      ( intercalate, nub, sort, sortBy )
+import           Data.List                      ( intercalate, sort )
 import           Data.List.NonEmpty             (NonEmpty ((:|)))
 import           Data.Maybe
 import           Data.String.Interpolate
@@ -70,7 +69,6 @@ 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
@@ -116,11 +114,6 @@ prettyToolVer :: ToolVersion -> String
 prettyToolVer (ToolVersion v') = T.unpack $ prettyTVer v'
 prettyToolVer (ToolTag t) = show t

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

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

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

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


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


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

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



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


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

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

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


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

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

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


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


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

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

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

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

          let runListGHC = runLogger . flip runReaderT appstate

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

          let runDebugInfo =
                runLogger
@@ -1201,7 +1102,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                      , UnknownArchive
                      , TarDirDoesNotExist
                      , NotInstalled
-                      , VerNotFound
 #if !defined(TAR)
                      , ArchiveResult
 #endif
@@ -1262,24 +1162,20 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
          let installGHC InstallOptions{..} =
                  (case instBindist of
                     Nothing -> runInstTool $ do
-                       (v, vi) <- liftE $ fromVersion dls instVer GHC
+                       v <- liftE $ fromVersion dls instVer GHC
                       liftE $ installGHCBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
                       when instSet $ void $ liftE $ setGHC v SetGHCOnly
-                       pure vi
                     Just uri -> runInstTool' appstate{ settings = settings {noVerify = True}} $ do
-                       (v, vi) <- liftE $ fromVersion dls instVer GHC
+                       v <- liftE $ fromVersion dls instVer GHC
                       liftE $ installGHCBindist
                         (DownloadInfo uri (Just $ RegexDir "ghc-.*") "")
                         (_tvVersion v)
                         (fromMaybe pfreq instPlatform)
                       when instSet $ void $ liftE $ setGHC v SetGHCOnly
-                       pure vi
                    )
                    >>= \case
-                          VRight vi -> do
+                          VRight _ -> do
                            runLogger $ $(logInfo) ("GHC installation successful")
-                            forM_ (_viPostInstall vi) $ \msg ->
-                              runLogger $ $(logInfo) msg
                            pure ExitSuccess
                          VLeft (V (AlreadyInstalled _ v)) -> do
                            runLogger $ $(logWarn)
@@ -1309,22 +1205,18 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
          let installCabal InstallOptions{..} =
                (case instBindist of
                   Nothing -> runInstTool $ do
-                     (v, vi) <- liftE $ fromVersion dls instVer Cabal
+                     v <- liftE $ fromVersion dls instVer Cabal
                     liftE $ installCabalBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
-                     pure vi
                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} $ do
-                     (v, vi) <- liftE $ fromVersion dls instVer Cabal
+                     v <- liftE $ fromVersion dls instVer Cabal
                     liftE $ installCabalBindist
                         (DownloadInfo uri Nothing "")
                         (_tvVersion v)
                         (fromMaybe pfreq instPlatform)
-                     pure vi
                  )
                  >>= \case
-                        VRight vi -> do
+                        VRight _ -> do
                          runLogger $ $(logInfo) ("Cabal installation successful")
-                          forM_ (_viPostInstall vi) $ \msg ->
-                            runLogger $ $(logInfo) msg
                          pure ExitSuccess
                        VLeft (V (AlreadyInstalled _ v)) -> do
                          runLogger $ $(logWarn)
@@ -1346,22 +1238,18 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
          let installHLS InstallOptions{..} =
                (case instBindist of
                   Nothing -> runInstTool $ do
-                     (v, vi) <- liftE $ fromVersion dls instVer HLS
+                     v <- liftE $ fromVersion dls instVer HLS
                     liftE $ installHLSBin dls (_tvVersion v) (fromMaybe pfreq instPlatform)
-                     pure vi
                   Just uri -> runInstTool' appstate{ settings = settings { noVerify = True}} $ do
-                     (v, vi) <- liftE $ fromVersion dls instVer HLS
+                     v <- liftE $ fromVersion dls instVer HLS
                     liftE $ installHLSBindist
                         (DownloadInfo uri Nothing "")
                         (_tvVersion v)
                         (fromMaybe pfreq instPlatform)
-                     pure vi
                  )
                  >>= \case
-                        VRight vi -> do
+                        VRight _ -> do
                          runLogger $ $(logInfo) ("HLS installation successful")
-                          forM_ (_viPostInstall vi) $ \msg ->
-                            runLogger $ $(logInfo) msg
                          pure ExitSuccess
                        VLeft (V (AlreadyInstalled _ v)) -> do
                          runLogger $ $(logWarn)
@@ -1383,7 +1271,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]

          let setGHC' SetOptions{..} =
                (runSetGHC $ do
-                    v <- liftE $ fst <$> fromVersion' dls sToolVer GHC
+                    v <- liftE $ fromVersion dls sToolVer GHC
                    liftE $ setGHC v SetGHCOnly
                  )
                  >>= \case
@@ -1398,83 +1286,52 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]

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

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

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

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

          let rmHLS' tv =
                (runRm $ do
-                    liftE $
-                      rmHLSVer tv
-                    vi <- liftE @_ @'[VerNotFound] $ getVersionInfo tv HLS dls
-                      ?? VerNotFound tv HLS
-                    pure vi
+                    liftE $ rmHLSVer tv
                  )
                  >>= \case
-                        VRight vi -> do
-                          forM_ (_viPostRemove vi) $ \msg ->
-                            runLogger $ $(logInfo) msg
-                          pure ExitSuccess
+                        VRight _ -> pure ExitSuccess
                        VLeft  e -> do
                          runLogger ($(logError) [i|#{e}|])
                          pure $ ExitFailure 15
@@ -1528,13 +1385,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]

            Compile (CompileGHC GHCCompileOptions {..}) ->
              (runCompileGHC $ do
-                vi <- liftE @_ @'[VerNotFound] $ getVersionInfo targetVer GHC dls
-                  ?? VerNotFound targetVer GHC
-                forM_ (_viPreCompile vi) $ \msg -> do
-                  lift $ $(logInfo) msg
-                  lift $ $(logInfo)
-                    ("...waiting for 5 seconds, you can still abort...")
-                  liftIO $ threadDelay 5000000 -- for compilation, give the user a sec to intervene
                liftE $ compileGHC dls
                            (GHCTargetVersion crossTarget targetVer)
                            bootstrapGhc
@@ -1543,16 +1393,13 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                            patchDir
                            addConfArgs
                            pfreq
-                when setCompile $ void $ liftE $
-                  setGHC (GHCTargetVersion crossTarget targetVer) SetGHCOnly
-                pure vi
+                when setCompile $ void $ liftE
+                  $ setGHC (GHCTargetVersion crossTarget targetVer) SetGHCOnly
                )
                >>= \case
-                      VRight vi -> do
+                      VRight _ -> do
                        runLogger $ $(logInfo)
                          ("GHC successfully compiled and installed")
-                        forM_ (_viPostInstall vi) $ \msg ->
-                          runLogger $ $(logInfo) msg
                        pure ExitSuccess
                      VLeft (V (AlreadyInstalled _ v)) -> do
                        runLogger $ $(logWarn)
@@ -1582,11 +1429,8 @@ 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|]
@@ -1657,72 +1501,29 @@ Make sure to clean up #{tmpdir} afterwards.|])
            ef@(ExitFailure _) -> exitWith ef
  pure ()

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


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

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

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

-  forM_ (getLatest dls HLS) $ \(l, _) -> do
+  forM_ (getLatest dls HLS) $ \l -> do
    mcabal_ver <- latestInstalled HLS
    forM mcabal_ver $ \cabal_ver ->
      when (l > cabal_ver)
--- a/8
+++ b/8
@@ -69,7 +69,7 @@ _done() {
 download_ghcup() {
 	_plat="$(uname -s)"
 	_arch=$(uname -m)
-	_ghver="0.1.13"
+	_ghver="0.1.12"
 	_base_url="https://downloads.haskell.org/~ghcup"

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

-source-repository-package
-    type: git
-    location: https://github.com/composewell/streamly.git
-    tag: befff892c60d1452b3cf3db14439f46ae1ea5042
-
 optimization: 2

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

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

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

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


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

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

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

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

        -- access time won't work on most linuxes, but we can try regardless
        if (currentTime - accessTime) > 300
--- a/lib/GHCup/Errors.hs
+++ b/lib/GHCup/Errors.hs
@@ -67,15 +67,6 @@ data CopyError = CopyError String
 data TagNotFound = TagNotFound Tag Tool
  deriving Show

-- | Unable to find a version of a tool.
-data VerNotFound = VerNotFound Version Tool
-  deriving Show
-
-- | Unable to find the next version of a tool (the one after the currently
-- set one).
-data NextVerNotFound = NextVerNotFound Tool
-  deriving Show
-
 -- | The tool (such as GHC) is already installed with that version.
 data AlreadyInstalled = AlreadyInstalled Tool Version
  deriving Show
@@ -127,9 +118,6 @@ data NoToolRequirements = NoToolRequirements

 data InvalidBuildConfig = InvalidBuildConfig Text
  deriving Show
- 
-data NoToolVersionSet = NoToolVersionSet Tool
-  deriving Show


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

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

-prettyTag :: Tag -> String
-prettyTag Recommended        = "recommended"
-prettyTag Latest             = "latest"
-prettyTag Prerelease         = "prerelease"
-prettyTag (Base       pvp'') = "base-" ++ T.unpack (prettyPVP pvp'')
-prettyTag (UnknownTag t    ) = t
-prettyTag Old                = ""

 data Architecture = A_64
                  | A_32
--- a/lib/GHCup/Utils.hs
+++ b/lib/GHCup/Utils.hs
@@ -497,11 +497,11 @@ getGHCForMajor major' minor' mt = do
 getLatestGHCFor :: Int -- ^ major version component
                -> Int -- ^ minor version component
                -> GHCupDownloads
-                -> Maybe (Version, VersionInfo)
+                -> Maybe Version
 getLatestGHCFor major' minor' dls = do
  join
-    . fmap (lastMay . filter (\(v, _) -> matchMajor v major' minor'))
-    . preview (ix GHC % to Map.toDescList)
+    . fmap (lastMay . filter (\v -> matchMajor v major' minor'))
+    . preview (ix GHC % to Map.keys)
    $ dls


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

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

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


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



@@ -795,25 +795,3 @@ createDirRecursive' p =
          _ -> throwIO e
      _ -> throwIO e

-
-getVersionInfo :: Version
-               -> Tool
-               -> GHCupDownloads
-               -> Maybe VersionInfo
-getVersionInfo v' tool dls =
-  headOf
-    ( ix tool
-    % to (Map.filterWithKey (\k _ -> k == v'))
-    % to Map.elems
-    % _head
-    )
-    dls
-
-
-- Gathering monoidal values
-traverseFold :: (Foldable t, Applicative m, Monoid b) => (a -> m b) -> t a -> m b
-traverseFold f = foldl (\mb a -> (<>) <$> mb <*> f a) (pure mempty)
-
-- | Gathering monoidal values
-forFold :: (Foldable t, Applicative m, Monoid b) => t a -> (a -> m b) -> m b
-forFold = \t -> \f -> traverseFold f t
--- a/lib/GHCup/Utils/Dirs.hs
+++ b/lib/GHCup/Utils/Dirs.hs
@@ -185,9 +185,9 @@ getDirs = do
 ghcupConfigFile :: (MonadIO m)
                => Excepts '[JSONError] m UserSettings
 ghcupConfigFile = do
-  confDir <- liftIO ghcupConfigDir
+  confDir <- liftIO $ ghcupConfigDir
  let file = confDir </> [rel|config.yaml|]
-  bs <- liftIO $ handleIO' NoSuchThing (\_ -> pure Nothing) $ Just <$> readFile file
+  bs <- liftIO $ handleIO' NoSuchThing (\_ -> pure $ Nothing) $ fmap Just $ readFile file 
  case bs of
      Nothing -> pure defaultUserSettings
      Just bs' -> lE' JSONDecodeError . bimap show id . Y.decodeEither' . L.toStrict $ bs'
--- a/lib/GHCup/Utils/File.hs
+++ b/lib/GHCup/Utils/File.hs
@@ -407,32 +407,6 @@ searchPath paths needle = go paths
      else pure False


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

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

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

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

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

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

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

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

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

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

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

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

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