Merge branch 'nightlies'

2023-06-29 18:27:17 +08:00 · 2023-06-29 18:27:17 +08:00 · 3e83a7fd83
parent 278a3005d1 34ac9cec4d
commit 3e83a7fd83
31 changed files with 14634 additions and 10647 deletions
--- a/.cirrus.yml
+++ b/.cirrus.yml
@ -1,5 +1,5 @@
 freebsd_instance:
-  image_family: freebsd-13-1
+  image_family: freebsd-13-2

 build_task:
  name: build
@ -16,7 +16,9 @@ build_task:
    AWS_ACCESS_KEY_ID: ENCRYPTED[6ed6287e2dd78ab5f84b22232c5245834ab042bd8ba443883aaf4b4d1ecc0481add1fdfad5ae6f6a8cfb418e6f19b2fc]
    AWS_SECRET_ACCESS_KEY: ENCRYPTED[16f3cda2954c7cee99444e6788eb5997382aa4ce1477e7523fef2586077541f43b5c816156961fc6b4677259679875a7]
    S3_HOST: ENCRYPTED[ce961780a33159f7d1d8046956b5ac6ebc3bfc8149428e5f538576cda51d9f3d0c35b79cdd1e325793639ff6e31f889d]
-  install_script: pkg install -y ghc hs-cabal-install git bash misc/compat10x misc/compat11x misc/compat12x gmake llvm14
+  install_script:
+    - sed -i.bak -e 's/quarterly/latest/' /etc/pkg/FreeBSD.conf
+    - pkg install -y ghc hs-cabal-install git bash misc/compat10x misc/compat11x misc/compat12x gmake llvm14
  script:
    - tzsetup Etc/GMT
    - adjkerntz -a
--- a/.github/workflows/bootstrap.yaml
+++ b/.github/workflows/bootstrap.yaml
@ -25,7 +25,7 @@ jobs:
        include:
          - os: ubuntu-latest
            DISTRO: Ubuntu
-          - os: macOS-10.15
+          - os: macOS-11
            DISTRO: na
          - os: windows-latest
            DISTRO: na
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@ -81,7 +81,7 @@ jobs:
    name: Build ARM binary
    runs-on: ${{ matrix.os }}
    env:
-      CABAL_VER: 3.8.1.0
+      CABAL_VER: 3.6.2.0
      JSON_VERSION: "0.0.7"
      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
@ -90,7 +90,7 @@ jobs:
      fail-fast: true
      matrix:
        include:
-          - os: [self-hosted, Linux, ARM64, aarch32-linux]
+          - os: [self-hosted, Linux, ARM64]
            ARTIFACT: "armv7-linux-ghcup"
            GHC_VER: 9.2.2
            ARCH: ARM
@ -168,7 +168,7 @@ jobs:
            ARTIFACT: "aarch64-apple-darwin-ghcup"
            GHC_VER: 9.2.6
            ARCH: ARM64
-          - os: macOS-10.15
+          - os: macOS-11
            ARTIFACT: "x86_64-apple-darwin-ghcup"
            GHC_VER: 9.2.6
            ARCH: 64
@ -325,12 +325,12 @@ jobs:
    needs: "build-arm"
    runs-on: ${{ matrix.os }}
    env:
-      CABAL_VER: 3.8.1.0
+      CABAL_VER: 3.6.2.0
      JSON_VERSION: "0.0.7"
    strategy:
      matrix:
        include:
-          - os: [self-hosted, Linux, ARM64, aarch32-linux]
+          - os: [self-hosted, Linux, ARM64]
            ARTIFACT: "armv7-linux-ghcup"
            GHC_VER: 9.2.2
            ARCH: ARM
@ -403,7 +403,7 @@ jobs:
            GHC_VER: 9.2.6
            ARCH: ARM64
            DISTRO: na
-          - os: macOS-10.15
+          - os: macOS-11
            ARTIFACT: "x86_64-apple-darwin-ghcup"
            GHC_VER: 9.2.6
            ARCH: 64
--- a/app/ghcup/BrickMain.hs
+++ b/app/ghcup/BrickMain.hs
@ -73,8 +73,8 @@ data BrickData = BrickData
  deriving Show

 data BrickSettings = BrickSettings
-  { showAllVersions :: Bool
-  , showAllTools    :: Bool
+  { showAllVersions    :: Bool
+  , showAllTools       :: Bool
  }
  deriving Show

@ -202,9 +202,11 @@ ui dimAttrs BrickState{ appSettings = as@BrickSettings{}, ..}
  printTag Recommended    = Just $ withAttr (attrName "recommended") $ str "recommended"
  printTag Latest         = Just $ withAttr (attrName "latest") $ str "latest"
  printTag Prerelease     = Just $ withAttr (attrName "prerelease") $ str "prerelease"
+  printTag Nightly        = Just $ withAttr (attrName "nightly") $ str "nightly"
  printTag (Base pvp'')   = Just $ str ("base-" ++ T.unpack (prettyPVP pvp''))
  printTag Old            = Nothing
  printTag LatestPrerelease = Just $ withAttr (attrName "latest-prerelease") $ str "latest-prerelease"
+  printTag LatestNightly    = Just $ withAttr (attrName "latest-nightly") $ str "latest-nightly"
  printTag (UnknownTag t) = Just $ str t

  printTool Cabal = str "cabal"
@ -218,6 +220,9 @@ ui dimAttrs BrickState{ appSettings = as@BrickSettings{}, ..}
      )
      ++ (if fromSrc then [withAttr (attrName "compiled") $ str "compiled"] else mempty)
      ++ (if lStray then [withAttr (attrName "stray") $ str "stray"] else mempty)
+      ++ (case lReleaseDay of
+            Nothing -> mempty
+            Just d  -> [withAttr (attrName "day") $ str (show d)])

  -- | Draws the list elements.
  --
@ -272,19 +277,22 @@ app attrs dimAttrs =
 defaultAttributes :: Bool -> AttrMap
 defaultAttributes no_color = attrMap
  Vty.defAttr
