{-# LANGUAGE CPP                   #-}
{-# LANGUAGE DataKinds             #-}
{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings     #-}

{-|
Module      : GHCup.List
Description : Listing versions and tools
Copyright   : (c) Julian Ospald, 2020
License     : LGPL-3.0
Maintainer  : hasufell@hasufell.de
Stability   : experimental
Portability : portable
-}
module GHCup.List where

import           GHCup.Download
import           GHCup.Errors
import           GHCup.Types
import           GHCup.Types.JSON               ( )
import           GHCup.Types.Optics
import           GHCup.Utils
import           GHCup.Prelude.Logger
import           GHCup.Version

import           Control.Applicative
import           Control.Exception.Safe
import           Control.Monad
#if !MIN_VERSION_base(4,13,0)
import           Control.Monad.Fail             ( MonadFail )
#endif
import           Control.Monad.Reader
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
import           Prelude                 hiding ( abs
                                                , writeFile
                                                )

import qualified Data.Map.Strict               as Map
import qualified Data.Text                     as T










    ------------------
    --[ List tools ]--
    ------------------


-- | Filter data type for 'listVersions'.
data ListCriteria = ListInstalled  Bool
                  | ListSet        Bool
                  | ListAvailable  Bool
                  deriving (ListCriteria -> ListCriteria -> Bool
(ListCriteria -> ListCriteria -> Bool)
-> (ListCriteria -> ListCriteria -> Bool) -> Eq ListCriteria
forall (a :: OpticKind).
(a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ListCriteria -> ListCriteria -> Bool
== :: ListCriteria -> ListCriteria -> Bool
$c/= :: ListCriteria -> ListCriteria -> Bool
/= :: ListCriteria -> ListCriteria -> Bool
Eq, Int -> ListCriteria -> ShowS
[ListCriteria] -> ShowS
ListCriteria -> String
(Int -> ListCriteria -> ShowS)
-> (ListCriteria -> String)
-> ([ListCriteria] -> ShowS)
-> Show ListCriteria
forall (a :: OpticKind).
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ListCriteria -> ShowS
showsPrec :: Int -> ListCriteria -> ShowS
$cshow :: ListCriteria -> String
show :: ListCriteria -> String
$cshowList :: [ListCriteria] -> ShowS
showList :: [ListCriteria] -> ShowS
Show)

-- | A list result describes a single tool version
-- and various of its properties.
data ListResult = ListResult
  { ListResult -> Tool
lTool      :: Tool
  , ListResult -> Version
lVer       :: Version
  , ListResult -> Maybe Text
lCross     :: Maybe Text -- ^ currently only for GHC
  , ListResult -> [Tag]
lTag       :: [Tag]
  , ListResult -> Bool
lInstalled :: Bool
  , ListResult -> Bool
lSet       :: Bool -- ^ currently active version
  , ListResult -> Bool
lStray     :: Bool -- ^ not in download info
  , ListResult -> Bool
lNoBindist :: Bool -- ^ whether the version is available for this platform/arch
  , ListResult -> Bool
hlsPowered :: Bool
  , ListResult -> Maybe Day
lReleaseDay :: Maybe Day
  }
  deriving (ListResult -> ListResult -> Bool
(ListResult -> ListResult -> Bool)
-> (ListResult -> ListResult -> Bool) -> Eq ListResult
forall (a :: OpticKind).
(a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ListResult -> ListResult -> Bool
== :: ListResult -> ListResult -> Bool
$c/= :: ListResult -> ListResult -> Bool
/= :: ListResult -> ListResult -> Bool
Eq, Eq ListResult
Eq ListResult
-> (ListResult -> ListResult -> Ordering)
-> (ListResult -> ListResult -> Bool)
-> (ListResult -> ListResult -> Bool)
-> (ListResult -> ListResult -> Bool)
-> (ListResult -> ListResult -> Bool)
-> (ListResult -> ListResult -> ListResult)
-> (ListResult -> ListResult -> ListResult)
-> Ord ListResult
ListResult -> ListResult -> Bool
ListResult -> ListResult -> Ordering
ListResult -> ListResult -> ListResult
forall (a :: OpticKind).
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ListResult -> ListResult -> Ordering
compare :: ListResult -> ListResult -> Ordering
$c< :: ListResult -> ListResult -> Bool
< :: ListResult -> ListResult -> Bool
$c<= :: ListResult -> ListResult -> Bool
<= :: ListResult -> ListResult -> Bool
$c> :: ListResult -> ListResult -> Bool
> :: ListResult -> ListResult -> Bool
$c>= :: ListResult -> ListResult -> Bool
>= :: ListResult -> ListResult -> Bool
$cmax :: ListResult -> ListResult -> ListResult
max :: ListResult -> ListResult -> ListResult
$cmin :: ListResult -> ListResult -> ListResult
min :: ListResult -> ListResult -> ListResult
Ord, Int -> ListResult -> ShowS
[ListResult] -> ShowS
ListResult -> String
(Int -> ListResult -> ShowS)
-> (ListResult -> String)
-> ([ListResult] -> ShowS)
-> Show ListResult
forall (a :: OpticKind).
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ListResult -> ShowS
showsPrec :: Int -> ListResult -> ShowS
$cshow :: ListResult -> String
show :: ListResult -> String
$cshowList :: [ListResult] -> ShowS
showList :: [ListResult] -> ShowS
Show)


-- | Extract all available tool versions and their tags.
availableToolVersions :: GHCupDownloads -> Tool -> Map.Map GHCTargetVersion VersionInfo
availableToolVersions :: GHCupDownloads -> Tool -> Map GHCTargetVersion VersionInfo
availableToolVersions GHCupDownloads
av Tool
tool = Optic'
  A_Lens NoIx GHCupDownloads (Map GHCTargetVersion VersionInfo)
-> GHCupDownloads -> Map GHCTargetVersion VersionInfo
forall (k :: OpticKind) (is :: IxList) (s :: OpticKind)
       (a :: OpticKind).
Is k A_Getter =>
Optic' k is s a -> s -> a
view
  (Index GHCupDownloads
-> Lens' GHCupDownloads (Maybe (IxValue GHCupDownloads))
forall (m :: OpticKind).
At m =>
Index m -> Lens' m (Maybe (IxValue m))
at Index GHCupDownloads
Tool
tool Optic
  A_Lens
  NoIx
  GHCupDownloads
  GHCupDownloads
  (Maybe (Map GHCTargetVersion VersionInfo))
  (Maybe (Map GHCTargetVersion VersionInfo))
-> Optic
     An_Iso
     NoIx
     (Maybe (Map GHCTargetVersion VersionInfo))
     (Maybe (Map GHCTargetVersion VersionInfo))
     (Map GHCTargetVersion VersionInfo)
     (Map GHCTargetVersion VersionInfo)
-> Optic'
     A_Lens NoIx GHCupDownloads (Map GHCTargetVersion VersionInfo)
forall (k :: OpticKind) (l :: OpticKind) (m :: OpticKind)
       (is :: IxList) (js :: IxList) (ks :: IxList) (s :: OpticKind)
       (t :: OpticKind) (u :: OpticKind) (v :: OpticKind) (a :: OpticKind)
       (b :: OpticKind).
(JoinKinds k l m, AppendIndices is js ks) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Map GHCTargetVersion VersionInfo
-> Optic
     An_Iso
     NoIx
     (Maybe (Map GHCTargetVersion VersionInfo))
     (Maybe (Map GHCTargetVersion VersionInfo))
     (Map GHCTargetVersion VersionInfo)
     (Map GHCTargetVersion VersionInfo)
forall (a :: OpticKind). Eq a => a -> Iso' (Maybe a) a
non Map GHCTargetVersion VersionInfo
forall (k :: OpticKind) (a :: OpticKind). Map k a
Map.empty)
  GHCupDownloads
av


-- | 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
                          -> [ListCriteria]
                          -> Bool
                          -> Bool
                          -> (Maybe Day, Maybe Day)
                          -> m [ListResult]
listVersions :: forall (m :: OpticKind -> OpticKind) (env :: OpticKind).
(MonadCatch m, 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 Maybe Tool
lt' [ListCriteria]
criteria Bool
hideOld Bool
showNightly (Maybe Day, Maybe Day)
days = do
  -- some annoying work to avoid too much repeated IO
  Maybe Version
cSet <- m (Maybe Version)
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(HasLog env, MonadReader env m, HasDirs env, MonadIO m,
 MonadThrow m, MonadCatch m) =>
m (Maybe Version)
cabalSet
  [Either String Version]
cabals <- m [Either String Version]
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasDirs env, MonadIO m, MonadCatch m) =>
m [Either String Version]
getInstalledCabals
  Maybe Version
hlsSet' <- m (Maybe Version)
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(HasLog env, MonadReader env m, HasDirs env, MonadIO m,
 MonadThrow m, MonadCatch m) =>
m (Maybe Version)
hlsSet
  [Either String Version]
hlses <- m [Either String Version]
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasDirs env, MonadIO m, MonadCatch m) =>
m [Either String Version]
getInstalledHLSs
  Maybe Version
sSet <- m (Maybe Version)
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasDirs env, MonadIO m, MonadThrow m,
 MonadCatch m, HasLog env) =>
m (Maybe Version)
stackSet
  [Either String Version]
stacks <- m [Either String Version]
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasDirs env, MonadIO m, MonadCatch m) =>
m [Either String Version]
getInstalledStacks

  Maybe Tool
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> m [ListResult]
forall {m :: OpticKind -> OpticKind} {env :: OpticKind}.
(MonadIO m, MonadCatch m,
 LabelOptic "dirs" A_Lens env env Dirs Dirs,
 LabelOptic "ghcupInfo" A_Lens env env GHCupInfo GHCupInfo,
 LabelOptic "pfreq" A_Lens env env PlatformRequest PlatformRequest,
 LabelOptic "loggerConfig" A_Lens env env LoggerConfig LoggerConfig,
 MonadReader env m) =>
Maybe Tool
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> m [ListResult]
go Maybe Tool
lt' Maybe Version
cSet [Either String Version]
cabals Maybe Version
hlsSet' [Either String Version]
hlses Maybe Version
sSet [Either String Version]
stacks
 where
  go :: Maybe Tool
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> m [ListResult]
go Maybe Tool
lt Maybe Version
cSet [Either String Version]
cabals Maybe Version
hlsSet' [Either String Version]
hlses Maybe Version
sSet [Either String Version]
stacks = do
    case Maybe Tool
lt of
      Just Tool
t -> do
        GHCupInfo { $sel:_ghcupDownloads:GHCupInfo :: GHCupInfo -> GHCupDownloads
_ghcupDownloads = GHCupDownloads
dls } <- m GHCupInfo
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m,
 LabelOptic' "ghcupInfo" A_Lens env GHCupInfo) =>
m GHCupInfo
getGHCupInfo
        -- get versions from GHCupDownloads
        let avTools :: Map GHCTargetVersion VersionInfo
avTools = GHCupDownloads -> Tool -> Map GHCTargetVersion VersionInfo
availableToolVersions GHCupDownloads
dls Tool
t
        [ListResult]
lr <- [ListResult] -> [ListResult]
filter' ([ListResult] -> [ListResult]) -> m [ListResult] -> m [ListResult]
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
<$> [(GHCTargetVersion, VersionInfo)]
-> ((GHCTargetVersion, VersionInfo) -> m ListResult)
-> m [ListResult]
forall (t :: OpticKind -> OpticKind) (m :: OpticKind -> OpticKind)
       (a :: OpticKind) (b :: OpticKind).
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM (Map GHCTargetVersion VersionInfo
-> [(GHCTargetVersion, VersionInfo)]
forall (k :: OpticKind) (a :: OpticKind). Map k a -> [(k, a)]
Map.toList Map GHCTargetVersion VersionInfo
avTools) (Tool
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> (GHCTargetVersion, VersionInfo)
-> m ListResult
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(HasLog env, MonadReader env m, HasDirs env, HasGHCupInfo env,
 HasPlatformReq env, MonadIO m, MonadCatch m) =>
Tool
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> (GHCTargetVersion, VersionInfo)
-> m ListResult
toListResult Tool
t Maybe Version
cSet [Either String Version]
cabals Maybe Version
hlsSet' [Either String Version]
hlses Maybe Version
sSet [Either String Version]
stacks)

        case Tool
t of
          Tool
GHC -> do
            [ListResult]
slr <- Map GHCTargetVersion VersionInfo -> m [ListResult]
forall (m :: OpticKind -> OpticKind) (env :: OpticKind).
(MonadCatch m, MonadReader env m, HasDirs env, MonadThrow m,
 HasLog env, MonadIO m) =>
Map GHCTargetVersion VersionInfo -> m [ListResult]
strayGHCs Map GHCTargetVersion VersionInfo
avTools
            [ListResult] -> m [ListResult]
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure ([ListResult] -> [ListResult]
forall (a :: OpticKind). Ord a => [a] -> [a]
sort ([ListResult]
slr [ListResult] -> [ListResult] -> [ListResult]
forall (a :: OpticKind). [a] -> [a] -> [a]
++ [ListResult]
lr))
          Tool
Cabal -> do
            [ListResult]
slr <- Map Version VersionInfo
-> Maybe Version -> [Either String Version] -> m [ListResult]
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasDirs env, MonadCatch m, MonadThrow m,
 HasLog env, MonadIO m) =>
Map Version VersionInfo
-> Maybe Version -> [Either String Version] -> m [ListResult]
strayCabals ((GHCTargetVersion -> Version)
-> Map GHCTargetVersion VersionInfo -> Map Version VersionInfo
forall (k2 :: OpticKind) (k1 :: OpticKind) (a :: OpticKind).
Ord k2 =>
(k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys GHCTargetVersion -> Version
_tvVersion Map GHCTargetVersion VersionInfo
avTools) Maybe Version
cSet [Either String Version]
cabals
            [ListResult] -> m [ListResult]
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure ([ListResult] -> [ListResult]
forall (a :: OpticKind). Ord a => [a] -> [a]
sort ([ListResult]
slr [ListResult] -> [ListResult] -> [ListResult]
forall (a :: OpticKind). [a] -> [a] -> [a]
++ [ListResult]
lr))
          Tool
HLS -> do
            [ListResult]
slr <- Map Version VersionInfo
-> Maybe Version -> [Either String Version] -> m [ListResult]
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasDirs env, MonadCatch m, MonadThrow m,
 HasLog env, MonadIO m) =>
Map Version VersionInfo
-> Maybe Version -> [Either String Version] -> m [ListResult]
strayHLS ((GHCTargetVersion -> Version)
-> Map GHCTargetVersion VersionInfo -> Map Version VersionInfo
forall (k2 :: OpticKind) (k1 :: OpticKind) (a :: OpticKind).
Ord k2 =>
(k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys GHCTargetVersion -> Version
_tvVersion Map GHCTargetVersion VersionInfo
avTools) Maybe Version
hlsSet' [Either String Version]
hlses
            [ListResult] -> m [ListResult]
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure ([ListResult] -> [ListResult]
forall (a :: OpticKind). Ord a => [a] -> [a]
sort ([ListResult]
slr [ListResult] -> [ListResult] -> [ListResult]
forall (a :: OpticKind). [a] -> [a] -> [a]
++ [ListResult]
lr))
          Tool
Stack -> do
            [ListResult]
slr <- Map Version VersionInfo
-> Maybe Version -> [Either String Version] -> m [ListResult]
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasDirs env, MonadCatch m, MonadThrow m,
 HasLog env, MonadIO m) =>
Map Version VersionInfo
-> Maybe Version -> [Either String Version] -> m [ListResult]
strayStacks ((GHCTargetVersion -> Version)
-> Map GHCTargetVersion VersionInfo -> Map Version VersionInfo
forall (k2 :: OpticKind) (k1 :: OpticKind) (a :: OpticKind).
Ord k2 =>
(k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys GHCTargetVersion -> Version
_tvVersion Map GHCTargetVersion VersionInfo
avTools) Maybe Version
sSet [Either String Version]
stacks
            [ListResult] -> m [ListResult]
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure ([ListResult] -> [ListResult]
forall (a :: OpticKind). Ord a => [a] -> [a]
sort ([ListResult]
slr [ListResult] -> [ListResult] -> [ListResult]
forall (a :: OpticKind). [a] -> [a] -> [a]
++ [ListResult]
lr))
          Tool
GHCup -> do
            let cg :: [ListResult]
cg = Maybe ListResult -> [ListResult]
forall (a :: OpticKind). Maybe a -> [a]
maybeToList (Maybe ListResult -> [ListResult])
-> Maybe ListResult -> [ListResult]
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ Map GHCTargetVersion VersionInfo -> Maybe ListResult
currentGHCup Map GHCTargetVersion VersionInfo
avTools
            [ListResult] -> m [ListResult]
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure ([ListResult] -> [ListResult]
forall (a :: OpticKind). Ord a => [a] -> [a]
sort ([ListResult]
cg [ListResult] -> [ListResult] -> [ListResult]
forall (a :: OpticKind). [a] -> [a] -> [a]
++ [ListResult]
lr))
      Maybe Tool
Nothing -> do
        [ListResult]
ghcvers   <- Maybe Tool
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> m [ListResult]
go (Tool -> Maybe Tool
forall (a :: OpticKind). a -> Maybe a
Just Tool
GHC) Maybe Version
cSet [Either String Version]
cabals Maybe Version
hlsSet' [Either String Version]
hlses Maybe Version
sSet [Either String Version]
stacks
        [ListResult]
cabalvers <- Maybe Tool
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> m [ListResult]
go (Tool -> Maybe Tool
forall (a :: OpticKind). a -> Maybe a
Just Tool
Cabal) Maybe Version
cSet [Either String Version]
cabals Maybe Version
hlsSet' [Either String Version]
hlses Maybe Version
sSet [Either String Version]
stacks
        [ListResult]
hlsvers   <- Maybe Tool
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> m [ListResult]
go (Tool -> Maybe Tool
forall (a :: OpticKind). a -> Maybe a
Just Tool
HLS) Maybe Version
cSet [Either String Version]
cabals Maybe Version
hlsSet' [Either String Version]
hlses Maybe Version
sSet [Either String Version]
stacks
        [ListResult]
ghcupvers <- Maybe Tool
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> m [ListResult]
go (Tool -> Maybe Tool
forall (a :: OpticKind). a -> Maybe a
Just Tool
GHCup) Maybe Version
cSet [Either String Version]
cabals Maybe Version
hlsSet' [Either String Version]
hlses Maybe Version
sSet [Either String Version]
stacks
        [ListResult]
stackvers <- Maybe Tool
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> m [ListResult]
go (Tool -> Maybe Tool
forall (a :: OpticKind). a -> Maybe a
Just Tool
Stack) Maybe Version
cSet [Either String Version]
cabals Maybe Version
hlsSet' [Either String Version]
hlses Maybe Version
sSet [Either String Version]
stacks
        [ListResult] -> m [ListResult]
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure ([ListResult]
ghcvers [ListResult] -> [ListResult] -> [ListResult]
forall (a :: OpticKind). Semigroup a => a -> a -> a
<> [ListResult]
cabalvers [ListResult] -> [ListResult] -> [ListResult]
forall (a :: OpticKind). Semigroup a => a -> a -> a
<> [ListResult]
hlsvers [ListResult] -> [ListResult] -> [ListResult]
forall (a :: OpticKind). Semigroup a => a -> a -> a
<> [ListResult]
stackvers [ListResult] -> [ListResult] -> [ListResult]
forall (a :: OpticKind). Semigroup a => a -> a -> a
<> [ListResult]
ghcupvers)
  strayGHCs :: ( MonadCatch m
               , MonadReader env m
               , HasDirs env
               , MonadThrow m
               , HasLog env
               , MonadIO m
               )
            => Map.Map GHCTargetVersion VersionInfo
            -> m [ListResult]
  strayGHCs :: forall (m :: OpticKind -> OpticKind) (env :: OpticKind).
(MonadCatch m, MonadReader env m, HasDirs env, MonadThrow m,
 HasLog env, MonadIO m) =>
Map GHCTargetVersion VersionInfo -> m [ListResult]
strayGHCs Map GHCTargetVersion VersionInfo
avTools = do
    [Either String GHCTargetVersion]
ghcs <- m [Either String GHCTargetVersion]
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasDirs env, MonadIO m) =>
m [Either String GHCTargetVersion]
getInstalledGHCs
    ([Maybe ListResult] -> [ListResult])
-> m [Maybe ListResult] -> m [ListResult]
forall (a :: OpticKind) (b :: OpticKind). (a -> b) -> m a -> m b
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
fmap [Maybe ListResult] -> [ListResult]
forall (a :: OpticKind). [Maybe a] -> [a]
catMaybes (m [Maybe ListResult] -> m [ListResult])
-> m [Maybe ListResult] -> m [ListResult]
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ [Either String GHCTargetVersion]
-> (Either String GHCTargetVersion -> m (Maybe ListResult))
-> m [Maybe ListResult]
forall (t :: OpticKind -> OpticKind) (m :: OpticKind -> OpticKind)
       (a :: OpticKind) (b :: OpticKind).
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Either String GHCTargetVersion]
ghcs ((Either String GHCTargetVersion -> m (Maybe ListResult))
 -> m [Maybe ListResult])
