{-# 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.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
                  | ListSet
                  | ListAvailable
                  deriving Int -> ListCriteria -> ShowS
[ListCriteria] -> ShowS
ListCriteria -> String
(Int -> ListCriteria -> ShowS)
-> (ListCriteria -> String)
-> ([ListCriteria] -> ShowS)
-> Show ListCriteria
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListCriteria] -> ShowS
$cshowList :: [ListCriteria] -> ShowS
show :: ListCriteria -> String
$cshow :: ListCriteria -> String
showsPrec :: Int -> ListCriteria -> ShowS
$cshowsPrec :: Int -> 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
fromSrc    :: Bool -- ^ compiled from source
  , 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
  }
  deriving (ListResult -> ListResult -> Bool
(ListResult -> ListResult -> Bool)
-> (ListResult -> ListResult -> Bool) -> Eq ListResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListResult -> ListResult -> Bool
$c/= :: ListResult -> ListResult -> Bool
== :: ListResult -> ListResult -> Bool
$c== :: 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.
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
min :: ListResult -> ListResult -> ListResult
$cmin :: ListResult -> ListResult -> ListResult
max :: ListResult -> ListResult -> ListResult
$cmax :: ListResult -> ListResult -> ListResult
>= :: ListResult -> ListResult -> Bool
$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
compare :: ListResult -> ListResult -> Ordering
$ccompare :: ListResult -> ListResult -> Ordering
$cp1Ord :: Eq ListResult
Ord, Int -> ListResult -> ShowS
[ListResult] -> ShowS
ListResult -> String
(Int -> ListResult -> ShowS)
-> (ListResult -> String)
-> ([ListResult] -> ShowS)
-> Show ListResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListResult] -> ShowS
$cshowList :: [ListResult] -> ShowS
show :: ListResult -> String
$cshow :: ListResult -> String
showsPrec :: Int -> ListResult -> ShowS
$cshowsPrec :: Int -> ListResult -> ShowS
Show)


