Add ghcup-0.1.9

Update ghcup bins for alpine, bc these must be explicit
See 22a5ad73
2020-08-14 09:48:57 +02:00 · 2020-08-11 18:27:44 +02:00
36 changed files with 5338 additions and 2246 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -12,4 +12,3 @@ tags
 TAGS
 /tmp/
 .entangled
-release/
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -14,7 +14,6 @@ variables:
    - x86_64-linux
  variables:
    OS: "LINUX"
-    BIT: "64"

 .alpine:64bit:
  image: "alpine:edge"
@@ -37,14 +36,12 @@ variables:
    - x86_64-darwin
  variables:
    OS: "DARWIN"
-    BIT: "64"

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

 .root_cleanup:
  after_script:
@@ -69,13 +66,6 @@ variables:
  before_script:
    - ./.gitlab/before_script/linux/install_deps.sh

-.test_ghcup_version:linux32:
-  extends:
-    - .test_ghcup_version
-    - .alpine:32bit
-  before_script:
-    - ./.gitlab/before_script/linux/alpine/install_deps.sh
-
 .test_ghcup_version:darwin:
  extends:
    - .test_ghcup_version
@@ -113,17 +103,10 @@ test:linux:recommended:
 test:linux:latest:
  extends: .test_ghcup_version:linux
  variables:
-    GHC_VERSION: "8.10.2"
+    GHC_VERSION: "8.10.1"
    CABAL_VERSION: "3.2.0.0"
  allow_failure: true

-######## linux 32bit test ########
-
-test:linux:recommended:32bit:
-  extends: .test_ghcup_version:linux32
-  variables:
-    GHC_VERSION: "8.8.4"
-    CABAL_VERSION: "3.2.0.0"

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

@@ -136,7 +119,7 @@ test:mac:recommended:
 test:mac:latest:
  extends: .test_ghcup_version:darwin
  variables:
-    GHC_VERSION: "8.10.2"
+    GHC_VERSION: "8.10.1"
    CABAL_VERSION: "3.2.0.0"
  allow_failure: true

@@ -152,7 +135,7 @@ test:freebsd:recommended:
 test:freebsd:latest:
  extends: .test_ghcup_version:freebsd
  variables:
-    GHC_VERSION: "8.10.2"
+    GHC_VERSION: "8.10.1"
    CABAL_VERSION: "3.2.0.0"
  allow_failure: true

--- a/.gitlab/before_script/linux/alpine/install_deps.sh
+++ b/.gitlab/before_script/linux/alpine/install_deps.sh
@@ -18,6 +18,10 @@ apk add --no-cache \
 	tar \
 	perl

+ln -sf libncurses.so /usr/lib/libtinfo.so
+ln -sf libncursesw.so.6 /usr/lib/libtinfow.so.6
+ln -sf libtinfow.so.6 /usr/lib/libtinfow.so
+
 if [ "${BIT}" = "32" ] ; then
 	curl -sSfL https://downloads.haskell.org/ghcup/i386-linux-ghcup > ./ghcup-bin
 else
@@ -45,3 +49,5 @@ apk add --no-cache \
 	xz-dev \
 	ncurses-static

+ln -sf libncursesw.a /usr/lib/libtinfow.a
+
--- a/.gitlab/script/ghcup_version.sh
+++ b/.gitlab/script/ghcup_version.sh
@@ -11,7 +11,7 @@ ecabal() {
 }

 eghcup() {
-	ghcup -v -c -s file://$(pwd)/ghcup-${JSON_VERSION}.yaml "$@"
+	ghcup -v -c -s file://$(pwd)/ghcup-${JSON_VERSION}.json "$@"
 }

 git describe --always
@@ -22,20 +22,14 @@ ecabal update

 if [ "${OS}" = "DARWIN" ] ; then
 	ecabal build -w ghc-${GHC_VERSION} -ftui
-elif [ "${OS}" = "LINUX" ] ; then
-	if [ "${BIT}" = "32" ] ; then
-		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui -ftar
-	else
-		ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
-	fi
 else
 	ecabal build -w ghc-${GHC_VERSION} -finternal-downloader -ftui
 fi

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

-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 --enable-tests --verbose=0 --offline sh -- -c 'command -v ghcup')" .
+cp "$(ecabal new-exec --enable-tests --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
@@ -48,7 +42,7 @@ rm -rf "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
 ### manual cli based testing


-ghcup-gen check -f ghcup-${JSON_VERSION}.yaml
+ghcup-gen check -f ghcup-${JSON_VERSION}.json

 eghcup --numeric-version

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

-## 0.1.10 -- 2020-08-14
-
-* Show stray Cabals (useful for pre-releases or compiled ones)
-
-## 0.1.9 -- 2020-08-14
-
-* Fix bug when uninstalling all cabal versions
-* Fix bug when setting a non-installed ghc version as current default
-* Use yaml instead of generated json for download info for ease of adding new GHC versions #44
-* Allow pre-release versions of GHC/cabal
-* Add XDG dirs support (set `GHCUP_USE_XDG_DIRS`) wrt #39
-* Allow to specify regex for tarball subdir (e.g. `ghc-.*`)
-* Allow installing arbitrary bindists more seamlessly:
-  - e.g. installing GHC HEAD: `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`
-* Avoid duplicate edits to .bashrc/.zshrc wrt #43
-
 ## 0.1.8 -- 2020-07-21

 * Fix bug in logging thread dying on newlines