-> (Either String GHCTargetVersion -> m (Maybe ListResult))
-> m [Maybe ListResult]
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ \case
      Right tver :: GHCTargetVersion
tver@GHCTargetVersion{ Maybe Text
Version
$sel:_tvVersion:GHCTargetVersion :: GHCTargetVersion -> Version
_tvTarget :: Maybe Text
_tvVersion :: Version
$sel:_tvTarget:GHCTargetVersion :: GHCTargetVersion -> Maybe Text
.. } -> do
        case GHCTargetVersion
-> Map GHCTargetVersion VersionInfo -> Maybe VersionInfo
forall (k :: OpticKind) (a :: OpticKind).
Ord k =>
k -> Map k a -> Maybe a
Map.lookup GHCTargetVersion
tver Map GHCTargetVersion VersionInfo
avTools of
          Just VersionInfo
_  -> Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure Maybe ListResult
forall (a :: OpticKind). Maybe a
Nothing
          Maybe VersionInfo
Nothing -> do
            Bool
lSet    <- (Maybe GHCTargetVersion -> Bool)
-> m (Maybe GHCTargetVersion) -> m Bool
forall (a :: OpticKind) (b :: OpticKind). (a -> b) -> m a -> m b
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
fmap (Bool
-> (GHCTargetVersion -> Bool) -> Maybe GHCTargetVersion -> Bool
forall (b :: OpticKind) (a :: OpticKind).
b -> (a -> b) -> Maybe a -> b
maybe Bool
False (\(GHCTargetVersion Maybe Text
_ Version
v ) -> Version
v Version -> Version -> Bool
forall (a :: OpticKind). Eq a => a -> a -> Bool
== Version
_tvVersion)) (m (Maybe GHCTargetVersion) -> m Bool)
-> m (Maybe GHCTargetVersion) -> m Bool
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ Maybe Text -> m (Maybe GHCTargetVersion)
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasDirs env, MonadThrow m, MonadIO m) =>
Maybe Text -> m (Maybe GHCTargetVersion)
ghcSet Maybe Text
_tvTarget
            Bool