-  [ (attrName "active"       , Vty.defAttr `withBackColor` Vty.blue)
-  , (attrName "not-installed", Vty.defAttr `withForeColor` Vty.red)
-  , (attrName "set"          , Vty.defAttr `withForeColor` Vty.green)
-  , (attrName "installed"    , Vty.defAttr `withForeColor` Vty.green)
-  , (attrName "recommended"  , Vty.defAttr `withForeColor` Vty.green)
-  , (attrName "hls-powered"  , Vty.defAttr `withForeColor` Vty.green)
-  , (attrName "latest"       , Vty.defAttr `withForeColor` Vty.yellow)
+  [ (attrName "active"            , Vty.defAttr `withBackColor` Vty.blue)
+  , (attrName "not-installed"     , Vty.defAttr `withForeColor` Vty.red)
+  , (attrName "set"               , Vty.defAttr `withForeColor` Vty.green)
+  , (attrName "installed"         , Vty.defAttr `withForeColor` Vty.green)
+  , (attrName "recommended"       , Vty.defAttr `withForeColor` Vty.green)
+  , (attrName "hls-powered"       , Vty.defAttr `withForeColor` Vty.green)
+  , (attrName "latest"            , Vty.defAttr `withForeColor` Vty.yellow)
  , (attrName "latest-prerelease" , Vty.defAttr `withForeColor` Vty.red)
-  , (attrName "prerelease"   , Vty.defAttr `withForeColor` Vty.red)
-  , (attrName "compiled"     , Vty.defAttr `withForeColor` Vty.blue)
-  , (attrName "stray"        , Vty.defAttr `withForeColor` Vty.blue)
-  , (attrName "help"         , Vty.defAttr `withStyle`     Vty.italic)
-  , (attrName "hooray"       , Vty.defAttr `withForeColor` Vty.brightWhite)
+  , (attrName "latest-nightly"    , Vty.defAttr `withForeColor` Vty.red)
+  , (attrName "prerelease"        , Vty.defAttr `withForeColor` Vty.red)
+  , (attrName "nightly"           , Vty.defAttr `withForeColor` Vty.red)
+  , (attrName "compiled"          , Vty.defAttr `withForeColor` Vty.blue)
+  , (attrName "stray"             , Vty.defAttr `withForeColor` Vty.blue)
+  , (attrName "day"               , Vty.defAttr `withForeColor` Vty.blue)
+  , (attrName "help"              , Vty.defAttr `withStyle`     Vty.italic)
+  , (attrName "hooray"            , Vty.defAttr `withForeColor` Vty.brightWhite)
  ]
  where
    withForeColor | no_color  = const
@ -411,13 +419,17 @@ filterVisible :: Bool -> Bool -> ListResult -> Bool
 filterVisible v t e | lInstalled e = True
                    | v
                    , not t
+                    , Nightly `notElem` lTag e
                    , lTool e `notElem` hiddenTools = True
                    | not v
                    , t
-                    , Old `notElem` lTag e = True
+                    , Old `notElem` lTag e
+                    , Nightly `notElem` lTag e = True
                    | v
+                    , Nightly `notElem` lTag e
                    , t = True
-                    | otherwise = (Old `notElem` lTag e) &&
+                    | otherwise = (Old `notElem` lTag e)       &&
+                                  (Nightly `notElem` lTag e)   &&
                                  (lTool e `notElem` hiddenTools)


@ -576,7 +588,7 @@ changelog' :: (MonadReader AppState m, MonadIO m)
           -> m (Either String ())
 changelog' _ (_, ListResult {..}) = do
  AppState { pfreq, ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
-  case getChangeLog dls lTool (Left lVer) of
+  case getChangeLog dls lTool (ToolVersion lVer) of
    Nothing -> pure $ Left $
      "Could not find ChangeLog for " <> prettyShow lTool <> ", version " <> T.unpack (prettyVer lVer)
    Just uri -> do
@ -656,5 +668,5 @@ getAppData mgi = runExceptT $ do
  settings <- liftIO $ readIORef settings'

  flip runReaderT settings $ do
-    lV <- listVersions Nothing Nothing
+    lV <- listVersions Nothing [] False True (Nothing, Nothing)
    pure $ BrickData (reverse lV)
--- a/app/ghcup/GHCup/OptParse.hs
+++ b/app/ghcup/GHCup/OptParse.hs
@ -244,7 +244,8 @@ com =
      <> command
           "list"
           (info (List <$> listOpts <**> helper)
-                 (progDesc "Show available GHCs and other tools")
+                 (progDesc "Show available GHCs and other tools"
+                 <> footerDoc (Just $ text listToolFooter))
           )
      <> command
           "upgrade"
--- a/app/ghcup/GHCup/OptParse/ChangeLog.hs
+++ b/app/ghcup/GHCup/OptParse/ChangeLog.hs
@ -35,7 +35,6 @@ import qualified Data.Text                     as T
 import Control.Exception.Safe (MonadMask)
 import GHCup.Types.Optics
 import GHCup.Utils
-import Data.Versions
 import URI.ByteString (serializeURIRef')
 import Data.Char (toLower)

@ -81,7 +80,7 @@ changelogP =
              <> completer toolCompleter
            )
          )
-    <*> optional (toolVersionTagArgument Nothing Nothing)
+    <*> optional (toolVersionTagArgument [] Nothing)



@ -115,20 +114,15 @@ changelog :: ( Monad m
 changelog ChangeLogOptions{..} runAppState runLogger = do
  GHCupInfo { _ghcupDownloads = dls } <- runAppState getGHCupInfo
  let tool = fromMaybe GHC clTool
-      ver' = maybe
-        (Right Latest)
-        (\case
-          GHCVersion tv  -> Left (_tvVersion tv)
-          ToolVersion tv -> Left tv
-          ToolTag     t  -> Right t
-        )
+      ver' = fromMaybe
+        (ToolTag Latest)
        clToolVer
      muri = getChangeLog dls tool ver'
  case muri of
    Nothing -> do
      runLogger
        (logWarn $
-          "Could not find ChangeLog for " <> T.pack (prettyShow tool) <> ", version " <> either prettyVer (T.pack . show) ver'
+          "Could not find ChangeLog for " <> T.pack (prettyShow tool) <> ", version " <> T.pack (prettyShow ver')
        )
      pure ExitSuccess
    Just uri -> do
--- a/app/ghcup/GHCup/OptParse/Common.hs
+++ b/app/ghcup/GHCup/OptParse/Common.hs
@ -45,6 +45,8 @@ import           Data.Functor
 import           Data.List                      ( nub, sort, sortBy, isPrefixOf, stripPrefix )
 import           Data.Maybe
 import           Data.Text                      ( Text )
+import           Data.Time.Calendar             ( Day )
+import           Data.Time.Format               ( parseTimeM, defaultTimeLocale )
 import           Data.Versions           hiding ( str )
 import           Data.Void
 import qualified Data.Vector      as V
@ -72,26 +74,26 @@ import qualified Cabal.Config            as CC
    --[ Types ]--
    -------------

-data ToolVersion = GHCVersion GHCTargetVersion
-                 | ToolVersion Version
-                 | ToolTag Tag

 -- a superset of ToolVersion
 data SetToolVersion = SetGHCVersion GHCTargetVersion
                    | SetToolVersion Version
                    | SetToolTag Tag
+                    | SetToolDay Day
                    | SetRecommended
                    | SetNext

 prettyToolVer :: ToolVersion -> String
-prettyToolVer (GHCVersion v') = T.unpack $ tVerToText v'
+prettyToolVer (GHCVersion v')  = T.unpack $ tVerToText v'
 prettyToolVer (ToolVersion v') = T.unpack $ prettyVer v'
-prettyToolVer (ToolTag t) = show t
+prettyToolVer (ToolTag t)      = show t
+prettyToolVer (ToolDay day)    = show day

 toSetToolVer :: Maybe ToolVersion -> SetToolVersion
 toSetToolVer (Just (GHCVersion v')) = SetGHCVersion v'
 toSetToolVer (Just (ToolVersion v')) = SetToolVersion v'
 toSetToolVer (Just (ToolTag t')) = SetToolTag t'
+toSetToolVer (Just (ToolDay d')) = SetToolDay d'
 toSetToolVer Nothing = SetRecommended


@ -102,28 +104,28 @@ toSetToolVer Nothing = SetRecommended
    --------------


-toolVersionTagArgument :: Maybe ListCriteria -> Maybe Tool -> Parser ToolVersion
+toolVersionTagArgument :: [ListCriteria] -> Maybe Tool -> Parser ToolVersion
 toolVersionTagArgument criteria tool =
  argument (eitherReader (parser tool))
    (metavar (mv tool)
    <> completer (tagCompleter (fromMaybe GHC tool) [])
    <> foldMap (completer . versionCompleter criteria) tool)
 where
-  mv (Just GHC) = "GHC_VERSION|TAG"
-  mv (Just HLS) = "HLS_VERSION|TAG"
-  mv _          = "VERSION|TAG"
+  mv (Just GHC) = "GHC_VERSION|TAG|RELEASE_DATE"
+  mv (Just HLS) = "HLS_VERSION|TAG|RELEASE_DATE"
+  mv _          = "VERSION|TAG|RELEASE_DATE"

  parser (Just GHC) = ghcVersionTagEither
  parser Nothing    = ghcVersionTagEither
  parser _          = toolVersionTagEither


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

-ghcVersionArgument :: Maybe ListCriteria -> Maybe Tool -> Parser GHCTargetVersion
+ghcVersionArgument :: [ListCriteria] -> Maybe Tool -> Parser GHCTargetVersion
 ghcVersionArgument criteria tool = argument (eitherReader ghcVersionEither)
                                            (metavar "VERSION" <> foldMap (completer . versionCompleter criteria) tool)

@ -237,22 +239,23 @@ isolateParser f = case isValid f && isAbsolute f of
 -- this accepts cross prefix
 ghcVersionTagEither :: String -> Either String ToolVersion
 ghcVersionTagEither s' =
-  second ToolTag (tagEither s') <|> second GHCVersion (ghcVersionEither s')
+  second ToolDay (dayParser s') <|> second ToolTag (tagEither s') <|> second GHCVersion (ghcVersionEither s')

 -- this ignores cross prefix
 toolVersionTagEither :: String -> Either String ToolVersion
 toolVersionTagEither s' =
-  second ToolTag (tagEither s') <|> second ToolVersion (toolVersionEither s')
+  second ToolDay (dayParser s') <|> second ToolTag (tagEither s') <|> second ToolVersion (toolVersionEither s')

 tagEither :: String -> Either String Tag
 tagEither s' = case fmap toLower s' of
  "recommended"              -> Right Recommended
  "latest"                   -> Right Latest
  "latest-prerelease"        -> Right LatestPrerelease
+  "latest-nightly"           -> Right LatestNightly
  ('b':'a':'s':'e':'-':ver') -> case pvp (T.pack ver') of
                                  Right x -> Right (Base x)
                                  Left  _ -> Left $ "Invalid PVP version for base " <> ver'
-  other         -> Left $ "Unknown tag " <> other
+  other                      -> Left $ "Unknown tag " <> other


 ghcVersionEither :: String -> Either String GHCTargetVersion
@ -261,7 +264,7 @@ ghcVersionEither =

 toolVersionEither :: String -> Either String Version
 toolVersionEither =
-  first (const "Not a valid version") . MP.parse version' "" . T.pack
+  first (const "Not a valid version") . MP.parse (version' <* MP.eof) "" . T.pack


 toolParser :: String -> Either String Tool
@ -272,12 +275,22 @@ toolParser s' | t == T.pack "ghc"   = Right GHC
              | otherwise           = Left ("Unknown tool: " <> s')
  where t = T.toLower (T.pack s')

+dayParser :: String -> Either String Day
+dayParser s = maybe (Left $ "Could not parse \"" <> s <> "\". Expected format is: YYYY-MM-DD") Right
+            $ parseTimeM True defaultTimeLocale "%Y-%-m-%-d" s
+

 criteriaParser :: String -> Either String ListCriteria
-criteriaParser s' | t == T.pack "installed" = Right ListInstalled
-                  | t == T.pack "set"       = Right ListSet
-                  | t == T.pack "available" = Right ListAvailable
-                  | otherwise               = Left ("Unknown criteria: " <> s')
+criteriaParser s' | t == T.pack "installed"   = Right $ ListInstalled True
+                  | t == T.pack "set"         = Right $ ListSet True
+                  | t == T.pack "available"   = Right $ ListAvailable True
+                  | t == T.pack "+installed"  = Right $ ListInstalled True
+                  | t == T.pack "+set"        = Right $ ListSet True
+                  | t == T.pack "+available"  = Right $ ListAvailable True
+                  | t == T.pack "-installed"  = Right $ ListInstalled False
+                  | t == T.pack "-set"        = Right $ ListSet False
+                  | t == T.pack "-available"  = Right $ ListAvailable False
+                  | otherwise                 = Left ("Unknown criteria: " <> s')
  where t = T.toLower (T.pack s')


@ -455,10 +468,10 @@ tagCompleter tool add = listIOCompleter $ do
      pure $ nub $ (add ++) $ fmap tagToString allTags
    VLeft _ -> pure  (nub $ ["recommended", "latest", "latest-prerelease"] ++ add)

-versionCompleter :: Maybe ListCriteria -> Tool -> Completer
+versionCompleter :: [ListCriteria] -> Tool -> Completer
 versionCompleter criteria tool = versionCompleter' criteria tool (const True)

-versionCompleter' :: Maybe ListCriteria -> Tool -> (Version -> Bool) -> Completer
+versionCompleter' :: [ListCriteria] -> Tool -> (Version -> Bool) -> Completer
 versionCompleter' criteria tool filter' = listIOCompleter $ do
  dirs' <- liftIO getAllDirs
  let loggerConfig = LoggerConfig
@ -487,7 +500,7 @@ versionCompleter' criteria tool filter' = listIOCompleter $ do

          runEnv = flip runReaderT appState

-      installedVersions <- runEnv $ listVersions (Just tool) criteria
+      installedVersions <- runEnv $ listVersions (Just tool) criteria False False (Nothing, Nothing)
      return $ fmap (T.unpack . prettyVer) . filter filter' . fmap lVer $ installedVersions


@ -655,6 +668,7 @@ fromVersion :: ( HasLog env
            -> Tool
            -> Excepts
                 '[ TagNotFound
+                  , DayNotFound
                  , NextVerNotFound
                  , NoToolVersionSet
                  ] m (GHCTargetVersion, Maybe VersionInfo)
@ -673,6 +687,7 @@ fromVersion' :: ( HasLog env
             -> Tool
             -> Excepts
                  '[ TagNotFound
+                   , DayNotFound
                   , NextVerNotFound
                   , NoToolVersionSet
                   ] m (GHCTargetVersion, Maybe VersionInfo)
@ -707,9 +722,17 @@ fromVersion' (SetToolVersion v) tool = do
 fromVersion' (SetToolTag Latest) tool = do
  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
  bimap mkTVer Just <$> getLatest dls tool ?? TagNotFound Latest tool
+fromVersion' (SetToolDay day) tool = do
+  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  bimap mkTVer Just <$> case getByReleaseDay dls tool day of
+                          Left ad -> throwE $ DayNotFound day tool ad
+                          Right v -> pure v
 fromVersion' (SetToolTag LatestPrerelease) tool = do
  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
  bimap mkTVer Just <$> getLatestPrerelease dls tool ?? TagNotFound LatestPrerelease tool
+fromVersion' (SetToolTag LatestNightly) tool = do
+  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
+  bimap mkTVer Just <$> getLatestNightly dls tool ?? TagNotFound LatestNightly tool
 fromVersion' (SetToolTag Recommended) tool = do
  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
  bimap mkTVer Just <$> getRecommended dls tool ?? TagNotFound Recommended tool
@ -779,7 +802,7 @@ checkForUpdates :: ( MonadReader env m
                => m [(Tool, Version)]
 checkForUpdates = do
  GHCupInfo { _ghcupDownloads = dls } <- getGHCupInfo
-  lInstalled <- listVersions Nothing (Just ListInstalled)
+  lInstalled <- listVersions Nothing [ListInstalled True] False False (Nothing, Nothing)
  let latestInstalled tool = (fmap lVer . lastMay . filter (\lr -> lTool lr == tool)) lInstalled

  ghcup <- forMM (getLatest dls GHCup) $ \(l, _) -> do
--- a/app/ghcup/GHCup/OptParse/Compile.hs
+++ b/app/ghcup/GHCup/OptParse/Compile.hs
@ -170,7 +170,7 @@ ghcCompileOpts =
          )
          (short 'v' <> long "version" <> metavar "VERSION" <> help
            "The tool version to compile"
-            <> (completer $ versionCompleter Nothing GHC)
+            <> (completer $ versionCompleter [] GHC)
          )
          ) <|>
          (GHC.GitDist <$> (GitBranch <$> option
@ -205,7 +205,7 @@ ghcCompileOpts =
          <> metavar "BOOTSTRAP_GHC"
          <> help
               "The GHC version (or full path) to bootstrap with (must be installed)"
-          <> (completer $ versionCompleter Nothing GHC)
+          <> (completer $ versionCompleter [] GHC)
          )
    <*> optional
          (option
@ -258,7 +258,7 @@ ghcCompileOpts =
            )
            (short 'o' <> long "overwrite-version" <> metavar "OVERWRITE_VERSION" <> help
              "Allows to overwrite the finally installed VERSION with a different one, e.g. when you build 8.10.4 with your own patches, you might want to set this to '8.10.4-p1'"
-            <> (completer $ versionCompleter Nothing GHC)
+            <> (completer $ versionCompleter [] GHC)
            )
          )
    <*> optional
@ -291,7 +291,7 @@ hlsCompileOpts =
          )
          (short 'v' <> long "version" <> metavar "VERSION" <> help
            "The version to compile (pulled from hackage)"
-            <> (completer $ versionCompleter' Nothing HLS (either (const False) (const True) . V.pvp . V.prettyVer))
+            <> (completer $ versionCompleter' [] HLS (either (const False) (const True) . V.pvp . V.prettyVer))
          )
          )
          <|>
@ -311,7 +311,7 @@ hlsCompileOpts =
            )
          (long "source-dist" <> metavar "VERSION" <> help
            "The version to compile (pulled from packaged git sources)"
-            <> (completer $ versionCompleter Nothing HLS)
+            <> (completer $ versionCompleter [] HLS)
          )
          ))
          <|>
@ -343,7 +343,7 @@ hlsCompileOpts =
            )
            (short 'o' <> long "overwrite-version" <> metavar "OVERWRITE_VERSION" <> help
              "Allows to overwrite the finally installed VERSION with a different one, e.g. when you build 8.10.4 with your own patches, you might want to set this to '8.10.4-p1'"
-            <> (completer $ versionCompleter Nothing HLS)
+            <> (completer $ versionCompleter [] HLS)
            )
          )
          <|>
@ -403,7 +403,7 @@ hlsCompileOpts =
          option (eitherReader ghcVersionTagEither)
            (  long "ghc" <> metavar "GHC_VERSION|TAG" <> help "For which GHC version to compile for (can be specified multiple times)"
            <> completer (tagCompleter GHC [])
-            <> completer (versionCompleter Nothing GHC))
+            <> completer (versionCompleter [] GHC))
        )
    <*> many (argument str (metavar "CABAL_ARGS" <> help "Additional arguments to cabal install, prefix with '-- ' (longopts)"))

@ -453,6 +453,7 @@ type HLSEffects = '[ AlreadyInstalled
                  , UnknownArchive
                  , TarDirDoesNotExist
                  , TagNotFound
+                  , DayNotFound
                  , NextVerNotFound
                  , NoToolVersionSet
                  , NotInstalled
--- a/app/ghcup/GHCup/OptParse/Install.hs
+++ b/app/ghcup/GHCup/OptParse/Install.hs
@ -184,7 +184,7 @@ installOpts tool =
                      <> completer (toolDlCompleter (fromMaybe GHC tool))
                    )
                  )
-            <*> (Just <$> toolVersionTagArgument Nothing tool)
+            <*> (Just <$> toolVersionTagArgument [] tool)
            )
        <|> pure (Nothing, Nothing)
        )
@ -241,6 +241,7 @@ type InstallEffects = '[ AlreadyInstalled
                       , NotInstalled
                       , BuildFailed
                       , TagNotFound
+                       , DayNotFound
                       , DigestError
                       , ContentLengthError
                       , GPGError
@ -284,6 +285,7 @@ type InstallGHCEffects = '[ AlreadyInstalled
                          , NotInstalled
                          , ProcessError
                          , TagNotFound
+                          , DayNotFound
                          , TarDirDoesNotExist
                          , UninstallFailed
                          , UnknownArchive
@ -333,7 +335,7 @@ install installCommand settings getAppState' runLogger = case installCommand of
         runInstGHC s'{ settings = settings {noVerify = True}} $ do
           (v, vi) <- liftE $ fromVersion instVer GHC
           liftE $ runBothE' (installGHCBindist
-                       (DownloadInfo uri (Just $ RegexDir "ghc-.*") "" Nothing)
+                       (DownloadInfo uri (Just $ RegexDir "ghc-.*") "" Nothing Nothing)
                       (_tvVersion v)
                       (maybe GHCupInternal IsolateDir isolateDir)
                       forceInstall
@ -403,7 +405,7 @@ install installCommand settings getAppState' runLogger = case installCommand of
         runInstTool s'{ settings = settings { noVerify = True}} $ do
           (_tvVersion -> v, vi) <- liftE $ fromVersion instVer Cabal
           liftE $ runBothE' (installCabalBindist
-                                      (DownloadInfo uri Nothing "" Nothing)
+                                      (DownloadInfo uri Nothing "" Nothing Nothing)
                                      v
                                      (maybe GHCupInternal IsolateDir isolateDir)
                                      forceInstall
@ -453,7 +455,7 @@ install installCommand settings getAppState' runLogger = case installCommand of
           (_tvVersion -> v, vi) <- liftE $ fromVersion instVer HLS
           -- TODO: support legacy
           liftE $ runBothE' (installHLSBindist
-                                      (DownloadInfo uri (if isWindows then Nothing else Just (RegexDir "haskell-language-server-*")) "" Nothing)
+                                      (DownloadInfo uri (if isWindows then Nothing else Just (RegexDir "haskell-language-server-*")) "" Nothing Nothing)
                                      v
                                      (maybe GHCupInternal IsolateDir isolateDir)
                                      forceInstall
@ -502,7 +504,7 @@ install installCommand settings getAppState' runLogger = case installCommand of
          runInstTool s'{ settings = settings { noVerify = True}} $ do
            (_tvVersion -> v, vi) <- liftE $ fromVersion instVer Stack
            liftE $ runBothE' (installStackBindist
-                                       (DownloadInfo uri Nothing "" Nothing)
+                                       (DownloadInfo uri Nothing "" Nothing Nothing)
                                       v
                                       (maybe GHCupInternal IsolateDir isolateDir)
                                       forceInstall
--- a/app/ghcup/GHCup/OptParse/List.hs
+++ b/app/ghcup/GHCup/OptParse/List.hs
@ -2,6 +2,7 @@
 {-# LANGUAGE DataKinds         #-}
 {-# LANGUAGE FlexibleContexts  #-}
 {-# LANGUAGE OverloadedStrings #-}
+{-# LANGUAGE QuasiQuotes       #-}
 {-# LANGUAGE DuplicateRecordFields #-}
 {-# LANGUAGE RankNTypes #-}

@ -14,6 +15,7 @@ import           GHCup
 import           GHCup.Prelude
 import           GHCup.Types
 import           GHCup.OptParse.Common
+import           GHCup.Prelude.String.QQ

 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
@ -24,6 +26,7 @@ import           Data.Char
 import           Data.List                      ( intercalate, sort )
 import           Data.Functor
 import           Data.Maybe
+import           Data.Time.Calendar             ( Day )
 import           Data.Versions           hiding ( str )
 import           Data.Void
 import           Options.Applicative     hiding ( style )
@ -50,6 +53,10 @@ import qualified Text.Megaparsec.Char          as MPC
 data ListOptions = ListOptions
  { loTool     :: Maybe Tool
  , lCriteria  :: Maybe ListCriteria
+  , lFrom      :: Maybe Day
+  , lTo        :: Maybe Day
+  , lHideOld   :: Bool
+  , lShowNightly :: Bool
  , lRawFormat :: Bool
  }

@ -60,7 +67,6 @@ data ListOptions = ListOptions
    --[ Parsers ]--
    ---------------

-          
 listOpts :: Parser ListOptions
 listOpts =
  ListOptions
@ -69,7 +75,7 @@ listOpts =
            (eitherReader toolParser)
            (short 't' <> long "tool" <> metavar "<ghc|cabal|hls|stack>" <> help
              "Tool to list versions for. Default is all"
-              <> completer (toolCompleter)
+              <> completer toolCompleter
            )
          )
    <*> optional
@ -78,15 +84,53 @@ listOpts =
            (  short 'c'
            <> long "show-criteria"
            <> metavar "<installed|set|available>"
-            <> help "Show only installed/set/available tool versions"
-              <> completer (listCompleter ["installed", "set", "available"])
+            <> help "Apply filtering criteria, prefix with + or -"
+              <> completer (listCompleter
+                [ "+installed", "+set", "+available", "-installed", "-set", "-available"])
            )
          )
+    <*> optional
+          (option
+            (eitherReader dayParser)
+            (short 's' <> long "since" <> metavar "YYYY-MM-DD" <> help
+              "List only tools with release date starting at YYYY-MM-DD or later"
+              <> completer toolCompleter
+            )
+          )
+    <*> optional
+          (option
+            (eitherReader dayParser)
+            (short 'u' <> long "until" <> metavar "YYYY-MM-DD" <> help
+              "List only tools with release date earlier than YYYY-MM-DD"
+              <> completer toolCompleter
+            )
+          )
+    <*> switch
+          (short 'o' <> long "hide-old" <> help "Hide 'old' GHC versions (installed ones are always shown)"
+          )
+    <*> switch
+          (short 'n' <> long "show-nightly" <> help "Show nightlies (installed ones are always shown)"
+          )
    <*> switch
          (short 'r' <> long "raw-format" <> help "More machine-parsable format"
          )


+    --------------
+    --[ Footer ]--
+    --------------
+
+
+listToolFooter :: String
+listToolFooter = [s|Discussion:
+  Lists tool versions with optional criteria.
+  Nightlies are by default hidden.
+
+Examples:
+  # query nightlies in a specific range
+  ghcup list --show-nightly --since 2022-12-07 --until 2022-12-31
+  # show all installed GHC versions
+  ghcup list -t ghc -c installed|]


    -----------------
@ -105,9 +149,11 @@ printListResult no_color raw lr = do
    printTag Recommended        = color Green "recommended"
    printTag Latest             = color Yellow "latest"
    printTag Prerelease         = color Red "prerelease"
+    printTag Nightly            = color Red "nightly"
    printTag (Base       pvp'') = "base-" ++ T.unpack (prettyPVP pvp'')
    printTag (UnknownTag t    ) = t
    printTag LatestPrerelease   = color Red "latest-prerelease"
+    printTag LatestNightly      = color Red "latest-nightly"
    printTag Old                = ""

  let
@ -136,6 +182,9 @@ printListResult no_color raw lr = do
                        )
                     ++ (if fromSrc then [color Blue "compiled"] else mempty)
                     ++ (if lStray then [color Yellow "stray"] else mempty)
+                     ++ (case lReleaseDay of
+                           Nothing -> mempty
+                           Just d  -> [color Blue (show d)])
                     ++ (if lNoBindist
                          then [color Red "no-bindist"]
                          else mempty
@ -260,7 +309,7 @@ list :: ( Monad m
      -> m ExitCode
 list ListOptions{..} no_color runAppState =
  runAppState (do
-      l <- listVersions loTool lCriteria
+      l <- listVersions loTool (maybeToList lCriteria) lHideOld lShowNightly (lFrom, lTo)
      liftIO $ printListResult no_color lRawFormat l
      pure ExitSuccess
    )
--- a/app/ghcup/GHCup/OptParse/Nuke.hs
+++ b/app/ghcup/GHCup/OptParse/Nuke.hs
@ -76,8 +76,8 @@ nuke appState runLogger = do

       lift $ logInfo "Initiating Nuclear Sequence 🚀🚀🚀"
       lift $ logInfo "Nuking in 3...2...1"
-  
-       lInstalled <- lift $ listVersions Nothing (Just ListInstalled)
+
+       lInstalled <- lift $ listVersions Nothing [ListInstalled True] False True (Nothing, Nothing)

       forM_ lInstalled (liftE . rmTool)

--- a/app/ghcup/GHCup/OptParse/Prefetch.hs
+++ b/app/ghcup/GHCup/OptParse/Prefetch.hs
@ -83,7 +83,7 @@ prefetchP = subparser
          <$> (PrefetchGHCOptions
                <$> ( switch (short 's' <> long "source" <> help "Download source tarball instead of bindist") <**> helper )
                <*> optional (option str (short 'd' <> long "directory" <> help "directory to download into (default: ~/.ghcup/cache/)" <> completer (bashCompleter "directory"))))
-          <*>  optional (toolVersionTagArgument Nothing (Just GHC)) )
+          <*>  optional (toolVersionTagArgument [] (Just GHC)) )
        ( progDesc "Download GHC assets for installation")
      )
      <>
@ -92,7 +92,7 @@ prefetchP = subparser
      (info
        (PrefetchCabal
          <$> fmap PrefetchOptions (optional (option str (short 'd' <> long "directory" <> help "directory to download into (default: ~/.ghcup/cache/)" <> completer (bashCompleter "directory"))))
-          <*> ( optional (toolVersionTagArgument Nothing (Just Cabal)) <**> helper ))
+          <*> ( optional (toolVersionTagArgument [] (Just Cabal)) <**> helper ))
        ( progDesc "Download cabal assets for installation")
      )
      <>
@ -101,7 +101,7 @@ prefetchP = subparser
      (info
        (PrefetchHLS
          <$> fmap PrefetchOptions (optional (option str (short 'd' <> long "directory" <> help "directory to download into (default: ~/.ghcup/cache/)" <> completer (bashCompleter "directory"))))
-          <*> ( optional (toolVersionTagArgument Nothing (Just HLS)) <**> helper ))
+          <*> ( optional (toolVersionTagArgument [] (Just HLS)) <**> helper ))
        ( progDesc "Download HLS assets for installation")
      )
      <>
@ -110,7 +110,7 @@ prefetchP = subparser
      (info
        (PrefetchStack
          <$> fmap PrefetchOptions (optional (option str (short 'd' <> long "directory" <> help "directory to download into (default: ~/.ghcup/cache/)" <> completer (bashCompleter "directory"))))
-          <*> ( optional (toolVersionTagArgument Nothing (Just Stack)) <**> helper ))
+          <*> ( optional (toolVersionTagArgument [] (Just Stack)) <**> helper ))
        ( progDesc "Download stack assets for installation")
      )
      <>
@ -148,6 +148,7 @@ Examples:


 type PrefetchEffects = '[ TagNotFound
+                        , DayNotFound
                        , NextVerNotFound
                        , NoToolVersionSet
                        , NoDownload
--- a/app/ghcup/GHCup/OptParse/Rm.hs
+++ b/app/ghcup/GHCup/OptParse/Rm.hs
@ -80,19 +80,19 @@ rmParser =
      <> command
           "cabal"
           (   RmCabal
-           <$> info (versionParser' (Just ListInstalled) (Just Cabal) <**> helper)
+           <$> info (versionParser' [ListInstalled True] (Just Cabal) <**> helper)
                    (progDesc "Remove Cabal version")
           )
      <> command
           "hls"
           (   RmHLS
-           <$> info (versionParser' (Just ListInstalled) (Just HLS) <**> helper)
+           <$> info (versionParser' [ListInstalled True] (Just HLS) <**> helper)
                    (progDesc "Remove haskell-language-server version")
           )
      <> command
           "stack"
           (   RmStack
-           <$> info (versionParser' (Just ListInstalled) (Just Stack) <**> helper)
+           <$> info (versionParser' [ListInstalled True] (Just Stack) <**> helper)
                    (progDesc "Remove stack version")
           )
      )
@ -102,7 +102,7 @@ rmParser =


 rmOpts :: Maybe Tool -> Parser RmOptions
-rmOpts tool = RmOptions <$> ghcVersionArgument (Just ListInstalled) tool
+rmOpts tool = RmOptions <$> ghcVersionArgument [ListInstalled True] tool



--- a/app/ghcup/GHCup/OptParse/Run.hs
+++ b/app/ghcup/GHCup/OptParse/Run.hs
@ -92,7 +92,7 @@ runOpts =
            (eitherReader ghcVersionTagEither)
            (metavar "GHC_VERSION" <> long "ghc" <> help "The ghc version"
            <> completer (tagCompleter GHC [])
-            <> (completer $ versionCompleter Nothing GHC)
+            <> (completer $ versionCompleter [] GHC)
            )
          )
    <*> optional
@ -100,7 +100,7 @@ runOpts =
            (eitherReader toolVersionTagEither)
            (metavar "CABAL_VERSION" <> long "cabal" <> help "The cabal version"
            <> completer (tagCompleter Cabal [])
-            <> (completer $ versionCompleter Nothing Cabal)
+            <> (completer $ versionCompleter [] Cabal)
            )
          )
    <*> optional
@ -108,7 +108,7 @@ runOpts =
            (eitherReader toolVersionTagEither)
            (metavar "HLS_VERSION" <> long "hls" <> help "The HLS version"
            <> completer (tagCompleter HLS [])
-            <> (completer $ versionCompleter Nothing HLS)
+            <> (completer $ versionCompleter [] HLS)
            )
          )
    <*> optional
@ -116,7 +116,7 @@ runOpts =
            (eitherReader toolVersionTagEither)
            (metavar "STACK_VERSION" <> long "stack" <> help "The stack version"
            <> completer (tagCompleter Stack [])
-            <> (completer $ versionCompleter Nothing Stack)
+            <> (completer $ versionCompleter [] Stack)
            )
          )
    <*> optional
@ -132,7 +132,7 @@ runOpts =
    <*> switch
          (short 'q' <> long "quick" <> help "Avoid any expensive work (such as downloads, version/tag resolution etc.). Disables --install.")
    <*> many (argument str (metavar "COMMAND" <> help "The command to run, with arguments (use longopts --). If omitted, just prints the created bin/ dir to stdout and exits."))
-          
+



@ -175,6 +175,7 @@ type RunEffects = '[ AlreadyInstalled
                   , NotInstalled
                   , BuildFailed
                   , TagNotFound
+                   , DayNotFound
                   , DigestError
                   , ContentLengthError
                   , GPGError
@ -282,6 +283,7 @@ run RunOptions{..} runAppState leanAppstate runLogger = do
                           )
                        => Excepts
                             '[ TagNotFound
+                              , DayNotFound
                              , NextVerNotFound
                              , NoToolVersionSet
                              ] (ResourceT (ReaderT AppState m)) Toolchain
@ -332,6 +334,7 @@ run RunOptions{..} runAppState leanAppstate runLogger = do
                        -> FilePath
                        -> Excepts
                             '[ TagNotFound
+                              , DayNotFound
                              , NextVerNotFound
                              , NoToolVersionSet
                              , UnknownArchive
--- a/app/ghcup/GHCup/OptParse/Set.hs
+++ b/app/ghcup/GHCup/OptParse/Set.hs
@ -139,9 +139,9 @@ setParser =
 setOpts :: Tool -> Parser SetOptions
 setOpts tool = SetOptions <$>
    (fromMaybe SetRecommended <$>
-      optional (setVersionArgument (Just ListInstalled) tool))
+      optional (setVersionArgument [ListInstalled True] tool))

-setVersionArgument :: Maybe ListCriteria -> Tool -> Parser SetToolVersion
+setVersionArgument :: [ListCriteria] -> Tool -> Parser SetToolVersion
 setVersionArgument criteria tool =
  argument (eitherReader setEither)
    (metavar "VERSION|TAG|next"
@ -184,6 +184,7 @@ setFooter = [s|Discussion:
 type SetGHCEffects = '[ FileDoesNotExistError
                   , NotInstalled
                   , TagNotFound
+                   , DayNotFound
                   , NextVerNotFound
                   , NoToolVersionSet]

@ -198,6 +199,7 @@ runSetGHC runAppState =

 type SetCabalEffects = '[ NotInstalled
                        , TagNotFound
+                        , DayNotFound
                        , NextVerNotFound
                        , NoToolVersionSet]

@ -212,6 +214,7 @@ runSetCabal runAppState =

 type SetHLSEffects = '[ NotInstalled
                      , TagNotFound
+                      , DayNotFound
                      , NextVerNotFound
                      , NoToolVersionSet]

@ -226,6 +229,7 @@ runSetHLS runAppState =

 type SetStackEffects = '[ NotInstalled
                        , TagNotFound
+                        , DayNotFound
                        , NextVerNotFound
                        , NoToolVersionSet]

--- a/app/ghcup/GHCup/OptParse/Test.hs
+++ b/app/ghcup/GHCup/OptParse/Test.hs
@ -112,7 +112,7 @@ testOpts tool =
                      <> completer (toolDlCompleter (fromMaybe GHC tool))
                    )
                  )
-            <*> (Just <$> toolVersionTagArgument Nothing tool)
+            <*> (Just <$> toolVersionTagArgument [] tool)
            )
        <|> pure (Nothing, Nothing)
        )
