Merge branch 'settings' into master

Allow configuring URLSource as well
Improve help output
2020-10-26 18:25:20 +01:00 · 2020-10-25 14:47:26 +01:00 · 2020-10-25 11:00:00 +01:00 · 2020-10-25 10:54:04 +01:00 · 2020-10-25 10:22:45 +01:00 · 2020-10-25 10:22:35 +01:00
40 changed files with 22514 additions and 788 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -17,7 +17,7 @@ variables:
    BIT: "64"

 .alpine:64bit:
-  image: "alpine:edge"
+  image: "alpine:3.12"
  tags:
    - x86_64-linux
  variables:
@ -25,7 +25,7 @@ variables:
    BIT: "64"

 .alpine:32bit:
-  image: "i386/alpine:edge"
+  image: "i386/alpine:3.12"
  tags:
    - x86_64-linux
  variables:
@ -60,7 +60,12 @@ variables:
  script:
    - ./.gitlab/script/ghcup_version.sh
  variables:
-    JSON_VERSION: "0.0.2"
+    JSON_VERSION: "0.0.3"
+  artifacts:
+    expire_in: 2 week
+    paths:
+      - golden
+    when: on_failure

 .test_ghcup_version:linux:
  extends:
@ -102,6 +107,29 @@ variables:
  only:
    - tags

+######## stack test ########
+
+test:linux:stack:
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_minimal.sh
+  script:
+    - ./.gitlab/script/ghcup_stack.sh
+  extends:
+    - .debian
+
+######## bootstrap test ########
+
+test:linux:bootstrap_script:
+  before_script:
+    - ./.gitlab/before_script/linux/install_deps_minimal.sh
+  script:
+    - ./.gitlab/script/ghcup_bootstrap.sh
+  variables:
+    GHC_VERSION: "8.8.4"
+    CABAL_VERSION: "3.2.0.0"
+  extends:
+    - .debian
+
 ######## linux test ########

 test:linux:recommended:
--- a/.gitlab/before_script/linux/install_deps_minimal.sh
+++ b/.gitlab/before_script/linux/install_deps_minimal.sh
@ -0,0 +1,10 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../../ghcup_env"
+
+mkdir -p "${TMPDIR}"
+
+sudo apt-get update -y
+sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev git wget
--- a/.gitlab/script/ghcup_bootstrap.sh
+++ b/.gitlab/script/ghcup_bootstrap.sh
@ -0,0 +1,30 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+ecabal() {
+	cabal --store-dir="$(pwd)"/.store "$@"
+}
+
+eghcup() {
+	ghcup -v -c -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml "$@"
+}
+
+git describe --always
+
+### build
+
+ecabal update
+
+export BOOTSTRAP_HASKELL_NONINTERACTIVE=yes
+export BOOTSTRAP_HASKELL_GHC_VERSION=$GHC_VERSION
+export BOOTSTRAP_HASKELL_CABAL_VERSION=$CABAL_VERSION
+
+./bootstrap-haskell
+
+[ "$(ghc --numeric-version)" = "${GHC_VERSION}" ]
+
--- a/.gitlab/script/ghcup_stack.sh
+++ b/.gitlab/script/ghcup_stack.sh
@ -0,0 +1,21 @@
+#!/bin/sh
+
+set -eux
+
+. "$( cd "$(dirname "$0")" ; pwd -P )/../ghcup_env"
+
+mkdir -p "$CI_PROJECT_DIR"/.local/bin
+
+git describe --always
+
+### build
+
+curl -L -O https://get.haskellstack.org/stable/linux-x86_64.tar.gz
+tar xf linux-x86_64.tar.gz
+cp stack-*-linux-*/stack "$CI_PROJECT_DIR"/.local/bin/stack
+chmod +x "$CI_PROJECT_DIR"/.local/bin/stack
+
+mkdir -p "$CI_PROJECT_DIR"/.stack_root
+export TAR_OPTIONS=--no-same-owner
+stack --allow-different-user --stack-root "$CI_PROJECT_DIR"/.stack_root build
+stack --allow-different-user --stack-root "$CI_PROJECT_DIR"/.stack_root test
--- a/.gitlab/script/ghcup_version.sh
+++ b/.gitlab/script/ghcup_version.sh
@ -20,22 +20,28 @@ git describe --always

 ecabal update

+ecabal install -w ghc-${GHC_VERSION} --installdir="$CI_PROJECT_DIR"/.local/bin hspec-discover
+
 if [ "${OS}" = "DARWIN" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} -ftui
+	ecabal test -w ghc-${GHC_VERSION} -ftui ghcup-test
 elif [ "${OS}" = "LINUX" ] ; then
 	if [ "${BIT}" = "32" ] ; then
 		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar
+		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar ghcup-test
 	else
 		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
+		ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui ghcup-test
 	fi
 else
 	ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
+	ecabal test -w ghc-${GHC_VERSION} -finternal-downloader -ftui ghcup-test
 fi

 ecabal haddock -w ghc-${GHC_VERSION} -ftar

-cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --enable-tests --verbose=0 --offline sh -- -c 'command -v ghcup')" .
-cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --enable-tests --verbose=0 --offline sh -- -c 'command -v ghcup-gen')" .
+cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup')" .
+cp "$(ecabal new-exec -w ghc-${GHC_VERSION} --verbose=0 --offline sh -- -c 'command -v ghcup-gen')" .

 cp ./ghcup "$CI_PROJECT_DIR"/.local/bin/ghcup
 cp ./ghcup-gen "$CI_PROJECT_DIR"/.local/bin/ghcup-gen
@ -87,6 +93,18 @@ eghcup set ${GHC_VERSION}
 eghcup rm 8.4.4
 [ "$(ghc --numeric-version)" = "${ghc_ver}" ]

+# install hls
+if [ "${OS}" = "DARWIN" ] ; then
+	eghcup install hls
+	haskell-language-server-wrapper --version
+elif [ "${OS}" = "LINUX" ] ; then
+	if [ "${BIT}" = "64" ] ; then
+		eghcup install hls
+		haskell-language-server-wrapper --version
+	fi
+fi
+
+
 eghcup rm $(ghc --numeric-version)

 eghcup upgrade
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,5 +1,25 @@
 # Revision history for ghcup

+## 0.1.12 -- ????-??-??
+
+* improve TUI:
+  - separators between tools sections
+  - reverse list order so latest is on top
+  - expand the blues selected bar
+  - show new latest versions in bright white
+* allow configuration file and settings TUI hotkeys wrt #41
+
+## 0.1.11 -- 2020-09-23
+
+* Add support for installing haskell-language-server, wrt #65
+* When compiling GHC from source create a bindist first, store that bindist in `~/.ghcup/cache` and install it, wrt #51
+* Allow to compile over existing version (`ghcup compile ghc -v 8.6.5 -b 8.6.5`) and replace it wrt #59
+* simplify installing from custom bindist wrt #60
+  - `ghcup install ghc -u <url> <version>`
+* fix bug when cabal isn't marked executable in bindist
+* fix bug when `~/.ghcup` is a valid symlink wrt #49
+* Drop support for compiling cabal from source (the old bootstrap script is discontinued)
+
 ## 0.1.10 -- 2020-08-14

 * Show stray Cabals (useful for pre-releases or compiled ones)