hlsPowered <- ([Version] -> Bool) -> m [Version] -> m Bool
forall (a :: OpticKind) (b :: OpticKind). (a -> b) -> m a -> m b
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
fmap (Version -> [Version] -> Bool
forall (a :: OpticKind). Eq a => a -> [a] -> Bool
forall (t :: OpticKind -> OpticKind) (a :: OpticKind).
(Foldable t, Eq a) =>
a -> t a -> Bool
elem Version
_tvVersion) m [Version]
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasDirs env, HasLog env, MonadIO m,
 MonadThrow m, MonadCatch m) =>
m [Version]
hlsGHCVersions
            Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure (Maybe ListResult -> m (Maybe ListResult))
-> Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ ListResult -> Maybe ListResult
forall (a :: OpticKind). a -> Maybe a
Just (ListResult -> Maybe ListResult) -> ListResult -> Maybe ListResult
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ ListResult
              { lTool :: Tool
lTool      = Tool
GHC
              , lVer :: Version
lVer       = Version
_tvVersion
              , lCross :: Maybe Text
lCross     = Maybe Text
_tvTarget
              , lTag :: [Tag]
lTag       = []
              , lInstalled :: Bool
lInstalled = Bool
True
              , lStray :: Bool
lStray     = Maybe VersionInfo -> Bool
forall (a :: OpticKind). Maybe a -> Bool
isNothing (GHCTargetVersion
-> Map GHCTargetVersion VersionInfo -> Maybe VersionInfo
forall (k :: OpticKind) (a :: OpticKind).
Ord k =>
k -> Map k a -> Maybe a
Map.lookup GHCTargetVersion
tver Map GHCTargetVersion VersionInfo
avTools)
              , lNoBindist :: Bool
lNoBindist = Bool
False
              , lReleaseDay :: Maybe Day
lReleaseDay = Maybe Day
forall (a :: OpticKind). Maybe a
Nothing
              , Bool
lSet :: Bool
hlsPowered :: Bool
lSet :: Bool
hlsPowered :: Bool
..
              }
      Left String
e -> do
        Text -> m ()
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m,
 LabelOptic' "loggerConfig" A_Lens env LoggerConfig, MonadIO m) =>
Text -> m ()
logWarn
          (Text -> m ()) -> Text -> m ()
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ Text
"Could not parse version of stray directory" Text -> Text -> Text
forall (a :: OpticKind). Semigroup a => a -> a -> a
<> String -> Text
T.pack String
e
        Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure Maybe ListResult
forall (a :: OpticKind). Maybe a
Nothing

  strayCabals :: ( MonadReader env m
                 , HasDirs env
                 , MonadCatch m
                 , MonadThrow m
                 , HasLog env
                 , MonadIO m
                 )
            => Map.Map Version VersionInfo
            -> Maybe Version
            -> [Either FilePath Version]
            -> m [ListResult]
  strayCabals :: forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasDirs env, MonadCatch m, MonadThrow m,
 HasLog env, MonadIO m) =>
Map Version VersionInfo
-> Maybe Version -> [Either String Version] -> m [ListResult]
strayCabals Map Version VersionInfo
avTools Maybe Version
cSet [Either String Version]
cabals = do
    ([Maybe ListResult] -> [ListResult])
-> m [Maybe ListResult] -> m [ListResult]
forall (a :: OpticKind) (b :: OpticKind). (a -> b) -> m a -> m b
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
fmap [Maybe ListResult] -> [ListResult]
forall (a :: OpticKind). [Maybe a] -> [a]
catMaybes (m [Maybe ListResult] -> m [ListResult])
-> m [Maybe ListResult] -> m [ListResult]
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ [Either String Version]
-> (Either String Version -> m (Maybe ListResult))
-> m [Maybe ListResult]
forall (t :: OpticKind -> OpticKind) (m :: OpticKind -> OpticKind)
       (a :: OpticKind) (b :: OpticKind).
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Either String Version]
cabals ((Either String Version -> m (Maybe ListResult))
 -> m [Maybe ListResult])
-> (Either String Version -> m (Maybe ListResult))
-> m [Maybe ListResult]
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ \case
      Right Version
ver ->
        case Version -> Map Version VersionInfo -> Maybe VersionInfo
forall (k :: OpticKind) (a :: OpticKind).
Ord k =>
k -> Map k a -> Maybe a
Map.lookup Version
ver Map Version VersionInfo
avTools of
          Just VersionInfo
_  -> Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure Maybe ListResult
forall (a :: OpticKind). Maybe a
Nothing
          Maybe VersionInfo
Nothing -> do
            let lSet :: Bool
lSet = Maybe Version
cSet Maybe Version -> Maybe Version -> Bool
forall (a :: OpticKind). Eq a => a -> a -> Bool
== Version -> Maybe Version
forall (a :: OpticKind). a -> Maybe a
Just Version
ver
            Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure (Maybe ListResult -> m (Maybe ListResult))
-> Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ ListResult -> Maybe ListResult
forall (a :: OpticKind). a -> Maybe a
Just (ListResult -> Maybe ListResult) -> ListResult -> Maybe ListResult
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ ListResult
              { lTool :: Tool
lTool      = Tool
Cabal
              , lVer :: Version
lVer       = Version
ver
              , lCross :: Maybe Text
lCross     = Maybe Text
forall (a :: OpticKind). Maybe a
Nothing
              , lTag :: [Tag]
lTag       = []
              , lInstalled :: Bool
lInstalled = Bool
True
              , lStray :: Bool
lStray     = Maybe VersionInfo -> Bool
forall (a :: OpticKind). Maybe a -> Bool
isNothing (Version -> Map Version VersionInfo -> Maybe VersionInfo
forall (k :: OpticKind) (a :: OpticKind).
Ord k =>
k -> Map k a -> Maybe a
Map.lookup Version
ver Map Version VersionInfo
avTools)
              , lNoBindist :: Bool
lNoBindist = Bool
False
              , hlsPowered :: Bool
hlsPowered = Bool
False
              , lReleaseDay :: Maybe Day
lReleaseDay = Maybe Day
forall (a :: OpticKind). Maybe a
Nothing
              , Bool
lSet :: Bool
lSet :: Bool
..
              }
      Left String
e -> do
        Text -> m ()
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m,
 LabelOptic' "loggerConfig" A_Lens env LoggerConfig, MonadIO m) =>
Text -> m ()
logWarn
          (Text -> m ()) -> Text -> m ()
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ Text
"Could not parse version of stray directory" Text -> Text -> Text
forall (a :: OpticKind). Semigroup a => a -> a -> a
<> String -> Text
T.pack String
e
        Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure Maybe ListResult
forall (a :: OpticKind). Maybe a
Nothing

  strayHLS :: ( MonadReader env m
              , HasDirs env
              , MonadCatch m
              , MonadThrow m
              , HasLog env
              , MonadIO m)
           => Map.Map Version VersionInfo
           -> Maybe Version
           -> [Either FilePath Version]
           -> m [ListResult]
  strayHLS :: forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasDirs env, MonadCatch m, MonadThrow m,
 HasLog env, MonadIO m) =>
Map Version VersionInfo
-> Maybe Version -> [Either String Version] -> m [ListResult]
strayHLS Map Version VersionInfo
avTools Maybe Version
hlsSet' [Either String Version]
hlss = do
    ([Maybe ListResult] -> [ListResult])
-> m [Maybe ListResult] -> m [ListResult]
forall (a :: OpticKind) (b :: OpticKind). (a -> b) -> m a -> m b
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
fmap [Maybe ListResult] -> [ListResult]
forall (a :: OpticKind). [Maybe a] -> [a]
catMaybes (m [Maybe ListResult] -> m [ListResult])
-> m [Maybe ListResult] -> m [ListResult]
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ [Either String Version]
-> (Either String Version -> m (Maybe ListResult))
-> m [Maybe ListResult]
forall (t :: OpticKind -> OpticKind) (m :: OpticKind -> OpticKind)
       (a :: OpticKind) (b :: OpticKind).
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Either String Version]
hlss ((Either String Version -> m (Maybe ListResult))
 -> m [Maybe ListResult])
-> (Either String Version -> m (Maybe ListResult))
-> m [Maybe ListResult]
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ \case
      Right Version
ver ->
        case Version -> Map Version VersionInfo -> Maybe VersionInfo
forall (k :: OpticKind) (a :: OpticKind).
Ord k =>
k -> Map k a -> Maybe a
Map.lookup Version
ver Map Version VersionInfo
avTools of
          Just VersionInfo
_  -> Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure Maybe ListResult
forall (a :: OpticKind). Maybe a
Nothing
          Maybe VersionInfo
Nothing -> do
            let lSet :: Bool
lSet = Maybe Version
hlsSet' Maybe Version -> Maybe Version -> Bool
forall (a :: OpticKind). Eq a => a -> a -> Bool
== Version -> Maybe Version
forall (a :: OpticKind). a -> Maybe a
Just Version
ver
            Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure (Maybe ListResult -> m (Maybe ListResult))
-> Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ ListResult -> Maybe ListResult
forall (a :: OpticKind). a -> Maybe a
Just (ListResult -> Maybe ListResult) -> ListResult -> Maybe ListResult
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ ListResult
              { lTool :: Tool
lTool      = Tool
HLS
              , lVer :: Version
lVer       = Version
ver
              , lCross :: Maybe Text
lCross     = Maybe Text
forall (a :: OpticKind). Maybe a
Nothing
              , lTag :: [Tag]
lTag       = []
              , lInstalled :: Bool
lInstalled = Bool
True
              , lStray :: Bool
lStray     = Maybe VersionInfo -> Bool
forall (a :: OpticKind). Maybe a -> Bool
isNothing (Version -> Map Version VersionInfo -> Maybe VersionInfo
forall (k :: OpticKind) (a :: OpticKind).
Ord k =>
k -> Map k a -> Maybe a
Map.lookup Version
ver Map Version VersionInfo
avTools)
              , lNoBindist :: Bool
lNoBindist = Bool
False
              , hlsPowered :: Bool
hlsPowered = Bool
False
              , lReleaseDay :: Maybe Day
lReleaseDay = Maybe Day
forall (a :: OpticKind). Maybe a
Nothing
              , Bool
lSet :: Bool
lSet :: Bool
..
              }
      Left String
e -> do
        Text -> m ()
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m,
 LabelOptic' "loggerConfig" A_Lens env LoggerConfig, MonadIO m) =>
Text -> m ()
logWarn
          (Text -> m ()) -> Text -> m ()
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ Text
"Could not parse version of stray directory" Text -> Text -> Text
forall (a :: OpticKind). Semigroup a => a -> a -> a
<> String -> Text
T.pack String
e
        Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure Maybe ListResult
forall (a :: OpticKind). Maybe a
Nothing

  strayStacks :: ( MonadReader env m
                 , HasDirs env
                 , MonadCatch m
                 , MonadThrow m
                 , HasLog env
                 , MonadIO m
                 )
              => Map.Map Version VersionInfo
              -> Maybe Version
              -> [Either FilePath Version]
              -> m [ListResult]
  strayStacks :: forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasDirs env, MonadCatch m, MonadThrow m,
 HasLog env, MonadIO m) =>
Map Version VersionInfo
-> Maybe Version -> [Either String Version] -> m [ListResult]
strayStacks Map Version VersionInfo
avTools Maybe Version
stackSet' [Either String Version]
stacks = do
    ([Maybe ListResult] -> [ListResult])
-> m [Maybe ListResult] -> m [ListResult]
forall (a :: OpticKind) (b :: OpticKind). (a -> b) -> m a -> m b
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
fmap [Maybe ListResult] -> [ListResult]
forall (a :: OpticKind). [Maybe a] -> [a]
catMaybes (m [Maybe ListResult] -> m [ListResult])
-> m [Maybe ListResult] -> m [ListResult]
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ [Either String Version]
-> (Either String Version -> m (Maybe ListResult))
-> m [Maybe ListResult]
forall (t :: OpticKind -> OpticKind) (m :: OpticKind -> OpticKind)
       (a :: OpticKind) (b :: OpticKind).
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM [Either String Version]
stacks ((Either String Version -> m (Maybe ListResult))
 -> m [Maybe ListResult])
-> (Either String Version -> m (Maybe ListResult))
-> m [Maybe ListResult]
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ \case
      Right Version
ver ->
        case Version -> Map Version VersionInfo -> Maybe VersionInfo
forall (k :: OpticKind) (a :: OpticKind).
Ord k =>
k -> Map k a -> Maybe a
Map.lookup Version
ver Map Version VersionInfo
avTools of
          Just VersionInfo
_  -> Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure Maybe ListResult
forall (a :: OpticKind). Maybe a
Nothing
          Maybe VersionInfo
Nothing -> do
            let lSet :: Bool
lSet = Maybe Version
stackSet' Maybe Version -> Maybe Version -> Bool
forall (a :: OpticKind). Eq a => a -> a -> Bool
== Version -> Maybe Version
forall (a :: OpticKind). a -> Maybe a
Just Version
ver
            Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure (Maybe ListResult -> m (Maybe ListResult))
-> Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ ListResult -> Maybe ListResult
forall (a :: OpticKind). a -> Maybe a
Just (ListResult -> Maybe ListResult) -> ListResult -> Maybe ListResult
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ ListResult
              { lTool :: Tool
lTool      = Tool
Stack
              , lVer :: Version
lVer       = Version
ver
              , lCross :: Maybe Text
lCross     = Maybe Text
forall (a :: OpticKind). Maybe a
Nothing
              , lTag :: [Tag]
lTag       = []
              , lInstalled :: Bool
lInstalled = Bool
True
              , lStray :: Bool
lStray     = Maybe VersionInfo -> Bool
forall (a :: OpticKind). Maybe a -> Bool
isNothing (Version -> Map Version VersionInfo -> Maybe VersionInfo
forall (k :: OpticKind) (a :: OpticKind).
Ord k =>
k -> Map k a -> Maybe a
Map.lookup Version
ver Map Version VersionInfo
avTools)
              , lNoBindist :: Bool
lNoBindist = Bool
False
              , hlsPowered :: Bool
hlsPowered = Bool
False
              , lReleaseDay :: Maybe Day
lReleaseDay = Maybe Day
forall (a :: OpticKind). Maybe a
Nothing
              , Bool
lSet :: Bool
lSet :: Bool
..
              }
      Left String
e -> do
        Text -> m ()
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m,
 LabelOptic' "loggerConfig" A_Lens env LoggerConfig, MonadIO m) =>