@ -140,6 +140,7 @@ type TestGHCEffects = [ DigestError
                      , TestFailed
                      , NextVerNotFound
                      , TagNotFound
+                      , DayNotFound
                      , NoToolVersionSet
                      ]

@ -173,7 +174,7 @@ test testCommand settings getAppState' runLogger = case testCommand of
       Just uri -> do
         runTestGHC s'{ settings = settings {noVerify = True}} $ do
           (v, vi) <- liftE $ fromVersion testVer GHC
-           liftE $ testGHCBindist (DownloadInfo uri (Just $ RegexDir ".*/.*") "" Nothing) (_tvVersion v) addMakeArgs
+           liftE $ testGHCBindist (DownloadInfo uri (Just $ RegexDir ".*/.*") "" Nothing Nothing) (_tvVersion v) addMakeArgs
           pure vi
      )
        >>= \case
--- a/app/ghcup/GHCup/OptParse/Whereis.hs
+++ b/app/ghcup/GHCup/OptParse/Whereis.hs
@ -82,7 +82,7 @@ whereisP = subparser
    command
      "ghc"
      (WhereisTool GHC <$> info
-        ( optional (toolVersionTagArgument Nothing (Just GHC)) <**> helper )
+        ( optional (toolVersionTagArgument [] (Just GHC)) <**> helper )
        ( progDesc "Get GHC location"
        <> footerDoc (Just $ text whereisGHCFooter ))
      )