-- | Extract all available tool versions and their tags.
availableToolVersions :: GHCupDownloads -> Tool -> Map.Map Version VersionInfo
availableToolVersions :: GHCupDownloads -> Tool -> Map Version VersionInfo
availableToolVersions GHCupDownloads
av Tool
tool = Optic' A_Lens '[] GHCupDownloads (Map Version VersionInfo)
-> GHCupDownloads -> Map Version VersionInfo
forall k (is :: IxList) s a.
Is k A_Getter =>
Optic' k is s a -> s -> a
view
  (Index GHCupDownloads
-> Lens' GHCupDownloads (Maybe (IxValue GHCupDownloads))
forall m. At m => Index m -> Lens' m (Maybe (IxValue m))
at Index GHCupDownloads
Tool
tool Optic
  A_Lens
  '[]
  GHCupDownloads
  GHCupDownloads
  (Maybe (Map Version VersionInfo))
  (Maybe (Map Version VersionInfo))
-> Optic
     An_Iso
     '[]
     (Maybe (Map Version VersionInfo))
     (Maybe (Map Version VersionInfo))
     (Map Version VersionInfo)
     (Map Version VersionInfo)
-> Optic' A_Lens '[] GHCupDownloads (Map Version VersionInfo)
forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
       b.
(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 Version VersionInfo
-> Optic
     An_Iso
     '[]
     (Maybe (Map Version VersionInfo))
     (Maybe (Map Version VersionInfo))
     (Map Version VersionInfo)
     (Map Version VersionInfo)
forall a. Eq a => a -> Iso' (Maybe a) a
non Map Version VersionInfo
forall k a. 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
             -> Maybe ListCriteria
             -> m [ListResult]
listVersions :: Maybe Tool -> Maybe ListCriteria -> m [ListResult]
listVersions Maybe Tool
lt' Maybe ListCriteria
criteria = do
  -- some annoying work to avoid too much repeated IO
  Maybe Version
cSet <- m (Maybe Version)
forall env (m :: * -> *).
(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 (m :: * -> *).
(MonadReader env m, HasDirs env, MonadIO m, MonadCatch m) =>
m [Either String Version]
getInstalledCabals
  Maybe Version
hlsSet' <- m (Maybe Version)
forall env (m :: * -> *).
(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 (m :: * -> *).
(MonadReader env m, HasDirs env, MonadIO m, MonadCatch m) =>
m [Either String Version]
getInstalledHLSs
  Maybe Version
sSet <- m (Maybe Version)
forall env (m :: * -> *).
(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 (m :: * -> *).
(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 env (m :: * -> *).
(MonadReader env m, MonadIO m, MonadCatch m,
 LabelOptic "dirs" A_Lens env env Dirs Dirs,
 LabelOptic "ghcupInfo" A_Lens env env GHCupInfo GHCupInfo,
 LabelOptic "loggerConfig" A_Lens env env LoggerConfig LoggerConfig,
 LabelOptic
   "pfreq" A_Lens env env PlatformRequest PlatformRequest) =>
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 (m :: * -> *).
(MonadReader env m,
 LabelOptic' "ghcupInfo" A_Lens env GHCupInfo) =>
m GHCupInfo
getGHCupInfo
        -- get versions from GHCupDownloads
        let avTools :: Map Version VersionInfo
avTools = GHCupDownloads -> Tool -> Map Version VersionInfo
availableToolVersions GHCupDownloads
dls Tool
t
        [ListResult]
lr <- [ListResult] -> [ListResult]
filter' ([ListResult] -> [ListResult]) -> m [ListResult] -> m [ListResult]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Version, VersionInfo)]
-> ((Version, VersionInfo) -> m ListResult) -> m [ListResult]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
t a -> (a -> m b) -> m (t b)
forM (Map Version VersionInfo -> [(Version, VersionInfo)]
forall k a. Map k a -> [(k, a)]
Map.toList Map Version VersionInfo
avTools) (Tool
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> (Version, VersionInfo)
-> m ListResult
forall env (m :: * -> *).
(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]
-> (Version, 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 Version VersionInfo -> m [ListResult]
forall (m :: * -> *) env.
(MonadCatch m, MonadReader env m, HasDirs env, MonadThrow m,
 HasLog env, MonadIO m) =>
Map Version VersionInfo -> m [ListResult]
strayGHCs Map Version VersionInfo
avTools
            [ListResult] -> m [ListResult]
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([ListResult] -> [ListResult]
forall a. Ord a => [a] -> [a]
sort ([ListResult]
slr [ListResult] -> [ListResult] -> [ListResult]
forall a. [a] -> [a] -> [a]
++ [ListResult]
lr))
          Tool
Cabal -> do
            [ListResult]
slr <- Map Version VersionInfo
-> Maybe Version -> [Either String Version] -> m [ListResult]
forall env (m :: * -> *).
(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
            [ListResult] -> m [ListResult]
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([ListResult] -> [ListResult]
forall a. Ord a => [a] -> [a]
sort ([ListResult]
slr [ListResult] -> [ListResult] -> [ListResult]
forall a. [a] -> [a] -> [a]
++ [ListResult]
lr))
          Tool
HLS -> do
            [ListResult]
slr <- Map Version VersionInfo
-> Maybe Version -> [Either String Version] -> m [ListResult]
forall env (m :: * -> *).
(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]
hlses
            [ListResult] -> m [ListResult]
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([ListResult] -> [ListResult]
forall a. Ord a => [a] -> [a]
sort ([ListResult]
slr [ListResult] -> [ListResult] -> [ListResult]
forall a. [a] -> [a] -> [a]
++ [ListResult]
lr))
          Tool
Stack -> do
            [ListResult]
slr <- Map Version VersionInfo
-> Maybe Version -> [Either String Version] -> m [ListResult]
forall env (m :: * -> *).
(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
sSet [Either String Version]
stacks
            [ListResult] -> m [ListResult]
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([ListResult] -> [ListResult]
forall a. Ord a => [a] -> [a]
sort ([ListResult]
slr [ListResult] -> [ListResult] -> [ListResult]
forall a. [a] -> [a] -> [a]
++ [ListResult]
lr))
          Tool
GHCup -> do
            let cg :: [ListResult]
cg = Maybe ListResult -> [ListResult]
forall a. Maybe a -> [a]
maybeToList (Maybe ListResult -> [ListResult])
-> Maybe ListResult -> [ListResult]
forall a b. (a -> b) -> a -> b
$ Map Version VersionInfo -> Maybe ListResult
currentGHCup Map Version VersionInfo
avTools
            [ListResult] -> m [ListResult]
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([ListResult] -> [ListResult]
forall a. Ord a => [a] -> [a]
sort ([ListResult]
cg [ListResult] -> [ListResult] -> [ListResult]
forall a. [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. 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. 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. 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. 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. 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 (f :: * -> *) a. Applicative f => a -> f a
pure ([ListResult]
ghcvers [ListResult] -> [ListResult] -> [ListResult]
forall a. Semigroup a => a -> a -> a
<> [ListResult]
cabalvers [ListResult] -> [ListResult] -> [ListResult]
forall a. Semigroup a => a -> a -> a
<> [ListResult]
hlsvers [ListResult] -> [ListResult] -> [ListResult]
forall a. Semigroup a => a -> a -> a
<> [ListResult]
stackvers [ListResult] -> [ListResult] -> [ListResult]
forall a. Semigroup a => a -> a -> a
<> [ListResult]
ghcupvers)
  strayGHCs :: ( MonadCatch m
               , MonadReader env m
               , HasDirs env
               , MonadThrow m
               , HasLog env
               , MonadIO m
               )
            => Map.Map Version VersionInfo
            -> m [ListResult]
  strayGHCs :: Map Version VersionInfo -> m [ListResult]
strayGHCs Map Version VersionInfo
avTools = do
    [Either String GHCTargetVersion]
ghcs <- m [Either String GHCTargetVersion]
forall env (m :: * -> *).
(MonadReader env m, HasDirs env, MonadIO m) =>
m [Either String GHCTargetVersion]
getInstalledGHCs
    ([Maybe ListResult] -> [ListResult])
-> m [Maybe ListResult] -> m [ListResult]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Maybe ListResult] -> [ListResult]
forall a. [Maybe a] -> [a]
catMaybes (m [Maybe ListResult] -> m [ListResult])
-> m [Maybe ListResult] -> m [ListResult]
forall a b. (a -> b) -> a -> b
$ [Either String GHCTargetVersion]
-> (Either String GHCTargetVersion -> m (Maybe ListResult))
-> m [Maybe ListResult]
forall (t :: * -> *) (m :: * -> *) a b.
(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 b. (a -> b) -> a -> b
$ \case
      Right tver :: GHCTargetVersion
tver@GHCTargetVersion{ $sel:_tvTarget:GHCTargetVersion :: GHCTargetVersion -> Maybe Text
_tvTarget = Maybe Text
Nothing, Version
$sel:_tvVersion:GHCTargetVersion :: GHCTargetVersion -> Version
_tvVersion :: Version
.. } -> do
        case Version -> Map Version VersionInfo -> Maybe VersionInfo
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Version
_tvVersion Map Version VersionInfo
avTools of
          Just VersionInfo
_  -> Maybe ListResult -> m (Maybe ListResult)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ListResult
forall a. Maybe a
Nothing
          Maybe VersionInfo
Nothing -> do
            Bool
lSet    <- (Maybe GHCTargetVersion -> Bool)
-> m (Maybe GHCTargetVersion) -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Bool
-> (GHCTargetVersion -> Bool) -> Maybe GHCTargetVersion -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False (\(GHCTargetVersion Maybe Text
_ Version
v ) -> Version
v Version -> Version -> Bool
forall a. Eq a => a -> a -> Bool
== Version
_tvVersion)) (m (Maybe GHCTargetVersion) -> m Bool)
-> m (Maybe GHCTargetVersion) -> m Bool
forall a b. (a -> b) -> a -> b
$ Maybe Text -> m (Maybe GHCTargetVersion)
forall env (m :: * -> *).
(MonadReader env m, HasDirs env, MonadThrow m, MonadIO m) =>
Maybe Text -> m (Maybe GHCTargetVersion)
ghcSet Maybe Text
forall a. Maybe a
Nothing
            Bool
fromSrc <- GHCTargetVersion -> m Bool
forall (m :: * -> *) env.
(MonadIO m, MonadReader env m, HasDirs env, MonadThrow m) =>
GHCTargetVersion -> m Bool
ghcSrcInstalled GHCTargetVersion
tver
            Bool
hlsPowered <- ([Version] -> Bool) -> m [Version] -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Version -> [Version] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem Version
_tvVersion) m [Version]
forall env (m :: * -> *).
(MonadReader env m, HasDirs env, MonadIO m, MonadThrow m,
 MonadCatch m) =>
m [Version]
hlsGHCVersions
            Maybe ListResult -> m (Maybe ListResult)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe ListResult -> m (Maybe ListResult))
-> Maybe ListResult -> m (Maybe ListResult)
forall a b. (a -> b) -> a -> b
$ ListResult -> Maybe ListResult
forall a. a -> Maybe a
Just (ListResult -> Maybe ListResult) -> ListResult -> Maybe ListResult
forall a b. (a -> b) -> a -> b
$ ListResult :: Tool
-> Version
-> Maybe Text
-> [Tag]
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> ListResult
ListResult
              { lTool :: Tool
lTool      = Tool
GHC
              , lVer :: Version
lVer       = Version
_tvVersion
              , lCross :: Maybe Text
lCross     = Maybe Text
forall a. Maybe a
Nothing
              , lTag :: [Tag]
lTag       = []
              , lInstalled :: Bool
lInstalled = Bool
True
             , lStray :: Bool
lStray     = Maybe VersionInfo -> Bool
forall a. Maybe a -> Bool
isNothing (Version -> Map Version VersionInfo -> Maybe VersionInfo
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Version
_tvVersion Map Version VersionInfo
avTools)
              , lNoBindist :: Bool
lNoBindist = Bool
False
              , Bool
hlsPowered :: Bool
fromSrc :: Bool
lSet :: Bool
hlsPowered :: Bool
fromSrc :: Bool
lSet :: Bool
..
              }
      Right tver :: GHCTargetVersion
tver@GHCTargetVersion{ Maybe Text
Version
_tvVersion :: Version
_tvTarget :: Maybe Text
$sel:_tvVersion:GHCTargetVersion :: GHCTargetVersion -> Version
$sel:_tvTarget:GHCTargetVersion :: GHCTargetVersion -> Maybe Text
.. } -> do
        Bool
lSet    <- (Maybe GHCTargetVersion -> Bool)
-> m (Maybe GHCTargetVersion) -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Bool
-> (GHCTargetVersion -> Bool) -> Maybe GHCTargetVersion -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False (\(GHCTargetVersion Maybe Text
_ Version
v ) -> Version
v Version -> Version -> Bool
forall a. Eq a => a -> a -> Bool
== Version
_tvVersion)) (m (Maybe GHCTargetVersion) -> m Bool)
-> m (Maybe GHCTargetVersion) -> m Bool
forall a b. (a -> b) -> a -> b
$ Maybe Text -> m (Maybe GHCTargetVersion)
forall env (m :: * -> *).
(MonadReader env m, HasDirs env, MonadThrow m, MonadIO m) =>
Maybe Text -> m (Maybe GHCTargetVersion)
ghcSet Maybe Text
_tvTarget
        Bool
fromSrc <- GHCTargetVersion -> m Bool
forall (m :: * -> *) env.
(MonadIO m, MonadReader env m, HasDirs env, MonadThrow m) =>
GHCTargetVersion -> m Bool
ghcSrcInstalled GHCTargetVersion
tver
        Bool
hlsPowered <- ([Version] -> Bool) -> m [Version] -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Version -> [Version] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem Version
_tvVersion) m [Version]
forall env (m :: * -> *).
(MonadReader env m, HasDirs env, MonadIO m, MonadThrow m,
 MonadCatch m) =>
m [Version]
hlsGHCVersions
        Maybe ListResult -> m (Maybe ListResult)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe ListResult -> m (Maybe ListResult))
-> Maybe ListResult -> m (Maybe ListResult)
forall a b. (a -> b) -> a -> b
$ ListResult -> Maybe ListResult
forall a. a -> Maybe a
Just (ListResult -> Maybe ListResult) -> ListResult -> Maybe ListResult
forall a b. (a -> b) -> a -> b
$ ListResult :: Tool
-> Version
-> Maybe Text
-> [Tag]
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> ListResult
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     = Bool
True -- NOTE: cross currently cannot be installed via bindist
          , lNoBindist :: Bool
lNoBindist = Bool
False
          , Bool
hlsPowered :: Bool
fromSrc :: Bool
lSet :: Bool
hlsPowered :: Bool
fromSrc :: Bool
lSet :: Bool
..
          }
      Left String
e -> do
        Text -> m ()
forall env (m :: * -> *).
(MonadReader env m,
 LabelOptic' "loggerConfig" A_Lens env LoggerConfig, MonadIO m) =>
Text -> m ()
logWarn
          (Text -> m ()) -> Text -> m ()
forall a b. (a -> b) -> a -> b
$ Text
"Could not parse version of stray directory" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> String -> Text
T.pack String
e
        Maybe ListResult -> m (Maybe ListResult)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ListResult
forall a. 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 :: 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 (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Maybe ListResult] -> [ListResult]
forall a. [Maybe a] -> [a]
catMaybes (m [Maybe ListResult] -> m [ListResult])
-> m [Maybe ListResult] -> m [ListResult]
forall a b. (a -> b) -> a -> b
$ [Either String Version]
-> (Either String Version -> m (Maybe ListResult))
-> m [Maybe ListResult]
forall (t :: * -> *) (m :: * -> *) a b.
(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 b. (a -> b) -> a -> b
$ \case
      Right Version
ver ->
        case Version -> Map Version VersionInfo -> Maybe VersionInfo
forall k a. 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 (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ListResult
forall a. Maybe a
Nothing
          Maybe VersionInfo
Nothing -> do
            let lSet :: Bool
lSet = Maybe Version
cSet Maybe Version -> Maybe Version -> Bool
forall a. Eq a => a -> a -> Bool
== Version -> Maybe Version
forall a. a -> Maybe a
Just Version
ver
            Maybe ListResult -> m (Maybe ListResult)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe ListResult -> m (Maybe ListResult))
-> Maybe ListResult -> m (Maybe ListResult)
forall a b. (a -> b) -> a -> b
$ ListResult -> Maybe ListResult
forall a. a -> Maybe a
Just (ListResult -> Maybe ListResult) -> ListResult -> Maybe ListResult
forall a b. (a -> b) -> a -> b
$ ListResult :: Tool
-> Version
-> Maybe Text
-> [Tag]
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> ListResult
ListResult
              { lTool :: Tool
lTool      = Tool
Cabal
              , lVer :: Version
lVer       = Version
ver
              , lCross :: Maybe Text
lCross     = Maybe Text
forall a. Maybe a
Nothing
              , lTag :: [Tag]
lTag       = []
              , lInstalled :: Bool
lInstalled = Bool
True
              , lStray :: Bool
lStray     = Maybe VersionInfo -> Bool
forall a. Maybe a -> Bool
isNothing (Version -> Map Version VersionInfo -> Maybe VersionInfo
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Version
ver Map Version VersionInfo
avTools)
              , lNoBindist :: Bool
lNoBindist = Bool
False
              , fromSrc :: Bool
fromSrc    = Bool
False -- actually, we don't know :>
              , hlsPowered :: Bool
hlsPowered = Bool
False
              , Bool
lSet :: Bool
lSet :: Bool
..
              }
      Left String
e -> do
        Text -> m ()
forall env (m :: * -> *).
(MonadReader env m,
 LabelOptic' "loggerConfig" A_Lens env LoggerConfig, MonadIO m) =>
Text -> m ()
logWarn
          (Text -> m ()) -> Text -> m ()
forall a b. (a -> b) -> a -> b
$ Text
"Could not parse version of stray directory" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> String -> Text
T.pack String
e
        Maybe ListResult -> m (Maybe ListResult)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ListResult
forall a. 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 :: 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 (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Maybe ListResult] -> [ListResult]
forall a. [Maybe a] -> [a]
catMaybes (m [Maybe ListResult] -> m [ListResult])
-> m [Maybe ListResult] -> m [ListResult]
forall a b. (a -> b) -> a -> b
$ [Either String Version]
-> (Either String Version -> m (Maybe ListResult))
-> m [Maybe ListResult]
forall (t :: * -> *) (m :: * -> *) a b.
(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 b. (a -> b) -> a -> b
$ \case
      Right Version
ver ->
        case Version -> Map Version VersionInfo -> Maybe VersionInfo
forall k a. 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 (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ListResult
forall a. Maybe a
Nothing
          Maybe VersionInfo
Nothing -> do
            let lSet :: Bool
lSet = Maybe Version
hlsSet' Maybe Version -> Maybe Version -> Bool
forall a. Eq a => a -> a -> Bool
== Version -> Maybe Version
forall a. a -> Maybe a
Just Version
ver
            Maybe ListResult -> m (Maybe ListResult)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe ListResult -> m (Maybe ListResult))
-> Maybe ListResult -> m (Maybe ListResult)
forall a b. (a -> b) -> a -> b
$ ListResult -> Maybe ListResult
forall a. a -> Maybe a
Just (ListResult -> Maybe ListResult) -> ListResult -> Maybe ListResult
forall a b. (a -> b) -> a -> b
$ ListResult :: Tool
-> Version
-> Maybe Text
-> [Tag]
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> ListResult
ListResult
              { lTool :: Tool
lTool      = Tool
HLS
              , lVer :: Version
lVer       = Version
ver
              , lCross :: Maybe Text
lCross     = Maybe Text
forall a. Maybe a
Nothing
              , lTag :: [Tag]
lTag       = []
              , lInstalled :: Bool
lInstalled = Bool
True
              , lStray :: Bool
lStray     = Maybe VersionInfo -> Bool
forall a. Maybe a -> Bool
isNothing (Version -> Map Version VersionInfo -> Maybe VersionInfo
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Version
ver Map Version VersionInfo
avTools)
              , lNoBindist :: Bool
lNoBindist = Bool
False
              , fromSrc :: Bool
fromSrc    = Bool
False -- actually, we don't know :>
              , hlsPowered :: Bool
hlsPowered = Bool
False
              , Bool
lSet :: Bool
lSet :: Bool
..
              }
      Left String
e -> do
        Text -> m ()
forall env (m :: * -> *).
(MonadReader env m,
 LabelOptic' "loggerConfig" A_Lens env LoggerConfig, MonadIO m) =>
Text -> m ()
logWarn
          (Text -> m ()) -> Text -> m ()
forall a b. (a -> b) -> a -> b
$ Text
"Could not parse version of stray directory" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> String -> Text
T.pack String
e
        Maybe ListResult -> m (Maybe ListResult)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ListResult
forall a. 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 :: 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 (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Maybe ListResult] -> [ListResult]
forall a. [Maybe a] -> [a]
catMaybes (m [Maybe ListResult] -> m [ListResult])
-> m [Maybe ListResult] -> m [ListResult]
forall a b. (a -> b) -> a -> b
$ [Either String Version]
-> (Either String Version -> m (Maybe ListResult))
-> m [Maybe ListResult]
forall (t :: * -> *) (m :: * -> *) a b.
(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 b. (a -> b) -> a -> b
$ \case
      Right Version
ver ->
        case Version -> Map Version VersionInfo -> Maybe VersionInfo
forall k a. 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 (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ListResult
forall a. Maybe a
Nothing
          Maybe VersionInfo
Nothing -> do
            let lSet :: Bool
lSet = Maybe Version
stackSet' Maybe Version -> Maybe Version -> Bool
forall a. Eq a => a -> a -> Bool
== Version -> Maybe Version
forall a. a -> Maybe a
Just Version
ver
            Maybe ListResult -> m (Maybe ListResult)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe ListResult -> m (Maybe ListResult))
-> Maybe ListResult -> m (Maybe ListResult)
forall a b. (a -> b) -> a -> b
$ ListResult -> Maybe ListResult
forall a. a -> Maybe a
Just (ListResult -> Maybe ListResult) -> ListResult -> Maybe ListResult
forall a b. (a -> b) -> a -> b
$ ListResult :: Tool
-> Version
-> Maybe Text
-> [Tag]
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> ListResult
ListResult
              { lTool :: Tool
lTool      = Tool
Stack
              , lVer :: Version
lVer       = Version
ver
              , lCross :: Maybe Text
lCross     = Maybe Text
forall a. Maybe a
Nothing
              , lTag :: [Tag]
lTag       = []
              , lInstalled :: Bool
lInstalled = Bool
True
              , lStray :: Bool
lStray     = Maybe VersionInfo -> Bool
forall a. Maybe a -> Bool
isNothing (Version -> Map Version VersionInfo -> Maybe VersionInfo
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Version
ver Map Version VersionInfo
avTools)
              , lNoBindist :: Bool
lNoBindist = Bool
False
              , fromSrc :: Bool
fromSrc    = Bool
False -- actually, we don't know :>
              , hlsPowered :: Bool
hlsPowered = Bool
False
              , Bool
lSet :: Bool
lSet :: Bool
..
              }
      Left String
e -> do
        Text -> m ()
forall env (m :: * -> *).
(MonadReader env m,
 LabelOptic' "loggerConfig" A_Lens env LoggerConfig, MonadIO m) =>
Text -> m ()
logWarn
          (Text -> m ()) -> Text -> m ()
forall a b. (a -> b) -> a -> b
$ Text
"Could not parse version of stray directory" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> String -> Text
T.pack String
e
        Maybe ListResult -> m (Maybe ListResult)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe ListResult
forall a. Maybe a
Nothing

  currentGHCup :: Map.Map Version VersionInfo -> Maybe ListResult
  currentGHCup :: Map Version VersionInfo -> Maybe ListResult
currentGHCup Map Version VersionInfo
av =
    let currentVer :: Version
currentVer = Maybe Version -> Version
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Version -> Version) -> Maybe Version -> Version
forall a b. (a -> b) -> a -> b
$ PVP -> Text -> Maybe Version
forall (m :: * -> *). MonadThrow m => PVP -> Text -> m Version
pvpToVersion PVP
ghcUpVer Text
""
        listVer :: Maybe VersionInfo
listVer    = Version -> Map Version VersionInfo -> Maybe VersionInfo
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Version
currentVer Map Version VersionInfo
av
        latestVer :: Maybe Version
latestVer  = (Version, VersionInfo) -> Version
forall a b. (a, b) -> a
fst ((Version, VersionInfo) -> Version)
-> Maybe (Version, VersionInfo) -> Maybe Version
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Optic' A_Fold '[] (Map Version VersionInfo) (Version, VersionInfo)
-> Map Version VersionInfo -> Maybe (Version, VersionInfo)
forall k (is :: IxList) s a.
Is k A_Fold =>
Optic' k is s a -> s -> Maybe a
headOf (Tag
-> Optic'
     A_Fold '[] (Map Version VersionInfo) (Version, VersionInfo)
getTagged Tag
Latest) Map Version VersionInfo
av
        recommendedVer :: Maybe Version
recommendedVer = (Version, VersionInfo) -> Version
forall a b. (a, b) -> a
fst ((Version, VersionInfo) -> Version)
-> Maybe (Version, VersionInfo) -> Maybe Version
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Optic' A_Fold '[] (Map Version VersionInfo) (Version, VersionInfo)
-> Map Version VersionInfo -> Maybe (Version, VersionInfo)
forall k (is :: IxList) s a.
Is k A_Fold =>
Optic' k is s a -> s -> Maybe a
headOf (Tag
-> Optic'
     A_Fold '[] (Map Version VersionInfo) (Version, VersionInfo)
getTagged Tag
Latest) Map Version VersionInfo
av
        isOld :: Bool
isOld  = Bool -> (Version -> Bool) -> Maybe Version -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
True (Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
> Version
currentVer) Maybe Version
latestVer Bool -> Bool -> Bool
&& Bool -> (Version -> Bool) -> Maybe Version -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
True (Version -> Version -> Bool
forall a. Ord a => a -> a -> Bool
> Version
currentVer) Maybe Version
recommendedVer
    in if | Version -> Map Version VersionInfo -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Map.member Version
currentVer Map Version VersionInfo
av -> Maybe ListResult
forall a. Maybe a
Nothing
          | Bool
otherwise -> ListResult -> Maybe ListResult
forall a. a -> Maybe a
Just (ListResult -> Maybe ListResult) -> ListResult -> Maybe ListResult
forall a b. (a -> b) -> a -> b
$ ListResult :: Tool
-> Version
-> Maybe Text
-> [Tag]
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> ListResult
ListResult { lVer :: Version
lVer    = Version
currentVer
                                           , lTag :: [Tag]
lTag    = [Tag] -> (VersionInfo -> [Tag]) -> Maybe VersionInfo -> [Tag]
forall b a. 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. Maybe a
Nothing
                                           , lTool :: Tool
lTool   = Tool
GHCup
                                           , fromSrc :: Bool
fromSrc = Bool
False
                                           , lStray :: Bool
lStray  = Maybe VersionInfo -> Bool
forall a. 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
                                           }

  -- 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]
               -> (Version, VersionInfo)
               -> m ListResult
  toListResult :: Tool
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> Maybe Version
-> [Either String Version]
-> (Version, 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 (Version
v, VersionInfo -> [Tag]
_viTags -> [Tag]
tags) = do
    case Tool
t of
      Tool
GHC -> do
        Bool
lNoBindist <- (VEither '[NoDownload] DownloadInfo -> Bool)
-> m (VEither '[NoDownload] DownloadInfo) -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Either (V '[NoDownload]) DownloadInfo -> Bool
forall a b. Either a b -> Bool
isLeft (Either (V '[NoDownload]) DownloadInfo -> Bool)
-> (VEither '[NoDownload] DownloadInfo
    -> Either (V '[NoDownload]) DownloadInfo)
-> VEither '[NoDownload] DownloadInfo
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VEither '[NoDownload] DownloadInfo
-> Either (V '[NoDownload]) DownloadInfo
forall (es :: IxList) a. VEither es a -> Either (V es) a
veitherToEither) (m (VEither '[NoDownload] DownloadInfo) -> m Bool)
-> m (VEither '[NoDownload] DownloadInfo) -> m Bool
forall a b. (a -> b) -> a -> b
$ forall (es :: IxList) a (m :: * -> *).
Excepts es m a -> m (VEither es a)
forall a (m :: * -> *).
Excepts '[NoDownload] m a -> m (VEither '[NoDownload] a)
runE @'[NoDownload] (Excepts '[NoDownload] m DownloadInfo
 -> m (VEither '[NoDownload] DownloadInfo))
-> Excepts '[NoDownload] m DownloadInfo
-> m (VEither '[NoDownload] DownloadInfo)
forall a b. (a -> b) -> a -> b
$ Tool -> Version -> Excepts '[NoDownload] m DownloadInfo
forall env (m :: * -> *).
(MonadReader env m, HasPlatformReq env, HasGHCupInfo env) =>
Tool -> Version -> Excepts '[NoDownload] m DownloadInfo
getDownloadInfo Tool
GHC Version
v
        let tver :: GHCTargetVersion
tver = Version -> GHCTargetVersion
mkTVer Version
v
        Bool
lSet       <- (Maybe GHCTargetVersion -> Bool)
-> m (Maybe GHCTargetVersion) -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Bool
-> (GHCTargetVersion -> Bool) -> Maybe GHCTargetVersion -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False (\(GHCTargetVersion Maybe Text
_ Version
v') -> Version
v' Version -> Version -> Bool
forall a. Eq a => a -> a -> Bool
== Version
v)) (m (Maybe GHCTargetVersion) -> m Bool)
-> m (Maybe GHCTargetVersion) -> m Bool
forall a b. (a -> b) -> a -> b
$ Maybe Text -> m (Maybe GHCTargetVersion)
forall env (m :: * -> *).
(MonadReader env m, HasDirs env, MonadThrow m, MonadIO m) =>
Maybe Text -> m (Maybe GHCTargetVersion)
ghcSet Maybe Text
forall a. Maybe a
Nothing
        Bool
lInstalled <- GHCTargetVersion -> m Bool
forall (m :: * -> *) env.
(MonadIO m, MonadReader env m, HasDirs env, MonadThrow m) =>
GHCTargetVersion -> m Bool
ghcInstalled GHCTargetVersion
tver
        Bool
fromSrc    <- GHCTargetVersion -> m Bool
forall (m :: * -> *) env.
(MonadIO m, MonadReader env m, HasDirs env, MonadThrow m) =>
GHCTargetVersion -> m Bool
ghcSrcInstalled GHCTargetVersion
tver
        Bool
hlsPowered <- ([Version] -> Bool) -> m [Version] -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Version -> [Version] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem Version
v) m [Version]
forall env (m :: * -> *).
(MonadReader env m, HasDirs env, MonadIO m, MonadThrow m,
 MonadCatch m) =>
m [Version]
hlsGHCVersions
        ListResult -> m ListResult
forall (f :: * -> *) a. Applicative f => a -> f a
pure ListResult :: Tool
-> Version
-> Maybe Text
-> [Tag]
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> ListResult
ListResult { lVer :: Version
lVer = Version
v, lCross :: Maybe Text
lCross = Maybe Text
forall a. Maybe a
Nothing , lTag :: [Tag]
lTag = [Tag]
tags, lTool :: Tool
lTool = Tool
t, lStray :: Bool
lStray = Bool
False, Bool
hlsPowered :: Bool
fromSrc :: Bool
lInstalled :: Bool
lSet :: Bool
lNoBindist :: Bool
hlsPowered :: Bool
lNoBindist :: Bool
fromSrc :: Bool
lSet :: Bool
lInstalled :: Bool
.. }
      Tool
Cabal -> do
        Bool
lNoBindist <- (VEither '[NoDownload] DownloadInfo -> Bool)
-> m (VEither '[NoDownload] DownloadInfo) -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Either (V '[NoDownload]) DownloadInfo -> Bool
forall a b. Either a b -> Bool
isLeft (Either (V '[NoDownload]) DownloadInfo -> Bool)
-> (VEither '[NoDownload] DownloadInfo
    -> Either (V '[NoDownload]) DownloadInfo)
-> VEither '[NoDownload] DownloadInfo
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VEither '[NoDownload] DownloadInfo
-> Either (V '[NoDownload]) DownloadInfo
forall (es :: IxList) a. VEither es a -> Either (V es) a
veitherToEither) (m (VEither '[NoDownload] DownloadInfo) -> m Bool)
-> m (VEither '[NoDownload] DownloadInfo) -> m Bool
forall a b. (a -> b) -> a -> b
$ forall (es :: IxList) a (m :: * -> *).
Excepts es m a -> m (VEither es a)
forall a (m :: * -> *).
Excepts '[NoDownload] m a -> m (VEither '[NoDownload] a)
runE @'[NoDownload] (Excepts '[NoDownload] m DownloadInfo
 -> m (VEither '[NoDownload] DownloadInfo))
-> Excepts '[NoDownload] m DownloadInfo
-> m (VEither '[NoDownload] DownloadInfo)
forall a b. (a -> b) -> a -> b
$ Tool -> Version -> Excepts '[NoDownload] m DownloadInfo
forall env (m :: * -> *).
(MonadReader env m, HasPlatformReq env, HasGHCupInfo env) =>
Tool -> Version -> Excepts '[NoDownload] m DownloadInfo
getDownloadInfo Tool
Cabal Version
v
        let lSet :: Bool
lSet = Maybe Version
cSet Maybe Version -> Maybe Version -> Bool
forall a. Eq a => a -> a -> Bool
== Version -> Maybe Version
forall a. a -> Maybe a
Just Version
v
        let lInstalled :: Bool
lInstalled = Version -> [Version] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem Version
v ([Version] -> Bool) -> [Version] -> Bool
forall a b. (a -> b) -> a -> b
$ [Either String Version] -> [Version]
forall a b. [Either a b] -> [b]
rights [Either String Version]
cabals
        ListResult -> m ListResult
forall (f :: * -> *) a. Applicative f => a -> f a
pure ListResult :: Tool
-> Version
-> Maybe Text
-> [Tag]
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> ListResult
ListResult { lVer :: Version
lVer    = Version
v
                        , lCross :: Maybe Text
lCross  = Maybe Text
forall a. Maybe a
Nothing
                        , lTag :: [Tag]
lTag    = [Tag]
tags
                        , lTool :: Tool
lTool   = Tool
t
                        , fromSrc :: Bool
fromSrc = Bool
False
                        , lStray :: Bool
lStray  = Bool
False
                        , hlsPowered :: Bool
hlsPowered = Bool
False
                        , 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. Eq a => a -> a -> Bool
== Version -> Text
prettyVer Version
v
        let lInstalled :: Bool
lInstalled = Bool
lSet
        ListResult -> m ListResult
forall (f :: * -> *) a. Applicative f => a -> f a
pure ListResult :: Tool
-> Version
-> Maybe Text
-> [Tag]
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> ListResult
ListResult { lVer :: Version
lVer    = Version
v
                        , lTag :: [Tag]
lTag    = [Tag]
tags
                        , lCross :: Maybe Text
lCross  = Maybe Text
forall a. Maybe a
Nothing
                        , lTool :: Tool
lTool   = Tool
t
                        , fromSrc :: Bool
fromSrc = Bool
False
                        , lStray :: Bool
lStray  = Bool
False
                        , lNoBindist :: Bool
lNoBindist = Bool
False
                        , hlsPowered :: Bool
hlsPowered = Bool
False
                        , Bool
lInstalled :: Bool
lSet :: Bool
lSet :: Bool
lInstalled :: Bool
..
                        }
      Tool
HLS -> do
        Bool
lNoBindist <- (VEither '[NoDownload] DownloadInfo -> Bool)
-> m (VEither '[NoDownload] DownloadInfo) -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Either (V '[NoDownload]) DownloadInfo -> Bool
forall a b. Either a b -> Bool
isLeft (Either (V '[NoDownload]) DownloadInfo -> Bool)
-> (VEither '[NoDownload] DownloadInfo
    -> Either (V '[NoDownload]) DownloadInfo)
-> VEither '[NoDownload] DownloadInfo
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VEither '[NoDownload] DownloadInfo
-> Either (V '[NoDownload]) DownloadInfo
forall (es :: IxList) a. VEither es a -> Either (V es) a
veitherToEither) (m (VEither '[NoDownload] DownloadInfo) -> m Bool)
-> m (VEither '[NoDownload] DownloadInfo) -> m Bool
forall a b. (a -> b) -> a -> b
$ forall (es :: IxList) a (m :: * -> *).
Excepts es m a -> m (VEither es a)
forall a (m :: * -> *).
Excepts '[NoDownload] m a -> m (VEither '[NoDownload] a)
runE @'[NoDownload] (Excepts '[NoDownload] m DownloadInfo
 -> m (VEither '[NoDownload] DownloadInfo))
-> Excepts '[NoDownload] m DownloadInfo
-> m (VEither '[NoDownload] DownloadInfo)
forall a b. (a -> b) -> a -> b
$ Tool -> Version -> Excepts '[NoDownload] m DownloadInfo
forall env (m :: * -> *).
(MonadReader env m, HasPlatformReq env, HasGHCupInfo env) =>
Tool -> Version -> Excepts '[NoDownload] m DownloadInfo
getDownloadInfo Tool
HLS Version
v
        let lSet :: Bool
lSet = Maybe Version
hlsSet' Maybe Version -> Maybe Version -> Bool
forall a. Eq a => a -> a -> Bool
== Version -> Maybe Version
forall a. a -> Maybe a
Just Version
v
        let lInstalled :: Bool
lInstalled = Version -> [Version] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem Version
v ([Version] -> Bool) -> [Version] -> Bool
forall a b. (a -> b) -> a -> b
$ [Either String Version] -> [Version]
forall a b. [Either a b] -> [b]
rights [Either String Version]
hlses
        ListResult -> m ListResult
forall (f :: * -> *) a. Applicative f => a -> f a
pure ListResult :: Tool
-> Version
-> Maybe Text
-> [Tag]
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> ListResult
ListResult { lVer :: Version
lVer    = Version
v
                        , lCross :: Maybe Text
lCross  = Maybe Text
forall a. Maybe a
Nothing
                        , lTag :: [Tag]
lTag    = [Tag]
tags
                        , lTool :: Tool
lTool   = Tool
t
                        , fromSrc :: Bool
fromSrc = Bool
False
                        , lStray :: Bool
lStray  = Bool
False
                        , hlsPowered :: Bool
hlsPowered = Bool
False
                        , Bool
lInstalled :: Bool
lSet :: Bool
lNoBindist :: Bool
lNoBindist :: Bool
lSet :: Bool
lInstalled :: Bool
..
                        }
      Tool
Stack -> do
        Bool
lNoBindist <- (VEither '[NoDownload] DownloadInfo -> Bool)
-> m (VEither '[NoDownload] DownloadInfo) -> m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Either (V '[NoDownload]) DownloadInfo -> Bool
forall a b. Either a b -> Bool
isLeft (Either (V '[NoDownload]) DownloadInfo -> Bool)
-> (VEither '[NoDownload] DownloadInfo
    -> Either (V '[NoDownload]) DownloadInfo)
-> VEither '[NoDownload] DownloadInfo
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VEither '[NoDownload] DownloadInfo
-> Either (V '[NoDownload]) DownloadInfo
forall (es :: IxList) a. VEither es a -> Either (V es) a
veitherToEither) (m (VEither '[NoDownload] DownloadInfo) -> m Bool)
-> m (VEither '[NoDownload] DownloadInfo) -> m Bool
forall a b. (a -> b) -> a -> b
$ forall (es :: IxList) a (m :: * -> *).
Excepts es m a -> m (VEither es a)
forall a (m :: * -> *).
Excepts '[NoDownload] m a -> m (VEither '[NoDownload] a)
runE @'[NoDownload] (Excepts '[NoDownload] m DownloadInfo
 -> m (VEither '[NoDownload] DownloadInfo))
-> Excepts '[NoDownload] m DownloadInfo
-> m (VEither '[NoDownload] DownloadInfo)
forall a b. (a -> b) -> a -> b
$ Tool -> Version -> Excepts '[NoDownload] m DownloadInfo
forall env (m :: * -> *).
(MonadReader env m, HasPlatformReq env, HasGHCupInfo env) =>
Tool -> Version -> Excepts '[NoDownload] m DownloadInfo
getDownloadInfo Tool
Stack Version
v
        let lSet :: Bool
lSet = Maybe Version
stackSet' Maybe Version -> Maybe Version -> Bool
forall a. Eq a => a -> a -> Bool
== Version -> Maybe Version
forall a. a -> Maybe a
Just Version
v
        let lInstalled :: Bool
lInstalled = Version -> [Version] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem Version
v ([Version] -> Bool) -> [Version] -> Bool
forall a b. (a -> b) -> a -> b
$ [Either String Version] -> [Version]
forall a b. [Either a b] -> [b]
rights [Either String Version]
stacks
        ListResult -> m ListResult
forall (f :: * -> *) a. Applicative f => a -> f a
pure ListResult :: Tool
-> Version
-> Maybe Text
-> [Tag]
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> Bool
-> ListResult
ListResult { lVer :: Version
lVer    = Version
v
                        , lCross :: Maybe Text
lCross  = Maybe Text
forall a. Maybe a
Nothing
                        , lTag :: [Tag]
lTag    = [Tag]
tags
                        , lTool :: Tool
lTool   = Tool
t
                        , fromSrc :: Bool
fromSrc = Bool
False
                        , lStray :: Bool
lStray  = Bool
False
                        , hlsPowered :: Bool
hlsPowered = Bool
False
                        , Bool
lInstalled :: Bool
lSet :: Bool
lNoBindist :: Bool
lNoBindist :: Bool
lSet :: Bool
lInstalled :: Bool
..
                        }


  filter' :: [ListResult] -> [ListResult]
  filter' :: [ListResult] -> [ListResult]
filter' [ListResult]
lr = case Maybe ListCriteria
criteria of
    Maybe ListCriteria
Nothing            -> [ListResult]
lr
    Just ListCriteria
ListInstalled -> (ListResult -> Bool) -> [ListResult] -> [ListResult]
forall a. (a -> Bool) -> [a] -> [a]
filter (\ListResult {Bool
[Tag]
Maybe Text
Version
Tool
hlsPowered :: Bool
lNoBindist :: Bool
lStray :: Bool
fromSrc :: Bool
lSet :: Bool
lInstalled :: Bool
lTag :: [Tag]
lCross :: Maybe Text
lVer :: Version
lTool :: Tool
hlsPowered :: ListResult -> Bool
lNoBindist :: ListResult -> Bool
lStray :: ListResult -> Bool
fromSrc :: ListResult -> Bool
lSet :: ListResult -> Bool
lInstalled :: ListResult -> Bool
lTag :: ListResult -> [Tag]
lCross :: ListResult -> Maybe Text
lVer :: ListResult -> Version
lTool :: ListResult -> Tool
..} -> Bool
lInstalled) [ListResult]
lr
    Just ListCriteria
ListSet       -> (ListResult -> Bool) -> [ListResult] -> [ListResult]
forall a. (a -> Bool) -> [a] -> [a]
filter (\ListResult {Bool
[Tag]
Maybe Text
Version
Tool
hlsPowered :: Bool
lNoBindist :: Bool
lStray :: Bool
fromSrc :: Bool
lSet :: Bool
lInstalled :: Bool
lTag :: [Tag]
lCross :: Maybe Text
lVer :: Version
lTool :: Tool
hlsPowered :: ListResult -> Bool
lNoBindist :: ListResult -> Bool
lStray :: ListResult -> Bool
fromSrc :: ListResult -> Bool
lSet :: ListResult -> Bool
lInstalled :: ListResult -> Bool
lTag :: ListResult -> [Tag]
lCross :: ListResult -> Maybe Text
lVer :: ListResult -> Version
lTool :: ListResult -> Tool
..} -> Bool
lSet) [ListResult]
lr
    Just ListCriteria
ListAvailable -> (ListResult -> Bool) -> [ListResult] -> [ListResult]
forall a. (a -> Bool) -> [a] -> [a]
filter (\ListResult {Bool
[Tag]
Maybe Text
Version
Tool
hlsPowered :: Bool
lNoBindist :: Bool
lStray :: Bool
fromSrc :: Bool
lSet :: Bool
lInstalled :: Bool
lTag :: [Tag]
lCross :: Maybe Text
lVer :: Version
lTool :: Tool
hlsPowered :: ListResult -> Bool
lNoBindist :: ListResult -> Bool
lStray :: ListResult -> Bool
fromSrc :: ListResult -> Bool
lSet :: ListResult -> Bool
lInstalled :: ListResult -> Bool
lTag :: ListResult -> [Tag]
lCross :: ListResult -> Maybe Text
lVer :: ListResult -> Version
lTool :: ListResult -> Tool
..} -> Bool -> Bool
not Bool
lNoBindist) [ListResult]
lr