Text -> m ()
logWarn
          (Text -> m ()) -> Text -> m ()
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ Text
"Could not parse version of stray directory" Text -> Text -> Text
forall (a :: OpticKind). Semigroup a => a -> a -> a
<> String -> Text
T.pack String
e
        Maybe ListResult -> m (Maybe ListResult)
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure Maybe ListResult
forall (a :: OpticKind). Maybe a
Nothing

  currentGHCup :: Map.Map GHCTargetVersion VersionInfo -> Maybe ListResult
  currentGHCup :: Map GHCTargetVersion VersionInfo -> Maybe ListResult
currentGHCup Map GHCTargetVersion VersionInfo
av =
    let currentVer :: GHCTargetVersion
currentVer = Version -> GHCTargetVersion
mkTVer (Version -> GHCTargetVersion) -> Version -> GHCTargetVersion
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ Maybe Version -> Version
forall (a :: OpticKind). HasCallStack => Maybe a -> a
fromJust (Maybe Version -> Version) -> Maybe Version -> Version
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ PVP -> Text -> Maybe Version
forall (m :: OpticKind -> OpticKind).
MonadThrow m =>
PVP -> Text -> m Version
pvpToVersion PVP
ghcUpVer Text
""
        listVer :: Maybe VersionInfo
listVer    = GHCTargetVersion
-> Map GHCTargetVersion VersionInfo -> Maybe VersionInfo
forall (k :: OpticKind) (a :: OpticKind).
Ord k =>
k -> Map k a -> Maybe a
Map.lookup GHCTargetVersion
currentVer Map GHCTargetVersion VersionInfo
av
        latestVer :: Maybe GHCTargetVersion
latestVer  = (GHCTargetVersion, VersionInfo) -> GHCTargetVersion
forall (a :: OpticKind) (b :: OpticKind). (a, b) -> a
fst ((GHCTargetVersion, VersionInfo) -> GHCTargetVersion)
-> Maybe (GHCTargetVersion, VersionInfo) -> Maybe GHCTargetVersion
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
<$> Optic'
  A_Fold
  NoIx
  (Map GHCTargetVersion VersionInfo)
  (GHCTargetVersion, VersionInfo)
-> Map GHCTargetVersion VersionInfo
-> Maybe (GHCTargetVersion, VersionInfo)
forall (k :: OpticKind) (is :: IxList) (s :: OpticKind)
       (a :: OpticKind).
Is k A_Fold =>
Optic' k is s a -> s -> Maybe a
headOf (Tag
-> Optic'
     A_Fold
     NoIx
     (Map GHCTargetVersion VersionInfo)
     (GHCTargetVersion, VersionInfo)
getTagged Tag
Latest) Map GHCTargetVersion VersionInfo
av
        recommendedVer :: Maybe GHCTargetVersion
recommendedVer = (GHCTargetVersion, VersionInfo) -> GHCTargetVersion
forall (a :: OpticKind) (b :: OpticKind). (a, b) -> a
fst ((GHCTargetVersion, VersionInfo) -> GHCTargetVersion)
-> Maybe (GHCTargetVersion, VersionInfo) -> Maybe GHCTargetVersion
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
<$> Optic'
  A_Fold
  NoIx
  (Map GHCTargetVersion VersionInfo)
  (GHCTargetVersion, VersionInfo)
-> Map GHCTargetVersion VersionInfo
-> Maybe (GHCTargetVersion, VersionInfo)
forall (k :: OpticKind) (is :: IxList) (s :: OpticKind)
       (a :: OpticKind).
Is k A_Fold =>
Optic' k is s a -> s -> Maybe a
headOf (Tag
-> Optic'
     A_Fold
     NoIx
     (Map GHCTargetVersion VersionInfo)
     (GHCTargetVersion, VersionInfo)
getTagged Tag
Latest) Map GHCTargetVersion VersionInfo
av
        isOld :: Bool
isOld  = Bool
-> (GHCTargetVersion -> Bool) -> Maybe GHCTargetVersion -> Bool
forall (b :: OpticKind) (a :: OpticKind).
b -> (a -> b) -> Maybe a -> b
maybe Bool
True (GHCTargetVersion -> GHCTargetVersion -> Bool
forall (a :: OpticKind). Ord a => a -> a -> Bool
> GHCTargetVersion
currentVer) Maybe GHCTargetVersion
latestVer Bool -> Bool -> Bool
&& Bool
-> (GHCTargetVersion -> Bool) -> Maybe GHCTargetVersion -> Bool
forall (b :: OpticKind) (a :: OpticKind).
b -> (a -> b) -> Maybe a -> b
maybe Bool
True (GHCTargetVersion -> GHCTargetVersion -> Bool
forall (a :: OpticKind). Ord a => a -> a -> Bool
> GHCTargetVersion
currentVer) Maybe GHCTargetVersion
recommendedVer
    in if | GHCTargetVersion -> Map GHCTargetVersion VersionInfo -> Bool
forall (k :: OpticKind) (a :: OpticKind).
Ord k =>
k -> Map k a -> Bool
Map.member GHCTargetVersion
currentVer Map GHCTargetVersion VersionInfo
av -> Maybe ListResult
forall (a :: OpticKind). Maybe a
Nothing
          | Bool
otherwise -> ListResult -> Maybe ListResult
forall (a :: OpticKind). a -> Maybe a
Just (ListResult -> Maybe ListResult) -> ListResult -> Maybe ListResult
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ ListResult { lVer :: Version
lVer    = GHCTargetVersion -> Version
_tvVersion GHCTargetVersion
currentVer
                                           , lTag :: [Tag]
lTag    = [Tag] -> (VersionInfo -> [Tag]) -> Maybe VersionInfo -> [Tag]
forall (b :: OpticKind) (a :: OpticKind).
b -> (a -> b) -> Maybe a -> b
maybe (if Bool
isOld then [Tag
Old] else []) VersionInfo -> [Tag]
_viTags Maybe VersionInfo
listVer
                                           , lCross :: Maybe Text
lCross  = Maybe Text
forall (a :: OpticKind). Maybe a
Nothing
                                           , lTool :: Tool
lTool   = Tool
GHCup
                                           , lStray :: Bool
lStray  = Maybe VersionInfo -> Bool
forall (a :: OpticKind). Maybe a -> Bool
isNothing Maybe VersionInfo
listVer
                                           , lSet :: Bool
lSet    = Bool
True
                                           , lInstalled :: Bool
lInstalled = Bool
True
                                           , lNoBindist :: Bool
lNoBindist = Bool
False
                                           , hlsPowered :: Bool
hlsPowered = Bool
False
                                           , lReleaseDay :: Maybe Day
lReleaseDay = Maybe Day
forall (a :: OpticKind). Maybe a
Nothing
                                           }

  -- NOTE: this are not cross ones, because no bindists
  toListResult :: ( HasLog env
                  , MonadReader env m
                  , HasDirs env
                  , HasGHCupInfo env
                  , HasPlatformReq env
                  , MonadIO m
                  , MonadCatch m
                  )
               => Tool
               -> Maybe Version
               -> [Either FilePath Version]
               -> Maybe Version
               -> [Either FilePath Version]
               -> Maybe Version
               -> [Either FilePath Version]
               -> (GHCTargetVersion, VersionInfo)
               -> m ListResult
  toListResult :: forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(HasLog env, MonadReader env m, HasDirs env, HasGHCupInfo env,
 HasPlatformReq env, MonadIO m, MonadCatch m) =>
Tool
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> (GHCTargetVersion, VersionInfo)
-> m ListResult
toListResult Tool
t Maybe Version
cSet [Either String Version]
cabals Maybe Version
hlsSet' [Either String Version]
hlses Maybe Version
stackSet' [Either String Version]
stacks (GHCTargetVersion
tver, VersionInfo{[Tag]
Maybe Text
Maybe Day
Maybe URI
Maybe DownloadInfo
ArchitectureSpec
$sel:_viTags:VersionInfo :: VersionInfo -> [Tag]
_viTags :: [Tag]
_viReleaseDay :: Maybe Day
_viChangeLog :: Maybe URI
_viSourceDL :: Maybe DownloadInfo
_viTestDL :: Maybe DownloadInfo
_viArch :: ArchitectureSpec
_viPostInstall :: Maybe Text
_viPostRemove :: Maybe Text
_viPreCompile :: Maybe Text
$sel:_viReleaseDay:VersionInfo :: VersionInfo -> Maybe Day
$sel:_viChangeLog:VersionInfo :: VersionInfo -> Maybe URI
$sel:_viSourceDL:VersionInfo :: VersionInfo -> Maybe DownloadInfo
$sel:_viTestDL:VersionInfo :: VersionInfo -> Maybe DownloadInfo
$sel:_viArch:VersionInfo :: VersionInfo -> ArchitectureSpec
$sel:_viPostInstall:VersionInfo :: VersionInfo -> Maybe Text
$sel:_viPostRemove:VersionInfo :: VersionInfo -> Maybe Text
$sel:_viPreCompile:VersionInfo :: VersionInfo -> Maybe Text
..}) = do
    let v :: Version
v = GHCTargetVersion -> Version
_tvVersion GHCTargetVersion
tver
    case Tool
t of
      Tool
GHC -> do
        Bool