@ -90,7 +90,7 @@ whereisP = subparser
     command
      "cabal"
      (WhereisTool Cabal <$> info
-        ( optional (toolVersionTagArgument Nothing (Just Cabal)) <**> helper )
+        ( optional (toolVersionTagArgument [] (Just Cabal)) <**> helper )
        ( progDesc "Get cabal location"
        <> footerDoc (Just $ text whereisCabalFooter ))
      )
@ -98,7 +98,7 @@ whereisP = subparser
     command
      "hls"
      (WhereisTool HLS <$> info
-        ( optional (toolVersionTagArgument Nothing (Just HLS)) <**> helper )
+        ( optional (toolVersionTagArgument [] (Just HLS)) <**> helper )
        ( progDesc "Get HLS location"
        <> footerDoc (Just $ text whereisHLSFooter ))
      )
@ -106,7 +106,7 @@ whereisP = subparser
     command
      "stack"
      (WhereisTool Stack <$> info
-        ( optional (toolVersionTagArgument Nothing (Just Stack)) <**> helper )
+        ( optional (toolVersionTagArgument [] (Just Stack)) <**> helper )
        ( progDesc "Get stack location"
        <> footerDoc (Just $ text whereisStackFooter ))
      )
@ -222,6 +222,7 @@ type WhereisEffects = '[ NotInstalled
                , NoToolVersionSet
                , NextVerNotFound
                , TagNotFound