--- a/README.md
+++ b/README.md
@ -13,6 +13,7 @@ Similar in scope to [rustup](https://github.com/rust-lang-nursery/rustup.rs), [p
     * [Manual install](#manual-install)
     * [Vim integration](#vim-integration)
   * [Usage](#usage)
+     * [Configuration](#configuration)
     * [Manpages](#manpages)
     * [Shell-completion](#shell-completion)
     * [Cross support](#cross-support)
@ -80,6 +81,13 @@ ghcup upgrade
 Generally this is meant to be used with [`cabal-install`](https://hackage.haskell.org/package/cabal-install), which
 handles your haskell packages and can demand that [a specific version](https://cabal.readthedocs.io/en/latest/nix-local-build.html#cfg-flag---with-compiler)  of `ghc` is available, which `ghcup` can do.

+### Configuration
+
+A configuration file can be put in `~/.ghcup/config.yaml`. The default config file
+explaining all possible configurations can be found in this repo: [config.yaml](./config.yaml).
+
+Partial configuration is fine. Command line options always overwrite the config file settings.
+
 ### Manpages

 For man pages to work you need [man-db](http://man-db.nongnu.org/) as your `man` provider, then issue `man ghc`. Manpages only work for the currently set ghc.
@ -120,11 +128,11 @@ Then you can control the locations via XDG environment variables as such:
 There are a couple of good use cases to install custom bindists:

 1. manually built bindists (e.g. with patches)
-  - example: `ghcup -n install ghc -u '{"dlHash": "", "dlSubdir": { "RegexDir": "ghc-.*"}, "dlUri": "file:///home/mearwald/tmp/ghc-eff-patches/ghc-8.10.2-x86_64-deb10-linux.tar.xz" }' 8.10.2-eff`
+  - example: `ghcup install ghc -u 'file:///home/mearwald/tmp/ghc-eff-patches/ghc-8.10.2-x86_64-deb10-linux.tar.xz' 8.10.2-eff`
 2. GHC head CI bindists
-  - example: `ghcup -n install ghc -u '{"dlHash": "", "dlSubdir": { "RegexDir": "ghc-.*"}, "dlUri": "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`
+  - example: `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`
 3. DWARF bindists
-  - example: `ghcup -c -n install ghc -u '{"dlHash": "", "dlSubdir": { "RegexDir": "ghc-.*"}, "dlUri": "https://downloads.haskell.org/~ghc/8.10.2/ghc-8.10.2-x86_64-deb10-linux-dwarf.tar.xz" }' 8.10.2-dwarf`
+  - example: `ghcup install ghc -u 'https://downloads.haskell.org/~ghc/8.10.2/ghc-8.10.2-x86_64-deb10-linux-dwarf.tar.xz' 8.10.2-dwarf`

 Since the version parser is pretty lax, `8.10.2-eff` and `head` are both valid versions
 and produce the binaries `ghc-8.10.2-eff` and `ghc-head` respectively.
@ -163,6 +171,17 @@ In addition this script can also install `cabal-install`.

 ## Known problems

+### Custom ghc version names
+
+When installing ghc bindists with custom version names as outlined in
+[installing custom bindists](#installing-custom-bindists), then cabal might
+be unable to find the correct `ghc-pkg` (also see [#73](https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/73))
+if you use `cabal build --with-compiler=ghc-foo`. Instead, point it to the full path, such as:
+`cabal build --with-compiler=$HOME/.ghcup/ghc/<version-name>/bin/ghc` or set that GHC version
+as the current one via: `ghcup set ghc <version-name>`.
+
+This problem doesn't exist for regularly installed GHC versions.
+
 ### Limited distributions supported

 Currently only GNU/Linux distributions compatible with the [upstream GHC](https://www.haskell.org/ghc/download_ghc_8_6_1.html#binaries) binaries are supported.
--- a/app/ghcup-gen/Validate.hs
+++ b/app/ghcup-gen/Validate.hs
@ -55,7 +55,7 @@ validate :: (Monad m, MonadLogger m, MonadThrow m, MonadIO m, MonadUnliftIO m)
 validate dls = do
  ref <- liftIO $ newIORef 0

-  -- * verify binary downloads * --
+  -- verify binary downloads --
  flip runReaderT ref $ do
    -- unique tags
    forM_ (M.toList dls) $ \(t, _) -> checkUniqueTags t
@ -122,6 +122,7 @@ validate dls = do
   where
    isUniqueTag Latest         = True
    isUniqueTag Recommended    = True
+    isUniqueTag Old            = False
    isUniqueTag Prerelease     = False
    isUniqueTag (Base       _) = False
    isUniqueTag (UnknownTag _) = False
@ -192,7 +193,7 @@ validateTarballs dls = do
 where
  downloadAll dli = do
    dirs <- liftIO getDirs
-    let settings = Settings True False Never Curl False dirs
+    let settings = AppState (Settings True False Never Curl False GHCupURL) dirs defaultKeyBindings
    let runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
                                           , colorOutter  = B.hPut stderr
                                           , rawOutter    = (\_ -> pure ())
--- a/app/ghcup/BrickMain.hs
+++ b/app/ghcup/BrickMain.hs
@ -1,9 +1,11 @@
 {-# LANGUAGE CPP               #-}
 {-# LANGUAGE DataKinds         #-}
-{-# LANGUAGE QuasiQuotes       #-}
-{-# LANGUAGE TypeApplications  #-}
-{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE FlexibleContexts  #-}
 {-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes       #-}
+{-# LANGUAGE TemplateHaskell   #-}
+{-# LANGUAGE TypeApplications  #-}
+{-# LANGUAGE ViewPatterns      #-}

 module BrickMain where

@ -19,7 +21,10 @@ import           Brick
 import           Brick.Widgets.Border
 import           Brick.Widgets.Border.Style
 import           Brick.Widgets.Center
-import           Brick.Widgets.List
+import           Brick.Widgets.List             ( listSelectedFocusedAttr
+                                                , listSelectedAttr
+                                                , listAttr
+                                                )
 #if !defined(TAR)
 import           Codec.Archive
 #endif
@ -31,10 +36,11 @@ import           Data.Bool
 import           Data.Functor
 import           Data.List
 import           Data.Maybe
-import           Data.Char
 import           Data.IORef
 import           Data.String.Interpolate
-import           Data.Vector                    ( Vector )
+import           Data.Vector                    ( Vector
+                                                , (!?)
+                                                )
 import           Data.Versions           hiding ( str )
 import           Haskus.Utils.Variant.Excepts
 import           Prelude                 hiding ( appendFile )
@ -47,43 +53,94 @@ import qualified Graphics.Vty                  as Vty
 import qualified Data.Vector                   as V


-data AppState = AppState {
-    lr :: LR
-  , dls :: GHCupDownloads
+
+data BrickData = BrickData
+  { lr    :: [ListResult]
+  , dls   :: GHCupDownloads
  , pfreq :: PlatformRequest
-}
+  }
+  deriving Show

-type LR = GenericList String Vector ListResult
+data BrickSettings = BrickSettings
+  { showAll :: Bool
+  }
+  deriving Show
+
+data BrickInternalState = BrickInternalState
+  { clr :: Vector ListResult
+  , ix  :: Int
+  }
+  deriving Show
+
+data BrickState = BrickState
+  { appData     :: BrickData
+  , appSettings :: BrickSettings
+  , appState    :: BrickInternalState
+  , appKeys     :: KeyBindings
+  }
+  deriving Show


-keyHandlers :: [(Char, String, AppState -> EventM n (Next AppState))]
-keyHandlers =
-  [ ('q', "Quit"     , halt)
-  , ('i', "Install"  , withIOAction install')
-  , ('u', "Uninstall", withIOAction del')
-  , ('s', "Set"      , withIOAction set')
-  , ('c', "ChangeLog", withIOAction changelog')
+keyHandlers :: KeyBindings
+            -> [ ( Vty.Key
+                 , BrickSettings -> String
+                 , BrickState -> EventM n (Next BrickState)
+                 )
+               ]
+keyHandlers KeyBindings {..} =
+  [ (bQuit, const "Quit"     , halt)
+  , (bInstall, const "Install"  , withIOAction install')
+  , (bUninstall, const "Uninstall", withIOAction del')
+  , (bSet, const "Set"      , withIOAction set')
+  , (bChangelog, const "ChangeLog", withIOAction changelog')
+  , ( bShowAll
+    , (\BrickSettings {..} ->
+        if showAll then "Hide old versions" else "Show all versions"
+      )
+    , hideShowHandler
+    )
+  , (bUp, const "Up", \BrickState {..} -> continue (BrickState { appState = (moveCursor 1 appState Up), .. }))
+  , (bDown, const "Down", \BrickState {..} -> continue (BrickState { appState = (moveCursor 1 appState Down), .. }))
  ]
+ where
+  hideShowHandler (BrickState {..}) =
+    let newAppSettings   = appSettings { showAll = not . showAll $ appSettings }
+        newInternalState = constructList appData newAppSettings (Just appState)
+    in  continue (BrickState appData newAppSettings newInternalState appKeys)


-ui :: AppState -> Widget String
-ui AppState {..} =
-  ( padBottom Max
+showKey :: Vty.Key -> String
+showKey (Vty.KChar c) = [c]
+showKey (Vty.KUp) = "↑"
+showKey (Vty.KDown) = "↓"
+showKey key = tail (show key)
+
+
+ui :: BrickState -> Widget String
+ui BrickState { appSettings = as@(BrickSettings {}), ..}
+  = ( padBottom Max
    $ ( withBorderStyle unicode
      $ borderWithLabel (str "GHCup")
-      $ (center $ renderList renderItem True lr)
+      $ (center $ (header <=> hBorder <=> renderList' appState))
      )
    )
-    <=> ( withAttr "help"
-        . txtWrap
-        . T.pack
-        . foldr1 (\x y -> x <> "  " <> y)
-        . (++ ["↑↓:Navigation"])
-        $ (fmap (\(c, s, _) -> (c : ':' : s)) keyHandlers)
-        )
+    <=> footer

 where
-  renderItem b ListResult {..} =
+  footer =
+    withAttr "help"
+      . txtWrap
+      . T.pack
+      . foldr1 (\x y -> x <> "  " <> y)
+      $ (fmap (\(key, s, _) -> (showKey key <> ":" <> s as)) $ keyHandlers appKeys)
+  header =
+    (minHSize 2 $ emptyWidget)
+      <+> (padLeft (Pad 2) $ minHSize 6 $ str "Tool")
+      <+> (minHSize 15 $ str "Version")
+      <+> (padLeft (Pad 1) $ minHSize 25 $ str "Tags")
+      <+> (padLeft (Pad 5) $ str "Notes")
+  renderList' = withDefAttr listAttr . drawListElements renderItem True
+  renderItem _ b listResult@(ListResult {..}) =
    let marks = if
          | lSet       -> (withAttr "set" $ str "✔✔")
          | lInstalled -> (withAttr "installed" $ str "✓ ")
@ -94,34 +151,93 @@ ui AppState {..} =
        dim = if lNoBindist
          then updateAttrMap (const dimAttributes) . withAttr "no-bindist"
          else id
-    in  dim
+        hooray
+          | elem Latest lTag && not lInstalled =
+              withAttr "hooray"
+          | otherwise = id
+        active = if b then forceAttr "active" else id
+    in  hooray $ active $ dim
          (   marks
-          <+> ( padLeft (Pad 2)
-              $ minHSize 20
-              $ ((if b then withAttr "active" else id)
-                  (str $ (fmap toLower . show $ lTool) <> " " <> ver)
-                )
+          <+> (( padLeft (Pad 2)
+               $ minHSize 6
+               $ (printTool lTool)
+               )
              )
-          <+> (padLeft (Pad 1) $ if null lTag
-                then emptyWidget
-                else
-                  foldr1 (\x y -> x <+> str "," <+> y)
-                    $ (fmap printTag $ sort lTag)
+          <+> (minHSize 15 $ (str ver))
+          <+> (let l = catMaybes . fmap printTag $ sort lTag
+               in  padLeft (Pad 1) $ minHSize 25 $ if null l
+                     then emptyWidget
+                     else foldr1 (\x y -> x <+> str "," <+> y) l
              )
+          <+> ( padLeft (Pad 5)
+              $ let notes = printNotes listResult
+                in  if null notes
+                      then emptyWidget
+                      else foldr1 (\x y -> x <+> str "," <+> y) $ notes
+              )
+          <+> (vLimit 1 $ fill ' ')
          )

-  printTag Recommended        = withAttr "recommended" $ str "recommended"
-  printTag Latest             = withAttr "latest" $ str "latest"
-  printTag Prerelease         = withAttr "prerelease" $ str "prerelease"
-  printTag (Base       pvp'') = str ("base-" ++ T.unpack (prettyPVP pvp''))
-  printTag (UnknownTag t    ) = str t
+  printTag Recommended    = Just $ withAttr "recommended" $ str "recommended"
+  printTag Latest         = Just $ withAttr "latest" $ str "latest"
+  printTag Prerelease     = Just $ withAttr "prerelease" $ str "prerelease"
+  printTag (Base pvp'')   = Just $ str ("base-" ++ T.unpack (prettyPVP pvp''))
+  printTag Old            = Nothing
+  printTag (UnknownTag t) = Just $ str t
+
+  printTool Cabal = str "cabal"
+  printTool GHC = str "GHC"
+  printTool GHCup = str "GHCup"
+  printTool HLS = str "HLS"
+
+  printNotes ListResult {..} =
+    (if hlsPowered then [withAttr "hls-powered" $ str "hls-powered"] else mempty
+      )
+      ++ (if fromSrc then [withAttr "compiled" $ str "compiled"] else mempty)
+      ++ (if lStray then [withAttr "stray" $ str "stray"] else mempty)
+
+  -- | Draws the list elements.
+  --
+  -- Evaluates the underlying container up to, and a bit beyond, the
+  -- selected element. The exact amount depends on available height
+  -- for drawing and 'listItemHeight'. At most, it will evaluate up to
+  -- element @(i + h + 1)@ where @i@ is the selected index and @h@ is the
+  -- available height.
+  drawListElements :: (Int -> Bool -> ListResult -> Widget String)
+                   -> Bool
+                   -> BrickInternalState
+                   -> Widget String
+  drawListElements drawElem foc is@(BrickInternalState clr _) =
+    Widget Greedy Greedy $
+      let
+        es = clr
+        listSelected        = fmap fst $ listSelectedElement' is
+
+        drawnElements = flip V.imap es $ \i' e ->
+          let addSeparator w = case es !? (i' - 1) of
+                Just e' | lTool e' /= lTool e ->
+                  hBorder <=> w
+                _                             -> w
+
+              isSelected  = Just i' == listSelected
+              elemWidget  = drawElem i' isSelected e
+              selItemAttr = if foc
+                then withDefAttr listSelectedFocusedAttr
+                else withDefAttr listSelectedAttr
+              makeVisible = if isSelected then visible . selItemAttr else id
+          in  addSeparator $ makeVisible elemWidget
+
+      in render
+        $ viewport "GHCup" Vertical
+        $ vBox
+        $ V.toList drawnElements


 minHSize :: Int -> Widget n -> Widget n
 minHSize s' = hLimit s' . vLimit 1 . (<+> fill ' ')


-app :: App AppState e String
+app :: App BrickState e String
 app = App { appDraw         = \st -> [ui st]
          , appHandleEvent  = eventHandler
          , appStartEvent   = return
@ -137,9 +253,13 @@ defaultAttributes = attrMap
  , ("set"          , Vty.defAttr `Vty.withForeColor` Vty.green)
  , ("installed"    , Vty.defAttr `Vty.withForeColor` Vty.green)
  , ("recommended"  , Vty.defAttr `Vty.withForeColor` Vty.green)
+  , ("hls-powered"  , Vty.defAttr `Vty.withForeColor` Vty.green)
  , ("latest"       , Vty.defAttr `Vty.withForeColor` Vty.yellow)
  , ("prerelease"   , Vty.defAttr `Vty.withForeColor` Vty.red)
+  , ("compiled"     , Vty.defAttr `Vty.withForeColor` Vty.blue)
+  , ("stray"        , Vty.defAttr `Vty.withForeColor` Vty.blue)
  , ("help"         , Vty.defAttr `Vty.withStyle` Vty.italic)
+  , ("hooray"       , Vty.defAttr `Vty.withForeColor` Vty.brightWhite)
  ]


@ -151,78 +271,144 @@ dimAttributes = attrMap
  ]


+eventHandler :: BrickState -> BrickEvent n e -> EventM n (Next BrickState)
+eventHandler st@(BrickState {..}) ev = do
+  AppState { keyBindings = kb } <- liftIO $ readIORef settings'
+  case ev of
+    (MouseDown _ Vty.BScrollUp _ _) ->
+      continue (BrickState { appState = moveCursor 1 appState Up, .. })
+    (MouseDown _ Vty.BScrollDown _ _) ->
+      continue (BrickState { appState = moveCursor 1 appState Down, .. })
+    (VtyEvent (Vty.EvResize _ _)) -> continue st
+    (VtyEvent (Vty.EvKey Vty.KUp _)) ->
+      continue (BrickState { appState = (moveCursor 1 appState Up), .. })
+    (VtyEvent (Vty.EvKey Vty.KDown _)) ->
+      continue (BrickState { appState = (moveCursor 1 appState Down), .. })
+    (VtyEvent (Vty.EvKey key _)) ->
+      case find (\(key', _, _) -> key' == key) (keyHandlers kb) of
+        Nothing -> continue st
+        Just (_, _, handler) -> handler st
+    _ -> continue st

-eventHandler :: AppState -> BrickEvent n e -> EventM n (Next AppState)
-eventHandler st (VtyEvent (Vty.EvResize _               _)) = continue st
-eventHandler st (VtyEvent (Vty.EvKey    (Vty.KChar 'q') _)) = halt st
-eventHandler st (VtyEvent (Vty.EvKey    Vty.KEsc        _)) = halt st
-eventHandler AppState {..} (VtyEvent (Vty.EvKey (Vty.KUp) _)) =
-  continue (AppState (listMoveUp lr) dls pfreq)
-eventHandler AppState {..} (VtyEvent (Vty.EvKey (Vty.KDown) _)) =
-  continue (AppState (listMoveDown lr) dls pfreq)
-eventHandler as (VtyEvent (Vty.EvKey (Vty.KChar c) _)) =
-  case find (\(c', _, _) -> c' == c) keyHandlers of
-    Nothing              -> continue as
-    Just (_, _, handler) -> handler as
-eventHandler st _ = continue st
+
+moveCursor :: Int -> BrickInternalState -> Direction -> BrickInternalState
+moveCursor steps ais@(BrickInternalState {..}) direction =
+  let newIx = if direction == Down then ix + steps else ix - steps
+  in  case clr !? newIx of
+        Just _  -> BrickInternalState { ix = newIx, .. }
+        Nothing -> ais


 -- | Suspend the current UI and run an IO action in terminal. If the
 -- IO action returns a Left value, then it's thrown as userError.
-withIOAction :: (AppState -> (Int, ListResult) -> IO (Either String a))
-             -> AppState
-             -> EventM n (Next AppState)
-withIOAction action as = case listSelectedElement (lr as) of
+withIOAction :: (BrickState -> (Int, ListResult) -> IO (Either String a))
+             -> BrickState
+             -> EventM n (Next BrickState)
+withIOAction action as = case listSelectedElement' (appState as) of
  Nothing      -> continue as
  Just (ix, e) -> suspendAndResume $ do
    action as (ix, e) >>= \case
      Left  err -> putStrLn $ ("Error: " <> err)
      Right _   -> putStrLn "Success"
-    apps <- (fmap . fmap)
-      (\AppState {..} -> AppState { lr = listMoveTo ix lr, .. })
-      $ getAppState Nothing (pfreq as)
-    case apps of
-      Right nas -> do
+    getAppData Nothing (pfreq . appData $ as) >>= \case
+      Right data' -> do
        putStrLn "Press enter to continue"
        _ <- getLine
-        pure nas
+        pure (updateList data' as)
      Left err -> throwIO $ userError err


-install' :: AppState -> (Int, ListResult) -> IO (Either String ())
-install' AppState {..} (_, ListResult {..}) = do
+-- | Update app data and list internal state based on new evidence.
+-- This synchronises @BrickInternalState@ with @BrickData@
+-- and @BrickSettings@.
+updateList :: BrickData -> BrickState -> BrickState
+updateList appD (BrickState {..}) =
+  let newInternalState = constructList appD appSettings (Just appState)
+  in  BrickState { appState    = newInternalState
+                 , appData     = appD
+                 , appSettings = appSettings
+                 , appKeys     = appKeys
+                 }
+
+
+constructList :: BrickData
+              -> BrickSettings
+              -> Maybe BrickInternalState
+              -> BrickInternalState
+constructList appD appSettings mapp =
+  replaceLR (filterVisible (showAll appSettings)) (lr appD) mapp
+
+listSelectedElement' :: BrickInternalState -> Maybe (Int, ListResult)
+listSelectedElement' (BrickInternalState {..}) = fmap (ix, ) $ clr !? ix
+
+
+selectLatest :: Vector ListResult -> Int
+selectLatest v =
+  case V.findIndex (\ListResult {..} -> lTool == GHC && Latest `elem` lTag) v of
+    Just ix -> ix
+    Nothing -> 0
+
+
+-- | Replace the @appState@ or construct it based on a filter function
+-- and a new @[ListResult]@ evidence.
+-- When passed an existing @appState@, tries to keep the selected element.
+replaceLR :: (ListResult -> Bool)
+          -> [ListResult]
+          -> Maybe BrickInternalState
+          -> BrickInternalState
+replaceLR filterF lr s =
+  let oldElem = s >>= listSelectedElement'
+      newVec  = V.fromList . filter filterF $ lr
+      newSelected =
+        case oldElem >>= \(_, oldE) -> V.findIndex (toolEqual oldE) newVec of
+          Just ix -> ix
+          Nothing -> selectLatest newVec
+  in  BrickInternalState newVec newSelected
+ where
+  toolEqual e1 e2 =
+    lTool e1 == lTool e2 && lVer e1 == lVer e2 && lCross e1 == lCross e2
+
+
+filterVisible :: Bool -> ListResult -> Bool
+filterVisible showAll e | lInstalled e = True
+                        | showAll      = True
+                        | otherwise    = not (elem Old (lTag e))
+
+
+install' :: BrickState -> (Int, ListResult) -> IO (Either String ())
+install' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
  settings <- readIORef settings'
  l        <- readIORef logger'
  let runLogger = myLoggerT l

-  let
-    run =
-      runLogger
-        . flip runReaderT settings
-        . runResourceT
-        . runE
-          @'[AlreadyInstalled
-            , UnknownArchive
+  let run =
+        runLogger
+          . flip runReaderT settings
+          . runResourceT
+          . runE
+            @'[ AlreadyInstalled
 #if !defined(TAR)
-            , ArchiveResult
+              , ArchiveResult
 #endif
-            , FileDoesNotExistError
-            , CopyError
-            , NoDownload
-            , NotInstalled
-            , BuildFailed
-            , TagNotFound
-            , DigestError
-            , DownloadFailed
-            , NoUpdate
-            , TarDirDoesNotExist
-            ]
+              , UnknownArchive
+              , FileDoesNotExistError
+              , CopyError
+              , NoDownload
+              , NotInstalled
+              , BuildFailed
+              , TagNotFound
+              , DigestError
+              , DownloadFailed
+              , NoUpdate
+              , TarDirDoesNotExist
+              ]

  (run $ do
      case lTool of
        GHC   -> liftE $ installGHCBin dls lVer pfreq
        Cabal -> liftE $ installCabalBin dls lVer pfreq
        GHCup -> liftE $ upgradeGHCup dls Nothing False pfreq $> ()
+        HLS   -> liftE $ installHLSBin dls lVer pfreq $> ()
    )
    >>= \case
          VRight _                          -> pure $ Right ()
@ -236,7 +422,7 @@ install' AppState {..} (_, ListResult {..}) = do
 Also check the logs in ~/.ghcup/logs|]


-set' :: AppState -> (Int, ListResult) -> IO (Either String ())
+set' :: BrickState -> (Int, ListResult) -> IO (Either String ())
 set' _ (_, ListResult {..}) = do
  settings <- readIORef settings'
  l        <- readIORef logger'
@ -245,12 +431,13 @@ set' _ (_, ListResult {..}) = do
  let run =
        runLogger
          . flip runReaderT settings
-          . runE @'[FileDoesNotExistError, NotInstalled, TagNotFound]
+          . runE @'[FileDoesNotExistError , NotInstalled , TagNotFound]

  (run $ do
      case lTool of
        GHC   -> liftE $ setGHC (GHCTargetVersion lCross lVer) SetGHCOnly $> ()
        Cabal -> liftE $ setCabal lVer $> ()
+        HLS   -> liftE $ setHLS lVer $> ()
        GHCup -> pure ()
    )
    >>= \case
@ -258,7 +445,7 @@ set' _ (_, ListResult {..}) = do
          VLeft  e -> pure $ Left [i|#{e}|]


-del' :: AppState -> (Int, ListResult) -> IO (Either String ())
+del' :: BrickState -> (Int, ListResult) -> IO (Either String ())
 del' _ (_, ListResult {..}) = do
  settings <- readIORef settings'
  l        <- readIORef logger'
@ -270,6 +457,7 @@ del' _ (_, ListResult {..}) = do
      case lTool of
        GHC   -> liftE $ rmGHCVer (GHCTargetVersion lCross lVer) $> ()
        Cabal -> liftE $ rmCabalVer lVer $> ()
+        HLS   -> liftE $ rmHLSVer lVer $> ()
        GHCup -> pure ()
    )
    >>= \case
@ -277,16 +465,16 @@ del' _ (_, ListResult {..}) = do
          VLeft  e -> pure $ Left [i|#{e}|]


-changelog' :: AppState -> (Int, ListResult) -> IO (Either String ())
-changelog' AppState {..} (_, ListResult {..}) = do
+changelog' :: BrickState -> (Int, ListResult) -> IO (Either String ())
+changelog' BrickState { appData = BrickData {..} } (_, ListResult {..}) = do
  case getChangeLog dls lTool (Left lVer) of
    Nothing -> pure $ Left
      [i|Could not find ChangeLog for #{lTool}, version #{prettyVer lVer}|]
    Just uri -> do
      let cmd = case _rPlatform pfreq of
-                  Darwin  -> "open"
-                  Linux _ -> "xdg-open"
-                  FreeBSD -> "xdg-open"
+            Darwin  -> "open"
+            Linux _ -> "xdg-open"
+            FreeBSD -> "xdg-open"
      exec cmd True [serializeURIRef' uri] Nothing Nothing >>= \case
        Right _ -> pure $ Right ()
        Left  e -> pure $ Left [i|#{e}|]
@ -297,17 +485,21 @@ uri' :: IORef (Maybe URI)
 uri' = unsafePerformIO (newIORef Nothing)


-settings' :: IORef Settings
+settings' :: IORef AppState
 {-# NOINLINE settings' #-}
 settings' = unsafePerformIO $ do
  dirs <- getDirs
-  newIORef Settings { cache      = True
-                     , noVerify   = False
-                     , keepDirs   = Never
-                     , downloader = Curl
-                     , verbose    = False
-                     , ..
-                     }
+  newIORef $ AppState (Settings { cache      = True
+                                , noVerify   = False
+                                , keepDirs   = Never
+                                , downloader = Curl
+                                , verbose    = False
+                                , urlSource  = GHCupURL
+                                , ..
+                                })
+                      dirs
+                      defaultKeyBindings
+


 logger' :: IORef LoggerConfig
@ -320,7 +512,12 @@ logger' = unsafePerformIO
  )


-brickMain :: Settings -> Maybe URI -> LoggerConfig -> GHCupDownloads -> PlatformRequest -> IO ()
+brickMain :: AppState
+          -> Maybe URI
+          -> LoggerConfig
+          -> GHCupDownloads
+          -> PlatformRequest
+          -> IO ()
 brickMain s muri l av pfreq' = do
  writeIORef uri'      muri
  writeIORef settings' s
@ -328,23 +525,29 @@ brickMain s muri l av pfreq' = do
  writeIORef logger'   l
  let runLogger = myLoggerT l

-  eApps <- getAppState (Just av) pfreq'
-  case eApps of
-    Right as -> defaultMain app (selectLatest as) $> ()
-    Left  e  -> do
+  eAppData <- getAppData (Just av) pfreq'
+  case eAppData of
+    Right ad ->
+      defaultMain
+          app
+          (BrickState ad
+                    defaultAppSettings
+                    (constructList ad defaultAppSettings Nothing)
+                    (keyBindings s)
+
+          )
+        $> ()
+    Left e -> do
      runLogger ($(logError) [i|Error building app state: #{show e}|])
      exitWith $ ExitFailure 2
- where
-  selectLatest :: AppState -> AppState
-  selectLatest AppState {..} =
-    (\ix -> AppState { lr = listMoveTo ix lr, .. })
-      . fromJust
-      . V.findIndex (\ListResult {..} -> lTool == GHC && Latest `elem` lTag)
-      $ (listElements lr)


-getAppState :: Maybe GHCupDownloads -> PlatformRequest -> IO (Either String AppState)
-getAppState mg pfreq' = do
+defaultAppSettings :: BrickSettings
+defaultAppSettings = BrickSettings { showAll = False }
+
+
+getDownloads' :: IO (Either String GHCupDownloads)
+getDownloads' = do
  muri     <- readIORef uri'
  settings <- readIORef settings'
  l        <- readIORef logger'
@ -353,14 +556,30 @@ getAppState mg pfreq' = do
  r <-
    runLogger
    . flip runReaderT settings
-    . runE
-      @'[JSONError, DownloadFailed, FileDoesNotExistError]
-    $ do
-        dls <- maybe (fmap _ghcupDownloads $ liftE $ getDownloadsF (maybe GHCupURL OwnSource muri)) pure mg
-
-        lV <- lift $ listVersions dls Nothing Nothing pfreq'
-        pure $ (AppState (list "Tool versions" (V.fromList lV) 1) dls pfreq')
+    . runE @'[JSONError , DownloadFailed , FileDoesNotExistError]
+    $ fmap _ghcupDownloads
+    $ liftE
+    $ getDownloadsF (maybe GHCupURL OwnSource muri)

  case r of
    VRight a -> pure $ Right a
    VLeft  e -> pure $ Left [i|#{e}|]
+
+
+getAppData :: Maybe GHCupDownloads
+           -> PlatformRequest
+           -> IO (Either String BrickData)
+getAppData mg pfreq' = do
+  settings <- readIORef settings'
+  l        <- readIORef logger'
+  let runLogger = myLoggerT l
+
+  r <- maybe getDownloads' (pure . Right) mg
+
+  runLogger . flip runReaderT settings $ do
+    case r of
+      Right dls -> do
+        lV <- listVersions dls Nothing Nothing pfreq'
+        pure $ Right $ (BrickData (reverse lV) dls pfreq')
+      Left e -> pure $ Left [i|#{e}|]
+
--- a/app/ghcup/Main.hs
+++ b/app/ghcup/Main.hs
--- a/40
+++ b/40
@ -59,7 +59,7 @@ _done() {
 download_ghcup() {
 	_plat="$(uname -s)"
 	_arch=$(uname -m)
-	_ghver="0.1.10"
+	_ghver="0.1.11"
 	_base_url="https://downloads.haskell.org/~ghcup"

    case "${_plat}" in
@ -188,7 +188,30 @@ printf "\\033[0;35m%s\\033[0m\\n" ""
 printf "\\033[0;35m%s\\033[0m\\n" "Installation done!"
 printf "\\033[0;35m%s\\033[0m\\n" ""

+
 if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
+	printf "\\033[0;35m%s\\033[0m\\n" "Do you want to install haskell-language-server (HLS) now?"
+	printf "\\033[0;35m%s\\033[0m\\n" "HLS is a language-server that provides IDE-like functionality"
+	printf "\\033[0;35m%s\\033[0m\\n" "and can integrate with different editors, such as Vim, Emacs, VS Code, Atom, ..."
+	printf "\\033[0;35m%s\\033[0m\\n" "Also see https://github.com/haskell/haskell-language-server/blob/master/README.md"
+	printf "\\033[0;35m%s\\033[0m\\n" ""
+	printf "\\033[0;35m%s\\033[0m\\n" "Answer with YES or NO and press ENTER."
+	printf "\\033[0;35m%s\\033[0m\\n" ""
+
+	while true; do
+		read -r hls_answer </dev/tty
+
+		case $hls_answer in
+			[Yy]*)
+				eghcup --cache install hls
+				break ;;
+			[Nn]*)
+				break ;;
+			*)
+				echo "Please type YES or NO and press enter.";;
+		esac
+	done
+
    echo "In order to run ghc and cabal, you need to adjust your PATH variable."
    echo "You may want to source '$GHCUP_DIR/env' in your shell"
    echo "configuration to do so (e.g. ~/.bashrc)."
@ -238,7 +261,20 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
 							echo "test -f $GHCUP_DIR/env ; and set -gx PATH \$HOME/.cabal/bin $GHCUP_BIN \$PATH" >> "${GHCUP_PROFILE_FILE}"
 						fi
 						break ;;
-					*)
+					bash)
+						if ! grep -q "ghcup-env" "${GHCUP_PROFILE_FILE}" ; then
+							echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
+						fi
+						case "$(uname -s)" in
+							"Darwin"|"darwin")
+								if ! grep -q "ghcup-env" "${HOME}/.bash_profile" ; then
+									echo "[[ -f ~/.bashrc ]] && source ~/.bashrc # ghcup-env" >> "${HOME}/.bash_profile"
+								fi
+								;;
+						esac
+						break ;;
+
+					zsh)
 						if ! grep -q "ghcup-env" "${GHCUP_PROFILE_FILE}" ; then
 							echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
 						fi
--- a/cabal.ghc884.project
+++ b/cabal.ghc884.project
@ -0,0 +1,47 @@
+-- Generated by stackage-to-hackage
+
+index-state: 2020-10-24T20:53:55Z
+
+with-compiler: ghc-8.8.4
+
+packages:
+    ./
+  , 3rdparty/lzma/
+  , 3rdparty/lzma-clib/
+  , 3rdparty/zlib/
+
+source-repository-package
+    type: git
+    location: https://github.com/haskus/packages.git
+    tag: 80a1c5fc07f7226c424250ec17f674cd4d618f42
+    subdir: haskus-utils-types
+
+source-repository-package
+    type: git
+    location: https://github.com/hasufell/hpath.git
+    tag: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
+    subdir: hpath-directory
+            hpath-io
+
+source-repository-package
+    type: git
+    location: https://github.com/hasufell/text-conversions.git
+    tag: 9abf0e5e5664a3178367597c32db19880477a53c
+
+allow-older: *
+allow-newer: *
+
+package lzma
+    ghc-options: -O2
+
+package lzma-clib
+    ghc-options: -O2
+
+package zlib
+    ghc-options: -O2
+
+package ghcup
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+
+package streamly
+    ghc-options: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
--- a/cabal.ghc884.project.freeze
+++ b/cabal.ghc884.project.freeze
--- a/cabal.project
+++ b/cabal.project
@ -8,6 +8,18 @@ source-repository-package
    tag: 80a1c5fc07f7226c424250ec17f674cd4d618f42
    subdir: haskus-utils-types

+source-repository-package
+    type: git
+    location: https://github.com/hasufell/hpath.git
+    tag: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
+    subdir: hpath-io
+
+source-repository-package
+    type: git
+    location: https://github.com/hasufell/hpath.git
+    tag: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
+    subdir: hpath-directory
+
 optimization: 2

 package streamly
--- a/config.yaml
+++ b/config.yaml
@ -0,0 +1,61 @@
+# Cache downloads in ~/.ghcup/cache
+cache: False
+# Skip tarball checksum verification
+no-verify: False
+# enable verbosity
+verbose: False
+# When to keep build directories
+keep-dirs: Errors  # Always | Never | Errors
+# Which downloader to use
+downloader: Curl   # Curl | Wget | Internal
+
+# TUI key bindings,
+# see https://hackage.haskell.org/package/vty-5.31/docs/Graphics-Vty-Input-Events.html#t:Key
+# for possible values.
+key-bindings:
+  up:
+    KUp: []
+  down:
+    KDown: []
+  quit:
+    KChar: 'q'
+  install:
+    KChar: 'i'
+  uninstall:
+    KChar: 'u'
+  set:
+    KChar: 's'
+  changelog:
+    KChar: 'c'
+  show-all:
+    KChar: 'a'
+
+# Where to get GHC/cabal/hls download info/versions from. For more detailed explanation
+# check the 'URLSource' type in the code.
+url-source:
+  ## Use the internal download uri, this is the default
+  GHCupURL: []
+
+  ## Example 1: Read download info from this location instead
+  ## Accepts file/http/https scheme
+  # OwnSource: "file:///home/jule/git/ghcup-hs/ghcup-0.0.3.yaml"
+
+  ## Example 2: Add custom tarballs to the default downloads, overwriting duplicate versions
+  # AddSource:
+    # Left:
+      # toolRequirements: {} # this is ignored
+      # ghcupDownloads:
+        # GHC:
+          # 9.10.2:
+            # viTags: []
+            # viArch:
+              # A_64:
+                # Linux_UnknownLinux:
+                  # unknown_versioning:
+                    # dlUri: https://downloads.haskell.org/~ghc/7.10.3/ghc-7.10.3-x86_64-deb8-linux.tar.bz2
+                    # dlSubdir: ghc-7.10.3
+                    # dlHash: 01cfbad8dff1e8b34a5fdca8caeaf843b56e36af919e29cd68870d2588563db5
+
+  ## Example 3: Add a custom download file to the default downloads, overwriting duplicate versions
+  # AddSource:
+    # Right: "file:///home/jule/git/ghcup-hs/ghcup-custom.yaml"
--- a/ghcup-0.0.2.yaml
+++ b/ghcup-0.0.2.yaml
@ -1193,86 +1193,10 @@ ghcupDownloads:
              dlUri: https://files.hasufell.de/ghc/ghc-8.10.2-i386-alpine-linux.tar.xz
              dlSubdir: ghc-8.10.2
              dlHash: 9ee1cf1e85e9536088b3c9e80e975074e525ea378cd4eb156071bbc4b7b38327
-    9.0.1-alpha1:
-      viTags:
-      - Prerelease
-      - base-4.15.0.0
-      viSourceDL:
-        dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200821-src.tar.xz
-        dlSubdir: ghc-9.0.0.20200821
-        dlHash: 8a3a36a0d770dbe678dbc084c3cc9a426749ac9d695f34fa30dc4da1564be6cb
-      viArch:
-        A_64:
-          Linux_Debian:
-            '9': &ghc-901a1-64-deb9
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200821-x86_64-deb9-linux.tar.xz
-              dlSubdir: ghc-9.0.0
-              dlHash: a58b508e5d9f85a5831c7e451766105c4b2188987b3110ac62c8182e3e6ed0f6
-            '10': &ghc-901a1-64-deb10
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200821-x86_64-deb10-linux-dwarf.tar.xz
-              dlSubdir: ghc-9.0.0
-              dlHash: 963d4cef71780f24d23cd947d33f61e9ee338f85e2aed06ec588fdb8be339a04
-            unknown_versioning: *ghc-901a1-64-deb9
-          Linux_Ubuntu:
-            unknown_versioning: &ghc-901a1-64-fedora
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200821-x86_64-fedora27-linux.tar.xz
-              dlSubdir: ghc-9.0.0
-              dlHash: e6c241d7945fe84e03501c8a9b947a5f50ad489cdf2b6e286d5de76046a8a6f3
-            '16.04': *ghc-901a1-64-deb9
-            '18.04': *ghc-901a1-64-deb9
-          Linux_Mint:
-            unknown_versioning: *ghc-901a1-64-deb10
-          Linux_Fedora:
-            '27': *ghc-901a1-64-fedora
-            unknown_versioning: *ghc-901a1-64-fedora
-          Linux_CentOS:
-            '7': &ghc-901a1-64-centos
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200821-x86_64-centos7-linux.tar.xz
-              dlSubdir: ghc-9.0.0
-              dlHash: e9be471727d6753514667781335018be0fed91483bf80da3f24d21c2e49086e9
-            unknown_versioning: *ghc-901a1-64-centos
-          Linux_RedHat:
-            unknown_versioning: *ghc-901a1-64-centos
-          Linux_Alpine:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200821-x86_64-alpine3.10-linux-integer-simple.tar.xz
-              dlSubdir: ghc-9.0.0
-              dlHash: 8a73cbcebe8aac004dda4411873b6cd57169af9af74cbeb636d695852da1f10c
-          Linux_AmazonLinux:
-            unknown_versioning: *ghc-901a1-64-centos
-          Linux_UnknownLinux:
-            unknown_versioning: *ghc-901a1-64-fedora
-          Darwin:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200821-x86_64-apple-darwin.tar.xz
-              dlSubdir: ghc-9.0.0
-              dlHash: 5bb43fe34997222ae092f3c255d0545dd8ff17409d00f56a356aece9042ace2a
-          FreeBSD:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200821-x86_64-unknown-freebsd.tar.xz
-              dlSubdir: ghc-9.0.0
-              dlHash: 2cb2763fa59bff4c045b7012170132a7a49f09e4f0f894c5367f990b60c38830
-        A_32:
-          Linux_Debian:
-            '9': &ghc-901a1-32-deb9
-              dlUri: https://downloads.haskell.org/~ghc/9.0.1-alpha1/ghc-9.0.0.20200821-i386-deb9-linux.tar.xz
-              dlSubdir: ghc-9.0.0
-              dlHash: 8b025e0c66bb4e21c050755d4c77b7cea66d0269f00f5206c3cef51861aa360f
-            unknown_versioning: *ghc-901a1-32-deb9
-          Linux_Ubuntu:
-            unknown_versioning: *ghc-901a1-32-deb9
-          Linux_Mint:
-            unknown_versioning: *ghc-901a1-32-deb9
-          Linux_UnknownLinux:
-            unknown_versioning: *ghc-901a1-32-deb9
  Cabal:
    2.4.1.0:
      viTags: []
      viChangeLog: https://downloads.haskell.org/~cabal/cabal-install-2.4.1.0/changelog
-      viSourceDL:
-        dlUri: https://github.com/haskell/cabal/archive/cabal-install-v2.4.1.0.tar.gz
-        dlSubdir: cabal-cabal-install-v2.4.1.0/cabal-install
-        dlHash: 61eb64a5addafca026aff9277291f4643fe07e83886f76d059d42c734fed829c
      viArch:
        A_64:
          Linux_Alpine:
@ -1304,10 +1228,6 @@ ghcupDownloads:
    3.0.0.0:
      viTags: []
      viChangeLog: https://downloads.haskell.org/~cabal/cabal-install-3.0.0.0/changelog
-      viSourceDL:
-        dlUri: https://github.com/haskell/cabal/archive/cabal-install-v3.0.0.0.tar.gz
-        dlSubdir: cabal-cabal-install-v3.0.0.0/cabal-install
-        dlHash: c0b26817a7b7c2907e45cb38235ce1157e732211880f62e92eaff4066202e674
      viArch:
        A_64:
          Linux_Alpine:
@ -1340,10 +1260,6 @@ ghcupDownloads:
      - Recommended
      - Latest
      viChangeLog: https://downloads.haskell.org/~cabal/cabal-install-3.2.0.0/changelog
-      viSourceDL:
-        dlUri: https://github.com/haskell/cabal/archive/cabal-install-v3.2.0.0.tar.gz
-        dlSubdir: cabal-cabal-install-v3.2.0.0/cabal-install
-        dlHash: 77202358bdf0b481c09326268ce18880df14194c5aaa840f99510bdd1a124b75
      viArch:
        A_64:
          Linux_Alpine:
@ -1371,31 +1287,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-rc1:
+    3.4.0.0-rc4:
      viTags:
      - 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-3400rc1-ubuntu
-              dlUri: http://oleg.fi/cabal-install-3.4.0.0-rc1/cabal-install-3.4.0.0-x86_64-ubuntu-16.04.tar.xz
-              dlHash: 4a693eeacf91993d639b0296a366af7aec6899992352595835f7671e5adef4c6
+            unknown_versioning: &cabal-3400rc4-ubuntu
+              dlUri: https://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: http://oleg.fi/cabal-install-3.4.0.0-rc1/cabal-install-3.4.0.0-x86_64-alpine-3.11.6-static-noofd.tar.xz
-              dlHash: 143160e1768c9c21bad613f720a37aad34051f41fb3473f5f28c030f9ccb7aca
+              dlUri: https://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-3400rc1-ubuntu
+            unknown_versioning: *cabal-3400rc4-ubuntu
          Darwin:
            unknown_versioning:
-              dlUri: http://oleg.fi/cabal-install-3.4.0.0-rc1/cabal-install-3.4.0.0-x86_64-darwin-sierra.tar.xz
-              dlHash: 98e362a57c3b5c1a76f75ede2c2a7c29439902a3e21c3e4f8dcd701e276b164f
+              dlUri: https://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: http://oleg.fi/cabal-install-3.4.0.0-rc1/cabal-install-3.4.0.0-amd64-freebsd-12.1-release.tar.xz
-              dlHash: 0035cc5d35db15d254037a9448697e1daff0a6d21b12c8d43d72522c82cc7319
+              dlUri: https://oleg.fi/cabal-install-3.4.0.0-rc4/cabal-install-3.4.0.0-x86_64-freebsd-12.1-release.tar.xz
+              dlHash: 9705e16d03497b46be4ad477e6c64d10890af853eafa8a9adf6dba89aa9e05f7
  GHCup:
-    0.1.10:
+    0.1.11:
      viTags:
      - Recommended
      - Latest
@ -1405,22 +1322,22 @@ ghcupDownloads:
        A_64:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.10/x86_64-linux-ghcup-0.1.10
-              dlHash: 87661bd127f857b990174ac8d96ad4bd629865306b2058c8cc64d3b36ed317c9
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-linux-ghcup-0.1.11
+              dlHash: 99d97c9a1dce76892001e5cffd50cc23bf804f2282998c546d1b965aa2179699
          Darwin:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.10/x86_64-apple-darwin-ghcup-0.1.10
-              dlHash: e71666fde6a7700f307e1a55720859d3a042fe27c68ff32f3d1181f4436b7391
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-apple-darwin-ghcup-0.1.11
+              dlHash: 4b91dcd9bfdc40534156b8fadea3f317b3c44af1255169895f4911a221f819c6
          FreeBSD:
            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.10/x86_64-portbld-freebsd-ghcup-0.1.10
-              dlHash: b5ef1b0454f1a9c5a62b378c1e9c48c2b794d64a22086adf482b064dfb34e68d
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/x86_64-portbld-freebsd-ghcup-0.1.11
+              dlHash: 6f04ce98d3f3eb9299ce74f8264aa956f0dc38a64a3bd12ee048b7f146e9e1b4
          Linux_Alpine:
            unknown_versioning: *ghcup-64
        A_32:
          Linux_UnknownLinux:
            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.10/i386-linux-ghcup-0.1.10
-              dlHash: 50ac43199b64bc0724400b0a3db674bef3ec53cf6d41acc04a2c4ca8557e534f
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.11/i386-linux-ghcup-0.1.11
+              dlHash: ec339e4c2b8b4d502f66a03c0d3f112cb68cd922dd3c4a6f66323628cf6a76c2
          Linux_Alpine:
            unknown_versioning: *ghcup-32
--- a/ghcup-0.0.3.yaml
+++ b/ghcup-0.0.3.yaml
--- a/ghcup.cabal
+++ b/ghcup.cabal
@ -1,6 +1,6 @@
 cabal-version:      3.0
 name:               ghcup
-version:            0.1.10
+version:            0.1.12
 synopsis:           ghc toolchain installer as an exe/library
 description:
  A rewrite of the shell script ghcup, for providing
@ -72,6 +72,9 @@ common bz2
 common case-insensitive
  build-depends: case-insensitive >=1.2.1.0

+common casing
+  build-depends: casing >=0.1.4.1
+
 common concurrent-output
  build-depends: concurrent-output >=1.10.11

@ -81,6 +84,9 @@ common containers
 common cryptohash-sha256
  build-depends: cryptohash-sha256 >= 0.11.101.0

+common generic-arbitrary
+  build-depends: generic-arbitrary >=0.1.0
+
 common generics-sop
  build-depends: generics-sop >=0.5

@ -94,13 +100,13 @@ common hpath
  build-depends: hpath >=0.11

 common hpath-directory
-  build-depends: hpath-directory >=0.14
+  build-depends: hpath-directory >=0.14.1

 common hpath-filepath
  build-depends: hpath-filepath >=0.10.3

 common hpath-io
-  build-depends: hpath-io >=0.14
+  build-depends: hpath-io >=0.14.1

 common hpath-posix
  build-depends: hpath-posix >=0.13.2
@ -108,6 +114,12 @@ common hpath-posix
 common http-io-streams
  build-depends: http-io-streams >=0.1.2.0

+common hspec
+  build-depends: hspec >=2.7.4
+
+common hspec-golden-aeson
+  build-depends: hspec-golden-aeson >=0.7
+
 common io-streams
  build-depends: io-streams >=1.5

@ -171,9 +183,6 @@ common strict-base
 common string-interpolate
  build-depends: string-interpolate >=0.2.0.0

-common table-layout
-  build-depends: table-layout >=0.8
-
 common template-haskell
  build-depends: template-haskell >=2.7

@ -195,6 +204,12 @@ common transformers
 common os-release
  build-depends: os-release >=1.0.0

+common QuickCheck
+  build-depends: QuickCheck >=2.14.1
+
+common quickcheck-arbitrary-adt
+  build-depends: quickcheck-arbitrary-adt >=0.3.1.0
+
 common unix
  build-depends: unix >=2.7

@ -214,7 +229,7 @@ common vector
  build-depends: vector >=0.12

 common versions
-  build-depends: versions >=3.5
+  build-depends: versions >=4.0.1

 common vty
  build-depends: vty >=5.28.2
@ -240,8 +255,6 @@ common config
    PackageImports
    RecordWildCards
    ScopedTypeVariables
-    Strict
-    StrictData
    TupleSections

 library
@ -256,6 +269,7 @@ library
    , bytestring
    , bz2
    , case-insensitive
+    , casing
    , concurrent-output
    , containers
    , cryptohash-sha256
@ -297,6 +311,7 @@ library
    , utf8-string
    , vector
    , versions
+    , vty
    , word8
    , yaml
    , zlib
@ -321,6 +336,10 @@ library
    GHCup.Utils.Version.QQ
    GHCup.Version

+  default-extensions:
+    Strict
+    StrictData
+
  -- other-modules:
  -- other-extensions:
  hs-source-dirs:  lib
@ -361,7 +380,6 @@ executable ghcup
    , safe
    , safe-exceptions
    , string-interpolate
-    , table-layout
    , template-haskell
    , text
    , uri-bytestring
@ -377,6 +395,10 @@ executable ghcup
  hs-source-dirs:   app/ghcup
  default-language: Haskell2010

+  default-extensions:
+    Strict
+    StrictData
+
  if flag(internal-downloader)
    cpp-options:     -DINTERNAL_DOWNLOADER

@ -412,7 +434,6 @@ executable ghcup-gen
    , resourcet
    , safe-exceptions
    , string-interpolate
-    , table-layout
    , text
    , transformers
    , uri-bytestring
@ -431,8 +452,25 @@ executable ghcup-gen
  default-language: Haskell2010

 test-suite ghcup-test
-  default-language: Haskell2010
+  import:
+    config
+    , base
+    , bytestring
+    , containers
+    , QuickCheck
+    , generic-arbitrary
+    , hpath
+    , hspec
+    , hspec-golden-aeson
+    , quickcheck-arbitrary-adt
+    , text
+    , uri-bytestring
+    , versions
  type:             exitcode-stdio-1.0
+  build-depends:    ghcup
  hs-source-dirs:   test
-  main-is:          MyLibTest.hs
-  build-depends:    base >=4.12.0.0
+  main-is:          Main.hs
+  other-modules:
+                    GHCup.ArbitraryTypes
+                    GHCup.Types.JSONSpec
+                    Spec
--- a/golden/GHCupInfo.json
+++ b/golden/GHCupInfo.json
--- a/hie.yaml
+++ b/hie.yaml
@ -1,4 +1,19 @@
 cradle:
  cabal:
-    - path: "."
-      component: "ghcup:lib:ghcup"
+    - path: "./lib"
+      component: "lib:ghcup"
+
+    - path: "./app/ghcup/Main.hs"
+      component: "ghcup:exe:ghcup"
+
+    - path: "./app/ghcup/BrickMain.hs"
+      component: "ghcup:exe:ghcup"
+
+    - path: "./app/ghcup-gen/Main.hs"
+      component: "ghcup:exe:ghcup-gen"
+
+    - path: "./app/ghcup-gen/Validate.hs"
+      component: "ghcup:exe:ghcup-gen"
+
+    - path: "./test"
+      component: "ghcup:test:ghcup-test"
--- a/lib/GHCup.hs
+++ b/lib/GHCup.hs
@ -75,9 +75,12 @@ import           Prelude                 hiding ( abs
 import           Safe                    hiding ( at )
 import           System.IO.Error
 import           System.Posix.Env.ByteString    ( getEnvironment )
-import           System.Posix.FilePath          ( getSearchPath )
+import           System.Posix.FilePath          ( getSearchPath, takeExtension )
 import           System.Posix.Files.ByteString
+import           Text.Regex.Posix

+import qualified Crypto.Hash.SHA256            as SHA256
+import qualified Data.ByteString.Base16        as B16
 import qualified Data.ByteString               as B
 import qualified Data.ByteString.Lazy          as BL
 import qualified Data.Map.Strict               as Map
@ -96,7 +99,7 @@ import qualified Data.Text.Encoding            as E
 installGHCBindist :: ( MonadFail m
                     , MonadMask m
                     , MonadCatch m
-                     , MonadReader Settings m
+                     , MonadReader AppState m
                     , MonadLogger m
                     , MonadResource m
                     , MonadIO m
@ -119,7 +122,7 @@ installGHCBindist :: ( MonadFail m
                        ]
                       m
                       ()
-installGHCBindist dlinfo ver (PlatformRequest {..}) = do
+installGHCBindist dlinfo ver pfreq = do
  let tver = (mkTVer ver)
  lift $ $(logDebug) [i|Requested to install GHC with #{ver}|]
  whenM (lift $ ghcInstalled tver)
@ -128,42 +131,79 @@ installGHCBindist dlinfo ver (PlatformRequest {..}) = do
  -- download (or use cached version)
  dl                           <- liftE $ downloadCached dlinfo Nothing

-  -- unpack
-  tmpUnpack                    <- lift mkGhcupTmpDir
-  liftE $ unpackToDir tmpUnpack dl
-  void $ liftIO $ darwinNotarization _rPlatform tmpUnpack
-
  -- prepare paths
  ghcdir <- lift $ ghcupGHCDir tver

-  -- the subdir of the archive where we do the work
-  workdir <- maybe (pure tmpUnpack) (liftE . intoSubdir tmpUnpack) (view dlSubdir dlinfo)
-
-  liftE $ runBuildAction tmpUnpack (Just ghcdir) (installGHC' workdir ghcdir)
+  liftE $ installPackedGHC dl (view dlSubdir dlinfo) ghcdir ver pfreq

  liftE $ postGHCInstall tver

- where
-  -- | Install an unpacked GHC distribution. This only deals with the GHC build system and nothing else.
-  installGHC' :: (MonadReader Settings m, MonadThrow m, MonadLogger m, MonadIO m)
-              => Path Abs      -- ^ Path to the unpacked GHC bindist (where the configure script resides)
-              -> Path Abs      -- ^ Path to install to
-              -> Excepts '[ProcessError] m ()
-  installGHC' path inst = do
-    lift $ $(logInfo) "Installing GHC (this may take a while)"
-    lEM $ execLogged "./configure"
-                              False
-                              (["--prefix=" <> toFilePath inst] ++ alpineArgs)
-                              [rel|ghc-configure|]
-                              (Just path)
-                              Nothing
-    lEM $ make ["install"] (Just path)
-    pure ()
+-- | Install a packed GHC distribution. This only deals with unpacking and the GHC
+-- build system and nothing else.
+installPackedGHC :: ( MonadMask m
+                    , MonadCatch m
+                    , MonadReader AppState m
+                    , MonadThrow m
+                    , MonadLogger m
+                    , MonadIO m
+                    )
+                 => Path Abs          -- ^ Path to the packed GHC bindist
+                 -> Maybe TarDir      -- ^ Subdir of the archive
+                 -> Path Abs          -- ^ Path to install to
+                 -> Version           -- ^ The GHC version
+                 -> PlatformRequest
+                 -> Excepts
+                      '[ BuildFailed
+                       , UnknownArchive
+                       , TarDirDoesNotExist
+#if !defined(TAR)
+                       , ArchiveResult
+#endif
+                       ] m ()
+installPackedGHC dl msubdir inst ver pfreq@(PlatformRequest {..}) = do
+  -- unpack
+  tmpUnpack <- lift mkGhcupTmpDir
+  liftE $ unpackToDir tmpUnpack dl
+  void $ liftIO $ darwinNotarization _rPlatform tmpUnpack

+  -- the subdir of the archive where we do the work
+  workdir <- maybe (pure tmpUnpack)
+                   (liftE . intoSubdir tmpUnpack)
+                   (msubdir)
+
+  liftE $ runBuildAction tmpUnpack
+                         (Just inst)
+                         (installUnpackedGHC workdir inst ver pfreq)
+
+
+-- | Install an unpacked GHC distribution. This only deals with the GHC
+-- build system and nothing else.
+installUnpackedGHC :: ( MonadReader AppState m
+                      , MonadThrow m
+                      , MonadLogger m
+                      , MonadIO m
+                      )
+                   => Path Abs      -- ^ Path to the unpacked GHC bindist (where the configure script resides)
+                   -> Path Abs      -- ^ Path to install to
+                   -> Version       -- ^ The GHC version
+                   -> PlatformRequest
+                   -> Excepts '[ProcessError] m ()
+installUnpackedGHC path inst ver (PlatformRequest {..}) = do
+  lift $ $(logInfo) "Installing GHC (this may take a while)"
+  lEM $ execLogged "./configure"
+                   False
+                   (["--prefix=" <> toFilePath inst] ++ alpineArgs)
+                   [rel|ghc-configure|]
+                   (Just path)
+                   Nothing
+  lEM $ make ["install"] (Just path)
+  pure ()
+ where
  alpineArgs
-    | ver >= [vver|8.2.2|]
-    , Linux Alpine <- _rPlatform = ["--disable-ld-override"]
-    | otherwise = []
+    | ver >= [vver|8.2.2|], Linux Alpine <- _rPlatform
+    = ["--disable-ld-override"]
+    | otherwise
+    = []


 -- | Installs GHC into @~\/.ghcup\/ghc/\<ver\>@ and places the
@ -174,7 +214,7 @@ installGHCBindist dlinfo ver (PlatformRequest {..}) = do
 installGHCBin :: ( MonadFail m
                 , MonadMask m
                 , MonadCatch m
-                 , MonadReader Settings m
+                 , MonadReader AppState m
                 , MonadLogger m
                 , MonadResource m
                 , MonadIO m
@ -206,7 +246,7 @@ installGHCBin bDls ver pfreq = do
 -- argument instead of looking it up from 'GHCupDownloads'.
 installCabalBindist :: ( MonadMask m
                       , MonadCatch m
-                       , MonadReader Settings m
+                       , MonadReader AppState m
                       , MonadLogger m
                       , MonadResource m
                       , MonadIO m
@ -233,7 +273,7 @@ installCabalBindist :: ( MonadMask m
 installCabalBindist dlinfo ver (PlatformRequest {..}) = do
  lift $ $(logDebug) [i|Requested to install cabal version #{ver}|]

-  Settings {dirs = Dirs {..}} <- lift ask
+  AppState {dirs = Dirs {..}} <- lift ask

  whenM
      (lift (cabalInstalled ver) >>= \a -> liftIO $
@ -288,7 +328,7 @@ installCabalBindist dlinfo ver (PlatformRequest {..}) = do
 -- the latest installed version.
 installCabalBin :: ( MonadMask m
                   , MonadCatch m
-                   , MonadReader Settings m
+                   , MonadReader AppState m
                   , MonadLogger m
                   , MonadResource m
                   , MonadIO m
@ -317,6 +357,130 @@ installCabalBin bDls ver pfreq = do
  installCabalBindist dlinfo ver pfreq


+-- | Like 'installHLSBin, except takes the 'DownloadInfo' as
+-- argument instead of looking it up from 'GHCupDownloads'.
+installHLSBindist :: ( MonadMask m
+                     , MonadCatch m
+                     , MonadReader AppState m
+                     , MonadLogger m
+                     , MonadResource m
+                     , MonadIO m
+                     , MonadFail m
+                     )
+                  => DownloadInfo
+                  -> Version
+                  -> PlatformRequest
+                  -> Excepts
+                       '[ AlreadyInstalled
+                        , CopyError
+                        , DigestError
+                        , DownloadFailed
+                        , NoDownload
+                        , NotInstalled
+                        , UnknownArchive
+                        , TarDirDoesNotExist
+#if !defined(TAR)
+                        , ArchiveResult
+#endif
+                        ]
+                       m
+                       ()
+installHLSBindist dlinfo ver (PlatformRequest {..}) = do
+  lift $ $(logDebug) [i|Requested to install hls version #{ver}|]
+
+  AppState {dirs = Dirs {..}} <- lift ask
+
+  whenM (lift (hlsInstalled ver))
+    $ (throwE $ AlreadyInstalled HLS ver)
+
+  -- download (or use cached version)
+  dl                           <- liftE $ downloadCached dlinfo Nothing
+
+  -- unpack
+  tmpUnpack                    <- lift withGHCupTmpDir
+  liftE $ unpackToDir tmpUnpack dl
+  void $ liftIO $ darwinNotarization _rPlatform tmpUnpack
+
+  -- the subdir of the archive where we do the work
+  workdir <- maybe (pure tmpUnpack) (liftE . intoSubdir tmpUnpack) (view dlSubdir dlinfo)
+
+  liftE $ installHLS' workdir binDir
+
+  -- create symlink if this is the latest version
+  hlsVers <- lift $ fmap rights $ getInstalledHLSs
+  let lInstHLS = headMay . reverse . sort $ hlsVers
+  when (maybe True (ver >=) lInstHLS) $ liftE $ setHLS ver
+
+  pure ()
+
+ where
+  -- | Install an unpacked hls distribution.
+  installHLS' :: (MonadFail m, MonadLogger m, MonadCatch m, MonadIO m)
+                => Path Abs      -- ^ Path to the unpacked hls bindist (where the executable resides)
+                -> Path Abs      -- ^ Path to install to
+                -> Excepts '[CopyError] m ()
+  installHLS' path inst = do
+    lift $ $(logInfo) "Installing HLS"
+    liftIO $ createDirRecursive' inst
+
+    -- install haskell-language-server-<ghcver>
+    bins@(_:_) <- liftIO $ findFiles
+      path
+      (makeRegexOpts compExtended
+                     execBlank
+                     ([s|^haskell-language-server-[0-9].*$|] :: ByteString)
+      )
+    forM_ bins $ \f -> do
+      toF <- parseRel (toFilePath f <> "~" <> verToBS ver)
+      handleIO (throwE . CopyError . show) $ liftIO $ copyFile
+        (path </> f)
+        (inst </> toF)
+        Overwrite
+      lift $ chmod_777 (inst </> toF)
+
+    -- install haskell-language-server-wrapper
+    let wrapper = [rel|haskell-language-server-wrapper|]
+    toF <- parseRel (toFilePath wrapper <> "-" <> verToBS ver)
+    handleIO (throwE . CopyError . show) $ liftIO $ copyFile
+      (path </> wrapper)
+      (inst </> toF)
+      Overwrite
+    lift $ chmod_777 (inst </> toF)
+
+
+-- | Installs hls binaries @haskell-language-server-\<ghcver\>@
+-- into @~\/.ghcup\/bin/@, as well as @haskell-languager-server-wrapper@.
+installHLSBin :: ( MonadMask m
+                 , MonadCatch m
+                 , MonadReader AppState m
+                 , MonadLogger m
+                 , MonadResource m
+                 , MonadIO m
+                 , MonadFail m
+                 )
+              => GHCupDownloads
+              -> Version
+              -> PlatformRequest
+              -> Excepts
+                   '[ AlreadyInstalled
+                    , CopyError
+                    , DigestError
+                    , DownloadFailed
+                    , NoDownload
+                    , NotInstalled
+                    , UnknownArchive
+                    , TarDirDoesNotExist
+#if !defined(TAR)
+                    , ArchiveResult
+#endif
+                    ]
+                   m
+                   ()
+installHLSBin bDls ver pfreq = do
+  dlinfo <- lE $ getDownloadInfo HLS ver pfreq bDls
+  installHLSBindist dlinfo ver pfreq
+
+


    ---------------------
@ -334,7 +498,7 @@ installCabalBin bDls ver pfreq = do
 --
 -- Additionally creates a @~\/.ghcup\/share -> ~\/.ghcup\/ghc\/\<ver\>\/share symlink@
 -- for 'SetGHCOnly' constructor.
-setGHC :: ( MonadReader Settings m
+setGHC :: ( MonadReader AppState m
          , MonadLogger m
          , MonadThrow m
          , MonadFail m
@ -351,7 +515,7 @@ setGHC ver sghc = do
  whenM (lift $ fmap not $ ghcInstalled ver) (throwE (NotInstalled GHC (ver ^. tvVersion % to prettyVer)))

  -- symlink destination
-  Settings { dirs = Dirs {..} } <- lift ask
+  AppState { dirs = Dirs {..} } <- lift ask
  liftIO $ createDirRecursive' binDir

  -- first delete the old symlinks (this fixes compatibility issues
@ -392,12 +556,12 @@ setGHC ver sghc = do

 where

-  symlinkShareDir :: (MonadReader Settings m, MonadIO m, MonadLogger m)
+  symlinkShareDir :: (MonadReader AppState m, MonadIO m, MonadLogger m)
                  => Path Abs
                  -> ByteString
                  -> m ()
  symlinkShareDir ghcdir verBS = do
-    Settings { dirs = Dirs {..} } <- ask
+    AppState { dirs = Dirs {..} } <- ask
    let destdir = baseDir
    case sghc of
      SetGHCOnly -> do
@ -415,7 +579,7 @@ setGHC ver sghc = do


 -- | Set the @~\/.ghcup\/bin\/cabal@ symlink.
-setCabal :: (MonadReader Settings m, MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
+setCabal :: (MonadReader AppState m, MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
         => Version
         -> Excepts '[NotInstalled] m ()
 setCabal ver = do
@ -423,7 +587,7 @@ setCabal ver = do
  targetFile <- parseRel ("cabal-" <> verBS)

  -- symlink destination
-  Settings {dirs = Dirs {..}} <- lift ask
+  AppState {dirs = Dirs {..}} <- lift ask
  liftIO $ createDirRecursive' binDir

  whenM (liftIO $ fmap not $ doesFileExist (binDir </> targetFile))
@ -447,6 +611,55 @@ setCabal ver = do



+-- | Set the haskell-language-server symlinks.
+setHLS :: ( MonadCatch m
+          , MonadReader AppState m
+          , MonadLogger m
+          , MonadThrow m
+          , MonadFail m
+          , MonadIO m
+          )
+       => Version
+       -> Excepts '[NotInstalled] m ()
+setHLS ver = do
+  AppState { dirs = Dirs {..} } <- lift ask
+  liftIO $ createDirRecursive' binDir
+
+  -- Delete old symlinks, since these might have different ghc versions than the
+  -- selected version, so we could end up with stray or incorrect symlinks.
+  oldSyms <- lift hlsSymlinks
+  forM_ oldSyms $ \f -> do
+    lift $ $(logDebug) [i|rm #{toFilePath (binDir </> f)}|]
+    liftIO $ deleteFile (binDir </> f)
+
+  -- set haskell-language-server-<ghcver> symlinks
+  bins <- lift $ hlsServerBinaries ver
+  when (bins == []) $ throwE $ NotInstalled HLS (prettyVer ver)
+
+  forM_ bins $ \f -> do
+    let destL = toFilePath f
+    target <- parseRel . head . B.split _tilde . toFilePath $ f
+
+    lift $ $(logDebug) [i|rm -f #{toFilePath (binDir </> target)}|]
+    liftIO $ hideError doesNotExistErrorType $ deleteFile (binDir </> target)
+
+    lift $ $(logDebug) [i|ln -s #{destL} #{toFilePath (binDir </> target)}|]
+    liftIO $ createSymlink (binDir </> target) destL
+
+  -- set haskell-language-server-wrapper symlink
+  let destL = "haskell-language-server-wrapper-" <> verToBS ver
+  let wrapper = binDir </> [rel|haskell-language-server-wrapper|]
+
+  lift $ $(logDebug) [i|rm -f #{toFilePath wrapper}|]
+  liftIO $ hideError doesNotExistErrorType $ deleteFile wrapper
+
+  lift $ $(logDebug) [i|ln -s #{destL} #{toFilePath wrapper}|]
+  liftIO $ createSymlink wrapper destL
+
+  pure ()
+
+
+


    ------------------
@ -471,6 +684,7 @@ data ListResult = ListResult
  , fromSrc    :: Bool -- ^ compiled from source
  , lStray     :: Bool -- ^ not in download info
  , lNoBindist :: Bool -- ^ whether the version is available for this platform/arch
+  , hlsPowered :: Bool
  }
  deriving (Eq, Ord, Show)

@ -489,7 +703,7 @@ listVersions :: ( MonadCatch m
                , MonadThrow m
                , MonadLogger m
                , MonadIO m
-                , MonadReader Settings m
+                , MonadReader AppState m
                )
             => GHCupDownloads
             -> Maybe Tool
@ -504,22 +718,25 @@ listVersions av lt criteria pfreq = do
      lr <- filter' <$> forM (Map.toList avTools) (toListResult t)

      case t of
-        -- append stray GHCs
        GHC -> do
          slr <- strayGHCs avTools
          pure $ (sort (slr ++ lr))
        Cabal -> do
          slr <- strayCabals avTools
          pure $ (sort (slr ++ lr))
-        _ -> pure lr
+        HLS -> do
+          slr <- strayHLS avTools
+          pure $ (sort (slr ++ lr))
+        GHCup -> pure lr
    Nothing -> do
      ghcvers   <- listVersions av (Just GHC) criteria pfreq
      cabalvers <- listVersions av (Just Cabal) criteria pfreq
+      hlsvers   <- listVersions av (Just HLS) criteria pfreq
      ghcupvers <- listVersions av (Just GHCup) criteria pfreq
-      pure (ghcvers <> cabalvers <> ghcupvers)
+      pure (ghcvers <> cabalvers <> hlsvers <> ghcupvers)

 where
-  strayGHCs :: (MonadReader Settings m, MonadThrow m, MonadLogger m, MonadIO m)
+  strayGHCs :: (MonadCatch m, MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m)
            => Map.Map Version [Tag]
            -> m [ListResult]
  strayGHCs avTools = do
@ -531,6 +748,7 @@ listVersions av lt criteria pfreq = do
          Nothing -> do
            lSet    <- fmap (maybe False (\(GHCTargetVersion _ v ) -> v == _tvVersion)) $ ghcSet Nothing
            fromSrc <- ghcSrcInstalled tver
+            hlsPowered <- fmap (elem _tvVersion) $ hlsGHCVersions
            pure $ Just $ ListResult
              { lTool      = GHC
              , lVer       = _tvVersion
@ -544,6 +762,7 @@ listVersions av lt criteria pfreq = do
      Right tver@GHCTargetVersion{ .. } -> do
        lSet    <- fmap (maybe False (\(GHCTargetVersion _ v ) -> v == _tvVersion)) $ ghcSet _tvTarget
        fromSrc <- ghcSrcInstalled tver
+        hlsPowered <- fmap (elem _tvVersion) $ hlsGHCVersions
        pure $ Just $ ListResult
          { lTool      = GHC
          , lVer       = _tvVersion
@ -559,7 +778,7 @@ listVersions av lt criteria pfreq = do
          [i|Could not parse version of stray directory #{toFilePath e}|]
        pure Nothing

-  strayCabals :: (MonadReader Settings m, MonadCatch m, MonadThrow m, MonadLogger m, MonadIO m)
+  strayCabals :: (MonadReader AppState m, MonadCatch m, MonadThrow m, MonadLogger m, MonadIO m)
            => Map.Map Version [Tag]
            -> m [ListResult]
  strayCabals avTools = do
@ -579,6 +798,35 @@ listVersions av lt criteria pfreq = do
              , lStray     = maybe True (const False) (Map.lookup ver avTools)
              , lNoBindist = False
              , fromSrc    = False -- actually, we don't know :>
+              , hlsPowered = False
+              , ..
+              }
+      Left e -> do
+        $(logWarn)
+          [i|Could not parse version of stray directory #{toFilePath e}|]
+        pure Nothing
+
+  strayHLS :: (MonadReader AppState m, MonadCatch m, MonadThrow m, MonadLogger m, MonadIO m)
+           => Map.Map Version [Tag]
+           -> m [ListResult]
+  strayHLS avTools = do
+    hlss <- getInstalledHLSs
+    fmap catMaybes $ forM hlss $ \case
+      Right ver ->
+        case Map.lookup ver avTools of
+          Just _  -> pure Nothing
+          Nothing -> do
+            lSet    <- fmap (maybe False (== ver)) $ hlsSet
+            pure $ Just $ ListResult
+              { lTool      = HLS
+              , lVer       = ver
+              , lCross     = Nothing
+              , lTag       = []
+              , lInstalled = True
+              , lStray     = maybe True (const False) (Map.lookup ver avTools)
+              , lNoBindist = False
+              , fromSrc    = False -- actually, we don't know :>
+              , hlsPowered = False
              , ..
              }
      Left e -> do
@ -587,7 +835,7 @@ listVersions av lt criteria pfreq = do
        pure Nothing

  -- NOTE: this are not cross ones, because no bindists
-  toListResult :: (MonadReader Settings m, MonadIO m, MonadCatch m) => Tool -> (Version, [Tag]) -> m ListResult
+  toListResult :: (MonadReader AppState m, MonadIO m, MonadCatch m) => Tool -> (Version, [Tag]) -> m ListResult
  toListResult t (v, tags) = case t of
    GHC -> do
      let lNoBindist = isLeft $ getDownloadInfo GHC v pfreq av
@ -595,6 +843,7 @@ listVersions av lt criteria pfreq = do
      lSet       <- fmap (maybe False (\(GHCTargetVersion _ v') -> v' == v)) $ ghcSet Nothing
      lInstalled <- ghcInstalled tver
      fromSrc    <- ghcSrcInstalled tver
+      hlsPowered <- fmap (elem v) $ hlsGHCVersions
      pure ListResult { lVer = v, lCross = Nothing , lTag = tags, lTool = t, lStray = False, .. }
    Cabal -> do
      let lNoBindist = isLeft $ getDownloadInfo Cabal v pfreq av
@ -606,6 +855,7 @@ listVersions av lt criteria pfreq = do
                      , lTool   = t
                      , fromSrc = False
                      , lStray  = False
+                      , hlsPowered = False
                      , ..
                      }
    GHCup -> do
@ -618,6 +868,20 @@ listVersions av lt criteria pfreq = do
                      , fromSrc = False
                      , lStray  = False
                      , lNoBindist = False
+                      , hlsPowered = False
+                      , ..
+                      }
+    HLS -> do
+      let lNoBindist = isLeft $ getDownloadInfo HLS v pfreq av
+      lSet <- fmap (maybe False (== v)) $ hlsSet
+      lInstalled <- hlsInstalled v
+      pure ListResult { lVer    = v
+                      , lCross  = Nothing
+                      , lTag    = tags
+                      , lTool   = t
+                      , fromSrc = False
+                      , lStray  = False
+                      , hlsPowered = False
                      , ..
                      }

@ -640,7 +904,7 @@ listVersions av lt criteria pfreq = do
 -- This may leave GHCup without a "set" version.
 -- Will try to fix the ghc-x.y symlink after removal (e.g. to an
 -- older version).
-rmGHCVer :: ( MonadReader Settings m
+rmGHCVer :: ( MonadReader AppState m
            , MonadThrow m
            , MonadLogger m
            , MonadIO m
@ -678,7 +942,7 @@ rmGHCVer ver = do
  forM_ v' $ \(mj, mi) -> lift (getGHCForMajor mj mi (_tvTarget ver))
    >>= mapM_ (\v -> liftE $ setGHC v SetGHC_XY)

-  Settings { dirs = Dirs {..} } <- lift ask
+  AppState { dirs = Dirs {..} } <- lift ask

  liftIO
    $ hideError doesNotExistErrorType
@ -688,7 +952,7 @@ rmGHCVer ver = do

 -- | Delete a cabal version. Will try to fix the @cabal@ symlink
 -- after removal (e.g. setting it to an older version).
-rmCabalVer :: (MonadReader Settings m, MonadThrow m, MonadLogger m, MonadIO m, MonadFail m, MonadCatch m)
+rmCabalVer :: (MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m, MonadFail m, MonadCatch m)
           => Version
           -> Excepts '[NotInstalled] m ()
 rmCabalVer ver = do
@ -696,7 +960,7 @@ rmCabalVer ver = do

  cSet      <- lift $ cabalSet

-  Settings {dirs = Dirs {..}} <- lift ask
+  AppState {dirs = Dirs {..}} <- lift ask

  cabalFile <- lift $ parseRel ("cabal-" <> verToBS ver)
  liftIO $ hideError doesNotExistErrorType $ deleteFile (binDir </> cabalFile)
@ -709,19 +973,48 @@ rmCabalVer ver = do
        (binDir </> [rel|cabal|])


+-- | Delete a hls version. Will try to fix the hls symlinks
+-- after removal (e.g. setting it to an older version).
+rmHLSVer :: (MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m, MonadFail m, MonadCatch m)
+         => Version
+         -> Excepts '[NotInstalled] m ()
+rmHLSVer ver = do
+  whenM (lift $ fmap not $ hlsInstalled ver) $ throwE (NotInstalled HLS (prettyVer ver))
+
+  isHlsSet      <- lift $ hlsSet
+
+  AppState {dirs = Dirs {..}} <- lift ask
+
+  bins <- lift $ hlsAllBinaries ver
+  forM_ bins $ \f -> liftIO $ deleteFile (binDir </> f)
+
+  when (maybe False (== ver) isHlsSet) $ do
+    -- delete all set symlinks
+    oldSyms <- lift hlsSymlinks
+    forM_ oldSyms $ \f -> do
+      lift $ $(logDebug) [i|rm #{toFilePath (binDir </> f)}|]
+      liftIO $ deleteFile (binDir </> f)
+    -- set latest hls
+    hlsVers <- lift $ fmap rights $ getInstalledHLSs
+    case headMay . reverse . sort $ hlsVers of
+      Just latestver -> setHLS latestver
+      Nothing        -> pure ()
+
+
+

    ------------------
    --[ Debug info ]--
    ------------------


-getDebugInfo :: (MonadReader Settings m, MonadLogger m, MonadCatch m, MonadIO m)
+getDebugInfo :: (MonadReader AppState m, MonadLogger m, MonadCatch m, MonadIO m)
             => Excepts
                  '[NoCompatiblePlatform , NoCompatibleArch , DistroNotFound]
                  m
                  DebugInfo
 getDebugInfo = do
-  Settings {dirs = Dirs {..}} <- lift ask
+  AppState {dirs = Dirs {..}} <- lift ask
  let diBaseDir  = baseDir
  let diBinDir   = binDir
  diGHCDir       <- lift ghcupGHCBaseDir
@ -741,7 +1034,7 @@ getDebugInfo = do
 -- | Compile a GHC from source. This behaves wrt symlinks and installation
 -- the same as 'installGHCBin'.
 compileGHC :: ( MonadMask m
-              , MonadReader Settings m
+              , MonadReader AppState m
              , MonadThrow m
              , MonadResource m
              , MonadLogger m
@ -767,51 +1060,74 @@ compileGHC :: ( MonadMask m
                 , PatchFailed
                 , UnknownArchive
                 , TarDirDoesNotExist
+                 , NotInstalled
 #if !defined(TAR)
                 , ArchiveResult
 #endif
                 ]
                m
                ()
-compileGHC dls tver bstrap jobs mbuildConfig patchdir aargs PlatformRequest {..} = do
-  lift $ $(logDebug) [i|Requested to compile: #{tver} with #{bstrap}|]
-  whenM (lift $ ghcInstalled tver)
-        (throwE $ AlreadyInstalled GHC (tver ^. tvVersion))
+compileGHC dls tver bstrap jobs mbuildConfig patchdir aargs pfreq@(PlatformRequest {..})
+  = do
+    lift $ $(logDebug) [i|Requested to compile: #{tver} with #{bstrap}|]

-  -- download source tarball
-  dlInfo <-
-    preview (ix GHC % ix (tver ^. tvVersion) % viSourceDL % _Just) dls
-      ?? NoDownload
-  dl        <- liftE $ downloadCached dlInfo Nothing
+    alreadyInstalled <- lift $ ghcInstalled tver
+    alreadySet <- fmap (maybe False (==tver)) $ lift $ ghcSet (_tvTarget tver)

-  -- unpack
-  tmpUnpack <- lift mkGhcupTmpDir
-  liftE $ unpackToDir tmpUnpack dl
-  void $ liftIO $ darwinNotarization _rPlatform tmpUnpack
+    -- download source tarball
+    dlInfo <-
+      preview (ix GHC % ix (tver ^. tvVersion) % viSourceDL % _Just) dls
+        ?? NoDownload
+    dl        <- liftE $ downloadCached dlInfo Nothing

-  bghc <- case bstrap of
-    Right g    -> pure $ Right g
-    Left  bver -> Left <$> parseRel ("ghc-" <> verToBS bver)
-  workdir <- maybe (pure tmpUnpack) (liftE . intoSubdir tmpUnpack) (view dlSubdir dlInfo)
-  ghcdir <- lift $ ghcupGHCDir tver
+    -- unpack
+    tmpUnpack <- lift mkGhcupTmpDir
+    liftE $ unpackToDir tmpUnpack dl
+    void $ liftIO $ darwinNotarization _rPlatform tmpUnpack

-  liftE $ runBuildAction
-    tmpUnpack
-    (Just ghcdir)
-    (compile bghc ghcdir workdir >> markSrcBuilt ghcdir workdir)
+    bghc <- case bstrap of
+      Right g    -> pure $ Right g
+      Left  bver -> Left <$> parseRel ("ghc-" <> verToBS bver)
+    workdir <- maybe (pure tmpUnpack)
+                     (liftE . intoSubdir tmpUnpack)
+                     (view dlSubdir dlInfo)
+    ghcdir         <- lift $ ghcupGHCDir tver

-  reThrowAll GHCupSetError $ postGHCInstall tver
-  pure ()
+    (bindist, bmk) <- liftE $ runBuildAction
+      tmpUnpack
+      Nothing
+      (do
+        b   <- compileBindist bghc ghcdir workdir
+        bmk <- liftIO $ readFileStrict (build_mk workdir)
+        pure (b, bmk)
+      )
+
+    when alreadyInstalled $ do
+      lift $ $(logInfo) [i|Deleting existing installation|]
+      liftE $ rmGHCVer tver
+    liftE $ installPackedGHC bindist
+                             (view dlSubdir dlInfo)
+                             ghcdir
+                             (tver ^. tvVersion)
+                             pfreq
+
+    liftIO $ writeFile (ghcdir </> ghcUpSrcBuiltFile) (Just newFilePerms) bmk
+
+    reThrowAll GHCupSetError $ postGHCInstall tver
+
+    -- restore
+    when alreadySet $ liftE $ void $ setGHC tver SetGHCOnly
+    pure ()

 where
  defaultConf = case _tvTarget tver of
-                  Nothing -> [s|
+    Nothing -> [s|
 V=0
 BUILD_MAN = NO
 BUILD_SPHINX_HTML = NO
 BUILD_SPHINX_PDF = NO
 HADDOCK_DOCS = YES|]
-                  Just _ -> [s|
+    Just _ -> [s|
 V=0
 BUILD_MAN = NO
 BUILD_SPHINX_HTML = NO
@ -819,23 +1135,26 @@ BUILD_SPHINX_PDF = NO
 HADDOCK_DOCS = NO
 Stage1Only = YES|]

-  compile :: (MonadReader Settings m, MonadThrow m, MonadCatch m, MonadLogger m, MonadIO m)
-          => Either (Path Rel) (Path Abs)
-          -> Path Abs
-          -> Path Abs
-          -> Excepts
-               '[ FileDoesNotExistError
-                , InvalidBuildConfig
-                , PatchFailed
-                , ProcessError
-                , NotFoundInPATH
-                ]
-               m
-               ()
-  compile bghc ghcdir workdir = do
+  compileBindist :: ( MonadReader AppState m
+                    , MonadThrow m
+                    , MonadCatch m
+                    , MonadLogger m
+                    , MonadIO m
+                    , MonadFail m
+                    )
+                 => Either (Path Rel) (Path Abs)
+                 -> Path Abs
+                 -> Path Abs
+                 -> Excepts
+                      '[FileDoesNotExistError, InvalidBuildConfig, PatchFailed, ProcessError, NotFoundInPATH, CopyError]
+                      m
+                      (Path Abs)  -- ^ output path of bindist
+  compileBindist bghc ghcdir workdir = do
    lift $ $(logInfo) [i|configuring build|]
    liftE $ checkBuildConfig

+    AppState { dirs = Dirs {..} } <- lift ask
+
    forM_ patchdir $ \dir -> liftE $ applyPatches dir workdir

    cEnv <- liftIO $ getEnvironment
@ -886,29 +1205,49 @@ Stage1Only = YES|]
        liftIO $ writeFile (build_mk workdir) (Just newFilePerms) defaultConf

    lift $ $(logInfo) [i|Building (this may take a while)...|]
-    lEM $ make (maybe [] (\j -> ["-j" <> fS (show j)]) jobs)
-                        (Just workdir)
+    lEM $ make (maybe [] (\j -> ["-j" <> fS (show j)]) jobs) (Just workdir)

-    lift $ $(logInfo) [i|Installing...|]
-    lEM $ make ["install"] (Just workdir)
-
-  markSrcBuilt ghcdir workdir = do
-    let dest = (ghcdir </> ghcUpSrcBuiltFile)
-    liftIO $ copyFile (build_mk workdir) dest Overwrite
+    lift $ $(logInfo) [i|Creating bindist...|]
+    lEM $ make ["binary-dist"] (Just workdir)
+    [tar] <- liftIO $ findFiles
+      workdir
+      (makeRegexOpts compExtended
+                     execBlank
+                     ([s|^ghc-.*\.tar\..*$|] :: ByteString)
+      )
+    c       <- liftIO $ readFile (workdir </> tar)
+    cDigest <-
+      fmap (T.take 8)
+      . lift
+      . throwEither
+      . E.decodeUtf8'
+      . B16.encode
+      . SHA256.hashlazy
+      $ c
+    tarName <-
+      parseRel
+        [i|ghc-#{prettyTVer tver}-#{prettyPfReq pfreq}-#{cDigest}.tar#{takeExtension (toFilePath tar)}|]
+    let tarPath = cacheDir </> tarName
+    handleIO (throwE . CopyError . show) $ liftIO $ copyFile (workdir </> tar)
+                                                             tarPath
+                                                             Strict
+    lift $ $(logInfo) [i|Copied bindist to #{tarPath}|]
+    pure tarPath

  build_mk workdir = workdir </> [rel|mk/build.mk|]

  checkBuildConfig :: (MonadCatch m, MonadIO m)
                   => Excepts
-                        '[FileDoesNotExistError , InvalidBuildConfig]
+                        '[FileDoesNotExistError, InvalidBuildConfig]
                        m
                        ()
  checkBuildConfig = do
    c <- case mbuildConfig of
      Just bc -> do
-        BL.toStrict <$> liftIOException doesNotExistErrorType
-                                        (FileDoesNotExistError $ toFilePath bc)
-                                        (liftIO $ readFile bc)
+        BL.toStrict <$> liftIOException
+          doesNotExistErrorType
+          (FileDoesNotExistError $ toFilePath bc)
+          (liftIO $ readFile bc)
      Nothing -> pure defaultConf
    let lines' = fmap T.strip . T.lines $ decUTF8Safe c

@ -922,122 +1261,6 @@ Stage1Only = YES|]



-- | Compile a cabal from source. This behaves wrt symlinks and installation
-- the same as 'installCabalBin'.
-compileCabal :: ( MonadReader Settings m
-                , MonadResource m
-                , MonadMask m
-                , MonadLogger m
-                , MonadIO m
-                , MonadFail m
-                )
-             => GHCupDownloads
-             -> Version                    -- ^ version to install
-             -> Either Version (Path Abs)  -- ^ version to bootstrap with
-             -> Maybe Int
-             -> Maybe (Path Abs)
-             -> PlatformRequest
-             -> Excepts
-                  '[ AlreadyInstalled
-                   , BuildFailed
-                   , CopyError
-                   , DigestError
-                   , DownloadFailed
-                   , NoDownload
-                   , NotInstalled
-                   , PatchFailed
-                   , UnknownArchive
-                   , TarDirDoesNotExist
-#if !defined(TAR)
-                   , ArchiveResult
-#endif
-                   ]
-                  m
-                  ()
-compileCabal dls tver bghc jobs patchdir PlatformRequest{..} = do
-  lift $ $(logDebug) [i|Requested to compile: #{tver} with ghc-#{bghc}|]
-
-  Settings {dirs = Dirs {..}} <- lift ask
-
-  whenM
-      (lift (cabalInstalled tver) >>= \a -> liftIO $
-        handleIO (\_ -> pure False)
-          $ fmap (\x -> a && isSymbolicLink x)
-          -- ignore when the installation is a legacy cabal (binary, not symlink)
-          $ getSymbolicLinkStatus (toFilePath (binDir </> [rel|cabal|]))
-      )
-    $ (throwE $ AlreadyInstalled Cabal tver)
-
-  -- download source tarball
-  dlInfo <- preview (ix Cabal % ix tver % viSourceDL % _Just) dls ?? NoDownload
-  dl <- liftE $ downloadCached dlInfo Nothing
-
-  -- unpack
-  tmpUnpack <- lift mkGhcupTmpDir
-  liftE $ unpackToDir tmpUnpack dl
-  void $ liftIO $ darwinNotarization _rPlatform tmpUnpack
-
-  workdir <- maybe (pure tmpUnpack) (liftE . intoSubdir tmpUnpack) (view dlSubdir dlInfo)
-
-  cbin         <- liftE $ runBuildAction tmpUnpack Nothing (compile workdir)
-
-  destFileName <- lift $ parseRel ("cabal-" <> verToBS tver)
-  handleIO (throwE . CopyError . show) $ liftIO $ copyFile
-    cbin
-    (binDir </> destFileName)
-    Overwrite
-
-  -- create symlink if this is the latest version
-  cVers <- lift $ fmap rights $ getInstalledCabals
-  let lInstCabal = headMay . reverse . sort $ cVers
-  when (maybe True (tver >=) lInstCabal) $ liftE $ setCabal tver
-
-  pure ()
-
- where
-  compile :: (MonadReader Settings m, MonadThrow m, MonadLogger m, MonadIO m, MonadResource m)
-          => Path Abs
-          -> Excepts '[ProcessError , PatchFailed] m (Path Abs)
-  compile workdir = do
-    lift $ $(logInfo) [i|Building (this may take a while)...|]
-
-    forM_ patchdir $ \dir -> liftE $ applyPatches dir workdir
-
-    ghcEnv <- case bghc of
-      Right path -> do
-        -- recover the version from /foo/ghc-6.5.4
-        bn <- basename path
-        let dn  = toFilePath $ dirname path
-        let ver = snd . B.break (== _hyphen) . toFilePath $ bn
-
-        pure
-          [ ("GHC"    , toFilePath path)
-          , ("GHC_PKG", dn <> "/" <> "ghc-pkg" <> ver)
-          , ("HADDOCK", dn <> "/" <> "haddock" <> ver)
-          ]
-      Left bver -> do
-        let v' = verToBS bver
-        pure
-          [ ("GHC"    , "ghc-" <> v')
-          , ("GHC_PKG", "ghc-pkg-" <> v')
-          , ("HADDOCK", "haddock-" <> v')
-          ]
-
-    tmp <- lift withGHCupTmpDir
-    liftIO $ createDirRecursive' (tmp </> [rel|bin|])
-    newEnv <- lift $ addToCurrentEnv (("PREFIX", toFilePath tmp) : ghcEnv)
-    lift $ $(logDebug) [i|Environment: #{newEnv}|]
-
-    lEM $ execLogged "./bootstrap.sh"
-                              False
-                              (maybe [] (\j -> ["-j", fS (show j)]) jobs)
-                              [rel|cabal-bootstrap|]
-                              (Just workdir)
-                              (Just newEnv)
-    pure $ (tmp </> [rel|bin/cabal|])
-
-
-

    ---------------------
    --[ Upgrade GHCup ]--
@ -1047,7 +1270,7 @@ compileCabal dls tver bghc jobs patchdir PlatformRequest{..} = do
 -- | Upgrade ghcup and place it in @~\/.ghcup\/bin\/ghcup@,
 -- if no path is provided.
 upgradeGHCup :: ( MonadMask m
-                , MonadReader Settings m
+                , MonadReader AppState m
                , MonadCatch m
                , MonadLogger m
                , MonadThrow m
@ -1069,7 +1292,7 @@ upgradeGHCup :: ( MonadMask m
                  m
                  Version
 upgradeGHCup dls mtarget force pfreq = do
-  Settings {dirs = Dirs {..}} <- lift ask
+  AppState {dirs = Dirs {..}} <- lift ask
  lift $ $(logInfo) [i|Upgrading GHCup...|]
  let latestVer = fromJust $ getLatest dls GHCup
  when (not force && (latestVer <= pvpToVersion ghcUpVer)) $ throwE NoUpdate
@ -1094,7 +1317,7 @@ upgradeGHCup dls mtarget force pfreq = do

 -- | Creates @ghc-x.y.z@ and @ghc-x.y@ symlinks. This is used for
 -- both installing from source and bindist.
-postGHCInstall :: ( MonadReader Settings m
+postGHCInstall :: ( MonadReader AppState m
                  , MonadLogger m
                  , MonadThrow m
                  , MonadFail m
--- a/lib/GHCup/Download.hs
+++ b/lib/GHCup/Download.hs
@ -83,9 +83,9 @@ import qualified Crypto.Hash.SHA256            as SHA256
 import qualified Data.ByteString               as BS
 import qualified Data.ByteString.Base16        as B16
 import qualified Data.ByteString.Lazy          as L
+import qualified Data.Map.Strict               as M
 #if defined(INTERNAL_DOWNLOADER)
 import qualified Data.CaseInsensitive          as CI
-import qualified Data.Map.Strict               as M
 import qualified Data.Text                     as T
 #endif
 import qualified Data.Text.Encoding            as E
@ -104,8 +104,8 @@ import qualified System.Posix.RawFilePath.Directory
    ------------------


-- | Like 'getDownloads', but tries to fall back to
-- cached ~/.ghcup/cache/ghcup-<format-ver>.yaml
+
+-- | Downloads the download information! But only if we need to ;P
 getDownloadsF :: ( FromJSONKey Tool
                 , FromJSONKey Version
                 , FromJSON VersionInfo
@ -114,7 +114,7 @@ getDownloadsF :: ( FromJSONKey Tool
                 , MonadLogger m
                 , MonadThrow m
                 , MonadFail m
-                 , MonadReader Settings m
+                 , MonadReader AppState m
                 )
              => URLSource
              -> Excepts
@ -123,17 +123,24 @@ getDownloadsF :: ( FromJSONKey Tool
                   GHCupInfo
 getDownloadsF urlSource = do
  case urlSource of
-    GHCupURL ->
-      liftE
-        $ handleIO (\_ -> readFromCache)
-        $ catchE @_ @'[JSONError , FileDoesNotExistError]
-            (\(DownloadFailed _) -> readFromCache)
-        $ getDownloads urlSource
-    (OwnSource _) -> liftE $ getDownloads urlSource
-    (OwnSpec   _) -> liftE $ getDownloads urlSource
+    GHCupURL -> liftE getBase
+    (OwnSource url) -> do
+      bs <- reThrowAll DownloadFailed $ downloadBS url
+      lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bs)
+    (OwnSpec av) -> pure av
+    (AddSource (Left ext)) -> do
+      base <- liftE getBase
+      pure (mergeGhcupInfo base ext)
+    (AddSource (Right uri)) -> do
+      base <- liftE getBase
+      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
-    Settings {dirs = Dirs {..}} <- lift ask
+    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
@ -145,32 +152,25 @@ getDownloadsF urlSource = do
      $ 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))

-- | Downloads the download information! But only if we need to ;P
-getDownloads :: ( FromJSONKey Tool
-                , FromJSONKey Version
-                , FromJSON VersionInfo
-                , MonadIO m
-                , MonadCatch m
-                , MonadLogger m
-                , MonadThrow m
-                , MonadFail m
-                , MonadReader Settings m
-                )
-             => URLSource
-             -> Excepts '[JSONError , DownloadFailed] m GHCupInfo
-getDownloads urlSource = do
-  lift $ $(logDebug) [i|Receiving download info from: #{urlSource}|]
-  case urlSource of
-    GHCupURL -> do
-      bs <- reThrowAll DownloadFailed $ smartDl ghcupURL
-      lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bs)
-    (OwnSource url) -> do
-      bs <- reThrowAll DownloadFailed $ downloadBS url
-      lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bs)
-    (OwnSpec av) -> pure $ av
+  mergeGhcupInfo :: GHCupInfo -- ^ base to merge with
+                 -> GHCupInfo -- ^ extension overwriting the base
+                 -> GHCupInfo
+  mergeGhcupInfo (GHCupInfo tr base) (GHCupInfo _ ext) =
+    let new = M.mapWithKey (\k a -> case M.lookup k ext of
+                                        Just a' -> M.union a' a
+                                        Nothing -> a
+                           ) base
+    in GHCupInfo tr new

- 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.
@ -185,7 +185,7 @@ getDownloads urlSource = do
             , MonadIO m1
             , MonadFail m1
             , MonadLogger m1
-             , MonadReader Settings m1
+             , MonadReader AppState m1
             )
          => URI
          -> Excepts
@ -200,7 +200,7 @@ getDownloads urlSource = do
               m1
               L.ByteString
  smartDl uri' = do
-    Settings {dirs = Dirs {..}} <- lift ask
+    AppState {dirs = Dirs {..}} <- lift ask
    let path = view pathL' uri'
    json_file <- (cacheDir </>) <$> urlBaseName path
    e         <- liftIO $ doesFileExist json_file
@ -311,7 +311,7 @@ getDownloadInfo t v (PlatformRequest a p mv) dls = maybe
 --
 -- The file must not exist.
 download :: ( MonadMask m
-            , MonadReader Settings m
+            , MonadReader AppState m
            , MonadThrow m
            , MonadLogger m
            , MonadIO m
@ -383,7 +383,7 @@ downloadCached :: ( MonadMask m
                  , MonadThrow m
                  , MonadLogger m
                  , MonadIO m
-                  , MonadReader Settings m
+                  , MonadReader AppState m
                  )
               => DownloadInfo
               -> Maybe (Path Rel)  -- ^ optional filename
@ -392,7 +392,7 @@ downloadCached dli mfn = do
  cache <- lift getCache
  case cache of
    True -> do
-      Settings {dirs = Dirs {..}} <- lift ask
+      AppState {dirs = Dirs {..}} <- lift ask
      fn       <- maybe (urlBaseName $ view (dlUri % pathL') dli) pure mfn
      let cachfile = cacheDir </> fn
      fileExists <- liftIO $ doesFileExist cachfile
@ -416,7 +416,7 @@ downloadCached dli mfn = do


 -- | This is used for downloading the JSON.
-downloadBS :: (MonadReader Settings m, MonadCatch m, MonadIO m, MonadLogger m)
+downloadBS :: (MonadReader AppState m, MonadCatch m, MonadIO m, MonadLogger m)
           => URI
           -> Excepts
                '[ FileDoesNotExistError
@ -473,12 +473,12 @@ downloadBS uri'
 #endif


-checkDigest :: (MonadIO m, MonadThrow m, MonadLogger m, MonadReader Settings m)
+checkDigest :: (MonadIO m, MonadThrow m, MonadLogger m, MonadReader AppState m)
            => DownloadInfo
            -> Path Abs
            -> Excepts '[DigestError] m ()
 checkDigest dli file = do
-  verify <- lift ask <&> (not . noVerify)
+  verify <- lift ask <&> (not . noVerify . settings)
  when verify $ do
    p' <- toFilePath <$> basename file
    lift $ $(logInfo) [i|verifying digest of: #{p'}|]
--- a/lib/GHCup/Errors.hs
+++ b/lib/GHCup/Errors.hs
@ -152,3 +152,10 @@ data ParseError = ParseError String
  deriving Show

 instance Exception ParseError
+
+
+data UnexpectedListLength = UnexpectedListLength String
+  deriving Show
+
+instance Exception UnexpectedListLength
+
--- a/lib/GHCup/Requirements.hs
+++ b/lib/GHCup/Requirements.hs
@ -48,7 +48,7 @@ prettyRequirements :: Requirements -> T.Text
 prettyRequirements Requirements {..} =
  let d = if not . null $ _distroPKGs
        then
-          "\n  Install the following distro packages: "
+          "\n  Please install the following distro packages: "
            <> T.intercalate " " _distroPKGs
        else ""
      n = if not . T.null $ _notes then "\n  Note: " <> _notes else ""
--- a/lib/GHCup/Types.hs
+++ b/lib/GHCup/Types.hs
@ -19,7 +19,9 @@ import           Data.Versions
 import           HPath
 import           URI.ByteString

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



@ -75,6 +77,7 @@ type PlatformVersionSpec = Map (Maybe Versioning) DownloadInfo
 data Tool = GHC
          | Cabal
          | GHCup
+          | HLS
  deriving (Eq, GHC.Generic, Ord, Show)


@ -86,7 +89,7 @@ data VersionInfo = VersionInfo
  , _viSourceDL  :: Maybe DownloadInfo -- ^ source tarball
  , _viArch      :: ArchitectureSpec   -- ^ descend for binary downloads per arch
  }
-  deriving (Eq, Show)
+  deriving (Eq, GHC.Generic, Show)


 -- | A tag. These are currently attached to a version of a tool.
@ -94,8 +97,9 @@ data Tag = Latest
         | Recommended
         | Prerelease
         | Base PVP
+         | Old                -- ^ old version are hidden by default in TUI
         | UnknownTag String  -- ^ used for upwardscompat
-         deriving (Ord, Eq, Show) -- FIXME: manual JSON instance
+         deriving (Ord, Eq, GHC.Generic, Show) -- FIXME: manual JSON instance


 data Architecture = A_64
@ -108,6 +112,15 @@ data Architecture = A_64
                  | A_ARM64
  deriving (Eq, GHC.Generic, Ord, Show)

+prettyArch :: Architecture -> String
+prettyArch A_64 = "x86_64"
+prettyArch A_32 = "i386"
+prettyArch A_PowerPC = "powerpc"
+prettyArch A_PowerPC64 = "powerpc64"
+prettyArch A_Sparc = "sparc"
+prettyArch A_Sparc64 = "sparc64"
+prettyArch A_ARM = "arm"
+prettyArch A_ARM64 = "aarch64"

 data Platform = Linux LinuxDistro
              -- ^ must exit
@ -116,6 +129,11 @@ data Platform = Linux LinuxDistro
              | FreeBSD
  deriving (Eq, GHC.Generic, Ord, Show)

+prettyPlatfrom :: Platform -> String
+prettyPlatfrom (Linux distro) = "linux-" ++ prettyDistro distro
+prettyPlatfrom Darwin = "darwin"
+prettyPlatfrom FreeBSD = "freebsd"
+
 data LinuxDistro = Debian
                 | Ubuntu
                 | Mint
@ -132,6 +150,19 @@ data LinuxDistro = Debian
                 -- ^ must exit
  deriving (Eq, GHC.Generic, Ord, Show)

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

 -- | An encapsulation of a download. This can be used
 -- to download, extract and install a tool.
@ -140,7 +171,7 @@ data DownloadInfo = DownloadInfo
  , _dlSubdir :: Maybe TarDir
  , _dlHash   :: Text
  }
-  deriving (Eq, Show)
+  deriving (Eq, GHC.Generic, Show)



@ -153,34 +184,89 @@ data DownloadInfo = DownloadInfo
 -- | How to descend into a tar archive.
 data TarDir = RealDir (Path Rel)
            | RegexDir String     -- ^ will be compiled to regex, the first match will "win"
-            deriving (Eq, Show)
+            deriving (Eq, GHC.Generic, Show)


 -- | Where to fetch GHCupDownloads from.
 data URLSource = GHCupURL
               | OwnSource URI
               | OwnSpec GHCupInfo
-               deriving Show
+               | AddSource (Either GHCupInfo URI) -- ^ merge with GHCupURL
+               deriving (GHC.Generic, Show)


+data UserSettings = UserSettings
+  { uCache       :: Maybe Bool
+  , uNoVerify    :: Maybe Bool
+  , uVerbose     :: Maybe Bool
+  , uKeepDirs    :: Maybe KeepDirs
+  , uDownloader  :: Maybe Downloader
+  , uKeyBindings :: Maybe UserKeyBindings
+  , uUrlSource   :: Maybe URLSource
+  }
+  deriving (Show, GHC.Generic)
+
+defaultUserSettings :: UserSettings
+defaultUserSettings = UserSettings Nothing Nothing Nothing Nothing Nothing Nothing Nothing
+
+data UserKeyBindings = UserKeyBindings
+  { kUp        :: Maybe Vty.Key
+  , kDown      :: Maybe Vty.Key
+  , kQuit      :: Maybe Vty.Key
+  , kInstall   :: Maybe Vty.Key
+  , kUninstall :: Maybe Vty.Key
+  , kSet       :: Maybe Vty.Key
+  , kChangelog :: Maybe Vty.Key
+  , kShowAll   :: Maybe Vty.Key
+  }
+  deriving (Show, GHC.Generic)
+
+data KeyBindings = KeyBindings
+  { bUp        :: Vty.Key
+  , bDown      :: Vty.Key
+  , bQuit      :: Vty.Key
+  , bInstall   :: Vty.Key
+  , bUninstall :: Vty.Key
+  , bSet       :: Vty.Key
+  , bChangelog :: Vty.Key
+  , bShowAll   :: Vty.Key
+  }
+  deriving (Show, GHC.Generic)
+
+defaultKeyBindings :: KeyBindings
+defaultKeyBindings = KeyBindings
+  { bUp = Vty.KUp
+  , bDown = Vty.KDown
+  , bQuit = Vty.KChar 'q'
+  , bInstall = Vty.KChar 'i'
+  , bUninstall = Vty.KChar 'u'
+  , bSet = Vty.KChar 's'
+  , bChangelog = Vty.KChar 'c'
+  , bShowAll = Vty.KChar 'a'
+  }
+
+data AppState = AppState
+  { settings :: Settings
+  , dirs :: Dirs
+  , keyBindings :: KeyBindings
+  } deriving (Show)
+
 data Settings = Settings
-  { -- set by user
-    cache      :: Bool
+  { cache      :: Bool
  , noVerify   :: Bool
  , keepDirs   :: KeepDirs
  , downloader :: Downloader
  , verbose    :: Bool
-
-    -- set on app start
-  , dirs       :: Dirs
+  , urlSource  :: URLSource
  }
-  deriving Show
+  deriving (Show, GHC.Generic)

 data Dirs = Dirs
  { baseDir  :: Path Abs
  , binDir   :: Path Abs
  , cacheDir :: Path Abs
  , logsDir  :: Path Abs
+  , confDir  :: Path Abs
  }
  deriving Show

@ -219,6 +305,12 @@ data PlatformResult = PlatformResult
  }
  deriving (Eq, Show)

+prettyPlatform :: PlatformResult -> String
+prettyPlatform PlatformResult { _platform = plat, _distroVersion = Just v' }
+  = show plat <> ", " <> show v'
+prettyPlatform PlatformResult { _platform = plat, _distroVersion = Nothing }
+  = show plat
+
 data PlatformRequest = PlatformRequest
  { _rArch     :: Architecture
  , _rPlatform :: Platform
@ -226,6 +318,13 @@ data PlatformRequest = PlatformRequest
  }
  deriving (Eq, Show)

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

 -- | A GHC identified by the target platform triple
 -- and the version.
--- a/lib/GHCup/Types/JSON.hs
+++ b/lib/GHCup/Types/JSON.hs
@ -33,14 +33,17 @@ import           Data.Versions
 import           Data.Word8
 import           HPath
 import           URI.ByteString
+import           Text.Casing

 import qualified Data.ByteString               as BS
 import qualified Data.Text                     as T
+import qualified Graphics.Vty                  as Vty


 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } { fieldLabelModifier = removeLensFieldLabel } ''Architecture
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''LinuxDistro
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Mess
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''MChunk
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Platform
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''SemVer
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Tool
@ -50,11 +53,18 @@ deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Versio
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''DownloadInfo
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''GHCupInfo
 deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Requirements
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''KeepDirs
+deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Downloader
+deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''URLSource
+deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "u-") . T.pack . kebab $ str' } ''UserSettings
+deriveJSON defaultOptions { fieldLabelModifier = \str' -> maybe str' T.unpack . T.stripPrefix (T.pack "k-") . T.pack . kebab $ str' } ''UserKeyBindings
+deriveJSON defaultOptions { sumEncoding = ObjectWithSingleField } ''Vty.Key

 instance ToJSON Tag where
  toJSON Latest             = String "Latest"
  toJSON Recommended        = String "Recommended"
  toJSON Prerelease         = String "Prerelease"
+  toJSON Old                = String "old"
  toJSON (Base       pvp'') = String ("base-" <> prettyPVP pvp'')
  toJSON (UnknownTag x    ) = String (T.pack x)

@ -63,6 +73,7 @@ instance FromJSON Tag where
    "Latest"                             -> pure Latest
    "Recommended"                        -> pure Recommended
    "Prerelease"                         -> pure Prerelease
+    "old"                                -> pure Old
    ('b' : 'a' : 's' : 'e' : '-' : ver') -> case pvp (T.pack ver') of
      Right x -> pure $ Base x
      Left  e -> fail . show $ e
--- a/lib/GHCup/Utils.hs
+++ b/lib/GHCup/Utils.hs
@ -50,6 +50,7 @@ import           Data.ByteString                ( ByteString )
 import           Data.Either
 import           Data.Foldable
 import           Data.List
+import           Data.List.NonEmpty             ( NonEmpty( (:|) ))
 import           Data.List.Split
 import           Data.Maybe
 import           Data.String.Interpolate
@ -99,21 +100,21 @@ import qualified Text.Megaparsec               as MP


 -- | The symlink destination of a ghc tool.
-ghcLinkDestination :: (MonadReader Settings m, MonadThrow m, MonadIO m)
+ghcLinkDestination :: (MonadReader AppState m, MonadThrow m, MonadIO m)
                   => ByteString -- ^ the tool, such as 'ghc', 'haddock' etc.
                   -> GHCTargetVersion
                   -> m ByteString
 ghcLinkDestination tool ver = do
-  Settings {dirs = Dirs {..}} <- ask
+  AppState { dirs = Dirs {..} } <- ask
  t <- parseRel tool
  ghcd <- ghcupGHCDir ver
  pure (relativeSymlink binDir (ghcd </> [rel|bin|] </> t))


 -- | Removes the minor GHC symlinks, e.g. ghc-8.6.5.
-rmMinorSymlinks :: (MonadReader Settings m, MonadIO m, MonadLogger m) => GHCTargetVersion -> m ()
+rmMinorSymlinks :: (MonadReader AppState m, MonadIO m, MonadLogger m) => GHCTargetVersion -> m ()
 rmMinorSymlinks GHCTargetVersion {..} = do
-  Settings {dirs = Dirs {..}} <- ask
+  AppState { dirs = Dirs {..} } <- ask

  files  <- liftIO $ findFiles'
    binDir
@ -130,11 +131,11 @@ rmMinorSymlinks GHCTargetVersion {..} = do


 -- | Removes the set ghc version for the given target, if any.
-rmPlain :: (MonadReader Settings m, MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
+rmPlain :: (MonadReader AppState m, MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
  => Maybe Text -- ^ target
        -> Excepts '[NotInstalled] m ()
 rmPlain target = do
-  Settings {dirs = Dirs {..}} <- lift ask
+  AppState { dirs = Dirs {..} } <- lift ask
  mtv <- lift $ ghcSet target
  forM_ mtv $ \tv -> do
    files  <- liftE $ ghcToolFiles tv
@ -149,11 +150,11 @@ rmPlain target = do


 -- | Remove the major GHC symlink, e.g. ghc-8.6.
-rmMajorSymlinks :: (MonadReader Settings m, MonadThrow m, MonadLogger m, MonadIO m)
+rmMajorSymlinks :: (MonadReader AppState m, MonadThrow m, MonadLogger m, MonadIO m)
                => GHCTargetVersion
                -> m ()
 rmMajorSymlinks GHCTargetVersion {..} = do
-  Settings {dirs = Dirs {..}} <- ask
+  AppState { dirs = Dirs {..} } <- ask
  (mj, mi) <- getMajorMinorV _tvVersion
  let v' = intToText mj <> "." <> intToText mi

@ -179,26 +180,26 @@ rmMajorSymlinks GHCTargetVersion {..} = do


 -- | Whethe the given GHC versin is installed.
-ghcInstalled :: (MonadIO m, MonadReader Settings m, MonadThrow m) => GHCTargetVersion -> m Bool
+ghcInstalled :: (MonadIO m, MonadReader AppState m, MonadThrow m) => GHCTargetVersion -> m Bool
 ghcInstalled ver = do
  ghcdir <- ghcupGHCDir ver
  liftIO $ doesDirectoryExist ghcdir


 -- | Whether the given GHC version is installed from source.
-ghcSrcInstalled :: (MonadIO m, MonadReader Settings m, MonadThrow m) => GHCTargetVersion -> m Bool
+ghcSrcInstalled :: (MonadIO m, MonadReader AppState m, MonadThrow m) => GHCTargetVersion -> m Bool
 ghcSrcInstalled ver = do
  ghcdir <- ghcupGHCDir ver
  liftIO $ doesFileExist (ghcdir </> ghcUpSrcBuiltFile)


 -- | Whether the given GHC version is set as the current.
-ghcSet :: (MonadReader Settings m, MonadThrow m, MonadIO m)
+ghcSet :: (MonadReader AppState m, MonadThrow m, MonadIO m)
       => Maybe Text   -- ^ the target of the GHC version, if any
                       --  (e.g. armv7-unknown-linux-gnueabihf)
       -> m (Maybe GHCTargetVersion)
 ghcSet mtarget = do
-  Settings {dirs = Dirs {..}} <- ask
+  AppState {dirs = Dirs {..}} <- ask
  ghc    <- parseRel $ E.encodeUtf8 (maybe "ghc" (<> "-ghc") mtarget)
  let ghcBin = binDir </> ghc

@ -231,7 +232,7 @@ ghcLinkVersion bs = do

 -- | Get all installed GHCs by reading ~/.ghcup/ghc/<dir>.
 -- If a dir cannot be parsed, returns left.
-getInstalledGHCs :: (MonadReader Settings m, MonadIO m) => m [Either (Path Rel) GHCTargetVersion]
+getInstalledGHCs :: (MonadReader AppState m, MonadIO m) => m [Either (Path Rel) GHCTargetVersion]
 getInstalledGHCs = do
  ghcdir <- ghcupGHCBaseDir
  fs     <- liftIO $ hideErrorDef [NoSuchThing] [] $ getDirsFiles' ghcdir
@ -241,10 +242,10 @@ getInstalledGHCs = do


 -- | Get all installed cabals, by matching on @~\/.ghcup\/bin/cabal-*@.
-getInstalledCabals :: (MonadReader Settings m, MonadIO m, MonadCatch m)
+getInstalledCabals :: (MonadReader AppState m, MonadIO m, MonadCatch m)
                   => m [Either (Path Rel) Version]
 getInstalledCabals = do
-  Settings {dirs = Dirs {..}} <- ask
+  AppState {dirs = Dirs {..}} <- ask
  bins   <- liftIO $ handleIO (\_ -> pure []) $ findFiles
    binDir
    (makeRegexOpts compExtended execBlank ([s|^cabal-.*$|] :: ByteString))
@ -257,16 +258,16 @@ getInstalledCabals = do


 -- | Whether the given cabal version is installed.
-cabalInstalled :: (MonadIO m, MonadReader Settings m, MonadCatch m) => Version -> m Bool
+cabalInstalled :: (MonadIO m, MonadReader AppState m, MonadCatch m) => Version -> m Bool
 cabalInstalled ver = do
  vers <- fmap rights $ getInstalledCabals
  pure $ elem ver $ vers


 -- Return the currently set cabal version, if any.
-cabalSet :: (MonadReader Settings m, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
+cabalSet :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
 cabalSet = do
-  Settings {dirs = Dirs {..}} <- ask
+  AppState {dirs = Dirs {..}} <- ask
  let cabalbin = binDir </> [rel|cabal|]
  b        <- handleIO (\_ -> pure False) $ fmap (== SymbolicLink) $ liftIO $ getFileType cabalbin
  if
@ -301,6 +302,150 @@ cabalSet = do



+-- | Get all installed hls, by matching on
+-- @~\/.ghcup\/bin/haskell-language-server-wrapper-<\hlsver\>@.
+getInstalledHLSs :: (MonadReader AppState m, MonadIO m, MonadCatch m)
+                 => m [Either (Path Rel) Version]
+getInstalledHLSs = do
+  AppState { dirs = Dirs {..} } <- ask
+  bins                          <- liftIO $ handleIO (\_ -> pure []) $ findFiles
+    binDir
+    (makeRegexOpts compExtended
+                   execBlank
+                   ([s|^haskell-language-server-wrapper-.*$|] :: ByteString)
+    )
+  vs <- forM bins $ \f ->
+    case
+        fmap
+          version
+          (fmap decUTF8Safe . B.stripPrefix "haskell-language-server-wrapper-" . toFilePath $ f)
+      of
+        Just (Right r) -> pure $ Right r
+        Just (Left  _) -> pure $ Left f
+        Nothing        -> pure $ Left f
+  pure $ vs
+
+
+-- | Whether the given HLS version is installed.
+hlsInstalled :: (MonadIO m, MonadReader AppState m, MonadCatch m) => Version -> m Bool
+hlsInstalled ver = do
+  vers <- fmap rights $ getInstalledHLSs
+  pure $ elem ver $ vers
+
+
+
+-- Return the currently set hls version, if any.
+hlsSet :: (MonadReader AppState m, MonadIO m, MonadThrow m, MonadCatch m) => m (Maybe Version)
+hlsSet = do
+  AppState {dirs = Dirs {..}} <- ask
+  let hlsBin = binDir </> [rel|haskell-language-server-wrapper|]
+
+  liftIO $ handleIO' NoSuchThing (\_ -> pure $ Nothing) $ do
+    broken <- isBrokenSymlink hlsBin
+    if broken
+      then pure Nothing
+      else do
+        link <- readSymbolicLink $ toFilePath hlsBin
+        Just <$> linkVersion link
+ where
+  linkVersion :: MonadThrow m => ByteString -> m Version
+  linkVersion bs = do
+    t <- throwEither $ E.decodeUtf8' bs
+    throwEither $ MP.parse parser "" t
+   where
+    parser =
+      MP.chunk "haskell-language-server-wrapper-" *> version'
+
+
+-- | Return the GHC versions the currently selected HLS supports.
+hlsGHCVersions :: ( MonadReader AppState m
+                  , MonadIO m
+                  , MonadThrow m
+                  , MonadCatch m
+                  )
+               => m [Version]
+hlsGHCVersions = do
+  h                             <- hlsSet
+  vers                          <- forM h $ \h' -> do
+    bins <- hlsServerBinaries h'
+    pure $ fmap
+      (\bin ->
+        version
+          . decUTF8Safe
+          . fromJust
+          . B.stripPrefix "haskell-language-server-"
+          . head
+          . B.split _tilde
+          . toFilePath
+          $ bin
+      )
+      bins
+  pure . rights . concat . maybeToList $ vers
+
+
+-- | Get all server binaries for an hls version, if any.
+hlsServerBinaries :: (MonadReader AppState m, MonadIO m)
+                  => Version
+                  -> m [Path Rel]
+hlsServerBinaries ver = do
+  AppState { dirs = Dirs {..} } <- ask
+  liftIO $ handleIO (\_ -> pure []) $ findFiles
+    binDir
+    (makeRegexOpts
+      compExtended
+      execBlank
+      ([s|^haskell-language-server-.*~|] <> escapeVerRex ver <> [s|$|] :: ByteString
+      )
+    )
+
+
+-- | Get the wrapper binary for an hls version, if any.
+hlsWrapperBinary :: (MonadReader AppState m, MonadThrow m, MonadIO m)
+                 => Version
+                 -> m (Maybe (Path Rel))
+hlsWrapperBinary ver = do
+  AppState { dirs = Dirs {..} } <- ask
+  wrapper                       <- liftIO $ handleIO (\_ -> pure []) $ findFiles
+    binDir
+    (makeRegexOpts
+      compExtended
+      execBlank
+      ([s|^haskell-language-server-wrapper-|] <> escapeVerRex ver <> [s|$|] :: ByteString
+      )
+    )
+  case wrapper of
+    []  -> pure $ Nothing
+    [x] -> pure $ Just x
+    _   -> throwM $ UnexpectedListLength
+      "There were multiple hls wrapper binaries for a single version"
+
+
+-- | Get all binaries for an hls version, if any.
+hlsAllBinaries :: (MonadReader AppState m, MonadIO m, MonadThrow m) => Version -> m [Path Rel]
+hlsAllBinaries ver = do
+  hls     <- hlsServerBinaries ver
+  wrapper <- hlsWrapperBinary ver
+  pure (maybeToList wrapper ++ hls)
+
+
+-- | Get the active symlinks for hls.
+hlsSymlinks :: (MonadReader AppState m, MonadIO m, MonadCatch m) => m [Path Rel]
+hlsSymlinks = do
+  AppState { dirs = Dirs {..} } <- ask
+  oldSyms                       <- liftIO $ handleIO (\_ -> pure []) $ findFiles
+    binDir
+    (makeRegexOpts compExtended
+                   execBlank
+                   ([s|^haskell-language-server-.*$|] :: ByteString)
+    )
+  filterM
+    ( fmap (== SymbolicLink)
+    . liftIO
+    . getFileType
+    . (binDir </>)
+    )
+    oldSyms
+


    -----------------------------------------
@ -311,7 +456,7 @@ cabalSet = do
 -- | Extract (major, minor) from any version.
 getMajorMinorV :: MonadThrow m => Version -> m (Int, Int)
 getMajorMinorV Version {..} = case _vChunks of
-  ([Digits x] : [Digits y] : _) -> pure (fromIntegral x, fromIntegral y)
+  ((Digits x :| []) :| ((Digits y :| []):_)) -> pure (fromIntegral x, fromIntegral y)
  _ -> throwM $ ParseError "Could not parse X.Y from version"


@ -323,7 +468,7 @@ matchMajor v' major' minor' = case getMajorMinorV v' of

 -- | Get the latest installed full GHC version that satisfies X.Y.
 -- This reads `ghcupGHCBaseDir`.
-getGHCForMajor :: (MonadReader Settings m, MonadIO m, MonadThrow m)
+getGHCForMajor :: (MonadReader AppState m, MonadIO m, MonadThrow m)
               => Int        -- ^ major version component
               -> Int        -- ^ minor version component
               -> Maybe Text -- ^ the target triple
@ -459,16 +604,16 @@ getLatestBaseVersion av pvpVer =


    -----------------------
-    --[ Settings Getter ]--
+    --[ AppState Getter ]--
    -----------------------


-getCache :: MonadReader Settings m => m Bool
-getCache = ask <&> cache
+getCache :: MonadReader AppState m => m Bool
+getCache = ask <&> cache . settings


-getDownloader :: MonadReader Settings m => m Downloader
-getDownloader = ask <&> downloader
+getDownloader :: MonadReader AppState m => m Downloader
+getDownloader = ask <&> downloader . settings



@ -489,7 +634,7 @@ urlBaseName = parseRel . snd . B.breakEnd (== _slash) . urlDecode False
 -- Returns unversioned relative files, e.g.:
 --
 --   - @["hsc2hs","haddock","hpc","runhaskell","ghc","ghc-pkg","ghci","runghc","hp2ps"]@
-ghcToolFiles :: (MonadReader Settings m, MonadThrow m, MonadFail m, MonadIO m)
+ghcToolFiles :: (MonadReader AppState m, MonadThrow m, MonadFail m, MonadIO m)
             => GHCTargetVersion
             -> Excepts '[NotInstalled] m [Path Rel]
 ghcToolFiles ver = do
@ -542,7 +687,7 @@ ghcUpSrcBuiltFile = [rel|.ghcup_src_built|]


 -- | Calls gmake if it exists in PATH, otherwise make.
-make :: (MonadThrow m, MonadIO m, MonadReader Settings m)
+make :: (MonadThrow m, MonadIO m, MonadReader AppState m)
     => [ByteString]
     -> Maybe (Path Abs)
     -> m (Either ProcessError ())
@ -595,13 +740,13 @@ getChangeLog dls tool (Right tag) =
 --
 --   1. the build directory, depending on the KeepDirs setting
 --   2. the install destination, depending on whether the build failed
-runBuildAction :: (Show (V e), MonadReader Settings m, MonadIO m, MonadMask m)
-               => Path Abs          -- ^ build directory
-               -> Maybe (Path Abs)  -- ^ install location (e.g. for GHC)
+runBuildAction :: (Show (V e), MonadReader AppState m, MonadIO m, MonadMask m)
+               => Path Abs          -- ^ build directory (cleaned up depending on Settings)
+               -> Maybe (Path Abs)  -- ^ dir to *always* clean up on exception
               -> Excepts e m a
               -> Excepts '[BuildFailed] m a
 runBuildAction bdir instdir action = do
-  Settings {..} <- lift ask
+  AppState { settings = Settings {..} } <- lift ask
  let exAction = do
        forM_ instdir $ \dir ->
          liftIO $ hideError doesNotExistErrorType $ deleteDirRecursive dir
--- a/lib/GHCup/Utils/Dirs.hs
+++ b/lib/GHCup/Utils/Dirs.hs
@ -1,3 +1,4 @@
+{-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE OverloadedStrings     #-}
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE QuasiQuotes           #-}
@ -14,16 +15,18 @@ Portability : POSIX
 -}
 module GHCup.Utils.Dirs
  ( getDirs
+  , ghcupConfigFile
  , ghcupGHCBaseDir
  , ghcupGHCDir
-  , parseGHCupGHCDir
  , mkGhcupTmpDir
-  , withGHCupTmpDir
+  , parseGHCupGHCDir
  , relativeSymlink
+  , withGHCupTmpDir
  )
 where


+import           GHCup.Errors
 import           GHCup.Types
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.MegaParsec
@ -34,8 +37,11 @@ import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource
+import           Data.Bifunctor
 import           Data.ByteString                ( ByteString )
 import           Data.Maybe
+import           GHC.IO.Exception               ( IOErrorType(NoSuchThing) )
+import           Haskus.Utils.Variant.Excepts
 import           HPath
 import           HPath.IO
 import           Optics
@ -49,8 +55,10 @@ import           System.Posix.Env.ByteString    ( getEnv
 import           System.Posix.FilePath   hiding ( (</>) )
 import           System.Posix.Temp.ByteString   ( mkdtemp )

+import qualified Data.ByteString.Lazy          as L
 import qualified Data.ByteString.UTF8          as UTF8
 import qualified Data.Text.Encoding            as E
+import qualified Data.Yaml                     as Y
 import qualified System.Posix.FilePath         as FP
 import qualified System.Posix.User             as PU
 import qualified Text.Megaparsec               as MP
@ -84,6 +92,28 @@ ghcupBaseDir = do
      pure (bdir </> [rel|.ghcup|])


+-- | ~/.ghcup by default
+--
+-- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
+-- then uses 'XDG_CONFIG_HOME/ghcup' as per xdg spec.
+ghcupConfigDir :: IO (Path Abs)
+ghcupConfigDir = do
+  xdg <- useXDG
+  if xdg
+    then do
+      bdir <- getEnv "XDG_CONFIG_HOME" >>= \case
+        Just r  -> parseAbs r
+        Nothing -> do
+          home <- liftIO getHomeDirectory
+          pure (home </> [rel|.config|])
+      pure (bdir </> [rel|ghcup|])
+    else do
+      bdir <- getEnv "GHCUP_INSTALL_BASE_PREFIX" >>= \case
+        Just r  -> parseAbs r
+        Nothing -> liftIO getHomeDirectory
+      pure (bdir </> [rel|.ghcup|])
+
+
 -- | If 'GHCUP_USE_XDG_DIRS' is set (to anything),
 -- then uses 'XDG_BIN_HOME' env var or defaults to '~/.local/bin'
 -- (which, sadly is not strictly xdg spec).
@ -142,27 +172,44 @@ getDirs = do
  binDir   <- ghcupBinDir
  cacheDir <- ghcupCacheDir
  logsDir  <- ghcupLogsDir
+  confDir  <- ghcupConfigDir
  pure Dirs { .. }



+    -------------------
+    --[ GHCup files ]--
+    -------------------
+
+
+ghcupConfigFile :: (MonadIO m)
+                => Excepts '[JSONError] m UserSettings
+ghcupConfigFile = do
+  confDir <- liftIO $ ghcupConfigDir
+  let file = confDir </> [rel|config.yaml|]
+  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'
+
+
    -------------------------
    --[ GHCup directories ]--
    -------------------------


 -- | ~/.ghcup/ghc by default.
-ghcupGHCBaseDir :: (MonadReader Settings m) => m (Path Abs)
+ghcupGHCBaseDir :: (MonadReader AppState m) => m (Path Abs)
 ghcupGHCBaseDir = do
-  Settings {..} <- ask
-  pure (baseDir dirs </> [rel|ghc|])
+  AppState { dirs = Dirs {..} } <- ask
+  pure (baseDir </> [rel|ghc|])


 -- | Gets '~/.ghcup/ghc/<ghcupGHCDir>'.
 -- The dir may be of the form
 --   * armv7-unknown-linux-gnueabihf-8.8.3
 --   * 8.8.4
-ghcupGHCDir :: (MonadReader Settings m, MonadThrow m)
+ghcupGHCDir :: (MonadReader AppState m, MonadThrow m)
            => GHCTargetVersion
            -> m (Path Abs)
 ghcupGHCDir ver = do
--- a/lib/GHCup/Utils/File.hs
+++ b/lib/GHCup/Utils/File.hs
@ -117,7 +117,7 @@ executeOut path args chdir = captureOutStreams $ do
  SPPB.executeFile (toFilePath path) True args Nothing


-execLogged :: (MonadReader Settings m, MonadIO m, MonadThrow m)
+execLogged :: (MonadReader AppState m, MonadIO m, MonadThrow m)
           => ByteString       -- ^ thing to execute
           -> Bool             -- ^ whether to search PATH for the thing
           -> [ByteString]     -- ^ args for the thing
@ -126,7 +126,7 @@ execLogged :: (MonadReader Settings m, MonadIO m, MonadThrow m)
           -> Maybe [(ByteString, ByteString)] -- ^ optional environment
           -> m (Either ProcessError ())
 execLogged exe spath args lfile chdir env = do
-  Settings {dirs = Dirs {..}, ..} <- ask
+  AppState { settings = Settings {..}, dirs = Dirs {..} } <- ask
  logfile       <- (logsDir </>) <$> parseRel (toFilePath lfile <> ".log")
  liftIO $ bracket (createFile (toFilePath logfile) newFilePerms)
                   closeFd
--- a/lib/GHCup/Utils/Logger.hs
+++ b/lib/GHCup/Utils/Logger.hs
@ -65,9 +65,9 @@ myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
    rawOutter outr


-initGHCupFileLogging :: (MonadIO m, MonadReader Settings m) => Path Rel -> m (Path Abs)
+initGHCupFileLogging :: (MonadIO m, MonadReader AppState m) => Path Rel -> m (Path Abs)
 initGHCupFileLogging context = do
-  Settings {dirs = Dirs {..}} <- ask
+  AppState {dirs = Dirs {..}} <- ask
  let logfile = logsDir </> context
  liftIO $ do
    createDirRecursive' logsDir
--- a/lib/GHCup/Utils/MegaParsec.hs
+++ b/lib/GHCup/Utils/MegaParsec.hs
@ -25,6 +25,7 @@ import           Data.Text                      ( Text )
 import           Data.Versions
 import           Data.Void

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

@ -90,6 +91,8 @@ ghcTargetVerP =
                  (Digits _) -> True
                  (Str    _) -> False
                )
+            . fmap NE.toList
+            . NE.toList
            $ (_vChunks v)
    if startsWithDigists && not (isJust (_vEpoch v))
      then pure $ prettyVer v
--- a/lib/GHCup/Utils/Prelude.hs
+++ b/lib/GHCup/Utils/Prelude.hs
@ -31,11 +31,13 @@ import           Data.ByteString                ( ByteString )
 import           Data.String
 import           Data.Text                      ( Text )
 import           Data.Versions
+import           Data.Word8
 import           Haskus.Utils.Types.List
 import           Haskus.Utils.Variant.Excepts
 import           System.IO.Error
 import           System.Posix.Env.ByteString    ( getEnvironment )

+import qualified Data.ByteString               as B
 import qualified Data.ByteString.Lazy          as L
 import qualified Data.Strict.Maybe             as S
 import qualified Data.Text                     as T
@ -275,3 +277,13 @@ decUTF8Safe = E.decodeUtf8With E.lenientDecode

 decUTF8Safe' :: L.ByteString -> Text
 decUTF8Safe' = TL.toStrict . TLE.decodeUtf8With E.lenientDecode
+
+
+-- | Escape a version for use in regex
+escapeVerRex :: Version -> ByteString
+escapeVerRex = B.pack . go . B.unpack . verToBS
+ where
+  go [] = []
+  go (x : xs) | x == _period = [_backslash, _period] ++ go xs
+              | otherwise    = x : go xs
+
--- a/lib/GHCup/Utils/Version/QQ.hs
+++ b/lib/GHCup/Utils/Version/QQ.hs
@ -42,6 +42,8 @@ deriving instance Data SemVer
 deriving instance Lift SemVer
 deriving instance Data Mess
 deriving instance Lift Mess
+deriving instance Data MChunk
+deriving instance Lift MChunk
 deriving instance Data PVP
 deriving instance Lift PVP
 deriving instance Lift VSep
--- a/lib/GHCup/Version.hs
+++ b/lib/GHCup/Version.hs
@ -22,11 +22,11 @@ import qualified Data.Text                     as T

 -- | This reflects the API version of the YAML.
 ghcupURL :: URI
-ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.2.yaml|]
+ghcupURL = [uri|https://www.haskell.org/ghcup/data/ghcup-0.0.3.yaml|]

 -- | The current ghcup version.
 ghcUpVer :: PVP
-ghcUpVer = [pver|0.1.10|]
+ghcUpVer = [pver|0.1.12|]

 -- | ghcup version as numeric string.
 numericVer :: String
--- a/stack.yaml
+++ b/stack.yaml
@ -0,0 +1,72 @@
+resolver: lts-16.17
+
+packages:
+  - .
+
+extra-deps:
+  - 3rdparty/lzma
+  - 3rdparty/lzma-clib
+  - 3rdparty/zlib
+
+  - git: https://github.com/haskus/packages.git
+    commit: 80a1c5fc07f7226c424250ec17f674cd4d618f42
+    subdirs:
+      - haskus-utils-types
+
+  - git: https://github.com/hasufell/hpath.git
+    commit: bf6d28cf989b70286e12fecc183d5bbf5454a1a2
+    subdirs:
+      - hpath-io
+      - hpath-directory
+
+  - git: https://github.com/hasufell/text-conversions.git
+    commit: 9abf0e5e5664a3178367597c32db19880477a53c
+
+  - IfElse-0.85@sha256:6939b94acc6a55f545f63a168a349dd2fbe4b9a7cca73bf60282db5cc6aa47d2,445
+  - QuickCheck-2.14.1@sha256:01e46d7b0a8d3148288ec977625f62d5516ebb5031a50c63f0453863301b4a79,7736
+  - ascii-string-1.0.1.4@sha256:fa34f1d9ba57e8e89c0d4c9cef5e01ba32cb2d4373d13f92dcc0b531a6c6749b,2582
+  - base64-bytestring-1.1.0.0@sha256:190264fef9e65d9085f00ccda419137096d1dc94777c58272bc96821dc7f37c3,2334
+  - brick-0.55@sha256:f98736eca0cd694837062e06da4655eed969d53b789dfd919716e9b6f5b4c5ce,15858
+  - brotli-0.0.0.0@sha256:2bf383a4cd308745740986be0b18381c5a0784393fe69b91456aacb2d603de46,2964
+  - brotli-streams-0.0.0.0@sha256:1af1e22f67b8bfd6ad0d05e61825e7a178d738f689ebbb21c1aab5f1bbcae176,2331
+  - chs-cabal-0.1.1.0@sha256:20ec6a9fb5ab6991f1a4adf157c537bd5d3b98d08d3c09c387c954c7c50bd011,1153
+  - chs-deps-0.1.0.0@sha256:0cdada6d2c682c41b20331b8c63c2ecfc7e806928585195fd544c9d41f3074fd,2496
+  - composition-prelude-3.0.0.0@sha256:7407835ce8c1e0e2fd6febd25391b12989b216773e685e3cf95bd89072af0ecc,1149
+  - haskus-utils-data-1.3@sha256:f62c4e49021b463185d043f7b69c727b63af641a71d7edd582d9f4f98e80e500,1466
+  - haskus-utils-variant-3.0@sha256:8d51e45d3b664e61ccc25a58b37c0ccc4ee7537138b9fee21cd15c356906dd34,2159
+  - hpath-0.11.0@sha256:12b8405bee13d0007d644a888ef8407069ce7bbbd76970f8746b801447124ade,1440
+  - hpath-filepath-0.10.4@sha256:e9e44fb5fdbade7f30b5b5451257dbee15b6ef1aae4060034d73008bb3b5d878,1269
+  - hpath-posix-0.13.2@sha256:eec4ff2b00dc86be847aca0f409fc8f6212ffd2170ec36a17dc9a52b46562392,1615
+  - http-io-streams-0.1.4.0@sha256:9a74a059daeddf7a41d361919190b9f4d4292f05e0e4bdf156e2098a116a8145,3582
+  - libarchive-3.0.0.0@sha256:e4157b307acf16cca0ec3d398ac5093cc06f092b33a9743be559ef0f6c6ae52f,11204
+  - os-release-1.0.1@sha256:1281c62081f438fc3f0874d3bae6a4887d5964ac25261ba06e29d368ab173467,2716
+  - primitive-extras-0.8@sha256:fca0310150496867f5b9421fe1541ecda87fae17eae44885a29f9c52dd00c8ff,2963
+  - primitive-unlifted-0.1.3.0@sha256:a98f827740f5dcf097d885b3a47c32f4462204449620abc9d51b8c4f8619f9e6,1427
+  - random-1.2.0@sha256:4321209c8faedc034810ea8ed0dbc4a36f1a1df97b75af024219f2f533da57de,6094
+  - splitmix-0.1.0.1@sha256:22f9662e7e8b173421872241edd39350078a9ed4bb9e9f503948c5b483c79276,5253
+  - streamly-posix-0.1.0.1@sha256:5d89b806281035d34020387ed99dde1ddab282c7ed66df3b7cd010b38fd3517b,2138
+  - strict-base-0.4.0.0@sha256:2ff4e43cb95eedf2995558d7fc34d19362846413dd39e6aa6a5b3ea8228fef9f,1248
+  - tar-bytestring-0.6.3.2@sha256:88f29bed56b688c543a4cb3986402d64b360f76b3fd9b88ac618b8344f8da712,5715
+  - versions-4.0.1@sha256:0f644c1587d38f0eb3c3fe364bf1822424db43cbd4d618d0e21473b062c45239,1936
+  - vty-5.30@sha256:4af3938d7b9e6096e222bf52d0ea5d39873bc6fe19febd34106906306af13730,20857
+  - xor-0.0.1.0@sha256:f8362b4a68562b9afbcd727ff64c1a303970df3a032e0033d2f4c094c3501df3,2243
+
+flags:
+  http-io-streams:
+    brotli: false
+
+  libarchive:
+    system-libarchive: false
+
+  ghcup:
+    tui: true
+    internal-downloader: true
+
+system-ghc: true
+compiler: ghc-8.8.4
+compiler-check: match-exact
+
+ghc-options:
+  "$locals": -O2
+  streamly: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
+  ghcup: -O2 -fspec-constr-recursive=16 -fmax-worker-args=16
--- a/test/GHCup/ArbitraryTypes.hs
+++ b/test/GHCup/ArbitraryTypes.hs
@ -0,0 +1,193 @@
+{-# OPTIONS_GHC -Wno-orphans #-}
+
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE StandaloneDeriving #-}
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE TypeApplications #-}
+
+module GHCup.ArbitraryTypes where
+
+
+import           GHCup.Types
+
+import           Data.ByteString                ( ByteString )
+import           Data.Versions
+import           Data.List.NonEmpty
+import           HPath
+import           Test.QuickCheck
+import           Test.QuickCheck.Arbitrary.ADT  ( ToADTArbitrary )
+import           Test.QuickCheck.Arbitrary.Generic
+import           URI.ByteString
+
+import qualified Data.Map.Strict               as M
+import qualified Data.Text                     as T
+import qualified Data.Text.Encoding            as E
+import qualified Data.Text.Lazy                as T
+                                                ( toStrict )
+import qualified Data.Text.Lazy.Builder        as B
+import qualified Data.Text.Lazy.Builder.Int    as B
+
+
+    -----------------
+    --[ utilities ]--
+    -----------------
+
+intToText :: Integral a => a -> T.Text
+intToText = T.toStrict . B.toLazyText . B.decimal
+
+genVer :: Gen (Int, Int, Int)
+genVer =
+  (\x y z -> (getPositive x, getPositive y, getPositive z))
+    <$> arbitrary
+    <*> arbitrary
+    <*> arbitrary
+
+
+instance ToADTArbitrary GHCupInfo
+
+
+
+    ----------------------
+    --[ base arbitrary ]--
+    ----------------------
+
+instance Arbitrary T.Text where
+  arbitrary = fmap T.pack $ listOf $ elements ['a' .. 'z']
+  shrink xs = T.pack <$> shrink (T.unpack xs)
+
+instance Arbitrary (NonEmpty Word) where
+  arbitrary = fmap fromList $ listOf1 $ arbitrary
+
+-- utf8 encoded bytestring
+instance Arbitrary ByteString where
+  arbitrary = fmap (E.encodeUtf8 . T.pack) $ listOf $ elements ['a' .. 'z']
+
+
+
+    ---------------------
+    --[ uri arbitrary ]--
+    ---------------------
+
+instance Arbitrary Scheme where
+  arbitrary = oneof [ Scheme <$> pure "http", Scheme <$> pure "https" ]
+
+instance Arbitrary Host where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary Port where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary (URIRef Absolute) where
+  arbitrary =
+    URI <$> arbitrary <*> pure Nothing <*> arbitrary <*> (Query <$> pure []) <*> pure Nothing
+
+
+
+    -------------------------
+    --[ version arbitrary ]--
+    -------------------------
+
+instance Arbitrary Mess where
+  arbitrary = do
+    (x, y, z) <- genVer
+    pure
+      $ either (error . show) id
+      $ mess
+      $ (intToText x <> "." <> intToText y <> "." <> intToText z)
+
+instance Arbitrary Version where
+  arbitrary = do
+    (x, y, z) <- genVer
+    pure
+      $ either (error . show) id
+      $ version
+      $ (intToText x <> "." <> intToText y <> "." <> intToText z)
+
+instance Arbitrary SemVer where
+  arbitrary = do
+    (x, y, z) <- genVer
+    pure
+      $ either (error . show) id
+      $ semver
+      $ (intToText x <> "." <> intToText y <> "." <> intToText z)
+
+instance Arbitrary PVP where
+  arbitrary = do
+    (x, y, z) <- genVer
+    pure
+      $ either (error . show) id
+      $ pvp
+      $ (intToText x <> "." <> intToText y <> "." <> intToText z)
+
+instance Arbitrary Versioning where
+  arbitrary = Ideal <$> arbitrary
+
+
+
+    -----------------------
+    --[ ghcup arbitrary ]--
+    -----------------------
+
+instance Arbitrary Requirements where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary DownloadInfo where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary LinuxDistro where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary Platform where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary Tag where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary Architecture where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary VersionInfo where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary (Path Rel) where
+  arbitrary =
+    (either (error . show) id . parseRel . E.encodeUtf8 . T.pack)
+      <$> (listOf1 $ elements ['a' .. 'z'])
+
+instance Arbitrary TarDir where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary Tool where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+instance Arbitrary GHCupInfo where
+  arbitrary = genericArbitrary
+  shrink    = genericShrink
+
+
+-- our maps are nested... the default size easily blows up most ppls ram
+
+instance {-# OVERLAPS #-} Arbitrary v => Arbitrary (M.Map Tool v) where
+  arbitrary = resize 8 $ M.fromList <$> arbitrary
+
+instance {-# OVERLAPS #-} Arbitrary v => Arbitrary (M.Map (Maybe Version) v) where
+  arbitrary = resize 8 $ M.fromList <$> arbitrary
+
+instance {-# OVERLAPS #-} Arbitrary v => Arbitrary (M.Map Platform v) where
+  arbitrary = resize 8 $ M.fromList <$> arbitrary
+
+instance {-# OVERLAPS #-} Arbitrary v => Arbitrary (M.Map (Maybe Versioning) v) where
+  arbitrary = resize 8 $ M.fromList <$> arbitrary
+
--- a/test/GHCup/Types/JSONSpec.hs
+++ b/test/GHCup/Types/JSONSpec.hs
@ -0,0 +1,17 @@
+{-# LANGUAGE DeriveGeneric #-}
+{-# LANGUAGE TypeApplications #-}
+
+module GHCup.Types.JSONSpec where
+
+import           GHCup.ArbitraryTypes ()
+import           GHCup.Types
+import           GHCup.Types.JSON ()
+
+import           Test.Aeson.GenericSpecs
+import           Test.Hspec
+
+
+
+spec :: Spec
+spec = do
+  roundtripAndGoldenSpecs (Proxy @GHCupInfo)
--- a/test/Main.hs
+++ b/test/Main.hs
@ -0,0 +1,12 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+import Test.Hspec.Runner
+import Test.Hspec.Formatters
+import qualified Spec
+
+
+main :: IO ()
+main =
+  hspecWith
+    defaultConfig { configFormatter = Just progress }
+    $ Spec.spec
--- a/test/MyLibTest.hs
+++ b/test/MyLibTest.hs
@ -1,4 +0,0 @@
-module Main (main) where
-
-main :: IO ()
-main = putStrLn "Test suite not yet implemented."
--- a/test/Spec.hs
+++ b/test/Spec.hs
@ -0,0 +1,2 @@
+-- file test/Spec.hs
+{-# OPTIONS_GHC -F -pgmF hspec-discover -optF --module-name=Spec #-}
Author	SHA1	Message	Date
Julian Ospald	3e841b3c68	Merge branch 'settings' into master	2020-10-26 18:25:20 +01:00
Julian Ospald	53f5a08924	Allow configuring URLSource as well	2020-10-25 14:47:26 +01:00
Julian Ospald	d368863c3d	Improve help output	2020-10-25 11:00:00 +01:00
Julian Ospald	c76cce5830	Add a --set option to install/compile, fixes #81	2020-10-25 10:54:04 +01:00
Julian Ospald	4fef93b7b1	Allow to configure ghcup with a yaml config file Fixes #41	2020-10-25 10:22:45 +01:00
Julian Ospald	241dadbeb5	Update to versions-4.0.1 API	2020-10-25 10:22:35 +01:00
Julian Ospald	12459c2544	Add internal downloader and tui flags to stack	2020-10-25 10:22:35 +01:00
Julian Ospald	e250d6013f	Redo Settings as AppState	2020-10-24 01:07:31 +02:00
Julian Ospald	0d41d180d6	Merge remote-tracking branch 'origin/merge-requests/40' into master	2020-10-14 11:59:15 +02:00
amesgen	ef251ce17e	update to cabal-3.4.0.0-rc4	2020-10-13 20:53:09 +02:00
Julian Ospald	956e11c3f8	Bump version to 0.1.12	2020-10-13 00:09:35 +02:00
Julian Ospald	951b0843b2	Update hls to 0.5.1	2020-10-12 23:54:56 +02:00
Julian Ospald	a4e4080a1b	Merge branch 'TUI-improvements' into master	2020-10-12 23:40:26 +02:00
Julian Ospald	2aa91c5d91	Update golden test	2020-10-12 21:48:06 +02:00
Julian Ospald	6471b3877f	Bump ghcup version in bootstrap-haskell	2020-10-12 21:05:25 +02:00
Julian Ospald	778ee142d5	Upload golden files as artifacts on failure	2020-10-12 00:10:37 +02:00
Julian Ospald	1140132a25	Update hie.yaml	2020-10-11 23:40:02 +02:00
Julian Ospald	c5c299179d	Remove text-conversion workaround	2020-10-11 23:39:49 +02:00
Julian Ospald	0ce4549eb8	Ditch the viewport logic	2020-10-11 23:37:27 +02:00
Julian Ospald	97d568ddd6	Show new versions in bright white	2020-10-11 21:44:11 +02:00
Julian Ospald	ea58465240	Expand the selected bar	2020-10-11 21:16:48 +02:00
Julian Ospald	7afd262b1b	Put separators between tools	2020-10-11 21:07:21 +02:00
Julian Ospald	34ceaa0823	Add brick to stack.yaml	2020-10-11 21:06:58 +02:00
Julian Ospald	57c34a07f2	Allow to hide old versions of tools in TUI	2020-10-09 23:05:11 +02:00
Julian Ospald	73d1d97f1f	Reverse order of tool list in TUI	2020-10-09 20:25:52 +02:00
Julian Ospald	f7ed1a4bde	Commit ghc-8.8.4 cabal.project files These are auto-generated from stack and meant for users.	2020-10-05 22:11:05 +02:00
Julian Ospald	bdd80d0229	Bump stack lts	2020-10-05 22:10:52 +02:00
Julian Ospald	0238f70c64	Bump hls to 0.5.0	2020-10-05 00:19:35 +02:00
Julian Ospald	24ff430c45	Add stack.yaml wrt #75	2020-10-01 17:49:23 +02:00
Julian Ospald	281fb14d4c	Rename ghc-9.0.1-alpha1 to 9.0.0.20200925 wrt #73	2020-09-29 23:33:55 +02:00
Julian Ospald	03bac93929	Improve bootstrap test	2020-09-29 10:57:21 +02:00
Julian Ospald	1ae0c2a654	Move printf to the right place	2020-09-29 10:52:31 +02:00
Julian Ospald	8140936bd3	Test bootstrap-haskell wrt #72	2020-09-29 10:23:29 +02:00
Julian Ospald	8786acf476	Fix BOOTSTRAP_HASKELL_NONINTERACTIVE	2020-09-29 10:12:03 +02:00
Julian Ospald	c460d4c743	Update bindists for Mint to fedora	2020-09-29 00:22:58 +02:00
Julian Ospald	5294adf0d7	Fix bootstrap-script	2020-09-28 23:52:23 +02:00
Julian Ospald	00f3fa35fd	Add hls installation to bootstrap-haskell	2020-09-28 23:48:59 +02:00
Julian Ospald	9c9aa4f9c0	Fix CI	2020-09-28 23:27:15 +02:00
Julian Ospald	e23a187cc4	Add ghc-9.0.1-alpha1	2020-09-28 23:23:11 +02:00
Julian Ospald	3e429945dc	Also modify .bash_profile on mac	2020-09-28 09:59:35 +02:00
Julian Ospald	8be2a8eed7	Update CHANGELOG date for 0.1.11	2020-09-23 09:53:44 +02:00
Julian Ospald	6b65167581	Update yaml files	2020-09-23 00:27:28 +02:00
Julian Ospald	9d7914e69a	Bump ghcupURL	2020-09-22 23:41:19 +02:00
Julian Ospald	6c62884b24	Update Changelog	2020-09-22 21:31:01 +02:00
Julian Ospald	965d2a3ba8	Drop 'ghcup compile cabal' Upstream has discontinued the old bootstrap shell script. The new python shell script doesn't work like the old one and is only useful for bootstrapping to a new architecture. If you miss this feature, consider running: cabal install cabal-install with the appropriate GHC version set (this might need some experimenting). This also fixes #64	2020-09-22 21:26:10 +02:00
Julian Ospald	40a1cc98c6	Drop use of table-layout, thanks to Simon	2020-09-22 21:05:59 +02:00
Julian Ospald	4c2d4ee6bd	Update hls tarballs	2020-09-22 19:23:24 +02:00
Julian Ospald	9276664465	Merge branch 'hls' into master	2020-09-22 15:23:10 +02:00
Julian Ospald	a94bcdb92d	Remove 9.0.1-alpha1 Ben requested removal, since this wasn't an announced release.	2020-09-21 14:13:45 +02:00
Julian Ospald	5da5fabfef	Use alpine:3.12 instead of edge	2020-09-21 12:23:14 +02:00
Julian Ospald	05cc55c52d	Improve brick UI	2020-09-21 10:40:06 +02:00
Julian Ospald	571df1349c	Update hie.yaml	2020-09-20 23:09:09 +02:00
Julian Ospald	cbbb75062c	Bump version to 0.1.11	2020-09-20 23:09:09 +02:00
Julian Ospald	bb7c4205db	Allow to install haskell-language-server wrt #65	2020-09-20 23:09:09 +02:00
Julian Ospald	b2027f1625	Simplify installing GHC from custom bindist wrt #60	2020-09-19 11:52:12 +02:00
Julian Ospald	65945c87df	Update CHANGELOG	2020-09-19 11:51:48 +02:00
Julian Ospald	081582d3e1	Merge branch 'compile-overwrite' into master	2020-09-18 09:31:14 +02:00
Julian Ospald	bf240af518	Fix build https://github.com/cjdev/text-conversions/pull/10	2020-09-17 22:18:03 +02:00
Julian Ospald	a269131e2d	Allow to compile over existing version, fixes #59	2020-09-17 21:21:16 +02:00
Julian Ospald	59ece98fdc	Fix bug in compileGHC cleanup logic	2020-09-17 21:20:38 +02:00
Julian Ospald	563924ff26	Fix gitlab CI	2020-09-15 22:22:15 +02:00
Julian Ospald	8ee3f55428	Fix test on i386	2020-09-15 21:59:56 +02:00
Julian Ospald	93c17607b5	Fix haddock build, fixes #62	2020-09-15 17:44:30 +02:00
Julian Ospald	8b4c239444	Add changelog entry for cabal-3.4.0.0-rc3	2020-09-15 15:43:07 +02:00
Julian Ospald	8bef17bf59	Add cabal-3.4.0.0-rc3	2020-09-15 15:38:10 +02:00
Julian Ospald	a649146a39	Add hspec tests to gitlab CI	2020-09-13 21:13:42 +02:00
Julian Ospald	9d6a5313ab	Add JSON roundtrip specs	2020-09-13 21:10:13 +02:00
Julian Ospald	de09c950d5	Improve requirements wording, fixes #56	2020-09-13 15:38:51 +02:00
Julian Ospald	47838b1bd9	Merge branch 'compile-bindist' into master	2020-09-13 13:30:28 +02:00
Julian Ospald	02b360e2a9	Create bindists when compiling GHC wrt #51	2020-09-12 23:47:12 +02:00
Julian Ospald	c10ab15e0c	Update cabal pre-release ot 3.4.0.0-rc2	2020-09-04 10:16:28 +02:00