lNoBindist <- (VEither (NoDownload : NoIx) DownloadInfo -> Bool)
-> m (VEither (NoDownload : NoIx) DownloadInfo) -> m Bool
forall (a :: OpticKind) (b :: OpticKind). (a -> b) -> m a -> m b
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
fmap (Either (V (NoDownload : NoIx)) DownloadInfo -> Bool
forall (a :: OpticKind) (b :: OpticKind). Either a b -> Bool
isLeft (Either (V (NoDownload : NoIx)) DownloadInfo -> Bool)
-> (VEither (NoDownload : NoIx) DownloadInfo
    -> Either (V (NoDownload : NoIx)) DownloadInfo)
-> VEither (NoDownload : NoIx) DownloadInfo
-> Bool
forall (b :: OpticKind) (c :: OpticKind) (a :: OpticKind).
(b -> c) -> (a -> b) -> a -> c
. VEither (NoDownload : NoIx) DownloadInfo
-> Either (V (NoDownload : NoIx)) DownloadInfo
forall (es :: IxList) (a :: OpticKind).
VEither es a -> Either (V es) a
veitherToEither) (m (VEither (NoDownload : NoIx) DownloadInfo) -> m Bool)
-> m (VEither (NoDownload : NoIx) DownloadInfo) -> m Bool
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ forall (es :: IxList) (a :: OpticKind)
       (m :: OpticKind -> OpticKind).
Excepts es m a -> m (VEither es a)
runE @'[NoDownload] (Excepts (NoDownload : NoIx) m DownloadInfo
 -> m (VEither (NoDownload : NoIx) DownloadInfo))
-> Excepts (NoDownload : NoIx) m DownloadInfo
-> m (VEither (NoDownload : NoIx) DownloadInfo)
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ Tool
-> GHCTargetVersion -> Excepts (NoDownload : NoIx) m DownloadInfo
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasPlatformReq env, HasGHCupInfo env) =>
Tool
-> GHCTargetVersion -> Excepts (NoDownload : NoIx) m DownloadInfo
getDownloadInfo' Tool
GHC GHCTargetVersion
tver
        Bool
lSet       <- (Maybe GHCTargetVersion -> Bool)
-> m (Maybe GHCTargetVersion) -> m Bool
forall (a :: OpticKind) (b :: OpticKind). (a -> b) -> m a -> m b
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
fmap (Maybe GHCTargetVersion -> Maybe GHCTargetVersion -> Bool
forall (a :: OpticKind). Eq a => a -> a -> Bool
== GHCTargetVersion -> Maybe GHCTargetVersion
forall (a :: OpticKind). a -> Maybe a
Just GHCTargetVersion
tver) (m (Maybe GHCTargetVersion) -> m Bool)
-> m (Maybe GHCTargetVersion) -> m Bool
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ Maybe Text -> m (Maybe GHCTargetVersion)
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasDirs env, MonadThrow m, MonadIO m) =>
Maybe Text -> m (Maybe GHCTargetVersion)
ghcSet (GHCTargetVersion -> Maybe Text
_tvTarget GHCTargetVersion
tver)
        Bool
lInstalled <- GHCTargetVersion -> m Bool
forall (m :: OpticKind -> OpticKind) (env :: OpticKind).
(MonadIO m, MonadReader env m, HasDirs env, MonadThrow m) =>
GHCTargetVersion -> m Bool
ghcInstalled GHCTargetVersion
tver
        Bool
hlsPowered <- ([GHCTargetVersion] -> Bool) -> m [GHCTargetVersion] -> m Bool
forall (a :: OpticKind) (b :: OpticKind). (a -> b) -> m a -> m b
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
fmap (GHCTargetVersion -> [GHCTargetVersion] -> Bool
forall (a :: OpticKind). Eq a => a -> [a] -> Bool
forall (t :: OpticKind -> OpticKind) (a :: OpticKind).
(Foldable t, Eq a) =>
a -> t a -> Bool
elem GHCTargetVersion
tver) ((Version -> GHCTargetVersion) -> [Version] -> [GHCTargetVersion]
forall (a :: OpticKind) (b :: OpticKind). (a -> b) -> [a] -> [b]
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
fmap Version -> GHCTargetVersion
mkTVer ([Version] -> [GHCTargetVersion])
-> m [Version] -> m [GHCTargetVersion]
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
<$> m [Version]
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasDirs env, HasLog env, MonadIO m,
 MonadThrow m, MonadCatch m) =>
m [Version]
hlsGHCVersions)
        ListResult -> m ListResult
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure ListResult { lVer :: Version
lVer = GHCTargetVersion -> Version
_tvVersion GHCTargetVersion
tver , lCross :: Maybe Text
lCross = GHCTargetVersion -> Maybe Text
_tvTarget GHCTargetVersion
tver , lTag :: [Tag]
lTag = [Tag]
_viTags, lTool :: Tool
lTool = Tool
t, lStray :: Bool
lStray = Bool
False, lReleaseDay :: Maybe Day
lReleaseDay = Maybe Day
_viReleaseDay, Bool
lInstalled :: Bool
lSet :: Bool
lNoBindist :: Bool
hlsPowered :: Bool
lNoBindist :: Bool
lSet :: Bool
lInstalled :: Bool
hlsPowered :: Bool
.. }
      Tool
Cabal -> do
        Bool
lNoBindist <- (VEither (NoDownload : NoIx) DownloadInfo -> Bool)
-> m (VEither (NoDownload : NoIx) DownloadInfo) -> m Bool
forall (a :: OpticKind) (b :: OpticKind). (a -> b) -> m a -> m b
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
fmap (Either (V (NoDownload : NoIx)) DownloadInfo -> Bool
forall (a :: OpticKind) (b :: OpticKind). Either a b -> Bool
isLeft (Either (V (NoDownload : NoIx)) DownloadInfo -> Bool)
-> (VEither (NoDownload : NoIx) DownloadInfo
    -> Either (V (NoDownload : NoIx)) DownloadInfo)
-> VEither (NoDownload : NoIx) DownloadInfo
-> Bool
forall (b :: OpticKind) (c :: OpticKind) (a :: OpticKind).
(b -> c) -> (a -> b) -> a -> c
. VEither (NoDownload : NoIx) DownloadInfo
-> Either (V (NoDownload : NoIx)) DownloadInfo
forall (es :: IxList) (a :: OpticKind).
VEither es a -> Either (V es) a
veitherToEither) (m (VEither (NoDownload : NoIx) DownloadInfo) -> m Bool)
-> m (VEither (NoDownload : NoIx) DownloadInfo) -> m Bool
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ forall (es :: IxList) (a :: OpticKind)
       (m :: OpticKind -> OpticKind).
Excepts es m a -> m (VEither es a)
runE @'[NoDownload] (Excepts (NoDownload : NoIx) m DownloadInfo
 -> m (VEither (NoDownload : NoIx) DownloadInfo))
-> Excepts (NoDownload : NoIx) m DownloadInfo
-> m (VEither (NoDownload : NoIx) DownloadInfo)
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ Tool -> Version -> Excepts (NoDownload : NoIx) m DownloadInfo
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasPlatformReq env, HasGHCupInfo env) =>
Tool -> Version -> Excepts (NoDownload : NoIx) m DownloadInfo
getDownloadInfo Tool
Cabal Version
v
        let lSet :: Bool
lSet = Maybe Version
cSet Maybe Version -> Maybe Version -> Bool
forall (a :: OpticKind). Eq a => a -> a -> Bool
== Version -> Maybe Version
forall (a :: OpticKind). a -> Maybe a
Just Version
v
        let lInstalled :: Bool
lInstalled = Version -> [Version] -> Bool
forall (a :: OpticKind). Eq a => a -> [a] -> Bool
forall (t :: OpticKind -> OpticKind) (a :: OpticKind).
(Foldable t, Eq a) =>
a -> t a -> Bool
elem Version
v ([Version] -> Bool) -> [Version] -> Bool
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ [Either String Version] -> [Version]
forall (a :: OpticKind) (b :: OpticKind). [Either a b] -> [b]
rights [Either String Version]
cabals
        ListResult -> m ListResult
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure ListResult { lVer :: Version
lVer    = Version
v
                        , lCross :: Maybe Text
lCross  = Maybe Text
forall (a :: OpticKind). Maybe a
Nothing
                        , lTag :: [Tag]
lTag    = [Tag]
_viTags
                        , lTool :: Tool
lTool   = Tool
t
                        , lStray :: Bool
lStray  = Bool
False
                        , hlsPowered :: Bool
hlsPowered = Bool
False
                        , lReleaseDay :: Maybe Day
lReleaseDay = Maybe Day
_viReleaseDay
                        , Bool
lInstalled :: Bool
lSet :: Bool
lNoBindist :: Bool
lNoBindist :: Bool
lSet :: Bool
lInstalled :: Bool
..
                        }
      Tool
GHCup -> do
        let lSet :: Bool
lSet       = PVP -> Text
prettyPVP PVP
ghcUpVer Text -> Text -> Bool
forall (a :: OpticKind). Eq a => a -> a -> Bool
== Version -> Text
prettyVer Version
v
        let lInstalled :: Bool
lInstalled = Bool
lSet
        ListResult -> m ListResult
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure ListResult { lVer :: Version
lVer    = Version
v
                        , lTag :: [Tag]
lTag    = [Tag]
_viTags
                        , lCross :: Maybe Text
lCross  = Maybe Text
forall (a :: OpticKind). Maybe a
Nothing
                        , lTool :: Tool
lTool   = Tool
t
                        , lStray :: Bool
lStray  = Bool
False
                        , lNoBindist :: Bool
lNoBindist = Bool
False
                        , hlsPowered :: Bool
hlsPowered = Bool
False
                        , lReleaseDay :: Maybe Day
lReleaseDay = Maybe Day
_viReleaseDay
                        , Bool
lInstalled :: Bool
lSet :: Bool
lSet :: Bool
lInstalled :: Bool
..
                        }
      Tool