+                , DayNotFound
                ]


--- a/app/ghcup/Main.hs
+++ b/app/ghcup/Main.hs
@ -240,7 +240,7 @@ Report bugs at <https://github.com/haskell/ghcup-hs/issues>|]
                  _
                    | Just False <- optVerbose -> pure ()
                    | otherwise -> lookupEnv "GHCUP_SKIP_UPDATE_CHECK" >>= \case
-                         Nothing -> void . flip runReaderT s' . runE @'[TagNotFound, NextVerNotFound, NoToolVersionSet] $ do
+                         Nothing -> void . flip runReaderT s' . runE @'[TagNotFound, DayNotFound, NextVerNotFound, NoToolVersionSet] $ do
                           newTools <- lift checkForUpdates
                           forM_ newTools $ \newTool@(t, l) -> do
                             -- https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/283
@ -335,6 +335,7 @@ Report bugs at <https://github.com/haskell/ghcup-hs/issues>|]
                    -> (Tool, Version)
                    -> Excepts
                         '[ TagNotFound
+                          , DayNotFound
                          , NextVerNotFound
                          , NoToolVersionSet
                          ] m Bool
@ -370,6 +371,7 @@ Report bugs at <https://github.com/haskell/ghcup-hs/issues>|]
       -> Version
       -> Excepts
            '[ TagNotFound
+             , DayNotFound
             , NextVerNotFound
             , NoToolVersionSet
             ] m Bool