--- a/README.md
+++ b/README.md
@@ -9,15 +9,10 @@ Similar in scope to [rustup](https://github.com/rust-lang-nursery/rustup.rs), [p
 ## Table of Contents

   * [Installation](#installation)
-     * [Simple bootstrap](#simple-bootstrap)
-     * [Manual install](#manual-install)
-     * [Vim integration](#vim-integration)
   * [Usage](#usage)
     * [Manpages](#manpages)
     * [Shell-completion](#shell-completion)
     * [Cross support](#cross-support)
-     * [XDG support](#xdg-support)
-     * [Installing custom bindists](#installing-custom-bindists)
   * [Design goals](#design-goals)
   * [How](#how)
   * [Known users](#known-users)
@@ -41,10 +36,6 @@ Then adjust your `PATH` in `~/.bashrc` (or similar, depending on your shell) lik
 export PATH="$HOME/.cabal/bin:$HOME/.ghcup/bin:$PATH"
 ```

-### Vim integration
-
-See [ghcup.vim](https://github.com/hasufell/ghcup.vim).
-
 ## Usage

 See `ghcup --help`.
@@ -105,32 +96,6 @@ For distributions with non-standard locations of cross toolchain and
 libraries, this may need some tweaking of `build.mk` or configure args.
 See `ghcup compile ghc --help` for further information.

-### XDG support
-
-To enable XDG style directories, set the environment variable `GHCUP_USE_XDG_DIRS` to anything.
-
-Then you can control the locations via XDG environment variables as such:
-
-* `XDG_DATA_HOME`: GHCs will be unpacked in `ghcup/ghc` subdir
-* `XDG_CACHE_HOME`: logs and download files will be stored in `ghcup` subdir
-* `XDG_BIN_HOME`: binaries end up here (default: `~/.local/bin`)
-
-### Installing custom bindists
-
-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`
-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`
-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`
-
-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.
-GHCup always needs to know which version the bindist corresponds to (this is not automatically
-detected).
-
 ## Design goals

 1. simplicity
--- a/RELEASING.md
+++ b/RELEASING.md
@@ -1,19 +1,19 @@
 # RELEASING

-1. update `GHCup.Version` module. `ghcupURL` must only be updated if we change the `_toolRequirements` type or the YAML representation of it. The version of the YAML represents the change increments. `ghcUpVer` is the current application version.
+1. update `GHCup.Version` module. `ghcupURL` must only be updated if we change the `_toolRequirements` type or the JSON representation of it. The version of the json represents the change increments. `ghcUpVer` is the current application version.

 2. Update version in ghcup.cabal

 3. Add ChangeLog entry

-4. Add/fix downloads in `ghcup-<ver>.yaml`, then verify with `ghcup-gen check -f ghcup-<ver>.yaml`
+4. Add/fix downloads to `GHCupDownloads` module, then run `ghcup-gen gen` to generate the new json and validate it via `ghcup-gen check`.

 5. Commit and git push with tag. Wait for tests to succeed and release artifacts to build.

 6. Download release artifacts and upload them `downloads.haskell.org/ghcup`

-7. Add release artifacts to yaml file (see point 4.)
+7. Add release artifacts to GHCupDownloads (see point 4.)

-8. Upload the final `ghcup-<ver>.yaml` to `webhost.haskell.org/ghcup/data/`.
+8. Upload the final `ghcup-<ver>.json` to `webhost.haskell.org/ghcup/data/`.

 9. Update bootstrap-haskell and symlinks on `downloads.haskell.org/ghcup`
--- a/app/ghcup-gen/Main.hs
+++ b/app/ghcup-gen/Main.hs
@@ -10,10 +10,13 @@

 module Main where

+import           GHCup.Data.GHCupInfo
 import           GHCup.Types
 import           GHCup.Types.JSON               ( )
 import           GHCup.Utils.Logger

+import           Data.Aeson                     ( eitherDecode, encode )
+import           Data.Aeson.Encode.Pretty
 #if !MIN_VERSION_base(4,13,0)
 import           Data.Semigroup                 ( (<>) )
 #endif
@@ -24,15 +27,48 @@ import           System.IO                      ( stdout )
 import           Validate

 import qualified Data.ByteString               as B
-import qualified Data.Yaml                     as Y
+import qualified Data.ByteString.Lazy          as L


 data Options = Options
  { optCommand :: Command
  }

-data Command = ValidateYAML ValidateYAMLOpts
-             | ValidateTarballs ValidateYAMLOpts
+data Command = GenJSON GenJSONOpts
+             | ValidateJSON ValidateJSONOpts
+             | ValidateTarballs ValidateJSONOpts
+
+data Output
+  = FileOutput FilePath -- optsparse-applicative doesn't handle ByteString correctly anyway
+  | StdOutput
+
+fileOutput :: Parser Output
+fileOutput =
+  FileOutput
+    <$> (strOption
+          (long "file" <> short 'f' <> metavar "FILENAME" <> help
+            "Output to a file"
+          )
+        )
+
+stdOutput :: Parser Output
+stdOutput = flag'
+  StdOutput
+  (short 'o' <> long "stdout" <> help "Print to stdout (default)")
+
+outputP :: Parser Output
+outputP = fileOutput <|> stdOutput
+
+
+data GenJSONOpts = GenJSONOpts
+  { output :: Maybe Output
+  , pretty :: Bool
+  }
+
+genJSONOpts :: Parser GenJSONOpts
+genJSONOpts = GenJSONOpts <$> optional outputP <*> switch
+  (short 'p' <> long "pretty" <> help "Make JSON output pretty (human readable)"
+  )


 data Input
@@ -56,12 +92,12 @@ stdInput = flag'
 inputP :: Parser Input
 inputP = fileInput <|> stdInput

-data ValidateYAMLOpts = ValidateYAMLOpts
-  { vInput :: Maybe Input
+data ValidateJSONOpts = ValidateJSONOpts
+  { input :: Maybe Input
  }

-validateYAMLOpts :: Parser ValidateYAMLOpts
-validateYAMLOpts = ValidateYAMLOpts <$> optional inputP
+validateJSONOpts :: Parser ValidateJSONOpts
+validateJSONOpts = ValidateJSONOpts <$> optional inputP

 opts :: Parser Options
 opts = Options <$> com
@@ -69,10 +105,18 @@ opts = Options <$> com
 com :: Parser Command
 com = subparser
  (  (command
+       "gen"
+       (   GenJSON
+       <$> (info (genJSONOpts <**> helper)
+                 (progDesc "Generate the json downloads file")
+           )
+       )
+     )
+  <> (command
       "check"
-       (   ValidateYAML
-       <$> (info (validateYAMLOpts <**> helper)
-                 (progDesc "Validate the YAML")
+       (   ValidateJSON
+       <$> (info (validateJSONOpts <**> helper)
+                 (progDesc "Validate the JSON")
           )
       )
     )
@@ -80,7 +124,7 @@ com = subparser
       "check-tarballs"
       (   ValidateTarballs
       <$> (info
-             (validateYAMLOpts <**> helper)
+             (validateJSONOpts <**> helper)
             (progDesc "Validate all tarballs (download and checksum)")
           )
       )
@@ -91,27 +135,38 @@ com = subparser

 main :: IO ()
 main = do
-  _ <- customExecParser (prefs showHelpOnError) (info (opts <**> helper) idm)
+  customExecParser (prefs showHelpOnError) (info (opts <**> helper) idm)
    >>= \Options {..} -> case optCommand of
-          ValidateYAML vopts -> case vopts of
-            ValidateYAMLOpts { vInput = Nothing } ->
-              B.getContents >>= valAndExit validate
-            ValidateYAMLOpts { vInput = Just StdInput } ->
-              B.getContents >>= valAndExit validate
-            ValidateYAMLOpts { vInput = Just (FileInput file) } ->
-              B.readFile file >>= valAndExit validate
+          GenJSON gopts -> do
+            let bs True =
+                  encodePretty' (defConfig { confIndent = Spaces 2 }) ghcupInfo
+                bs False = encode ghcupInfo
+            case gopts of
+              GenJSONOpts { output = Nothing, pretty } ->
+                L.hPutStr stdout (bs pretty)
+              GenJSONOpts { output = Just StdOutput, pretty } ->
+                L.hPutStr stdout (bs pretty)
+              GenJSONOpts { output = Just (FileOutput file), pretty } ->
+                L.writeFile file (bs pretty)
+          ValidateJSON vopts -> case vopts of
+            ValidateJSONOpts { input = Nothing } ->
+              L.getContents >>= valAndExit validate
+            ValidateJSONOpts { input = Just StdInput } ->
+              L.getContents >>= valAndExit validate
+            ValidateJSONOpts { input = Just (FileInput file) } ->
+              L.readFile file >>= valAndExit validate
          ValidateTarballs vopts -> case vopts of
-            ValidateYAMLOpts { vInput = Nothing } ->
-              B.getContents >>= valAndExit validateTarballs
-            ValidateYAMLOpts { vInput = Just StdInput } ->
-              B.getContents >>= valAndExit validateTarballs
-            ValidateYAMLOpts { vInput = Just (FileInput file) } ->
-              B.readFile file >>= valAndExit validateTarballs
+            ValidateJSONOpts { input = Nothing } ->
+              L.getContents >>= valAndExit validateTarballs
+            ValidateJSONOpts { input = Just StdInput } ->
+              L.getContents >>= valAndExit validateTarballs
+            ValidateJSONOpts { input = Just (FileInput file) } ->
+              L.readFile file >>= valAndExit validateTarballs
  pure ()

 where
  valAndExit f contents = do
-    (GHCupInfo _ av) <- case Y.decodeEither' contents of
+    (GHCupInfo _ av) <- case eitherDecode contents of
      Right r -> pure r
      Left  e -> die (color Red $ show e)
    myLoggerT (LoggerConfig True (B.hPut stdout) (\_ -> pure ())) (f av)
--- a/app/ghcup-gen/Validate.hs
+++ b/app/ghcup-gen/Validate.hs
@@ -7,9 +7,7 @@ module Validate where
 import           GHCup
 import           GHCup.Download
 import           GHCup.Types
-import           GHCup.Utils.Dirs
 import           GHCup.Utils.Logger
-import           GHCup.Utils.Version.QQ

 import           Control.Exception.Safe
 import           Control.Monad
@@ -90,15 +88,6 @@ validate dls = do
    when ((not $ any (== FreeBSD) pspecs) && arch == A_64) $ lift $ $(logWarn)
      [i|FreeBSD missing for #{t} #{v'} #{arch}|]

-    -- alpine needs to be set explicitly, because
-    -- we cannot assume that "Linux UnknownLinux" runs on Alpine
-    -- (although it could be static)
-    when (not $ any (== Linux Alpine) pspecs) $
-      case t of
-        GHCup -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
-        Cabal | v > [vver|2.4.1.0|] -> (lift $ $(logError) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]) >> addError
-        _     -> lift $ $(logWarn) [i|Linux Alpine missing for #{t} #{v'} #{arch}|]
-
  checkUniqueTags tool = do
    let allTags = join $ M.elems $ availableToolVersions dls tool
    let nonUnique =
@@ -122,7 +111,6 @@ validate dls = do
   where
    isUniqueTag Latest         = True
    isUniqueTag Recommended    = True
-    isUniqueTag Prerelease     = False
    isUniqueTag (Base       _) = False
    isUniqueTag (UnknownTag _) = False

@@ -191,8 +179,7 @@ validateTarballs dls = do

 where
  downloadAll dli = do
-    dirs <- liftIO getDirs
-    let settings = Settings True False Never Curl False dirs
+    let settings = Settings True False Never Curl False
    let runLogger = myLoggerT LoggerConfig { lcPrintDebug = True
                                           , colorOutter  = B.hPut stderr
                                           , rawOutter    = (\_ -> pure ())
--- a/app/ghcup/BrickMain.hs
+++ b/app/ghcup/BrickMain.hs
@@ -112,7 +112,6 @@ ui AppState {..} =

  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

@@ -138,7 +137,6 @@ defaultAttributes = attrMap
  , ("installed"    , Vty.defAttr `Vty.withForeColor` Vty.green)
  , ("recommended"  , Vty.defAttr `Vty.withForeColor` Vty.green)
  , ("latest"       , Vty.defAttr `Vty.withForeColor` Vty.yellow)
-  , ("prerelease"   , Vty.defAttr `Vty.withForeColor` Vty.red)
  , ("help"         , Vty.defAttr `Vty.withStyle` Vty.italic)
  ]

@@ -175,18 +173,19 @@ withIOAction :: (AppState -> (Int, ListResult) -> IO (Either String a))
 withIOAction action as = case listSelectedElement (lr 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
-        putStrLn "Press enter to continue"
-        _ <- getLine
-        pure nas
-      Left err -> throwIO $ userError err
+    r <- action as (ix, e)
+    case r of
+      Left  err -> throwIO $ userError err
+      Right _   -> do
+        apps <- (fmap . fmap)
+          (\AppState {..} -> AppState { lr = listMoveTo ix lr, .. })
+          $ getAppState Nothing (pfreq as)
+        case apps of
+          Right nas -> do
+            putStrLn "Press enter to continue"
+            _ <- getLine
+            pure nas
+          Left err -> throwIO $ userError err


 install' :: AppState -> (Int, ListResult) -> IO (Either String ())
@@ -214,9 +213,7 @@ install' AppState {..} (_, ListResult {..}) = do
            , TagNotFound
            , DigestError
            , DownloadFailed
-            , NoUpdate
-            , TarDirDoesNotExist
-            ]
+            , NoUpdate]

  (run $ do
      case lTool of
@@ -299,15 +296,14 @@ uri' = unsafePerformIO (newIORef Nothing)

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


 logger' :: IORef LoggerConfig
--- a/app/ghcup/Main.hs
+++ b/app/ghcup/Main.hs
@@ -1,7 +1,6 @@
 {-# LANGUAGE CPP               #-}
 {-# LANGUAGE DataKinds         #-}
 {-# LANGUAGE TypeApplications  #-}
-{-# LANGUAGE FlexibleContexts  #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE TemplateHaskell   #-}
 {-# LANGUAGE QuasiQuotes       #-}
@@ -404,11 +403,7 @@ installParser =
  installGHCFooter = [s|Discussion:
  Installs the specified GHC version (or a recommended default one) into
  a self-contained "~/.ghcup/ghc/<ghcver>" directory
-  and symlinks the ghc binaries to "~/.ghcup/bin/<binary>-<ghcver>".
-
-Examples:
-  # install GHC head
-  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|]
+  and symlinks the ghc binaries to "~/.ghcup/bin/<binary>-<ghcver>".|]


 installOpts :: Parser InstallOptions
@@ -432,7 +427,7 @@ installOpts =
            <> long "url"
            <> metavar "BINDIST_URL"
            <> help
-                 "Provide DownloadInfo as json string, e.g.: '{ \"dlHash\": \"<sha256 hash>\", \"dlSubdir\": { \"RegexDir\": \"ghc-.*\"}, \"dlUri\": \"<uri>\" }'"
+                 "Provide DownloadInfo as json string, e.g.: '{ \"dlHash\": \"<sha256 hash>\", \"dlSubdir\": \"ghc-<ver>\", \"dlUri\": \"<uri>\" }'"
            )
          )
        )
@@ -823,15 +818,14 @@ bindistParser :: String -> Either String DownloadInfo
 bindistParser = eitherDecode . BLU.fromString


-toSettings :: Options -> IO Settings
-toSettings Options {..} = do
+toSettings :: Options -> Settings
+toSettings Options {..} =
  let cache      = optCache
      noVerify   = optNoVerify
      keepDirs   = optKeepDirs
      downloader = optsDownloader
      verbose    = optVerbose
-  dirs <- getDirs
-  pure $ Settings { .. }
+  in  Settings { .. }


 upgradeOptsP :: Parser UpgradeOpts
@@ -907,13 +901,14 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
            (footerDoc (Just $ text main_footer))
      )
    >>= \opt@Options {..} -> do
-          settings@Settings{dirs = Dirs{..}, ..} <- toSettings opt
+          let settings@Settings{..} = toSettings opt

          -- create ~/.ghcup dir
-          createDirRecursive' baseDir
+          ghcdir <- ghcupBaseDir
+          createDirIfMissing newDirPerms ghcdir

          -- logger interpreter
-          logfile <- flip runReaderT settings $ initGHCupFileLogging [rel|ghcup.log|]
+          logfile <- initGHCupFileLogging [rel|ghcup.log|]
          let loggerConfig = LoggerConfig
                { lcPrintDebug = optVerbose
                , colorOutter  = B.hPut stderr
@@ -944,7 +939,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                      , TagNotFound
                      , DigestError
                      , DownloadFailed
-                      , TarDirDoesNotExist
                      ]

          let
@@ -960,13 +954,12 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
          let
            runSetCabal =
              runLogger
-                . flip runReaderT settings
                . runE
                  @'[ NotInstalled
                    , TagNotFound
                    ]

-          let runListGHC = runLogger . flip runReaderT settings
+          let runListGHC = runLogger

          let runRm =
                runLogger . flip runReaderT settings . runE @'[NotInstalled]
@@ -991,7 +984,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                      , NotFoundInPATH
                      , PatchFailed
                      , UnknownArchive
-                      , TarDirDoesNotExist
 #if !defined(TAR)
                      , ArchiveResult
 #endif
@@ -1011,7 +1003,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                      , NotInstalled
                      , PatchFailed
                      , UnknownArchive
-                      , TarDirDoesNotExist
 #if !defined(TAR)
                      , ArchiveResult
 #endif
@@ -1061,7 +1052,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]

          case optCommand of
            Upgrade _ _ -> pure ()
-            _ -> runLogger $ flip runReaderT settings $ checkForUpdates dls pfreq
+            _ -> runLogger $ checkForUpdates dls pfreq



@@ -1088,7 +1079,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                            case keepDirs of
                              Never -> runLogger ($(logError) [i|Build failed with #{e}|])
                              _ -> runLogger ($(logError) [i|Build failed with #{e}
-    Check the logs at #{logsDir} and the build directory #{tmpdir} for more clues.
+    Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues.
    Make sure to clean up #{tmpdir} afterwards.|])
                            pure $ ExitFailure 3
                          VLeft (V NoDownload) -> do
@@ -1101,7 +1092,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                          VLeft e -> do
                            runLogger $ do
                              $(logError) [i|#{e}|]
-                              $(logError) [i|Also check the logs in #{logsDir}|]
+                              $(logError) [i|Also check the logs in ~/.ghcup/logs|]
                            pure $ ExitFailure 3


@@ -1130,7 +1121,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                        VLeft e -> do
                          runLogger $ do
                            $(logError) [i|#{e}|]
-                            $(logError) [i|Also check the logs in #{logsDir}|]
+                            $(logError) [i|Also check the logs in ~/.ghcup/logs|]
                          pure $ ExitFailure 4

          let setGHC' SetOptions{..} =
@@ -1246,9 +1237,9 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                      VLeft (V (BuildFailed tmpdir e)) -> do
                        case keepDirs of
                          Never -> runLogger ($(logError) [i|Build failed with #{e}
-Check the logs at #{logsDir}|])
+Check the logs at ~/.ghcup/logs|])
                          _ -> runLogger ($(logError) [i|Build failed with #{e}
-Check the logs at #{logsDir} and the build directory #{tmpdir} for more clues.
+Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues.
 Make sure to clean up #{tmpdir} afterwards.|])
                        pure $ ExitFailure 9
                      VLeft e -> do
@@ -1270,7 +1261,7 @@ Make sure to clean up #{tmpdir} afterwards.|])
                        case keepDirs of
                          Never -> runLogger ($(logError) [i|Build failed with #{e}|])
                          _ -> runLogger ($(logError) [i|Build failed with #{e}
-Check the logs at #{logsDir} and the build directory #{tmpdir} for more clues.
+Check the logs at ~/.ghcup/logs and the build directory #{tmpdir} for more clues.
 Make sure to clean up #{tmpdir} afterwards.|])
                        pure $ ExitFailure 10
                      VLeft e -> do
@@ -1284,7 +1275,9 @@ Make sure to clean up #{tmpdir} afterwards.|])
                  p   <- parseAbs . E.encodeUtf8 . T.pack $ efp
                  pure $ Just p
                (UpgradeAt p)   -> pure $ Just p
-                UpgradeGHCupDir -> pure (Just (binDir </> [rel|ghcup|]))
+                UpgradeGHCupDir -> do
+                  bdir <- liftIO $ ghcupBinDir
+                  pure (Just (bdir </> [rel|ghcup|]))

              (runUpgrade $ (liftE $ upgradeGHCup dls target force pfreq)) >>= \case
                VRight v' -> do
@@ -1429,14 +1422,13 @@ printListResult raw lr = do
 where
  printTag Recommended        = color' Green "recommended"
  printTag Latest             = color' Yellow "latest"
-  printTag Prerelease         = color' Red "prerelease"
  printTag (Base pvp'') = "base-" ++ T.unpack (prettyPVP pvp'')
  printTag (UnknownTag t    ) = t
  color' = case raw of
    True  -> flip const
    False -> color

-checkForUpdates :: (MonadReader Settings m, MonadCatch m, MonadLogger m, MonadThrow m, MonadIO m, MonadFail m, MonadLogger m)
+checkForUpdates :: (MonadCatch m, MonadLogger m, MonadThrow m, MonadIO m, MonadFail m, MonadLogger m)
                => GHCupDownloads
                -> PlatformRequest
                -> m ()
--- a/78
+++ b/78
@@ -4,17 +4,6 @@
 (

 : "${GHCUP_INSTALL_BASE_PREFIX:=$HOME}"
-
-export GHCUP_USE_XDG_DIRS
-
-if [ -n "${GHCUP_USE_XDG_DIRS}" ] ; then
-	GHCUP_DIR=${XDG_DATA_HOME:=$HOME/.local}/ghcup
-	GHCUP_BIN=${XDG_BIN_HOME:=$HOME/.local/bin}
-else
-	GHCUP_DIR=${GHCUP_INSTALL_BASE_PREFIX}/.ghcup
-	GHCUP_BIN=${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/bin
-fi
-
 : "${BOOTSTRAP_HASKELL_GHC_VERSION:=recommended}"
 : "${BOOTSTRAP_HASKELL_CABAL_VERSION:=recommended}"

@@ -40,26 +29,10 @@ _eghcup() {
    fi
 }

-_done() {
-	echo
-    echo "All done!"
-	echo
-	echo "To start a simple repl, run:"
-	echo "  ghci"
-	echo
-	echo "To start a new haskell project in the current directory, run:"
-	echo "  cabal init --interactive"
-	echo
-	echo "To install other GHC versions, run:"
-	echo "  ghcup tui"
-
-	exit 0
-}
-
 download_ghcup() {
 	_plat="$(uname -s)"
 	_arch=$(uname -m)
-	_ghver="0.1.10"
+	_ghver="0.1.8"
 	_base_url="https://downloads.haskell.org/~ghcup"

    case "${_plat}" in
@@ -110,15 +83,15 @@ download_ghcup() {
 			;;
    esac

-	edo curl -Lf "${_url}" > "${GHCUP_BIN}"/ghcup
+	edo curl -Lf "${_url}" > "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/ghcup

-    edo chmod +x "${GHCUP_BIN}"/ghcup
+    edo chmod +x "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin/ghcup

-	cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
-		export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
+	cat <<-EOF > "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/env || die "Failed to create env file"
+		export PATH="\$HOME/.cabal/bin:\${GHCUP_INSTALL_BASE_PREFIX:=\$HOME}/.ghcup/bin:\$PATH"
 		EOF
 	# shellcheck disable=SC1090
-    edo . "${GHCUP_DIR}"/env
+    edo . "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/env
    eghcup upgrade

 	unset _plat _arch _url _ghver _base_url
@@ -129,19 +102,12 @@ echo
 echo "Welcome to Haskell!"
 echo
 echo "This script will download and install the following binaries:"
-echo "  * ghcup - The Haskell toolchain installer"
-echo "            (for managing GHC/cabal versions)"
+echo "  * ghcup - The Haskell toolchain installer (for managing GHC/cabal versions)"
 echo "  * ghc   - The Glasgow Haskell Compiler"
 echo "  * cabal - The Cabal build tool"
 echo
-if [ -z "${GHCUP_USE_XDG_DIRS}" ] ; then
-	echo "ghcup installs only into the following directory,"
-    echo "which can be removed anytime:"
-	echo "  $GHCUP_INSTALL_BASE_PREFIX/.ghcup"
-else
-	echo "ghcup installs into XDG directories as long as"
-    echo "'GHCUP_USE_XDG_DIRS' is set."
-fi
+echo "ghcup installs only into the following directory, which can be removed anytime:"
+echo "  $GHCUP_INSTALL_BASE_PREFIX/.ghcup"
 echo

 if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
@@ -153,7 +119,7 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
    read -r answer </dev/tty
 fi

-edo mkdir -p "${GHCUP_BIN}"
+edo mkdir -p "${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup/bin

 if command -V "ghcup" >/dev/null 2>&1 ; then
    if [ -z "${BOOTSTRAP_HASKELL_NO_UPGRADE}" ] ; then
@@ -190,7 +156,7 @@ printf "\\033[0;35m%s\\033[0m\\n" ""

 if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
    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 "You may want to source '$GHCUP_INSTALL_BASE_PREFIX/.ghcup/env' in your shell"
    echo "configuration to do so (e.g. ~/.bashrc)."

 	case $SHELL in
@@ -208,13 +174,13 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
 				GHCUP_PROFILE_FILE="$HOME/.zshrc"
 				MY_SHELL="zsh"
 			else
-			    _done
+				exit 0
 			fi
 			;;
 		*/fish) # login shell is fish
 			GHCUP_PROFILE_FILE="$HOME/.config/fish/config.fish"
 			MY_SHELL="fish" ;;
-		*) _done ;;
+		*) exit 0 ;;
 	esac


@@ -232,24 +198,18 @@ if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
 				case $MY_SHELL in
 					"") break ;;
 					fish)
-						if ! grep -q "ghcup-env" "${GHCUP_PROFILE_FILE}" ; then
-							echo "# ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-							echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME" >> "${GHCUP_PROFILE_FILE}"
-							echo "test -f $GHCUP_DIR/env ; and set -gx PATH \$HOME/.cabal/bin $GHCUP_BIN \$PATH" >> "${GHCUP_PROFILE_FILE}"
-						fi
+						echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME" >> "${GHCUP_PROFILE_FILE}"
+						echo "test -f \$GHCUP_INSTALL_BASE_PREFIX/.ghcup/env ; and set -gx PATH \$HOME/.cabal/bin \$GHCUP_INSTALL_BASE_PREFIX/.ghcup/bin \$PATH" >> "${GHCUP_PROFILE_FILE}"
 						break ;;
 					*)
-						if ! grep -q "ghcup-env" "${GHCUP_PROFILE_FILE}" ; then
-							echo "[ -f \"${GHCUP_DIR}/env\" ] && source \"${GHCUP_DIR}/env\" # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-						fi
+						echo "[ -f \"\${GHCUP_INSTALL_BASE_PREFIX:=\$HOME}/.ghcup/env\" ] && source \"\${GHCUP_INSTALL_BASE_PREFIX:=\$HOME}/.ghcup/env\"" >> "${GHCUP_PROFILE_FILE}"
 						break ;;
 				esac
                printf "\\033[0;35m%s\\033[0m\\n" "OK! ${GHCUP_PROFILE_FILE} has been modified. Restart your terminal for the changes to take effect,"
-                printf "\\033[0;35m%s\\033[0m\\n" "or type \"source ${GHCUP_DIR}/env\" to apply them in your current terminal session."
-				_done
-                ;;
+                printf "\\033[0;35m%s\\033[0m\\n" "or type \"source ${GHCUP_INSTALL_BASE_PREFIX}/.ghcup/env\" to apply them in your current terminal session."
+                exit 0;;
            [Nn]*)
-                _done ;;
+                exit 0;;
            *)
                echo "Please type YES or NO and press enter.";;
        esac
--- a/cabal.project
+++ b/cabal.project
@@ -19,6 +19,6 @@ package ghcup
 constraints: http-io-streams -brotli

 package libarchive
-  flags: -system-libarchive
+  flags: static

-allow-newer: base, ghc-prim, template-haskell
+allow-newer: base ghc-prim template-haskell
--- a/ghcup-0.0.2.json
+++ b/ghcup-0.0.2.json
--- a/ghcup-0.0.2.yaml
+++ b/ghcup-0.0.2.yaml
--- a/ghcup.cabal
+++ b/ghcup.cabal
@@ -1,6 +1,6 @@
 cabal-version:      3.0
 name:               ghcup
-version:            0.1.10
+version:            0.1.8
 synopsis:           ghc toolchain installer as an exe/library
 description:
  A rewrite of the shell script ghcup, for providing
@@ -112,7 +112,7 @@ common io-streams
  build-depends: io-streams >=1.5

 common libarchive
-  build-depends: libarchive >= 3.0.0.0
+  build-depends: libarchive >= 2.2.5.2

 common lzma
  build-depends: lzma >=0.0.0.3
@@ -153,9 +153,6 @@ common safe
 common safe-exceptions
  build-depends: safe-exceptions >=0.1

-common split
-  build-depends: split >=0.2.3.4
-
 common streamly
  build-depends: streamly >=0.7.1

@@ -222,9 +219,6 @@ common vty
 common word8
  build-depends: word8 >=0.1.3

-common yaml
-  build-depends: yaml >=0.11.4.0
-
 common zlib
  build-depends: zlib >=0.6.2.1

@@ -279,7 +273,6 @@ library
    , resourcet
    , safe
    , safe-exceptions
-    , split
    , streamly
    , streamly-posix
    , streamly-bytestring
@@ -298,11 +291,13 @@ library
    , vector
    , versions
    , word8
-    , yaml
    , zlib

  exposed-modules:
    GHCup
+    GHCup.Data.GHCupDownloads
+    GHCup.Data.GHCupInfo
+    GHCup.Data.ToolRequirements
    GHCup.Download
    GHCup.Download.Utils
    GHCup.Errors
@@ -418,7 +413,6 @@ executable ghcup-gen
    , uri-bytestring
    , utf8-string
    , versions
-    , yaml

  --
  main-is:          Main.hs
--- a/lib/GHCup.hs
+++ b/lib/GHCup.hs
@@ -15,7 +15,7 @@
 Module      : GHCup
 Description : GHCup installation functions
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
@@ -112,7 +112,6 @@ installGHCBindist :: ( MonadFail m
                        , NoDownload
                        , NotInstalled
                        , UnknownArchive
-                        , TarDirDoesNotExist
 #if !defined(TAR)
                        , ArchiveResult
 #endif
@@ -122,7 +121,7 @@ installGHCBindist :: ( MonadFail m
 installGHCBindist dlinfo ver (PlatformRequest {..}) = do
  let tver = (mkTVer ver)
  lift $ $(logDebug) [i|Requested to install GHC with #{ver}|]
-  whenM (lift $ ghcInstalled tver)
+  whenM (liftIO $ ghcInstalled tver)
    $ (throwE $ AlreadyInstalled GHC ver)

  -- download (or use cached version)
@@ -134,10 +133,10 @@ installGHCBindist dlinfo ver (PlatformRequest {..}) = do
  void $ liftIO $ darwinNotarization _rPlatform tmpUnpack

  -- prepare paths
-  ghcdir <- lift $ ghcupGHCDir tver
+  ghcdir <- liftIO $ ghcupGHCDir tver

  -- the subdir of the archive where we do the work
-  workdir <- maybe (pure tmpUnpack) (liftE . intoSubdir tmpUnpack) (view dlSubdir dlinfo)
+  let workdir = maybe tmpUnpack (tmpUnpack </>) (view dlSubdir dlinfo)

  liftE $ runBuildAction tmpUnpack (Just ghcdir) (installGHC' workdir ghcdir)

@@ -190,7 +189,6 @@ installGHCBin :: ( MonadFail m
                    , NoDownload
                    , NotInstalled
                    , UnknownArchive
-                    , TarDirDoesNotExist
 #if !defined(TAR)
                    , ArchiveResult
 #endif
@@ -223,7 +221,6 @@ installCabalBindist :: ( MonadMask m
                          , NoDownload
                          , NotInstalled
                          , UnknownArchive
-                          , TarDirDoesNotExist
 #if !defined(TAR)
                          , ArchiveResult
 #endif
@@ -233,14 +230,14 @@ installCabalBindist :: ( MonadMask m
 installCabalBindist dlinfo ver (PlatformRequest {..}) = do
  lift $ $(logDebug) [i|Requested to install cabal version #{ver}|]

-  Settings {dirs = Dirs {..}} <- lift ask
+  bindir <- liftIO ghcupBinDir

  whenM
-      (lift (cabalInstalled ver) >>= \a -> liftIO $
+      (liftIO $ cabalInstalled ver >>= \a ->
        handleIO (\_ -> pure False)
          $ fmap (\x -> a && isSymbolicLink x)
          -- ignore when the installation is a legacy cabal (binary, not symlink)
-          $ getSymbolicLinkStatus (toFilePath (binDir </> [rel|cabal|]))
+          $ getSymbolicLinkStatus (toFilePath (bindir </> [rel|cabal|]))
      )
    $ (throwE $ AlreadyInstalled Cabal ver)

@@ -253,12 +250,12 @@ installCabalBindist dlinfo ver (PlatformRequest {..}) = do
  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)
+  let workdir = maybe tmpUnpack (tmpUnpack </>) (view dlSubdir dlinfo)

-  liftE $ installCabal' workdir binDir
+  liftE $ installCabal' workdir bindir

  -- create symlink if this is the latest version
-  cVers <- lift $ fmap rights $ getInstalledCabals
+  cVers <- liftIO $ fmap rights $ getInstalledCabals
  let lInstCabal = headMay . reverse . sort $ cVers
  when (maybe True (ver >=) lInstCabal) $ liftE $ setCabal ver

@@ -273,14 +270,12 @@ installCabalBindist dlinfo ver (PlatformRequest {..}) = do
  installCabal' path inst = do
    lift $ $(logInfo) "Installing cabal"
    let cabalFile = [rel|cabal|]
-    liftIO $ createDirRecursive' inst
+    liftIO $ createDirIfMissing newDirPerms inst
    destFileName <- lift $ parseRel (toFilePath cabalFile <> "-" <> verToBS ver)
-    let destPath = inst </> destFileName
    handleIO (throwE . CopyError . show) $ liftIO $ copyFile
      (path </> cabalFile)
-      (destPath)
+      (inst </> destFileName)
      Overwrite
-    lift $ chmod_777 destPath


 -- | Installs cabal into @~\/.ghcup\/bin/cabal-\<ver\>@ and
@@ -305,7 +300,6 @@ installCabalBin :: ( MonadMask m
                      , NoDownload
                      , NotInstalled
                      , UnknownArchive
-                      , TarDirDoesNotExist
 #if !defined(TAR)
                      , ArchiveResult
 #endif
@@ -334,25 +328,17 @@ installCabalBin bDls ver pfreq = do
 --
 -- Additionally creates a @~\/.ghcup\/share -> ~\/.ghcup\/ghc\/\<ver\>\/share symlink@
 -- for 'SetGHCOnly' constructor.
-setGHC :: ( MonadReader Settings m
-          , MonadLogger m
-          , MonadThrow m
-          , MonadFail m
-          , MonadIO m
-          , MonadCatch m
-          )
+setGHC :: (MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
       => GHCTargetVersion
       -> SetGHC
       -> Excepts '[NotInstalled] m GHCTargetVersion
 setGHC ver sghc = do
  let verBS = verToBS (_tvVersion ver)
-  ghcdir                        <- lift $ ghcupGHCDir ver
-
-  whenM (lift $ fmap not $ ghcInstalled ver) (throwE (NotInstalled GHC (ver ^. tvVersion % to prettyVer)))
+  ghcdir <- liftIO $ ghcupGHCDir ver

  -- symlink destination
-  Settings { dirs = Dirs {..} } <- lift ask
-  liftIO $ createDirRecursive' binDir
+  bindir <- liftIO $ ghcupBinDir
+  liftIO $ hideError AlreadyExists $ createDirRecursive newDirPerms bindir

  -- first delete the old symlinks (this fixes compatibility issues
  -- with old ghcup)
@@ -364,26 +350,19 @@ setGHC ver sghc = do
  -- for ghc tools (ghc, ghci, haddock, ...)
  verfiles <- ghcToolFiles ver
  forM_ verfiles $ \file -> do
-    mTargetFile <- case sghc of
-      SetGHCOnly -> pure $ Just file
+    targetFile <- case sghc of
+      SetGHCOnly -> pure file
      SetGHC_XY  -> do
-        v' <-
-          handle
-            (\(e :: ParseError) -> lift $ $(logWarn) [i|#{e}|] >> pure Nothing)
-          $ fmap Just
-          $ getMajorMinorV (_tvVersion ver)
-        forM v' $ \(mj, mi) ->
-          let major' = E.encodeUtf8 $ intToText mj <> "." <> intToText mi
-          in  parseRel (toFilePath file <> B.singleton _hyphen <> major')
-      SetGHC_XYZ ->
-        fmap Just $ parseRel (toFilePath file <> B.singleton _hyphen <> verBS)
+        major' <- (\(mj, mi) -> E.encodeUtf8 $ intToText mj <> "." <> intToText mi)
+                     <$> getMajorMinorV (_tvVersion ver)
+        parseRel (toFilePath file <> B.singleton _hyphen <> major')
+      SetGHC_XYZ -> parseRel (toFilePath file <> B.singleton _hyphen <> verBS)

    -- create symlink
-    forM mTargetFile $ \targetFile -> do
-      let fullF = binDir </> targetFile
-      destL <- lift $ ghcLinkDestination (toFilePath file) ver
-      lift $ $(logDebug) [i|ln -s #{destL} #{toFilePath fullF}|]
-      liftIO $ createSymlink fullF destL
+    let fullF = bindir </> targetFile
+    let destL = ghcLinkDestination (toFilePath file) ver
+    lift $ $(logDebug) [i|ln -s #{destL} #{toFilePath fullF}|]
+    liftIO $ createSymlink fullF destL

  -- create symlink for share dir
  when (isNothing . _tvTarget $ ver) $ lift $ symlinkShareDir ghcdir verBS
@@ -392,13 +371,12 @@ setGHC ver sghc = do

 where

-  symlinkShareDir :: (MonadReader Settings m, MonadIO m, MonadLogger m)
+  symlinkShareDir :: (MonadIO m, MonadLogger m)
                  => Path Abs
                  -> ByteString
                  -> m ()
  symlinkShareDir ghcdir verBS = do
-    Settings { dirs = Dirs {..} } <- ask
-    let destdir = baseDir
+    destdir <- liftIO $ ghcupBaseDir
    case sghc of
      SetGHCOnly -> do
        let sharedir     = [rel|share|]
@@ -415,7 +393,7 @@ setGHC ver sghc = do


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

  -- symlink destination
-  Settings {dirs = Dirs {..}} <- lift ask
-  liftIO $ createDirRecursive' binDir
+  bindir     <- liftIO $ ghcupBinDir
+  liftIO $ hideError AlreadyExists $ createDirRecursive newDirPerms bindir

-  whenM (liftIO $ fmap not $ doesFileExist (binDir </> targetFile))
+  whenM (liftIO $ fmap not $ doesFileExist (bindir </> targetFile))
    $ throwE
    $ NotInstalled Cabal (prettyVer ver)

-  let cabalbin = binDir </> [rel|cabal|]
+  let cabalbin = bindir </> [rel|cabal|]

  -- delete old file (may be binary or symlink)
  lift $ $(logDebug) [i|rm -f #{toFilePath cabalbin}|]
@@ -489,7 +467,6 @@ listVersions :: ( MonadCatch m
                , MonadThrow m
                , MonadLogger m
                , MonadIO m
-                , MonadReader Settings m
                )
             => GHCupDownloads
             -> Maybe Tool
@@ -501,16 +478,13 @@ listVersions av lt criteria pfreq = do
    Just t -> do
      -- get versions from GHCupDownloads
      let avTools = availableToolVersions av t
-      lr <- filter' <$> forM (Map.toList avTools) (toListResult t)
+      lr <- filter' <$> forM (Map.toList avTools) (liftIO . 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
    Nothing -> do
      ghcvers   <- listVersions av (Just GHC) criteria pfreq
@@ -519,7 +493,7 @@ listVersions av lt criteria pfreq = do
      pure (ghcvers <> cabalvers <> ghcupvers)

 where
-  strayGHCs :: (MonadReader Settings m, MonadThrow m, MonadLogger m, MonadIO m)
+  strayGHCs :: (MonadThrow m, MonadLogger m, MonadIO m)
            => Map.Map Version [Tag]
            -> m [ListResult]
  strayGHCs avTools = do
@@ -530,7 +504,7 @@ listVersions av lt criteria pfreq = do
          Just _  -> pure Nothing
          Nothing -> do
            lSet    <- fmap (maybe False (\(GHCTargetVersion _ v ) -> v == _tvVersion)) $ ghcSet Nothing
-            fromSrc <- ghcSrcInstalled tver
+            fromSrc <- liftIO $ ghcSrcInstalled tver
            pure $ Just $ ListResult
              { lTool      = GHC
              , lVer       = _tvVersion
@@ -543,7 +517,7 @@ listVersions av lt criteria pfreq = do
              }
      Right tver@GHCTargetVersion{ .. } -> do
        lSet    <- fmap (maybe False (\(GHCTargetVersion _ v ) -> v == _tvVersion)) $ ghcSet _tvTarget
-        fromSrc <- ghcSrcInstalled tver
+        fromSrc <- liftIO $ ghcSrcInstalled tver
        pure $ Just $ ListResult
          { lTool      = GHC
          , lVer       = _tvVersion
@@ -559,35 +533,8 @@ 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)
-            => Map.Map Version [Tag]
-            -> m [ListResult]
-  strayCabals avTools = do
-    cabals <- getInstalledCabals
-    fmap catMaybes $ forM cabals $ \case
-      Right ver ->
-        case Map.lookup ver avTools of
-          Just _  -> pure Nothing
-          Nothing -> do
-            lSet    <- fmap (maybe False (== ver)) $ cabalSet
-            pure $ Just $ ListResult
-              { lTool      = Cabal
-              , 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 :>
-              , ..
-              }
-      Left e -> do
-        $(logWarn)
-          [i|Could not parse version of stray directory #{toFilePath e}|]
-        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 :: Tool -> (Version, [Tag]) -> IO ListResult
  toListResult t (v, tags) = case t of
    GHC -> do
      let lNoBindist = isLeft $ getDownloadInfo GHC v pfreq av
@@ -640,73 +587,64 @@ 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
-            , MonadThrow m
-            , MonadLogger m
-            , MonadIO m
-            , MonadFail m
-            , MonadCatch m
-            )
+rmGHCVer :: (MonadThrow m, MonadLogger m, MonadIO m, MonadFail m)
         => GHCTargetVersion
         -> Excepts '[NotInstalled] m ()
 rmGHCVer ver = do
-  isSetGHC <- lift $ fmap (maybe False (== ver)) $ ghcSet (_tvTarget ver)
+  isSetGHC <- fmap (maybe False (== ver)) $ ghcSet (_tvTarget ver)
+  dir      <- liftIO $ ghcupGHCDir ver
+  let d' = toFilePath dir
+  exists <- liftIO $ doesDirectoryExist dir

-  whenM (lift $ fmap not $ ghcInstalled ver) (throwE (NotInstalled GHC (ver ^. tvVersion % to prettyVer)))
-  dir <- lift $ ghcupGHCDir ver

-  -- this isn't atomic, order matters
-  when isSetGHC $ do
-    lift $ $(logInfo) [i|Removing ghc symlinks|]
-    liftE $ rmPlain (_tvTarget ver)
+  if exists
+    then do
+      -- this isn't atomic, order matters
+      when isSetGHC $ do
+        lift $ $(logInfo) [i|Removing ghc symlinks|]
+        liftE $ rmPlain (_tvTarget ver)

-  lift $ $(logInfo) [i|Removing directory recursively: #{toFilePath dir}|]
-  liftIO $ deleteDirRecursive dir
+      lift $ $(logInfo) [i|Removing directory recursively: #{d'}|]
+      liftIO $ deleteDirRecursive dir

-  lift $ $(logInfo) [i|Removing ghc-x.y.z symlinks|]
-  lift $ rmMinorSymlinks ver
+      lift $ $(logInfo) [i|Removing ghc-x.y.z symlinks|]
+      lift $ rmMinorSymlinks ver

-  lift $ $(logInfo) [i|Removing/rewiring ghc-x.y symlinks|]
-  -- first remove
-  handle (\(_ :: ParseError) -> pure ()) $ lift $ rmMajorSymlinks ver
-  -- then fix them (e.g. with an earlier version)
-  v' <-
-    handle
-      (\(e :: ParseError) -> lift $ $(logWarn) [i|#{e}|] >> pure Nothing)
-    $ fmap Just
-    $ getMajorMinorV (_tvVersion ver)
-  forM_ v' $ \(mj, mi) -> lift (getGHCForMajor mj mi (_tvTarget ver))
-    >>= mapM_ (\v -> liftE $ setGHC v SetGHC_XY)
+      lift $ $(logInfo) [i|Removing/rewiring ghc-x.y symlinks|]
+      -- first remove
+      lift $ rmMajorSymlinks ver
+      -- then fix them (e.g. with an earlier version)
+      (mj, mi) <- getMajorMinorV (_tvVersion ver)
+      getGHCForMajor mj mi (_tvTarget ver) >>= mapM_ (\v -> liftE $ setGHC v SetGHC_XY)

-  Settings { dirs = Dirs {..} } <- lift ask
-
-  liftIO
-    $ hideError doesNotExistErrorType
-    $ deleteFile
-    $ (baseDir </> [rel|share|])
+      liftIO
+        $   ghcupBaseDir
+        >>= hideError doesNotExistErrorType
+        .   deleteFile
+        .   (</> [rel|share|])
+    else throwE (NotInstalled GHC (ver ^. tvVersion % to prettyVer))


 -- | 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 :: (MonadThrow m, MonadLogger m, MonadIO m, MonadFail m)
           => Version
           -> Excepts '[NotInstalled] m ()
 rmCabalVer ver = do
-  whenM (lift $ fmap not $ cabalInstalled ver) $ throwE (NotInstalled Cabal (prettyVer ver))
+  whenM (fmap not $ liftIO $ cabalInstalled ver) $ throwE (NotInstalled GHC (prettyVer ver))

-  cSet      <- lift $ cabalSet
-
-  Settings {dirs = Dirs {..}} <- lift ask
+  cSet      <- liftIO cabalSet

+  bindir    <- liftIO ghcupBinDir
  cabalFile <- lift $ parseRel ("cabal-" <> verToBS ver)
-  liftIO $ hideError doesNotExistErrorType $ deleteFile (binDir </> cabalFile)
+  liftIO $ hideError doesNotExistErrorType $ deleteFile (bindir </> cabalFile)

  when (maybe False (== ver) cSet) $ do
-    cVers <- lift $ fmap rights $ getInstalledCabals
+    cVers <- liftIO $ fmap rights $ getInstalledCabals
    case headMay . reverse . sort $ cVers of
      Just latestver -> setCabal latestver
      Nothing        -> liftIO $ hideError doesNotExistErrorType $ deleteFile
-        (binDir </> [rel|cabal|])
+        (bindir </> [rel|cabal|])



@@ -715,19 +653,18 @@ rmCabalVer ver = do
    ------------------


-getDebugInfo :: (MonadReader Settings m, MonadLogger m, MonadCatch m, MonadIO m)
+getDebugInfo :: (MonadLogger m, MonadCatch m, MonadIO m)
             => Excepts
                  '[NoCompatiblePlatform , NoCompatibleArch , DistroNotFound]
                  m
                  DebugInfo
 getDebugInfo = do
-  Settings {dirs = Dirs {..}} <- lift ask
-  let diBaseDir  = baseDir
-  let diBinDir   = binDir
-  diGHCDir       <- lift ghcupGHCBaseDir
-  let diCacheDir = cacheDir
-  diArch         <- lE getArchitecture
-  diPlatform     <- liftE $ getPlatform
+  diBaseDir  <- liftIO $ ghcupBaseDir
+  diBinDir   <- liftIO $ ghcupBinDir
+  diGHCDir   <- liftIO $ ghcupGHCBaseDir
+  diCacheDir <- liftIO $ ghcupCacheDir
+  diArch     <- lE getArchitecture
+  diPlatform <- liftE $ getPlatform
  pure $ DebugInfo { .. }


@@ -766,7 +703,6 @@ compileGHC :: ( MonadMask m
                 , NotFoundInPATH
                 , PatchFailed
                 , UnknownArchive
-                 , TarDirDoesNotExist
 #if !defined(TAR)
                 , ArchiveResult
 #endif
@@ -775,7 +711,7 @@ compileGHC :: ( MonadMask m
                ()
 compileGHC dls tver bstrap jobs mbuildConfig patchdir aargs PlatformRequest {..} = do
  lift $ $(logDebug) [i|Requested to compile: #{tver} with #{bstrap}|]
-  whenM (lift $ ghcInstalled tver)
+  whenM (liftIO $ ghcInstalled tver)
        (throwE $ AlreadyInstalled GHC (tver ^. tvVersion))

  -- download source tarball
@@ -792,8 +728,8 @@ compileGHC dls tver bstrap jobs mbuildConfig patchdir aargs PlatformRequest {..}
  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
+  let workdir = maybe id (flip (</>)) (view dlSubdir dlInfo) $ tmpUnpack
+  ghcdir <- liftIO $ ghcupGHCDir tver

  liftE $ runBuildAction
    tmpUnpack
@@ -947,7 +883,6 @@ compileCabal :: ( MonadReader Settings m
                   , NotInstalled
                   , PatchFailed
                   , UnknownArchive
-                   , TarDirDoesNotExist
 #if !defined(TAR)
                   , ArchiveResult
 #endif
@@ -957,14 +892,14 @@ compileCabal :: ( MonadReader Settings m
 compileCabal dls tver bghc jobs patchdir PlatformRequest{..} = do
  lift $ $(logDebug) [i|Requested to compile: #{tver} with ghc-#{bghc}|]

-  Settings {dirs = Dirs {..}} <- lift ask
+  bindir <- liftIO ghcupBinDir

  whenM
-      (lift (cabalInstalled tver) >>= \a -> liftIO $
+      (liftIO $ cabalInstalled tver >>= \a ->
        handleIO (\_ -> pure False)
          $ fmap (\x -> a && isSymbolicLink x)
          -- ignore when the installation is a legacy cabal (binary, not symlink)
-          $ getSymbolicLinkStatus (toFilePath (binDir </> [rel|cabal|]))
+          $ getSymbolicLinkStatus (toFilePath (bindir </> [rel|cabal|]))
      )
    $ (throwE $ AlreadyInstalled Cabal tver)

@@ -977,18 +912,18 @@ compileCabal dls tver bghc jobs patchdir PlatformRequest{..} = do
  liftE $ unpackToDir tmpUnpack dl
  void $ liftIO $ darwinNotarization _rPlatform tmpUnpack

-  workdir <- maybe (pure tmpUnpack) (liftE . intoSubdir tmpUnpack) (view dlSubdir dlInfo)
+  let workdir = maybe id (flip (</>)) (view dlSubdir dlInfo) $ tmpUnpack

  cbin         <- liftE $ runBuildAction tmpUnpack Nothing (compile workdir)

  destFileName <- lift $ parseRel ("cabal-" <> verToBS tver)
  handleIO (throwE . CopyError . show) $ liftIO $ copyFile
    cbin
-    (binDir </> destFileName)
+    (bindir </> destFileName)
    Overwrite

  -- create symlink if this is the latest version
-  cVers <- lift $ fmap rights $ getInstalledCabals
+  cVers <- liftIO $ fmap rights $ getInstalledCabals
  let lInstCabal = headMay . reverse . sort $ cVers
  when (maybe True (tver >=) lInstCabal) $ liftE $ setCabal tver

@@ -1024,7 +959,7 @@ compileCabal dls tver bghc jobs patchdir PlatformRequest{..} = do
          ]

    tmp <- lift withGHCupTmpDir
-    liftIO $ createDirRecursive' (tmp </> [rel|bin|])
+    liftIO $ createDirRecursive newDirPerms (tmp </> [rel|bin|])
    newEnv <- lift $ addToCurrentEnv (("PREFIX", toFilePath tmp) : ghcEnv)
    lift $ $(logDebug) [i|Environment: #{newEnv}|]

@@ -1069,7 +1004,6 @@ upgradeGHCup :: ( MonadMask m
                  m
                  Version
 upgradeGHCup dls mtarget force pfreq = do
-  Settings {dirs = Dirs {..}} <- lift ask
  lift $ $(logInfo) [i|Upgrading GHCup...|]
  let latestVer = fromJust $ getLatest dls GHCup
  when (not force && (latestVer <= pvpToVersion ghcUpVer)) $ throwE NoUpdate
@@ -1077,12 +1011,18 @@ upgradeGHCup dls mtarget force pfreq = do
  tmp   <- lift withGHCupTmpDir
  let fn = [rel|ghcup|]
  p <- liftE $ download dli tmp (Just fn)
+  let fileMode' =
+        newFilePerms
+          `unionFileModes` ownerExecuteMode
+          `unionFileModes` groupExecuteMode
+          `unionFileModes` otherExecuteMode
+  binDir <- liftIO $ ghcupBinDir
  let fullDest = fromMaybe (binDir </> fn) mtarget
  liftIO $ hideError NoSuchThing $ deleteFile fullDest
  handleIO (throwE . CopyError . show) $ liftIO $ copyFile p
                                                           fullDest
                                                           Overwrite
-  lift $ chmod_777 fullDest
+  liftIO $ setFileMode (toFilePath fullDest) fileMode'
  pure latestVer


@@ -1094,24 +1034,13 @@ 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
-                  , MonadLogger m
-                  , MonadThrow m
-                  , MonadFail m
-                  , MonadIO m
-                  , MonadCatch m
-                  )
+postGHCInstall :: (MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
               => GHCTargetVersion
               -> Excepts '[NotInstalled] m ()
-postGHCInstall ver@GHCTargetVersion {..} = do
+postGHCInstall ver@GHCTargetVersion{..} = do
  void $ liftE $ setGHC ver SetGHC_XYZ

  -- Create ghc-x.y symlinks. This may not be the current
  -- version, create it regardless.
-  v' <-
-    handle (\(e :: ParseError) -> lift $ $(logWarn) [i|#{e}|] >> pure Nothing)
-    $ fmap Just
-    $ getMajorMinorV _tvVersion
-  forM_ v' $ \(mj, mi) -> lift (getGHCForMajor mj mi _tvTarget)
-    >>= mapM_ (\v -> liftE $ setGHC v SetGHC_XY)
-
+  (mj, mi) <- getMajorMinorV _tvVersion
+  getGHCForMajor mj mi _tvTarget >>= mapM_ (\v -> liftE $ setGHC v SetGHC_XY)
--- a/lib/GHCup/Data/GHCupDownloads.hs
+++ b/lib/GHCup/Data/GHCupDownloads.hs
--- a/lib/GHCup/Data/GHCupInfo.hs
+++ b/lib/GHCup/Data/GHCupInfo.hs
@@ -0,0 +1,20 @@
+{-|
+Module      : GHCup.Data.GHCupInfo
+Description :
+Copyright   : (c) Julian Ospald, 2020
+License     : GPL-3
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : POSIX
+-}
+module GHCup.Data.GHCupInfo where
+
+import           GHCup.Data.GHCupDownloads
+import           GHCup.Data.ToolRequirements
+import           GHCup.Types
+
+
+ghcupInfo :: GHCupInfo
+ghcupInfo = GHCupInfo { _toolRequirements = toolRequirements
+                      , _ghcupDownloads   = ghcupDownloads
+                      }
--- a/lib/GHCup/Data/ToolRequirements.hs
+++ b/lib/GHCup/Data/ToolRequirements.hs
@@ -0,0 +1,156 @@
+{-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes       #-}
+
+{-|
+Module      : GHCup.Data.ToolRequirements
+Description : Tool requirements
+Copyright   : (c) Julian Ospald, 2020
+License     : GPL-3
+Maintainer  : hasufell@hasufell.de
+Stability   : experimental
+Portability : POSIX
+-}
+module GHCup.Data.ToolRequirements where
+
+import           GHCup.Types
+import           GHCup.Utils.String.QQ
+import           GHCup.Utils.Version.QQ
+
+import qualified Data.Map                      as M
+
+
+
+-- | Currently 'GHC' is used for both GHC and cabal to simplify
+-- this, until we need actual separation.
+toolRequirements :: ToolRequirements
+toolRequirements = M.fromList
+  [ ( GHC
+    , M.fromList
+      [ ( Nothing
+        , M.fromList
+          [ ( Linux UnknownLinux
+            , M.fromList
+              [ ( Nothing
+                , Requirements
+                  []
+                  [s|You need the following packages: curl g++ gcc gmp make ncurses realpath xz-utils. Consult your distro documentation on the exact names of those packages.|]
+                )
+              ]
+            )
+          , ( Linux Alpine
+            , M.fromList
+              [ ( Nothing
+                , Requirements
+                  [ "curl"
+                  , "gcc"
+                  , "g++"
+                  , "gmp-dev"
+                  , "ncurses-dev"
+                  , "libffi-dev"
+                  , "make"
+                  , "xz"
+                  , "tar"
+                  , "perl"
+                  ]
+                  ""
+                )
+              ]
+            )
+          , ( Linux Ubuntu
+            , M.fromList
+              [ ( Nothing
+                , Requirements
+                  [ "build-essential"
+                  , "curl"
+                  , "libffi-dev"
+                  , "libffi6"
+                  , "libgmp-dev"
+                  , "libgmp10"
+                  , "libncurses-dev"
+                  , "libncurses5"
+                  , "libtinfo5"
+                  ]
+                  ""
+                )
+              ]
+            )
+          , ( Linux Debian
+            , M.fromList
+              [ ( Nothing
+                , Requirements
+                  [ "build-essential"
+                  , "curl"
+                  , "libffi-dev"
+                  , "libffi6"
+                  , "libgmp-dev"
+                  , "libgmp10"
+                  , "libncurses-dev"
+                  , "libncurses5"
+                  , "libtinfo5"
+                  ]
+                  ""
+                )
+              ]
+            )
+          , ( Linux CentOS
+            , M.fromList
+              [ ( Nothing
+                , Requirements
+                  [ "gcc"
+                  , "gcc-c++"
+                  , "gmp"
+                  , "gmp-devel"
+                  , "make"
+                  , "ncurses"
+                  , "ncurses-compat-libs"
+                  , "xz"
+                  , "perl"
+                  ]
+                  ""
+                ),
+              ( Just [vers|7|]
+                , Requirements
+                  [ "gcc"
+                  , "gcc-c++"
+                  , "gmp"
+                  , "gmp-devel"
+                  , "make"
+                  , "ncurses"
+                  , "xz"
+                  , "perl"
+                  ]
+                  ""
+                )
+              ]
+            )
+          , ( Darwin
+            , M.fromList
+              [ ( Nothing
+                , Requirements
+                  []
+                  "On OS X, in the course of running ghcup you will be given a dialog box to install the command line tools. Accept and the requirements will be installed for you. You will then need to run the command again."
+                )
+              ]
+            )
+          , ( FreeBSD
+            , M.fromList
+              [ ( Nothing
+                , Requirements
+                  [ "curl"
+                  , "gcc"
+                  , "gmp"
+                  , "gmake"
+                  , "ncurses"
+                  , "perl5"
+                  , "libffi"
+                  , "libiconv"
+                  ]
+                  ""
+                )
+              ]
+            )
+          ]
+        )
+      ]
+    )
+  ]
--- a/lib/GHCup/Download.hs
+++ b/lib/GHCup/Download.hs
@@ -13,7 +13,7 @@
 Module      : GHCup.Download
 Description : Downloading
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
@@ -52,7 +52,6 @@ import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource
                                         hiding ( throwM )
 import           Data.Aeson
-import           Data.Bifunctor
 import           Data.ByteString                ( ByteString )
 #if defined(INTERNAL_DOWNLOADER)
 import           Data.CaseInsensitive           ( CI )
@@ -89,7 +88,6 @@ import qualified Data.Map.Strict               as M
 import qualified Data.Text                     as T
 #endif
 import qualified Data.Text.Encoding            as E
-import qualified Data.Yaml                     as Y
 import qualified System.Posix.Files.ByteString as PF
 import qualified System.Posix.RawFilePath.Directory
                                               as RD
@@ -105,7 +103,7 @@ import qualified System.Posix.RawFilePath.Directory


 -- | Like 'getDownloads', but tries to fall back to
-- cached ~/.ghcup/cache/ghcup-<format-ver>.yaml
+-- cached ~/.ghcup/cache/ghcup-<format-ver>.json
 getDownloadsF :: ( FromJSONKey Tool
                 , FromJSONKey Version
                 , FromJSON VersionInfo
@@ -133,17 +131,17 @@ getDownloadsF urlSource = do
    (OwnSpec   _) -> liftE $ getDownloads urlSource
 where
  readFromCache = do
-    Settings {dirs = Dirs {..}} <- lift ask
    lift $ $(logWarn)
      [i|Could not get download info, trying cached version (this may not be recent!)|]
    let path = view pathL' ghcupURL
-    yaml_file <- (cacheDir </>) <$> urlBaseName path
+    cacheDir  <- liftIO $ ghcupCacheDir
+    json_file <- (cacheDir </>) <$> urlBaseName path
    bs        <-
      handleIO' NoSuchThing
-                (\_ -> throwE $ FileDoesNotExistError (toFilePath yaml_file))
+                (\_ -> throwE $ FileDoesNotExistError (toFilePath json_file))
      $ liftIO
-      $ readFile yaml_file
-    lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bs)
+      $ readFile json_file
+    lE' JSONDecodeError $ eitherDecode' bs


 -- | Downloads the download information! But only if we need to ;P
@@ -164,10 +162,10 @@ getDownloads urlSource = do
  case urlSource of
    GHCupURL -> do
      bs <- reThrowAll DownloadFailed $ smartDl ghcupURL
-      lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bs)
+      lE' JSONDecodeError $ eitherDecode' bs
    (OwnSource url) -> do
      bs <- reThrowAll DownloadFailed $ downloadBS url
-      lE' JSONDecodeError $ bimap show id $ Y.decodeEither' (L.toStrict bs)
+      lE' JSONDecodeError $ eitherDecode' bs
    (OwnSpec av) -> pure $ av

 where
@@ -200,8 +198,8 @@ getDownloads urlSource = do
               m1
               L.ByteString
  smartDl uri' = do
-    Settings {dirs = Dirs {..}} <- lift ask
    let path = view pathL' uri'
+    cacheDir  <- liftIO $ ghcupCacheDir
    json_file <- (cacheDir </>) <$> urlBaseName path
    e         <- liftIO $ doesFileExist json_file
    if e
@@ -226,7 +224,7 @@ getDownloads urlSource = do
          else -- access in less than 5 minutes, re-use file
               liftIO $ readFile json_file
      else do
-        liftIO $ createDirRecursive' cacheDir
+        liftIO $ createDirIfMissing newDirPerms cacheDir
        getModTime >>= \case
          Just modTime -> dlWithMod modTime json_file
          Nothing -> do
@@ -330,7 +328,7 @@ download dli dest mfn
  scheme = view (dlUri % uriSchemeL' % schemeBSL') dli
  cp     = do
    -- destination dir must exist
-    liftIO $ createDirRecursive' dest
+    liftIO $ hideError AlreadyExists $ createDirRecursive newDirPerms dest
    destFile <- getDestFile
    fromFile <- parseAbs path
    liftIO $ copyFile fromFile destFile Strict
@@ -340,7 +338,7 @@ download dli dest mfn
    lift $ $(logInfo) [i|downloading: #{uri'}|]

    -- destination dir must exist
-    liftIO $ createDirRecursive' dest
+    liftIO $ hideError AlreadyExists $ createDirRecursive newDirPerms dest
    destFile <- getDestFile

    -- download
@@ -392,15 +390,15 @@ downloadCached dli mfn = do
  cache <- lift getCache
  case cache of
    True -> do
-      Settings {dirs = Dirs {..}} <- lift ask
+      cachedir <- liftIO $ ghcupCacheDir
      fn       <- maybe (urlBaseName $ view (dlUri % pathL') dli) pure mfn
-      let cachfile = cacheDir </> fn
+      let cachfile = cachedir </> fn
      fileExists <- liftIO $ doesFileExist cachfile
      if
        | fileExists -> do
          liftE $ checkDigest dli cachfile
          pure $ cachfile
-        | otherwise -> liftE $ download dli cacheDir mfn
+        | otherwise -> liftE $ download dli cachedir mfn
    False -> do
      tmp <- lift withGHCupTmpDir
      liftE $ download dli tmp mfn
--- a/lib/GHCup/Errors.hs
+++ b/lib/GHCup/Errors.hs
@@ -7,7 +7,7 @@
 Module      : GHCup.Errors
 Description : GHCup error types
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
@@ -89,9 +89,6 @@ data JSONError = JSONDecodeError String
 data FileDoesNotExistError = FileDoesNotExistError ByteString
  deriving Show

-data TarDirDoesNotExist = TarDirDoesNotExist TarDir
-  deriving Show
-
 -- | File digest verification failed.
 data DigestError = DigestError Text Text
  deriving Show
--- a/lib/GHCup/Platform.hs
+++ b/lib/GHCup/Platform.hs
@@ -10,7 +10,7 @@
 Module      : GHCup.Plaform
 Description : Retrieving platform information
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
--- a/lib/GHCup/Requirements.hs
+++ b/lib/GHCup/Requirements.hs
@@ -4,7 +4,7 @@
 Module      : GHCup.Requirements
 Description : Requirements utilities
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
--- a/lib/GHCup/Types.hs
+++ b/lib/GHCup/Types.hs
@@ -6,7 +6,7 @@
 Module      : GHCup.Types
 Description : GHCup types
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
@@ -92,7 +92,6 @@ data VersionInfo = VersionInfo
 -- | A tag. These are currently attached to a version of a tool.
 data Tag = Latest
         | Recommended
-         | Prerelease
         | Base PVP
         | UnknownTag String  -- ^ used for upwardscompat
         deriving (Ord, Eq, Show) -- FIXME: manual JSON instance
@@ -137,7 +136,7 @@ data LinuxDistro = Debian
 -- to download, extract and install a tool.
 data DownloadInfo = DownloadInfo
  { _dlUri    :: URI
-  , _dlSubdir :: Maybe TarDir
+  , _dlSubdir :: Maybe (Path Rel)
  , _dlHash   :: Text
  }
  deriving (Eq, Show)
@@ -150,12 +149,6 @@ 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)
-
-
 -- | Where to fetch GHCupDownloads from.
 data URLSource = GHCupURL
               | OwnSource URI
@@ -164,25 +157,14 @@ data URLSource = GHCupURL


 data Settings = Settings
-  { -- set by user
-    cache      :: Bool
+  { cache      :: Bool
  , noVerify   :: Bool
  , keepDirs   :: KeepDirs
  , downloader :: Downloader
  , verbose    :: Bool
-
-    -- set on app start
-  , dirs       :: Dirs
  }
  deriving Show

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

 data KeepDirs = Always
              | Errors
--- a/lib/GHCup/Types/JSON.hs
+++ b/lib/GHCup/Types/JSON.hs
@@ -14,7 +14,7 @@
 Module      : GHCup.Types.JSON
 Description : GHCup JSON types/instances
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
@@ -24,7 +24,6 @@ module GHCup.Types.JSON where
 import           GHCup.Types
 import           GHCup.Utils.Prelude

-import           Control.Applicative            ( (<|>) )
 import           Data.Aeson
 import           Data.Aeson.TH
 import           Data.Aeson.Types
@@ -54,7 +53,6 @@ deriveJSON defaultOptions { fieldLabelModifier = removeLensFieldLabel } ''Requir
 instance ToJSON Tag where
  toJSON Latest             = String "Latest"
  toJSON Recommended        = String "Recommended"
-  toJSON Prerelease         = String "Prerelease"
  toJSON (Base       pvp'') = String ("base-" <> prettyPVP pvp'')
  toJSON (UnknownTag x    ) = String (T.pack x)

@@ -62,7 +60,6 @@ instance FromJSON Tag where
  parseJSON = withText "Tag" $ \t -> case T.unpack t of
    "Latest"                             -> pure Latest
    "Recommended"                        -> pure Recommended
-    "Prerelease"                         -> pure Prerelease
    ('b' : 'a' : 's' : 'e' : '-' : ver') -> case pvp (T.pack ver') of
      Right x -> pure $ Base x
      Left  e -> fail . show $ e
@@ -194,18 +191,3 @@ instance FromJSON (Path Rel) where
    case parseRel d of
      Right x -> pure x
      Left  e -> fail $ "Failure in HPath Rel (FromJSON)" <> show e
-
-
-instance ToJSON TarDir where
-  toJSON (RealDir  p) = toJSON p
-  toJSON (RegexDir r) = object ["RegexDir" .= r]
-
-instance FromJSON TarDir where
-  parseJSON v = realDir v <|> regexDir v
-   where
-    realDir = withText "TarDir" $ \t -> do
-      fp <- parseJSON (String t)
-      pure (RealDir fp)
-    regexDir = withObject "TarDir" $ \o -> do
-      r <- o .: "RegexDir"
-      pure $ RegexDir r
--- a/lib/GHCup/Types/Optics.hs
+++ b/lib/GHCup/Types/Optics.hs
@@ -4,7 +4,7 @@
 Module      : GHCup.Types.Optics
 Description : GHCup optics
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
--- a/lib/GHCup/Utils.hs
+++ b/lib/GHCup/Utils.hs
@@ -10,7 +10,7 @@
 Module      : GHCup.Utils
 Description : GHCup domain specific utilities
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
@@ -36,7 +36,7 @@ import           GHCup.Utils.Prelude
 import           GHCup.Utils.String.QQ

 #if !defined(TAR)
-import           Codec.Archive           hiding ( Directory )
+import           Codec.Archive
 #endif
 import           Control.Applicative
 import           Control.Exception.Safe
@@ -48,9 +48,7 @@ import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Data.ByteString                ( ByteString )
 import           Data.Either
-import           Data.Foldable
 import           Data.List
-import           Data.List.Split
 import           Data.Maybe
 import           Data.String.Interpolate
 import           Data.Text                      ( Text )
@@ -99,24 +97,20 @@ import qualified Text.Megaparsec               as MP


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


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

  files  <- liftIO $ findFiles'
-    binDir
+    bindir
    (  maybe mempty (\x -> MP.chunk (x <> "-")) _tvTarget
    *> parseUntil1 (MP.chunk $ prettyVer _tvVersion)
    *> (MP.chunk $ prettyVer _tvVersion)
@@ -124,41 +118,42 @@ rmMinorSymlinks GHCTargetVersion {..} = do
    )

  forM_ files $ \f -> do
-    let fullF = (binDir </> f)
+    let fullF = (bindir </> f)
    $(logDebug) [i|rm -f #{toFilePath fullF}|]
    liftIO $ hideError doesNotExistErrorType $ deleteFile fullF


 -- | Removes the set ghc version for the given target, if any.
-rmPlain :: (MonadReader Settings m, MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
+rmPlain :: (MonadLogger m, MonadThrow m, MonadFail m, MonadIO m)
  => Maybe Text -- ^ target
        -> Excepts '[NotInstalled] m ()
 rmPlain target = do
-  Settings {dirs = Dirs {..}} <- lift ask
-  mtv <- lift $ ghcSet target
+  mtv <- ghcSet target
  forM_ mtv $ \tv -> do
    files  <- liftE $ ghcToolFiles tv
+    bindir <- liftIO $ ghcupBinDir
    forM_ files $ \f -> do
-      let fullF = (binDir </> f)
+      let fullF = (bindir </> f)
      lift $ $(logDebug) [i|rm -f #{toFilePath fullF}|]
      liftIO $ hideError doesNotExistErrorType $ deleteFile fullF
    -- old ghcup
-    let hdc_file = (binDir </> [rel|haddock-ghc|])
+    let hdc_file = (bindir </> [rel|haddock-ghc|])
    lift $ $(logDebug) [i|rm -f #{toFilePath hdc_file}|]
    liftIO $ hideError doesNotExistErrorType $ deleteFile hdc_file


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

+  bindir <- liftIO ghcupBinDir
+
  files  <- liftIO $ findFiles'
-    binDir
+    bindir
    (  maybe mempty (\x -> MP.chunk (x <> "-")) _tvTarget
    *> parseUntil1 (MP.chunk v')
    *> MP.chunk v'
@@ -166,7 +161,7 @@ rmMajorSymlinks GHCTargetVersion {..} = do
    )

  forM_ files $ \f -> do
-    let fullF = (binDir </> f)
+    let fullF = (bindir </> f)
    $(logDebug) [i|rm -f #{toFilePath fullF}|]
    liftIO $ hideError doesNotExistErrorType $ deleteFile fullF

@@ -179,61 +174,59 @@ rmMajorSymlinks GHCTargetVersion {..} = do


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


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


 -- | Whether the given GHC version is set as the current.
-ghcSet :: (MonadReader Settings m, MonadThrow m, MonadIO m)
+ghcSet :: (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
  ghc    <- parseRel $ E.encodeUtf8 (maybe "ghc" (<> "-ghc") mtarget)
-  let ghcBin = binDir </> ghc
+  ghcBin <- (</> ghc) <$> liftIO ghcupBinDir

  -- link destination is of the form ../ghc/<ver>/bin/ghc
  -- for old ghcup, it is ../ghc/<ver>/bin/ghc-<ver>
  liftIO $ handleIO' NoSuchThing (\_ -> pure $ Nothing) $ do
    link <- readSymbolicLink $ toFilePath ghcBin
    Just <$> ghcLinkVersion link
-
-ghcLinkVersion :: MonadThrow m => ByteString -> m GHCTargetVersion
-ghcLinkVersion bs = do
-  t <- throwEither $ E.decodeUtf8' bs
-  throwEither $ MP.parse parser "ghcLinkVersion" t
 where
-  parser =
-      (do
-         _    <- parseUntil1 (MP.chunk "/ghc/")
-         _    <- MP.chunk "/ghc/"
-         r    <- parseUntil1 (MP.chunk "/")
-         rest <- MP.getInput
-         MP.setInput r
-         x <- ghcTargetVerP
-         MP.setInput rest
-         pure x
-       )
-      <* MP.chunk "/"
-      <* MP.takeRest
-      <* MP.eof
+  ghcLinkVersion :: MonadThrow m => ByteString -> m GHCTargetVersion
+  ghcLinkVersion bs = do
+    t <- throwEither $ E.decodeUtf8' bs
+    throwEither $ MP.parse parser "" t
+   where
+    parser =
+      MP.chunk "../ghc/"
+        *> (do
+             r    <- parseUntil1 (MP.chunk "/")
+             rest <- MP.getInput
+             MP.setInput r
+             x <- ghcTargetVerP
+             MP.setInput rest
+             pure x
+           )
+        <* MP.chunk "/"
+        <* MP.takeRest
+        <* MP.eof


 -- | 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 :: MonadIO m => m [Either (Path Rel) GHCTargetVersion]
 getInstalledGHCs = do
-  ghcdir <- ghcupGHCBaseDir
+  ghcdir <- liftIO $ ghcupGHCBaseDir
  fs     <- liftIO $ hideErrorDef [NoSuchThing] [] $ getDirsFiles' ghcdir
  forM fs $ \f -> case parseGHCupGHCDir f of
    Right r -> pure $ Right r
@@ -241,64 +234,43 @@ getInstalledGHCs = do


 -- | Get all installed cabals, by matching on @~\/.ghcup\/bin/cabal-*@.
-getInstalledCabals :: (MonadReader Settings m, MonadIO m, MonadCatch m)
-                   => m [Either (Path Rel) Version]
+getInstalledCabals :: IO [Either (Path Rel) Version]
 getInstalledCabals = do
-  Settings {dirs = Dirs {..}} <- ask
+  bindir <- liftIO $ ghcupBinDir
  bins   <- liftIO $ handleIO (\_ -> pure []) $ findFiles
-    binDir
+    bindir
    (makeRegexOpts compExtended execBlank ([s|^cabal-.*$|] :: ByteString))
  vs <- forM bins $ \f -> case fmap version (fmap decUTF8Safe . B.stripPrefix "cabal-" . toFilePath $ f) of
    Just (Right r) -> pure $ Right r
    Just (Left  _) -> pure $ Left f
    Nothing        -> pure $ Left f
  cs <- cabalSet -- for legacy cabal
-  pure $ maybe vs (\x -> nub $ Right x:vs) cs
+  pure $ maybe vs (\x -> Right x:vs) cs


 -- | Whether the given cabal version is installed.
-cabalInstalled :: (MonadIO m, MonadReader Settings m, MonadCatch m) => Version -> m Bool
+cabalInstalled :: Version -> IO 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 :: (MonadIO m, MonadThrow m) => m (Maybe Version)
 cabalSet = do
-  Settings {dirs = Dirs {..}} <- ask
-  let cabalbin = binDir </> [rel|cabal|]
-  b        <- handleIO (\_ -> pure False) $ fmap (== SymbolicLink) $ liftIO $ getFileType cabalbin
-  if
-    | b -> do
-      liftIO $ handleIO' NoSuchThing (\_ -> pure $ Nothing) $ do
-        broken <- isBrokenSymlink cabalbin
-        if broken
-          then pure Nothing
-          else do
-            link <- readSymbolicLink $ toFilePath cabalbin
-            Just <$> linkVersion link
-    | otherwise -> do -- legacy behavior
-      mc <- liftIO $ handleIO (\_ -> pure Nothing) $ fmap Just $ executeOut
-        cabalbin
-        ["--numeric-version"]
-        Nothing
-      fmap join $ forM mc $ \c -> if
-        | not (B.null (_stdOut c)), _exitCode c == ExitSuccess -> do
-          let reportedVer = fst . B.spanEnd (== _lf) . _stdOut $ c
-          case version $ decUTF8Safe reportedVer of
-            Left  e -> throwM e
-            Right r -> pure $ Just r
-        | otherwise -> pure Nothing
- where
-  linkVersion :: MonadThrow m => ByteString -> m Version
-  linkVersion bs = do
-    t <- throwEither $ E.decodeUtf8' bs
-    throwEither $ MP.parse parser "" t
-   where
-    parser =
-      MP.chunk "cabal-" *> version'
-
+  cabalbin <- (</> [rel|cabal|]) <$> liftIO ghcupBinDir
+  mc       <- liftIO $ handleIO (\_ -> pure Nothing) $ fmap Just $ executeOut
+    cabalbin
+    ["--numeric-version"]
+    Nothing
+  fmap join $ forM mc $ \c -> if
+             | not (B.null (_stdOut c))
+             , _exitCode c == ExitSuccess -> do
+                  let reportedVer = fst . B.spanEnd (== _lf) . _stdOut $ c
+                  case version $ decUTF8Safe reportedVer of
+                    Left  e -> throwM e
+                    Right r -> pure $ Just r
+             | otherwise -> pure Nothing



@@ -323,7 +295,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 :: (MonadIO m, MonadThrow m)
               => Int        -- ^ major version component
               -> Int        -- ^ minor version component
               -> Maybe Text -- ^ the target triple
@@ -380,17 +352,18 @@ unpackToDir dest av = do
 #if defined(TAR)
  let untar :: MonadIO m => BL.ByteString -> Excepts '[] m ()
      untar = liftIO . Tar.unpack (toFilePath dest) . Tar.read
-
-      rf :: MonadIO m => Path Abs -> Excepts '[] m BL.ByteString
-      rf = liftIO . readFile
 #else
  let untar :: MonadIO m => BL.ByteString -> Excepts '[ArchiveResult] m ()
      untar = lEM . liftIO . runArchiveM . unpackToDirLazy (T.unpack . decUTF8Safe . toFilePath $ dest)
-
-      rf :: MonadIO m => Path Abs -> Excepts '[ArchiveResult] m BL.ByteString
-      rf = liftIO . readFile
 #endif

+#if defined(TAR)
+      rf :: MonadIO m => Path Abs -> Excepts '[] m BL.ByteString
+#else
+      rf :: MonadIO m => Path Abs -> Excepts '[ArchiveResult] m BL.ByteString
+#endif
+      rf = liftIO . readFile
+
  -- extract, depending on file extension
  if
    | ".tar.gz" `B.isSuffixOf` fn -> liftE
@@ -405,28 +378,6 @@ unpackToDir dest av = do
    | otherwise -> throwE $ UnknownArchive fn


-intoSubdir :: (MonadLogger m, MonadIO m, MonadThrow m, MonadCatch m)
-           => Path Abs       -- ^ unpacked tar dir
-           -> TarDir         -- ^ how to descend
-           -> Excepts '[TarDirDoesNotExist] m (Path Abs)
-intoSubdir bdir tardir = case tardir of
-  RealDir pr -> do
-    whenM (fmap not . liftIO . doesDirectoryExist $ (bdir </> pr))
-          (throwE $ TarDirDoesNotExist tardir)
-    pure (bdir </> pr)
-  RegexDir r -> do
-    let rs = splitOn "/" r
-    foldlM
-      (\y x ->
-        (fmap sort . handleIO (\_ -> pure []) . liftIO . findFiles y . regex $ x) >>= \case
-          []      -> throwE $ TarDirDoesNotExist tardir
-          (p : _) -> pure (y </> p)
-      )
-      bdir
-      rs
-    where regex = makeRegexOpts compIgnoreCase execBlank
-
-


    ------------
@@ -489,11 +440,11 @@ 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 :: (MonadThrow m, MonadFail m, MonadIO m)
             => GHCTargetVersion
             -> Excepts '[NotInstalled] m [Path Rel]
 ghcToolFiles ver = do
-  ghcdir <- lift $ ghcupGHCDir ver
+  ghcdir <- liftIO $ ghcupGHCDir ver
  let bindir = ghcdir </> [rel|bin|]

  -- fail if ghc is not installed
@@ -602,18 +553,24 @@ runBuildAction :: (Show (V e), MonadReader Settings m, MonadIO m, MonadMask m)
               -> Excepts '[BuildFailed] m a
 runBuildAction bdir instdir action = do
  Settings {..} <- lift ask
-  let exAction = do
+  v <- flip
+      onException
+      (do
        forM_ instdir $ \dir ->
          liftIO $ hideError doesNotExistErrorType $ deleteDirRecursive dir
        when (keepDirs == Never)
          $ liftIO
          $ hideError doesNotExistErrorType
          $ deleteDirRecursive bdir
-  v <-
-    flip onException exAction
+      )
    $ catchAllE
        (\es -> do
-          exAction
+          forM_ instdir $ \dir ->
+            liftIO $ hideError doesNotExistErrorType $ deleteDirRecursive dir
+          when (keepDirs == Never)
+            $ liftIO
+            $ hideError doesNotExistErrorType
+            $ deleteDirRecursive bdir
          throwE (BuildFailed bdir es)
        )
    $ action
@@ -621,25 +578,3 @@ runBuildAction bdir instdir action = do
  when (keepDirs == Never || keepDirs == Errors) $ liftIO $ deleteDirRecursive
    bdir
  pure v
-
-
-- | More permissive version of 'createDirRecursive'. This doesn't
-- error when the destination is a symlink to a directory.
-createDirRecursive' :: Path b -> IO ()
-createDirRecursive' p =
-  handleIO (\e -> if isAlreadyExistsError e then isSymlinkDir e else throwIO e)
-    . createDirRecursive newDirPerms
-    $ p
-
- where
-  isSymlinkDir e = do
-    ft <- getFileType p
-    case ft of
-      SymbolicLink -> do
-        rp <- canonicalizePath p
-        rft <- getFileType rp
-        case rft of
-          Directory -> pure ()
-          _ -> throwIO e
-      _ -> throwIO e
-
--- a/lib/GHCup/Utils/Dirs.hs
+++ b/lib/GHCup/Utils/Dirs.hs
@@ -1,5 +1,4 @@
 {-# LANGUAGE OverloadedStrings     #-}
-{-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE QuasiQuotes           #-}
 {-# LANGUAGE ViewPatterns          #-}

@@ -7,21 +6,12 @@
 Module      : GHCup.Utils.Dirs
 Description : Definition of GHCup directories
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
 -}
-module GHCup.Utils.Dirs
-  ( getDirs
-  , ghcupGHCBaseDir
-  , ghcupGHCDir
-  , parseGHCupGHCDir
-  , mkGhcupTmpDir
-  , withGHCupTmpDir
-  , relativeSymlink
-  )
-where
+module GHCup.Utils.Dirs where


 import           GHCup.Types
@@ -34,7 +24,6 @@ import           Control.Exception.Safe
 import           Control.Monad
 import           Control.Monad.Reader
 import           Control.Monad.Trans.Resource
-import           Data.ByteString                ( ByteString )
 import           Data.Maybe
 import           HPath
 import           HPath.IO
@@ -46,7 +35,6 @@ import           Prelude                 hiding ( abs
 import           System.Posix.Env.ByteString    ( getEnv
                                                , getEnvDefault
                                                )
-import           System.Posix.FilePath   hiding ( (</>) )
 import           System.Posix.Temp.ByteString   ( mkdtemp )

 import qualified Data.ByteString.UTF8          as UTF8
@@ -57,117 +45,33 @@ import qualified Text.Megaparsec               as MP



-    ------------------------------
-    --[ GHCup base directories ]--
-    ------------------------------
-
-
-- | ~/.ghcup by default
--
-- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
-- then uses 'XDG_DATA_HOME/ghcup' as per xdg spec.
-ghcupBaseDir :: IO (Path Abs)
-ghcupBaseDir = do
-  xdg <- useXDG
-  if xdg
-    then do
-      bdir <- getEnv "XDG_DATA_HOME" >>= \case
-        Just r  -> parseAbs r
-        Nothing -> do
-          home <- liftIO getHomeDirectory
-          pure (home </> [rel|.local/share|])
-      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).
-ghcupBinDir :: IO (Path Abs)
-ghcupBinDir = do
-  xdg <- useXDG
-  if xdg
-    then do
-      getEnv "XDG_BIN_HOME" >>= \case
-        Just r  -> parseAbs r
-        Nothing -> do
-          home <- liftIO getHomeDirectory
-          pure (home </> [rel|.local/bin|])
-    else ghcupBaseDir <&> (</> [rel|bin|])
-
-
-- | Defaults to '~/.ghcup/cache'.
--
-- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
-- then uses 'XDG_CACHE_HOME/ghcup' as per xdg spec.
-ghcupCacheDir :: IO (Path Abs)
-ghcupCacheDir = do
-  xdg <- useXDG
-  if xdg
-    then do
-      bdir <- getEnv "XDG_CACHE_HOME" >>= \case
-        Just r  -> parseAbs r
-        Nothing -> do
-          home <- liftIO getHomeDirectory
-          pure (home </> [rel|.cache|])
-      pure (bdir </> [rel|ghcup|])
-    else ghcupBaseDir <&> (</> [rel|cache|])
-
-
-- | Defaults to '~/.ghcup/logs'.
--
-- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
-- then uses 'XDG_CACHE_HOME/ghcup/logs' as per xdg spec.
-ghcupLogsDir :: IO (Path Abs)
-ghcupLogsDir = do
-  xdg <- useXDG
-  if xdg
-    then do
-      bdir <- getEnv "XDG_CACHE_HOME" >>= \case
-        Just r  -> parseAbs r
-        Nothing -> do
-          home <- liftIO getHomeDirectory
-          pure (home </> [rel|.cache|])
-      pure (bdir </> [rel|ghcup/logs|])
-    else ghcupBaseDir <&> (</> [rel|logs|])
-
-
-getDirs :: IO Dirs
-getDirs = do
-  baseDir  <- ghcupBaseDir
-  binDir   <- ghcupBinDir
-  cacheDir <- ghcupCacheDir
-  logsDir  <- ghcupLogsDir
-  pure Dirs { .. }
-
-
-
    -------------------------
    --[ GHCup directories ]--
    -------------------------


+-- | ~/.ghcup by default
+ghcupBaseDir :: IO (Path Abs)
+ghcupBaseDir = do
+  bdir <- getEnv "GHCUP_INSTALL_BASE_PREFIX" >>= \case
+    Just r  -> parseAbs r
+    Nothing -> liftIO getHomeDirectory
+  pure (bdir </> [rel|.ghcup|])
+
+
 -- | ~/.ghcup/ghc by default.
-ghcupGHCBaseDir :: (MonadReader Settings m) => m (Path Abs)
-ghcupGHCBaseDir = do
-  Settings {..} <- ask
-  pure (baseDir dirs </> [rel|ghc|])
+ghcupGHCBaseDir :: IO (Path Abs)
+ghcupGHCBaseDir = ghcupBaseDir <&> (</> [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)
-            => GHCTargetVersion
-            -> m (Path Abs)
+ghcupGHCDir :: GHCTargetVersion -> IO (Path Abs)
 ghcupGHCDir ver = do
-  ghcbasedir    <- ghcupGHCBaseDir
-  verdir        <- parseRel $ E.encodeUtf8 (prettyTVer ver)
+  ghcbasedir <- ghcupGHCBaseDir
+  verdir     <- parseRel $ E.encodeUtf8 (prettyTVer ver)
  pure (ghcbasedir </> verdir)


@@ -178,6 +82,16 @@ parseGHCupGHCDir (toFilePath -> f) = do
  throwEither $ MP.parse ghcTargetVerP "" fp


+ghcupBinDir :: IO (Path Abs)
+ghcupBinDir = ghcupBaseDir <&> (</> [rel|bin|])
+
+ghcupCacheDir :: IO (Path Abs)
+ghcupCacheDir = ghcupBaseDir <&> (</> [rel|cache|])
+
+ghcupLogsDir :: IO (Path Abs)
+ghcupLogsDir = ghcupBaseDir <&> (</> [rel|logs|])
+
+
 mkGhcupTmpDir :: (MonadThrow m, MonadIO m) => m (Path Abs)
 mkGhcupTmpDir = do
  tmpdir <- liftIO $ getEnvDefault "TMPDIR" "/tmp"
@@ -189,8 +103,6 @@ withGHCupTmpDir :: (MonadResource m, MonadThrow m, MonadIO m) => m (Path Abs)
 withGHCupTmpDir = snd <$> allocate mkGhcupTmpDir deleteDirRecursive


-
-
    --------------
    --[ Others ]--
    --------------
@@ -204,23 +116,3 @@ getHomeDirectory = do
    Nothing -> do
      h <- PU.homeDirectory <$> (PU.getEffectiveUserID >>= PU.getUserEntryForID)
      parseAbs $ UTF8.fromString h -- this is a guess
-
-
-useXDG :: IO Bool
-useXDG = isJust <$> getEnv "GHCUP_USE_XDG_DIRS"
-
-
-relativeSymlink :: Path Abs  -- ^ the path in which to create the symlink
-                -> Path Abs  -- ^ the symlink destination
-                -> ByteString
-relativeSymlink (toFilePath -> p1) (toFilePath -> p2) =
-  let d1      = splitDirectories p1
-      d2      = splitDirectories p2
-      common  = takeWhile (\(x, y) -> x == y) $ zip d1 d2
-      cPrefix = drop (length common) d1
-  in  joinPath (replicate (length cPrefix) "..")
-        <> joinPath ("/" : (drop (length common) d2))
-
-
-
-
--- a/lib/GHCup/Utils/File.hs
+++ b/lib/GHCup/Utils/File.hs
@@ -2,13 +2,12 @@
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE FlexibleContexts  #-}
 {-# LANGUAGE TemplateHaskell   #-}
-{-# LANGUAGE ViewPatterns      #-}

 {-|
 Module      : GHCup.Utils.File
 Description : File and unix APIs
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
@@ -18,6 +17,7 @@ Some of these functions use sophisticated logging.
 -}
 module GHCup.Utils.File where

+import           GHCup.Utils.Dirs
 import           GHCup.Utils.Prelude
 import           GHCup.Types

@@ -26,7 +26,6 @@ import           Control.Concurrent.Async
 import           Control.Exception              ( evaluate )
 import           Control.Exception.Safe
 import           Control.Monad
-import           Control.Monad.Logger
 import           Control.Monad.Reader
 import           Control.Monad.Trans.State.Strict
 import           Data.ByteString                ( ByteString )
@@ -35,7 +34,6 @@ import           Data.Functor
 import           Data.IORef
 import           Data.Maybe
 import           Data.Sequence                  ( Seq, (|>) )
-import           Data.String.Interpolate
 import           Data.Text                      ( Text )
 import           Data.Void
 import           Data.Word8
@@ -49,7 +47,6 @@ import           System.IO.Error
 import           System.Posix.Directory.ByteString
 import           System.Posix.FD               as FD
 import           System.Posix.FilePath   hiding ( (</>) )
-import           System.Posix.Files.ByteString
 import           System.Posix.Foreign           ( oExcl )
 import "unix"    System.Posix.IO.ByteString
                                         hiding ( openFd )
@@ -126,8 +123,9 @@ 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
-  logfile       <- (logsDir </>) <$> parseRel (toFilePath lfile <> ".log")
+  Settings {..} <- ask
+  ldir          <- liftIO ghcupLogsDir
+  logfile       <- (ldir </>) <$> parseRel (toFilePath lfile <> ".log")
  liftIO $ bracket (createFile (toFilePath logfile) newFilePerms)
                   closeFd
                   (action verbose)
@@ -379,7 +377,7 @@ toProcessError :: ByteString
               -> Maybe ProcessStatus
               -> Either ProcessError ()
 toProcessError exe args mps = case mps of
-  Just (SPPB.Exited (ExitFailure xi)) -> Left $ NonZeroExit xi exe args
+  Just (SPPB.Exited (ExitFailure i)) -> Left $ NonZeroExit i exe args
  Just (SPPB.Exited ExitSuccess    ) -> Right ()
  Just (Terminated _ _             ) -> Left $ PTerminated exe args
  Just (Stopped _                  ) -> Left $ PStopped exe args
@@ -429,24 +427,3 @@ findFiles' path parser = do
                             Right p' -> isJust $ MP.parseMaybe parser p')
    $ dirContentsStream dirStream
  pure $ join $ fmap parseRel f
-
-
-isBrokenSymlink :: Path Abs -> IO Bool
-isBrokenSymlink p =
-  handleIO
-      (\e -> if ioeGetErrorType e == NoSuchThing then pure True else throwIO e)
-    $ do
-        _ <- canonicalizePath p
-        pure False
-
-
-chmod_777 :: (MonadLogger m, MonadIO m) => Path a -> m ()
-chmod_777 (toFilePath -> fp) = do
-  let exe_mode =
-          newFilePerms
-            `unionFileModes` ownerExecuteMode
-            `unionFileModes` groupExecuteMode
-            `unionFileModes` otherExecuteMode
-  $(logDebug) [i|chmod 777 #{fp}|]
-  liftIO $ setFileMode fp exe_mode
-
--- a/lib/GHCup/Utils/Logger.hs
+++ b/lib/GHCup/Utils/Logger.hs
@@ -1,11 +1,10 @@
 {-# LANGUAGE QuasiQuotes           #-}
-{-# LANGUAGE FlexibleContexts      #-}

 {-|
 Module      : GHCup.Utils.Logger
 Description : logger definition
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
@@ -14,12 +13,9 @@ Here we define our main logger.
 -}
 module GHCup.Utils.Logger where

-import           GHCup.Types
 import           GHCup.Utils

 import           Control.Monad
-import           Control.Monad.IO.Class
-import           Control.Monad.Reader
 import           Control.Monad.Logger
 import           HPath
 import           HPath.IO
@@ -65,12 +61,11 @@ myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
    rawOutter outr


-initGHCupFileLogging :: (MonadIO m, MonadReader Settings m) => Path Rel -> m (Path Abs)
+initGHCupFileLogging :: Path Rel -> IO (Path Abs)
 initGHCupFileLogging context = do
-  Settings {dirs = Dirs {..}} <- ask
-  let logfile = logsDir </> context
-  liftIO $ do
-    createDirRecursive' logsDir
-    hideError doesNotExistErrorType $ deleteFile logfile
-    createRegularFile newFilePerms logfile
-    pure logfile
+  logs <- ghcupLogsDir
+  let logfile = logs </> context
+  createDirIfMissing newDirPerms logs
+  hideError doesNotExistErrorType $ deleteFile logfile
+  createRegularFile newFilePerms logfile
+  pure logfile
--- a/lib/GHCup/Utils/MegaParsec.hs
+++ b/lib/GHCup/Utils/MegaParsec.hs
@@ -5,7 +5,7 @@
 Module      : GHCup.Utils.MegaParsec
 Description : MegaParsec utilities
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
--- a/lib/GHCup/Utils/Prelude.hs
+++ b/lib/GHCup/Utils/Prelude.hs
@@ -12,7 +12,7 @@
 Module      : GHCup.Utils.Prelude
 Description : MegaParsec utilities
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
--- a/lib/GHCup/Utils/String/QQ.hs
+++ b/lib/GHCup/Utils/String/QQ.hs
@@ -4,7 +4,7 @@
 Module      : GHCup.Utils.String.QQ
 Description : String quasi quoters
 Copyright   : (c) Audrey Tang <audreyt@audreyt.org> 2019, Julian Ospald <hasufell@posteo.de> 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
--- a/lib/GHCup/Utils/Version/QQ.hs
+++ b/lib/GHCup/Utils/Version/QQ.hs
@@ -11,7 +11,7 @@
 Module      : GHCup.Utils.Version.QQ
 Description : Version quasi-quoters
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
--- a/lib/GHCup/Version.hs
+++ b/lib/GHCup/Version.hs
@@ -5,7 +5,7 @@
 Module      : GHCup.Version
 Description : Static version information
 Copyright   : (c) Julian Ospald, 2020
-License     : LGPL-3.0
+License     : GPL-3
 Maintainer  : hasufell@hasufell.de
 Stability   : experimental
 Portability : POSIX
@@ -20,13 +20,13 @@ import           URI.ByteString.QQ

 import qualified Data.Text                     as T

-- | This reflects the API version of the YAML.
+-- | This reflects the API version of the JSON.
 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.2.json|]

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

 -- | ghcup version as numeric string.
 numericVer :: String
Author	SHA1	Message	Date
Julian Ospald	3d55675765	Add ghcup-0.1.9	2020-08-14 09:48:57 +02:00
Julian Ospald	bc6da15407	Update ghcup bins for alpine, bc these must be explicit See `22a5ad73`	2020-08-11 18:27:44 +02:00