HLS -> do
        Bool
lNoBindist <- (VEither (NoDownload : NoIx) DownloadInfo -> Bool)
-> m (VEither (NoDownload : NoIx) DownloadInfo) -> m Bool
forall (a :: OpticKind) (b :: OpticKind). (a -> b) -> m a -> m b
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
fmap (Either (V (NoDownload : NoIx)) DownloadInfo -> Bool
forall (a :: OpticKind) (b :: OpticKind). Either a b -> Bool
isLeft (Either (V (NoDownload : NoIx)) DownloadInfo -> Bool)
-> (VEither (NoDownload : NoIx) DownloadInfo
    -> Either (V (NoDownload : NoIx)) DownloadInfo)
-> VEither (NoDownload : NoIx) DownloadInfo
-> Bool
forall (b :: OpticKind) (c :: OpticKind) (a :: OpticKind).
(b -> c) -> (a -> b) -> a -> c
. VEither (NoDownload : NoIx) DownloadInfo
-> Either (V (NoDownload : NoIx)) DownloadInfo
forall (es :: IxList) (a :: OpticKind).
VEither es a -> Either (V es) a
veitherToEither) (m (VEither (NoDownload : NoIx) DownloadInfo) -> m Bool)
-> m (VEither (NoDownload : NoIx) DownloadInfo) -> m Bool
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ forall (es :: IxList) (a :: OpticKind)
       (m :: OpticKind -> OpticKind).
Excepts es m a -> m (VEither es a)
runE @'[NoDownload] (Excepts (NoDownload : NoIx) m DownloadInfo
 -> m (VEither (NoDownload : NoIx) DownloadInfo))
-> Excepts (NoDownload : NoIx) m DownloadInfo
-> m (VEither (NoDownload : NoIx) DownloadInfo)
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ Tool -> Version -> Excepts (NoDownload : NoIx) m DownloadInfo
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasPlatformReq env, HasGHCupInfo env) =>
Tool -> Version -> Excepts (NoDownload : NoIx) m DownloadInfo
getDownloadInfo Tool
HLS Version
v
        let lSet :: Bool
lSet = Maybe Version
hlsSet' Maybe Version -> Maybe Version -> Bool
forall (a :: OpticKind). Eq a => a -> a -> Bool
== Version -> Maybe Version
forall (a :: OpticKind). a -> Maybe a
Just Version
v
        let lInstalled :: Bool
lInstalled = Version -> [Version] -> Bool
forall (a :: OpticKind). Eq a => a -> [a] -> Bool
forall (t :: OpticKind -> OpticKind) (a :: OpticKind).
(Foldable t, Eq a) =>
a -> t a -> Bool
elem Version
v ([Version] -> Bool) -> [Version] -> Bool
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ [Either String Version] -> [Version]
forall (a :: OpticKind) (b :: OpticKind). [Either a b] -> [b]
rights [Either String Version]
hlses
        ListResult -> m ListResult
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure ListResult { lVer :: Version
lVer    = Version
v
                        , lCross :: Maybe Text
lCross  = Maybe Text
forall (a :: OpticKind). Maybe a
Nothing
                        , lTag :: [Tag]
lTag    = [Tag]
_viTags
                        , lTool :: Tool
lTool   = Tool
t
                        , lStray :: Bool
lStray  = Bool
False
                        , hlsPowered :: Bool
hlsPowered = Bool
False
                        , lReleaseDay :: Maybe Day
lReleaseDay = Maybe Day
_viReleaseDay
                        , Bool
lInstalled :: Bool
lSet :: Bool
lNoBindist :: Bool
lNoBindist :: Bool
lSet :: Bool
lInstalled :: Bool
..
                        }
      Tool
Stack -> do
        Bool
lNoBindist <- (VEither (NoDownload : NoIx) DownloadInfo -> Bool)
-> m (VEither (NoDownload : NoIx) DownloadInfo) -> m Bool
forall (a :: OpticKind) (b :: OpticKind). (a -> b) -> m a -> m b
forall (f :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Functor f =>
(a -> b) -> f a -> f b
fmap (Either (V (NoDownload : NoIx)) DownloadInfo -> Bool
forall (a :: OpticKind) (b :: OpticKind). Either a b -> Bool
isLeft (Either (V (NoDownload : NoIx)) DownloadInfo -> Bool)
-> (VEither (NoDownload : NoIx) DownloadInfo
    -> Either (V (NoDownload : NoIx)) DownloadInfo)
-> VEither (NoDownload : NoIx) DownloadInfo
-> Bool
forall (b :: OpticKind) (c :: OpticKind) (a :: OpticKind).
(b -> c) -> (a -> b) -> a -> c
. VEither (NoDownload : NoIx) DownloadInfo
-> Either (V (NoDownload : NoIx)) DownloadInfo
forall (es :: IxList) (a :: OpticKind).
VEither es a -> Either (V es) a
veitherToEither) (m (VEither (NoDownload : NoIx) DownloadInfo) -> m Bool)
-> m (VEither (NoDownload : NoIx) DownloadInfo) -> m Bool
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ forall (es :: IxList) (a :: OpticKind)
       (m :: OpticKind -> OpticKind).
Excepts es m a -> m (VEither es a)
runE @'[NoDownload] (Excepts (NoDownload : NoIx) m DownloadInfo
 -> m (VEither (NoDownload : NoIx) DownloadInfo))
-> Excepts (NoDownload : NoIx) m DownloadInfo
-> m (VEither (NoDownload : NoIx) DownloadInfo)
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ Tool -> Version -> Excepts (NoDownload : NoIx) m DownloadInfo
forall (env :: OpticKind) (m :: OpticKind -> OpticKind).
(MonadReader env m, HasPlatformReq env, HasGHCupInfo env) =>
Tool -> Version -> Excepts (NoDownload : NoIx) m DownloadInfo
getDownloadInfo Tool
Stack Version
v
        let lSet :: Bool
lSet = Maybe Version
stackSet' Maybe Version -> Maybe Version -> Bool
forall (a :: OpticKind). Eq a => a -> a -> Bool
== Version -> Maybe Version
forall (a :: OpticKind). a -> Maybe a
Just Version
v
        let lInstalled :: Bool
lInstalled = Version -> [Version] -> Bool
forall (a :: OpticKind). Eq a => a -> [a] -> Bool
forall (t :: OpticKind -> OpticKind) (a :: OpticKind).
(Foldable t, Eq a) =>
a -> t a -> Bool
elem Version
v ([Version] -> Bool) -> [Version] -> Bool
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ [Either String Version] -> [Version]
forall (a :: OpticKind) (b :: OpticKind). [Either a b] -> [b]
rights [Either String Version]
stacks
        ListResult -> m ListResult
forall (a :: OpticKind). a -> m a
forall (f :: OpticKind -> OpticKind) (a :: OpticKind).
Applicative f =>
a -> f a
pure ListResult { lVer :: Version
lVer    = Version
v
                        , lCross :: Maybe Text
lCross  = Maybe Text
forall (a :: OpticKind). Maybe a
Nothing
                        , lTag :: [Tag]
lTag    = [Tag]
_viTags
                        , lTool :: Tool
lTool   = Tool
t
                        , lStray :: Bool
lStray  = Bool
False
                        , hlsPowered :: Bool
hlsPowered = Bool
False
                        , lReleaseDay :: Maybe Day
lReleaseDay = Maybe Day
_viReleaseDay
                        , Bool
lInstalled :: Bool
lSet :: Bool
lNoBindist :: Bool
lNoBindist :: Bool
lSet :: Bool
lInstalled :: Bool
..
                        }


  filter' :: [ListResult] -> [ListResult]
  filter' :: [ListResult] -> [ListResult]
filter' = [ListResult] -> [ListResult]
filterNightly ([ListResult] -> [ListResult])
-> ([ListResult] -> [ListResult]) -> [ListResult] -> [ListResult]
forall (b :: OpticKind) (c :: OpticKind) (a :: OpticKind).
(b -> c) -> (a -> b) -> a -> c
. [ListResult] -> [ListResult]
filterOld ([ListResult] -> [ListResult])
-> ([ListResult] -> [ListResult]) -> [ListResult] -> [ListResult]
forall (b :: OpticKind) (c :: OpticKind) (a :: OpticKind).
(b -> c) -> (a -> b) -> a -> c
. (ListResult -> Bool) -> [ListResult] -> [ListResult]
forall (a :: OpticKind). (a -> Bool) -> [a] -> [a]
filter (\ListResult
lr -> (ListCriteria -> Bool -> Bool) -> Bool -> [ListCriteria] -> Bool
forall (a :: OpticKind) (b :: OpticKind).
(a -> b -> b) -> b -> [a] -> b
forall (t :: OpticKind -> OpticKind) (a :: OpticKind)
       (b :: OpticKind).
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\ListCriteria
a Bool
b -> ListCriteria -> ListResult -> Bool
fromCriteria ListCriteria
a ListResult
lr Bool -> Bool -> Bool
&& Bool
b) Bool
True [ListCriteria]
criteria) ([ListResult] -> [ListResult])
-> ([ListResult] -> [ListResult]) -> [ListResult] -> [ListResult]
forall (b :: OpticKind) (c :: OpticKind) (a :: OpticKind).
(b -> c) -> (a -> b) -> a -> c
. [ListResult] -> [ListResult]
filterDays

  filterDays :: [ListResult] -> [ListResult]
  filterDays :: [ListResult] -> [ListResult]