--- a/data/metadata
+++ b/data/metadata
@ -1 +1 @@
-Subproject commit 0b98de04cce150d70ef74a733513759e95577769
+Subproject commit 92efb732aceec87089327201c48f65f6158ed3d8
--- a/docs/guide.md
+++ b/docs/guide.md
@ -203,6 +203,34 @@ url-source:
  - "https://raw.githubusercontent.com/haskell/ghcup-metadata/master/ghcup-prereleases-0.0.7.yaml"
 ```

+### Nightlies
+
+Nightlies are just a nother release channel. Currently, only GHC supports nightlies, which are binary releases
+that are built every night from `master`.
+
+To add the nightly channel, run:
+
+```sh
+ghcup config add-release-channel https://ghc.gitlab.haskell.org/ghcup-metadata/ghcup-nightlies-0.0.7.yaml
+```
+
+To list all nightlies from 2023, run:
+
+```sh
+ghcup list --show-nightly --tool=ghc --since=2023-01-01
+```
+
+Ways to install a nightly:
+
+```sh
+# by date
+ghcup install ghc 2023-06-20
+# by version
+ghcup install ghc 9.7.20230619
+# by tag
+ghcup install ghc latest-nightly
+```
+
 ## Stack integration

 Stack manages GHC versions internally by default. In order to make it use ghcup installed
--- a/ghcup.cabal
+++ b/ghcup.cabal
@ -137,7 +137,7 @@ library
    , pretty-terminal       ^>=0.1.0.0
    , regex-posix           ^>=0.96
    , resourcet             ^>=1.2.2
-    , retry                 ^>=0.8.1.2
+    , retry                 ^>=0.8.1.2 || ^>=0.9
    , safe                  ^>=0.3.18
    , safe-exceptions       ^>=0.1
    , split                 ^>=0.2.3.4
@ -146,7 +146,7 @@ library
    , template-haskell      >=2.7        && <2.20
    , temporary             ^>=1.3
    , text                  ^>=2.0
-    , time                  ^>=1.9.3
+    , time                  ^>=1.9.3 || ^>=1.10 || ^>=1.11
    , transformers          ^>=0.5
    , unliftio-core         ^>=0.2.0.1
    , unordered-containers  ^>=0.2.10.0
@ -269,6 +269,7 @@ executable ghcup
    , template-haskell       >=2.7      && <2.20
    , temporary              ^>=1.3
    , text                   ^>=2.0
+    , time                   ^>=1.9.3 || ^>=1.10 || ^>=1.11
    , unordered-containers   ^>=0.2
    , uri-bytestring         ^>=0.3.2.2
    , utf8-string            ^>=1.0
@ -335,6 +336,7 @@ test-suite ghcup-test
    , QuickCheck                ^>=2.14.1
    , quickcheck-arbitrary-adt  ^>=0.3.1.0
    , streamly                  ^>=0.8.2
+    , time                      ^>=1.9.3 || ^>=1.10 || ^>=1.11
    , text                      ^>=2.0
    , uri-bytestring            ^>=0.3.2.2
    , versions                  >=4.0.1   && <5.1
--- a/lib/GHCup/Download.hs
+++ b/lib/GHCup/Download.hs
@ -633,7 +633,9 @@ downloadCached dli mfn = do
    True -> downloadCached' dli mfn Nothing
    False -> do
      tmp <- lift withGHCupTmpDir
-      liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) (_dlCSize dli) (fromGHCupPath tmp) mfn False
+      liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) (_dlCSize dli) (fromGHCupPath tmp) outputFileName False
+ where
+  outputFileName = mfn <|> _dlOutput dli


 downloadCached' :: ( MonadReader env m
@ -652,7 +654,7 @@ downloadCached' :: ( MonadReader env m
 downloadCached' dli mfn mDestDir = do
  Dirs { cacheDir } <- lift getDirs
  let destDir = fromMaybe (fromGHCupPath cacheDir) mDestDir
-  let fn = fromMaybe ((T.unpack . decUTF8Safe) $ urlBaseName $ view (dlUri % pathL') dli) mfn
+  let fn = fromMaybe ((T.unpack . decUTF8Safe) $ urlBaseName $ view (dlUri % pathL') dli) outputFileName
  let cachfile = destDir </> fn
  fileExists <- liftIO $ doesFileExist cachfile
  if
@ -660,7 +662,9 @@ downloadCached' dli mfn mDestDir = do
      forM_ (view dlCSize dli) $ \s -> liftE $ checkCSize s cachfile
      liftE $ checkDigest (view dlHash dli) cachfile
      pure cachfile
-    | otherwise -> liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) (_dlCSize dli) destDir mfn False
+    | otherwise -> liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) (_dlCSize dli) destDir outputFileName False
+ where
+  outputFileName = mfn <|> _dlOutput dli



--- a/lib/GHCup/Errors.hs
+++ b/lib/GHCup/Errors.hs
@ -38,6 +38,7 @@ import qualified Data.Text                     as T
 import qualified Data.Text.Encoding            as E
 import qualified Data.Text.Encoding.Error      as E
 import           Data.Data (Proxy(..))
+import Data.Time (Day)



@ -59,6 +60,7 @@ allHFError = unlines allErrors
    , let proxy = Proxy :: Proxy CopyError in format proxy
    , let proxy = Proxy :: Proxy MergeFileTreeError in format proxy
    , let proxy = Proxy :: Proxy TagNotFound in format proxy
+    , let proxy = Proxy :: Proxy DayNotFound in format proxy
    , let proxy = Proxy :: Proxy NextVerNotFound in format proxy
    , let proxy = Proxy :: Proxy AlreadyInstalled in format proxy
    , let proxy = Proxy :: Proxy DirNotEmpty in format proxy
@ -311,6 +313,21 @@ instance HFErrorProject TagNotFound where
  eBase _ = 90
  eDesc _ = "Unable to find a tag of a tool"

+-- | Unable to find a release day of a tool
+data DayNotFound = DayNotFound Day Tool (Maybe Day)
+  deriving Show
+
+instance Pretty DayNotFound where
+  pPrint (DayNotFound day tool Nothing) =
+    text "Unable to find release date" <+> text (show day) <+> text "of tool" <+> pPrint tool
+  pPrint (DayNotFound day tool (Just alternateDay)) =
+    text "Unable to find release date" <+> text (show day) <+> text "of tool" <+> pPrint tool <+>
+      text "but found an alternative date" <+> text (show alternateDay)
+
+instance HFErrorProject DayNotFound where
+  eBase _ = 95
+  eDesc _ = "Unable to find a release date of a tool"
+
 -- | Unable to find the next version of a tool (the one after the currently
 -- set one).
 data NextVerNotFound = NextVerNotFound Tool
--- a/lib/GHCup/List.hs
+++ b/lib/GHCup/List.hs
@ -36,6 +36,7 @@ import           Data.Either
 import           Data.List
 import           Data.Maybe
 import           Data.Text                      ( Text )
+import           Data.Time.Calendar             ( Day )
 import           Data.Versions                hiding ( patch )
 import           Haskus.Utils.Variant.Excepts
 import           Optics
@ -61,9 +62,9 @@ import qualified Data.Text                     as T


 -- | Filter data type for 'listVersions'.
-data ListCriteria = ListInstalled
-                  | ListSet
-                  | ListAvailable
+data ListCriteria = ListInstalled  Bool
+                  | ListSet        Bool
+                  | ListAvailable  Bool
                  deriving Show

 -- | A list result describes a single tool version
@ -79,6 +80,7 @@ data ListResult = ListResult
  , lStray     :: Bool -- ^ not in download info
  , lNoBindist :: Bool -- ^ whether the version is available for this platform/arch
  , hlsPowered :: Bool
+  , lReleaseDay :: Maybe Day
  }
  deriving (Eq, Ord, Show)

@ -93,19 +95,22 @@ availableToolVersions av tool = view
 -- | List all versions from the download info, as well as stray
 -- versions.
 listVersions :: ( MonadCatch m
-                , HasLog env
-                , MonadThrow m
-                , HasLog env
-                , MonadIO m
-                , MonadReader env m
-                , HasDirs env
-                , HasPlatformReq env
-                , HasGHCupInfo env
-                )
-             => Maybe Tool
-             -> Maybe ListCriteria
-             -> m [ListResult]
-listVersions lt' criteria = do
+                             , HasLog env
+                             , MonadThrow m
+                             , HasLog env
+                             , MonadIO m
+                             , MonadReader env m
+                             , HasDirs env
+                             , HasPlatformReq env
+                             , HasGHCupInfo env
+                             )
+                          => Maybe Tool
+                          -> [ListCriteria]
+                          -> Bool
+                          -> Bool
+                          -> (Maybe Day, Maybe Day)
+                          -> m [ListResult]
+listVersions lt' criteria hideOld showNightly days = do
  -- some annoying work to avoid too much repeated IO
  cSet <- cabalSet
  cabals <- getInstalledCabals
@ -172,8 +177,9 @@ listVersions lt' criteria = do
              , lCross     = Nothing
              , lTag       = []
              , lInstalled = True
-             , lStray     = isNothing (Map.lookup _tvVersion avTools)
+              , lStray     = isNothing (Map.lookup _tvVersion avTools)
              , lNoBindist = False
+              , lReleaseDay = Nothing
              , ..
              }
      Right tver@GHCTargetVersion{ .. } -> do
@ -188,6 +194,7 @@ listVersions lt' criteria = do
          , lInstalled = True
          , lStray     = True -- NOTE: cross currently cannot be installed via bindist
          , lNoBindist = False
+          , lReleaseDay = Nothing
          , ..
          }
      Left e -> do
@ -223,6 +230,7 @@ listVersions lt' criteria = do
              , lNoBindist = False
              , fromSrc    = False -- actually, we don't know :>
              , hlsPowered = False
+              , lReleaseDay = Nothing
              , ..
              }
      Left e -> do
@ -257,6 +265,7 @@ listVersions lt' criteria = do
              , lNoBindist = False
              , fromSrc    = False -- actually, we don't know :>
              , hlsPowered = False
+              , lReleaseDay = Nothing
              , ..
              }
      Left e -> do
@ -292,6 +301,7 @@ listVersions lt' criteria = do
              , lNoBindist = False
              , fromSrc    = False -- actually, we don't know :>
              , hlsPowered = False
+              , lReleaseDay = Nothing
              , ..
              }
      Left e -> do
@ -317,6 +327,7 @@ listVersions lt' criteria = do
                                           , lInstalled = True
                                           , lNoBindist = False
                                           , hlsPowered = False
+                                           , lReleaseDay = Nothing
                                           }

  -- NOTE: this are not cross ones, because no bindists
@ -337,7 +348,7 @@ listVersions lt' criteria = do
               -> [Either FilePath Version]
               -> (Version, VersionInfo)
               -> m ListResult
-  toListResult t cSet cabals hlsSet' hlses stackSet' stacks (v, _viTags -> tags) = do
+  toListResult t cSet cabals hlsSet' hlses stackSet' stacks (v, VersionInfo{..}) = do
    case t of
      GHC -> do
        lNoBindist <- fmap (isLeft . veitherToEither) $ runE @'[NoDownload] $ getDownloadInfo GHC v
@ -346,31 +357,33 @@ listVersions lt' criteria = do
        lInstalled <- ghcInstalled tver
        fromSrc    <- ghcSrcInstalled tver
        hlsPowered <- fmap (elem v) hlsGHCVersions
-        pure ListResult { lVer = v, lCross = Nothing , lTag = tags, lTool = t, lStray = False, .. }
+        pure ListResult { lVer = v, lCross = Nothing , lTag = _viTags, lTool = t, lStray = False, lReleaseDay = _viReleaseDay, .. }
      Cabal -> do
        lNoBindist <- fmap (isLeft . veitherToEither) $ runE @'[NoDownload] $ getDownloadInfo Cabal v
        let lSet = cSet == Just v
        let lInstalled = elem v $ rights cabals
        pure ListResult { lVer    = v
                        , lCross  = Nothing
-                        , lTag    = tags
+                        , lTag    = _viTags
                        , lTool   = t
                        , fromSrc = False
                        , lStray  = False
                        , hlsPowered = False
+                        , lReleaseDay = _viReleaseDay
                        , ..
                        }
      GHCup -> do
        let lSet       = prettyPVP ghcUpVer == prettyVer v
        let lInstalled = lSet
        pure ListResult { lVer    = v
-                        , lTag    = tags
+                        , lTag    = _viTags
                        , lCross  = Nothing
                        , lTool   = t
                        , fromSrc = False
                        , lStray  = False
                        , lNoBindist = False
                        , hlsPowered = False
+                        , lReleaseDay = _viReleaseDay
                        , ..
                        }
      HLS -> do
@ -379,11 +392,12 @@ listVersions lt' criteria = do
        let lInstalled = elem v $ rights hlses
        pure ListResult { lVer    = v
                        , lCross  = Nothing
-                        , lTag    = tags
+                        , lTag    = _viTags
                        , lTool   = t
                        , fromSrc = False
                        , lStray  = False
                        , hlsPowered = False
+                        , lReleaseDay = _viReleaseDay
                        , ..
                        }
      Stack -> do
@ -392,19 +406,43 @@ listVersions lt' criteria = do
        let lInstalled = elem v $ rights stacks
        pure ListResult { lVer    = v
                        , lCross  = Nothing
-                        , lTag    = tags
+                        , lTag    = _viTags
                        , lTool   = t
                        , fromSrc = False
                        , lStray  = False
                        , hlsPowered = False
+                        , lReleaseDay = _viReleaseDay
                        , ..
                        }


  filter' :: [ListResult] -> [ListResult]
-  filter' lr = case criteria of
-    Nothing            -> lr
-    Just ListInstalled -> filter (\ListResult {..} -> lInstalled) lr
-    Just ListSet       -> filter (\ListResult {..} -> lSet) lr
-    Just ListAvailable -> filter (\ListResult {..} -> not lNoBindist) lr
+  filter' = filterNightly . filterOld . filter (\lr -> foldr (\a b -> fromCriteria a lr && b) True criteria) . filterDays
+
+  filterDays :: [ListResult] -> [ListResult]
+  filterDays lrs = case days of
+                     (Nothing, Nothing)    -> lrs
+                     (Just from, Just to') -> filter (\ListResult{..} -> maybe False (\d -> d >= from && d <= to') lReleaseDay) lrs
+                     (Nothing, Just to')   -> filter (\ListResult{..} -> maybe False (<= to')                      lReleaseDay) lrs
+                     (Just from, Nothing)  -> filter (\ListResult{..} -> maybe False (>= from)                     lReleaseDay) lrs
+
+  fromCriteria :: ListCriteria -> ListResult -> Bool
+  fromCriteria lc ListResult{..} = case lc of
+    ListInstalled  b -> f b lInstalled
+    ListSet        b -> f b lSet
+    ListAvailable  b -> f b $ not lNoBindist
+   where
+    f b
+      | b         = id
+      | otherwise = not
+
+  filterOld :: [ListResult] -> [ListResult]
+  filterOld lr
+    | hideOld   = filter (\ListResult {..} -> lInstalled || Old `notElem` lTag) lr
+    | otherwise = lr
+
+  filterNightly :: [ListResult] -> [ListResult]
+  filterNightly lr
+    | showNightly = lr
+    | otherwise   = filter (\ListResult {..} -> lInstalled || (Nightly `notElem` lTag && LatestNightly `notElem` lTag)) lr

--- a/lib/GHCup/Types.hs
+++ b/lib/GHCup/Types.hs
@ -31,6 +31,7 @@ import {-# SOURCE #-} GHCup.Utils.Dirs          ( fromGHCupPath, GHCupPath )
 import           Control.DeepSeq                ( NFData, rnf )
 import           Data.Map.Strict                ( Map )
 import           Data.List.NonEmpty             ( NonEmpty (..) )
+import           Data.Time.Calendar             ( Day )
 import           Data.Text                      ( Text )
 import           Data.Versions
 import           GHC.IO.Exception               ( ExitCode )
@ -136,6 +137,7 @@ instance NFData GlobalTool
 -- source download and per-architecture downloads.
 data VersionInfo = VersionInfo
  { _viTags        :: [Tag]              -- ^ version specific tag
+  , _viReleaseDay  :: Maybe Day
  , _viChangeLog   :: Maybe URI
  , _viSourceDL    :: Maybe DownloadInfo -- ^ source tarball
  , _viTestDL      :: Maybe DownloadInfo -- ^ test tarball
@ -155,6 +157,8 @@ data Tag = Latest
         | Recommended
         | Prerelease
         | LatestPrerelease
+         | Nightly
+         | LatestNightly
         | Base PVP
         | Old                -- ^ old versions are hidden by default in TUI
         | UnknownTag String  -- ^ used for upwardscompat
@ -166,18 +170,22 @@ tagToString :: Tag -> String
 tagToString Recommended        = "recommended"
 tagToString Latest             = "latest"
 tagToString Prerelease         = "prerelease"
+tagToString Nightly            = "nightly"
 tagToString (Base       pvp'') = "base-" ++ T.unpack (prettyPVP pvp'')
 tagToString (UnknownTag t    ) = t
 tagToString LatestPrerelease   = "latest-prerelease"
+tagToString LatestNightly      = "latest-nightly"
 tagToString Old                = ""

 instance Pretty Tag where
  pPrint Recommended        = text "recommended"
  pPrint Latest             = text "latest"
  pPrint Prerelease         = text "prerelease"
+  pPrint Nightly            = text "nightly"
  pPrint (Base       pvp'') = text ("base-" ++ T.unpack (prettyPVP pvp''))
  pPrint (UnknownTag t    ) = text t
  pPrint LatestPrerelease   = text "latest-prerelease"
+  pPrint LatestNightly   = text "latest-prerelease"
  pPrint Old                = mempty

 data Architecture = A_64
@ -267,6 +275,7 @@ data DownloadInfo = DownloadInfo
  , _dlSubdir :: Maybe TarDir
  , _dlHash   :: Text
  , _dlCSize  :: Maybe Integer
+  , _dlOutput :: Maybe FilePath
  }
  deriving (Eq, Ord, GHC.Generic, Show)

@ -694,3 +703,18 @@ type PromptQuestion = Text

 data PromptResponse = PromptYes | PromptNo
  deriving (Show, Eq)
+
+data ToolVersion = GHCVersion GHCTargetVersion
+                 | ToolVersion Version
+                 | ToolTag Tag
+                 | ToolDay Day
+
+instance Pretty ToolVersion where
+  pPrint (GHCVersion v) = pPrint v
+  pPrint (ToolVersion v) = pPrint v
+  pPrint (ToolTag t) = pPrint t
+  pPrint (ToolDay d) = text (show d)
+
+
+
+
--- a/lib/GHCup/Types/JSON.hs
+++ b/lib/GHCup/Types/JSON.hs
@ -64,9 +64,11 @@ instance ToJSON Tag where
  toJSON Latest             = String "Latest"
  toJSON Recommended        = String "Recommended"
  toJSON Prerelease         = String "Prerelease"
+  toJSON Nightly            = String "Nightly"
  toJSON Old                = String "old"
  toJSON (Base       pvp'') = String ("base-" <> prettyPVP pvp'')
  toJSON LatestPrerelease   = String "LatestPrerelease"
+  toJSON LatestNightly      = String "LatestNightly"
  toJSON (UnknownTag x    ) = String (T.pack x)

 instance FromJSON Tag where
@ -74,7 +76,9 @@ instance FromJSON Tag where
    "Latest"                             -> pure Latest
    "Recommended"                        -> pure Recommended
    "Prerelease"                         -> pure Prerelease
+    "Nightly"                            -> pure Nightly
    "LatestPrerelease"                   -> pure LatestPrerelease
+    "LatestNightly"                      -> pure LatestNightly
    "old"                                -> pure Old
    ('b' : 'a' : 's' : 'e' : '-' : ver') -> case pvp (T.pack ver') of
      Right x -> pure $ Base x
--- a/lib/GHCup/Utils.hs
+++ b/lib/GHCup/Utils.hs
@ -94,6 +94,7 @@ import qualified Streamly.Prelude              as S
 import Control.DeepSeq (force)
 import GHC.IO (evaluate)
 import System.Environment (getEnvironment, setEnv)
+import Data.Time (Day(..), diffDays, addDays)


 -- $setup
@ -889,12 +890,30 @@ getTagged tag =
  to (Map.toDescList . Map.filter (\VersionInfo {..} -> tag `elem` _viTags))
  % folding id

+getByReleaseDay :: GHCupDownloads -> Tool -> Day -> Either (Maybe Day) (Version, VersionInfo)
+getByReleaseDay av tool day = let mvv = fromMaybe mempty $ headOf (ix tool) av
+                                  mdv = Map.foldrWithKey (\k vi@VersionInfo{..} m ->
+                                            maybe m (\d -> let diff = diffDays d day
+                                                           in Map.insert (abs diff) (diff, (k, vi)) m) _viReleaseDay)
+                                          Map.empty mvv
+                              in case headMay (Map.toAscList mdv) of
+                                   Nothing -> Left Nothing
+                                   Just (absDiff, (diff, (k, vi)))
+                                     | absDiff == 0 -> Right (k, vi)
+                                     | otherwise -> Left (Just (addDays diff day))
+
+getByReleaseDayFold :: Day -> Fold (Map.Map Version VersionInfo) (Version, VersionInfo)
+getByReleaseDayFold day = to (Map.toDescList . Map.filter (\VersionInfo {..} -> Just day == _viReleaseDay)) % folding id
+
 getLatest :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
 getLatest av tool = headOf (ix tool % getTagged Latest) av

 getLatestPrerelease :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
 getLatestPrerelease av tool = headOf (ix tool % getTagged LatestPrerelease) av

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

@ -1081,11 +1100,15 @@ darwinNotarization _ _ = pure $ Right ()



-getChangeLog :: GHCupDownloads -> Tool -> Either Version Tag -> Maybe URI
-getChangeLog dls tool (Left v') =
+getChangeLog :: GHCupDownloads -> Tool -> ToolVersion -> Maybe URI
+getChangeLog dls tool (GHCVersion (_tvVersion -> v')) =
  preview (ix tool % ix v' % viChangeLog % _Just) dls
-getChangeLog dls tool (Right tag) =
+getChangeLog dls tool (ToolVersion v') =
+  preview (ix tool % ix v' % viChangeLog % _Just) dls
+getChangeLog dls tool (ToolTag tag) =
  preview (ix tool % pre (getTagged tag) % to snd % viChangeLog % _Just) dls
+getChangeLog dls tool (ToolDay day) =
+  preview (ix tool % pre (getByReleaseDayFold day) % to snd % viChangeLog % _Just) dls


 -- | Execute a build action while potentially cleaning up:
--- a/stack.yaml
+++ b/stack.yaml
@ -1,52 +1,36 @@
-resolver: lts-18.28
+resolver: lts-20.20

 packages:
  - .

 extra-deps:
-  - Cabal-3.6.2.0@sha256:e2266e14758c1f799220fad7f0d4b0b4ec567d81b7ba3faea17ff76d4c31de95,12437
-  - IfElse-0.85@sha256:6939b94acc6a55f545f63a168a349dd2fbe4b9a7cca73bf60282db5cc6aa47d2,445
-  - ascii-string-1.0.1.4@sha256:fa34f1d9ba57e8e89c0d4c9cef5e01ba32cb2d4373d13f92dcc0b531a6c6749b,2582
-  - base16-bytestring-0.1.1.7@sha256:0021256a9628971c08da95cb8f4d0d72192f3bb8a7b30b55c080562d17c43dd3,2231
-  - brick-0.64@sha256:f03fa14607c22cf48af99e24c44f79a0fb073f7ec229f15e969fed9ff73c93f6,16530
-  - brotli-0.0.0.0@sha256:2bf383a4cd308745740986be0b18381c5a0784393fe69b91456aacb2d603de46,2964
-  - brotli-streams-0.0.0.0@sha256:1af1e22f67b8bfd6ad0d05e61825e7a178d738f689ebbb21c1aab5f1bbcae176,2331
+  - Cabal-3.6.3.0
+  - Cabal-syntax-3.10.1.0
+  - aeson-2.1.2.1
+  - cabal-install-parsers-0.6.1
  - chs-cabal-0.1.1.1
-  - chs-deps-0.1.0.0@sha256:0cdada6d2c682c41b20331b8c63c2ecfc7e806928585195fd544c9d41f3074fd,2496
-  - composition-prelude-3.0.0.2@sha256:1ffed216bd28d810fce0b5be83a661e2a892696d73b3f8de5c0f5edb9b5f0090,1216
+  - chs-deps-0.1.0.0
+  - generic-arbitrary-0.2.2@sha256:202ffbf2032672a51318f2e80d7e75b72f8950e690346b4314f38bc7e39215f7,1189
+  - generically-0.1.1
  - haskus-utils-data-1.4@sha256:bfa94363b94b14779edd6834fbd59dbb847c3d7b8f48e3844f456ffdc077da4a,1466
  - haskus-utils-types-1.5.1@sha256:991c472f4e751e2f0d7aab6ad4220ef151d6160876dcf0511bbf876bbd432020,1298
-  - haskus-utils-variant-3.2.1@sha256:791f4cf1e786eb578f4d37aef60986641f84c36e130164321f7d01542584066a,2200
-  - heaps-0.3.6.1@sha256:7928b759ca5180d35722c45948c0bde264229f3c99c1888188a3d9285f13d3d2,1340
-  - hpath-filepath-0.10.4@sha256:e9e44fb5fdbade7f30b5b5451257dbee15b6ef1aae4060034d73008bb3b5d878,1269
-  - hpath-posix-0.13.3@sha256:abe472cf16bccd3a8b8814865ed3551a728fde0f3a2baea2acc03023bec6c565,1615
-  - hspec-2.7.10@sha256:c9e82c90086acebac576552a06f3cabd249bba048edd1667c7fae0b1313d5bce,1712
-  - hspec-core-2.7.10@sha256:2aba6ea126442b29e8183ab27f1c811706b19b1d83b02f193a896f6fc1589d13,4621
-  - hspec-discover-2.7.10@sha256:d08bf5dd785629f589571477d9beb7cd91529471bd89f39517c1cb4b9b38160f,2184
-  - hspec-golden-aeson-0.9.0.0@sha256:aa17274114026661ba4dfc9c60c230673c8f408bd86482fd611d2d5cb6aff996,2179
-  - http-io-streams-0.1.6.0@sha256:53f5bab177efb52cd65ec396fd04ed59b93e5f919fb3700cd7dacd6cfce6f06d,3582
-  - libarchive-3.0.3.0
+  - haskus-utils-variant-3.2.1
+  - libarchive-3.0.3.2
  - libyaml-streamly-0.2.1
-  - lzma-static-5.2.5.3@sha256:2758ee58c35992fcf7db78e98684c357a16a82fa2a4e7c352a6c210c08c555d8,7308
-  - optics-0.4@sha256:9fb69bf0195b8d8f1f8cd0098000946868b8a3c3ffb51e5b64f79fc600c3eb4c,6568
-  - optics-core-0.4@sha256:59e04aebca536bd011ae50c781937f45af4c1456af1eb9fb578f9a69eee293cd,4995
-  - optics-extra-0.4@sha256:b9914f38aa7d5c92f231060d9168447f9f5a367c07df9bf47a003e3e786d5e05,3432
-  - optics-th-0.4@sha256:7c838b5b1d6998133bf8f0641c36197ed6cb468dc69515e1952f33f0bbe8e11d,2009
-  - os-release-1.0.1@sha256:1281c62081f438fc3f0874d3bae6a4887d5964ac25261ba06e29d368ab173467,2716
-  - primitive-0.7.1.0@sha256:29de6bfd0cf8ba023ceb806203dfbec0e51e3524e75ffe41056f70b4229c6f0f,2728
-  - regex-posix-clib-2.7
+  - lzma-static-5.2.5.5
+  - os-release-1.0.2.1
+  - parsec-3.1.15.0
  - streamly-0.8.2@sha256:ec521b7c1c4db068501c35804af77f40b7d34232f5e29d9b99e722229040eb80,23500
-  - unicode-data-0.3.0@sha256:0545e079705a5381d0893f8fe8daaa08fc9174baeab269b9cf651817d8eadbc6,5123
-  - strict-base-0.4.0.0@sha256:2ff4e43cb95eedf2995558d7fc34d19362846413dd39e6aa6a5b3ea8228fef9f,1248
-  - xor-0.0.1.0@sha256:f8362b4a68562b9afbcd727ff64c1a303970df3a032e0033d2f4c094c3501df3,2243
-  - yaml-streamly-0.12.1
+  - strict-base-0.4.0.0
+  - text-2.0.2
+  - yaml-streamly-0.12.2

 flags:
  http-io-streams:
    brotli: false

  libarchive:
-    system-libarchive: false
+    system-libarchive: true

  regex-posix:
    _regex-posix-clib: true
--- a/test/GHCup/ArbitraryTypes.hs
+++ b/test/GHCup/ArbitraryTypes.hs
@ -11,6 +11,7 @@ import           GHCup.Types
 import           Data.ByteString                ( ByteString )
 import           Data.Versions
 import           Data.List.NonEmpty
+import           Data.Time.Calendar             ( Day(..) )
 import           Test.QuickCheck
 import           Test.QuickCheck.Arbitrary.ADT  ( ToADTArbitrary )
 import           Test.QuickCheck.Arbitrary.Generic
@ -76,6 +77,9 @@ instance Arbitrary Port where
  arbitrary = genericArbitrary
  shrink    = genericShrink

+instance Arbitrary Day where
+  arbitrary = ModifiedJulianDay . fromIntegral <$> (chooseAny :: Gen Int)
+
 instance Arbitrary (URIRef Absolute) where
  arbitrary =
    URI <$> arbitrary <*> pure Nothing <*> arbitrary <*> pure (Query []) <*> pure Nothing
--- a/test/golden/unix/GHCupInfo.json
+++ b/test/golden/unix/GHCupInfo.json
--- a/test/golden/windows/GHCupInfo.json
+++ b/test/golden/windows/GHCupInfo.json