filterDays [ListResult]
lrs = case (Maybe Day, Maybe Day)
days of
                     (Maybe Day
Nothing, Maybe Day
Nothing)    -> [ListResult]
lrs
                     (Just Day
from, Just Day
to') -> (ListResult -> Bool) -> [ListResult] -> [ListResult]
forall (a :: OpticKind). (a -> Bool) -> [a] -> [a]
filter (\ListResult{Bool
[Tag]
Maybe Text
Maybe Day
Version
Tool
lTool :: ListResult -> Tool
lVer :: ListResult -> Version
lCross :: ListResult -> Maybe Text
lTag :: ListResult -> [Tag]
lInstalled :: ListResult -> Bool
lSet :: ListResult -> Bool
lStray :: ListResult -> Bool
lNoBindist :: ListResult -> Bool
hlsPowered :: ListResult -> Bool
lReleaseDay :: ListResult -> Maybe Day
lTool :: Tool
lVer :: Version
lCross :: Maybe Text
lTag :: [Tag]
lInstalled :: Bool
lSet :: Bool
lStray :: Bool
lNoBindist :: Bool
hlsPowered :: Bool
lReleaseDay :: Maybe Day
..} -> Bool -> (Day -> Bool) -> Maybe Day -> Bool
forall (b :: OpticKind) (a :: OpticKind).
b -> (a -> b) -> Maybe a -> b
maybe Bool
False (\Day
d -> Day
d Day -> Day -> Bool
forall (a :: OpticKind). Ord a => a -> a -> Bool
>= Day
from Bool -> Bool -> Bool
&& Day
d Day -> Day -> Bool
forall (a :: OpticKind). Ord a => a -> a -> Bool
<= Day
to') Maybe Day
lReleaseDay) [ListResult]
lrs
                     (Maybe Day
Nothing, Just Day
to')   -> (ListResult -> Bool) -> [ListResult] -> [ListResult]
forall (a :: OpticKind). (a -> Bool) -> [a] -> [a]
filter (\ListResult{Bool
[Tag]
Maybe Text
Maybe Day
Version
Tool
lTool :: ListResult -> Tool
lVer :: ListResult -> Version
lCross :: ListResult -> Maybe Text
lTag :: ListResult -> [Tag]
lInstalled :: ListResult -> Bool
lSet :: ListResult -> Bool
lStray :: ListResult -> Bool
lNoBindist :: ListResult -> Bool
hlsPowered :: ListResult -> Bool
lReleaseDay :: ListResult -> Maybe Day
lTool :: Tool
lVer :: Version
lCross :: Maybe Text
lTag :: [Tag]
lInstalled :: Bool
lSet :: Bool
lStray :: Bool
lNoBindist :: Bool
hlsPowered :: Bool
lReleaseDay :: Maybe Day
..} -> Bool -> (Day -> Bool) -> Maybe Day -> Bool
forall (b :: OpticKind) (a :: OpticKind).
b -> (a -> b) -> Maybe a -> b
maybe Bool
False (Day -> Day -> Bool
forall (a :: OpticKind). Ord a => a -> a -> Bool
<= Day
to')                      Maybe Day
lReleaseDay) [ListResult]
lrs
                     (Just Day
from, Maybe Day
Nothing)  -> (ListResult -> Bool) -> [ListResult] -> [ListResult]
forall (a :: OpticKind). (a -> Bool) -> [a] -> [a]
filter (\ListResult{Bool
[Tag]
Maybe Text
Maybe Day
Version
Tool
lTool :: ListResult -> Tool
lVer :: ListResult -> Version
lCross :: ListResult -> Maybe Text
lTag :: ListResult -> [Tag]
lInstalled :: ListResult -> Bool
lSet :: ListResult -> Bool
lStray :: ListResult -> Bool
lNoBindist :: ListResult -> Bool
hlsPowered :: ListResult -> Bool
lReleaseDay :: ListResult -> Maybe Day
lTool :: Tool
lVer :: Version
lCross :: Maybe Text
lTag :: [Tag]
lInstalled :: Bool
lSet :: Bool
lStray :: Bool
lNoBindist :: Bool
hlsPowered :: Bool
lReleaseDay :: Maybe Day
..} -> Bool -> (Day -> Bool) -> Maybe Day -> Bool
forall (b :: OpticKind) (a :: OpticKind).
b -> (a -> b) -> Maybe a -> b
maybe Bool
False (Day -> Day -> Bool
forall (a :: OpticKind). Ord a => a -> a -> Bool
>= Day
from)                     Maybe Day
lReleaseDay) [ListResult]
lrs

  fromCriteria :: ListCriteria -> ListResult -> Bool
  fromCriteria :: ListCriteria -> ListResult -> Bool
fromCriteria ListCriteria
lc ListResult{Bool
[Tag]
Maybe Text
Maybe Day
Version
Tool
lTool :: ListResult -> Tool
lVer :: ListResult -> Version
lCross :: ListResult -> Maybe Text
lTag :: ListResult -> [Tag]
lInstalled :: ListResult -> Bool
lSet :: ListResult -> Bool
lStray :: ListResult -> Bool
lNoBindist :: ListResult -> Bool
hlsPowered :: ListResult -> Bool
lReleaseDay :: ListResult -> Maybe Day
lTool :: Tool
lVer :: Version
lCross :: Maybe Text
lTag :: [Tag]
lInstalled :: Bool
lSet :: Bool
lStray :: Bool
lNoBindist :: Bool
hlsPowered :: Bool
lReleaseDay :: Maybe Day
..} = case ListCriteria
lc of
    ListInstalled  Bool
b -> Bool -> Bool -> Bool
f Bool
b Bool
lInstalled
    ListSet        Bool
b -> Bool -> Bool -> Bool
f Bool
b Bool
lSet
    ListAvailable  Bool
b -> Bool -> Bool -> Bool
f Bool
b (Bool -> Bool) -> Bool -> Bool
forall (a :: OpticKind) b. (a -> b) -> a -> b
$ Bool -> Bool
not Bool
lNoBindist
   where
    f :: Bool -> Bool -> Bool
f Bool
b
      | Bool
b         = Bool -> Bool
forall (a :: OpticKind). a -> a
id
      | Bool
otherwise = Bool -> Bool
not

  filterOld :: [ListResult] -> [ListResult]
  filterOld :: [ListResult] -> [ListResult]
filterOld [ListResult]
lr
    | Bool
hideOld   = (ListResult -> Bool) -> [ListResult] -> [ListResult]
forall (a :: OpticKind). (a -> Bool) -> [a] -> [a]
filter (\ListResult {Bool
[Tag]
Maybe Text
Maybe Day
Version
Tool
lTool :: ListResult -> Tool
lVer :: ListResult -> Version
lCross :: ListResult -> Maybe Text
lTag :: ListResult -> [Tag]
lInstalled :: ListResult -> Bool
lSet :: ListResult -> Bool
lStray :: ListResult -> Bool
lNoBindist :: ListResult -> Bool
hlsPowered :: ListResult -> Bool
lReleaseDay :: ListResult -> Maybe Day
lTool :: Tool
lVer :: Version
lCross :: Maybe Text
lTag :: [Tag]
lInstalled :: Bool
lSet :: Bool
lStray :: Bool
lNoBindist :: Bool
hlsPowered :: Bool
lReleaseDay :: Maybe Day
..} -> Bool
lInstalled Bool -> Bool -> Bool
|| Tag
Old Tag -> [Tag] -> Bool
forall (t :: OpticKind -> OpticKind) (a :: OpticKind).
(Foldable t, Eq a) =>
a -> t a -> Bool
`notElem` [Tag]
lTag) [ListResult]
lr
    | Bool
otherwise = [ListResult]
lr

  filterNightly :: [ListResult] -> [ListResult]
  filterNightly :: [ListResult] -> [ListResult]
filterNightly [ListResult]
lr
    | Bool
showNightly = [ListResult]
lr
    | Bool
otherwise   = (ListResult -> Bool) -> [ListResult] -> [ListResult]
forall (a :: OpticKind). (a -> Bool) -> [a] -> [a]
filter (\ListResult {Bool
[Tag]
Maybe Text
Maybe Day
Version
Tool
lTool :: ListResult -> Tool
lVer :: ListResult -> Version
lCross :: ListResult -> Maybe Text
lTag :: ListResult -> [Tag]
lInstalled :: ListResult -> Bool
lSet :: ListResult -> Bool
lStray :: ListResult -> Bool
lNoBindist :: ListResult -> Bool
hlsPowered :: ListResult -> Bool
lReleaseDay :: ListResult -> Maybe Day
lTool :: Tool
lVer :: Version
lCross :: Maybe Text
lTag :: [Tag]
lInstalled :: Bool
lSet :: Bool
lStray :: Bool
lNoBindist :: Bool
hlsPowered :: Bool
lReleaseDay :: Maybe Day
..} -> Bool
lInstalled Bool -> Bool -> Bool
|| (Tag
Nightly Tag -> [Tag] -> Bool
forall (t :: OpticKind -> OpticKind) (a :: OpticKind).
(Foldable t, Eq a) =>
a -> t a -> Bool
`notElem` [Tag]
lTag Bool -> Bool -> Bool
&& Tag
LatestNightly Tag -> [Tag] -> Bool
forall (t :: OpticKind -> OpticKind) (a :: OpticKind).
(Foldable t, Eq a) =>
a -> t a -> Bool
`notElem` [Tag]
lTag)) [ListResult]
lr