module Hix.Managed.Data.Mutable (
  MutableDep (MutableDep),
  MutableDeps,
  unsafeMutableDep,
  depName,
  isMutableDep,
  MutableVersions,
  MutableBounds,
  MutableRanges,
  LocalRanges,
  mutRestrictKeys,
  mutLookup,
  mutReplace,
  mutReplaceTargets,
  mutUpdate,
  mutUpdateTargets,
  classifyPackageDep,
  mutRelax,
  mutUpdatePartial,
  mutReplacePartial,
  addBuildVersions,
  mutFromSet,
  mutRelaxVersions,
) where

import Data.Aeson (ToJSON, ToJSONKey)
import qualified Data.Set as Set
import Distribution.Pretty (Pretty (pretty))
import Exon (ToSegment (toSegment))
import GHC.Exts (IsList)

import Hix.Class.EncodeNix (EncodeNix (encodeNix), EncodeNixKey)
import Hix.Class.Map (
  LookupMaybe,
  NLookup,
  NMap,
  nAmend,
  nFromKeys,
  nMap,
  nMapKeys,
  nPretty,
  nPrettyWith,
  nRestrictKeys,
  nTransformMaybe,
  (!!),
  )
import qualified Hix.Data.Dep
import Hix.Data.Dep (Dep (Dep))
import Hix.Data.PackageName (LocalPackage (LocalPackage), PackageName)
import Hix.Data.Version (Version, VersionRange, Versions)
import Hix.Data.VersionBounds (VersionBounds)
import Hix.Managed.Data.Packages (Deps, Packages)
import Hix.Managed.Data.Targets (Targets, overTargets)

newtype MutableDep =
  UnsafeMutableDep PackageName
  deriving stock (MutableDep -> MutableDep -> Bool
(MutableDep -> MutableDep -> Bool)
-> (MutableDep -> MutableDep -> Bool) -> Eq MutableDep
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MutableDep -> MutableDep -> Bool
== :: MutableDep -> MutableDep -> Bool
$c/= :: MutableDep -> MutableDep -> Bool
/= :: MutableDep -> MutableDep -> Bool
Eq, Int -> MutableDep -> ShowS
[MutableDep] -> ShowS
MutableDep -> String
(Int -> MutableDep -> ShowS)
-> (MutableDep -> String)
-> ([MutableDep] -> ShowS)
-> Show MutableDep
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MutableDep -> ShowS
showsPrec :: Int -> MutableDep -> ShowS
$cshow :: MutableDep -> String
show :: MutableDep -> String
$cshowList :: [MutableDep] -> ShowS
showList :: [MutableDep] -> ShowS
Show)
  deriving newtype (Eq MutableDep
Eq MutableDep =>
(MutableDep -> MutableDep -> Ordering)
-> (MutableDep -> MutableDep -> Bool)
-> (MutableDep -> MutableDep -> Bool)
-> (MutableDep -> MutableDep -> Bool)
-> (MutableDep -> MutableDep -> Bool)
-> (MutableDep -> MutableDep -> MutableDep)
-> (MutableDep -> MutableDep -> MutableDep)
-> Ord MutableDep
MutableDep -> MutableDep -> Bool
MutableDep -> MutableDep -> Ordering
MutableDep -> MutableDep -> MutableDep
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
$ccompare :: MutableDep -> MutableDep -> Ordering
compare :: MutableDep -> MutableDep -> Ordering
$c< :: MutableDep -> MutableDep -> Bool
< :: MutableDep -> MutableDep -> Bool
$c<= :: MutableDep -> MutableDep -> Bool
<= :: MutableDep -> MutableDep -> Bool
$c> :: MutableDep -> MutableDep -> Bool
> :: MutableDep -> MutableDep -> Bool
$c>= :: MutableDep -> MutableDep -> Bool
>= :: MutableDep -> MutableDep -> Bool
$cmax :: MutableDep -> MutableDep -> MutableDep
max :: MutableDep -> MutableDep -> MutableDep
$cmin :: MutableDep -> MutableDep -> MutableDep
min :: MutableDep -> MutableDep -> MutableDep
Ord, [MutableDep] -> Value
[MutableDep] -> Encoding
MutableDep -> Bool
MutableDep -> Value
MutableDep -> Encoding
(MutableDep -> Value)
-> (MutableDep -> Encoding)
-> ([MutableDep] -> Value)
-> ([MutableDep] -> Encoding)
-> (MutableDep -> Bool)
-> ToJSON MutableDep
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: MutableDep -> Value
toJSON :: MutableDep -> Value
$ctoEncoding :: MutableDep -> Encoding
toEncoding :: MutableDep -> Encoding
$ctoJSONList :: [MutableDep] -> Value
toJSONList :: [MutableDep] -> Value
$ctoEncodingList :: [MutableDep] -> Encoding
toEncodingList :: [MutableDep] -> Encoding
$comitField :: MutableDep -> Bool
omitField :: MutableDep -> Bool
ToJSON, ToJSONKeyFunction [MutableDep]
ToJSONKeyFunction MutableDep
ToJSONKeyFunction MutableDep
-> ToJSONKeyFunction [MutableDep] -> ToJSONKey MutableDep
forall a.
ToJSONKeyFunction a -> ToJSONKeyFunction [a] -> ToJSONKey a
$ctoJSONKey :: ToJSONKeyFunction MutableDep
toJSONKey :: ToJSONKeyFunction MutableDep
$ctoJSONKeyList :: ToJSONKeyFunction [MutableDep]
toJSONKeyList :: ToJSONKeyFunction [MutableDep]
ToJSONKey, CabalSpecVersion -> MutableDep -> Doc
MutableDep -> Doc
(MutableDep -> Doc)
-> (CabalSpecVersion -> MutableDep -> Doc) -> Pretty MutableDep
forall a. (a -> Doc) -> (CabalSpecVersion -> a -> Doc) -> Pretty a
$cpretty :: MutableDep -> Doc
pretty :: MutableDep -> Doc
$cprettyVersioned :: CabalSpecVersion -> MutableDep -> Doc
prettyVersioned :: CabalSpecVersion -> MutableDep -> Doc
Pretty, MutableDep -> Text
(MutableDep -> Text) -> EncodeNixKey MutableDep
forall a. (a -> Text) -> EncodeNixKey a
$cencodeNixKey :: MutableDep -> Text
encodeNixKey :: MutableDep -> Text
EncodeNixKey)

pattern MutableDep :: PackageName -> MutableDep
pattern $mMutableDep :: forall {r}. MutableDep -> (PackageName -> r) -> ((# #) -> r) -> r
MutableDep name <- UnsafeMutableDep name

{-# complete MutableDep #-}

unsafeMutableDep :: PackageName -> MutableDep
unsafeMutableDep :: PackageName -> MutableDep
unsafeMutableDep = PackageName -> MutableDep
UnsafeMutableDep

depName :: MutableDep -> PackageName
depName :: MutableDep -> PackageName
depName (UnsafeMutableDep PackageName
name) = PackageName
name

isMutableDep :: Set MutableDep -> PackageName -> Bool
isMutableDep :: Set MutableDep -> PackageName -> Bool
isMutableDep Set MutableDep
mut PackageName
p = MutableDep -> Set MutableDep -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member (PackageName -> MutableDep
UnsafeMutableDep PackageName
p) Set MutableDep
mut

instance IsString a => ToSegment MutableDep a where
  toSegment :: MutableDep -> a
toSegment (UnsafeMutableDep PackageName
name) = PackageName -> a
forall a b. ToSegment a b => a -> b
toSegment PackageName
name

newtype MutableDeps a =
  MutableDeps (Map MutableDep a)
  deriving stock (MutableDeps a -> MutableDeps a -> Bool
(MutableDeps a -> MutableDeps a -> Bool)
-> (MutableDeps a -> MutableDeps a -> Bool) -> Eq (MutableDeps a)
forall a. Eq a => MutableDeps a -> MutableDeps a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => MutableDeps a -> MutableDeps a -> Bool
== :: MutableDeps a -> MutableDeps a -> Bool
$c/= :: forall a. Eq a => MutableDeps a -> MutableDeps a -> Bool
/= :: MutableDeps a -> MutableDeps a -> Bool
Eq, Int -> MutableDeps a -> ShowS
[MutableDeps a] -> ShowS
MutableDeps a -> String
(Int -> MutableDeps a -> ShowS)
-> (MutableDeps a -> String)
-> ([MutableDeps a] -> ShowS)
-> Show (MutableDeps a)
forall a. Show a => Int -> MutableDeps a -> ShowS
forall a. Show a => [MutableDeps a] -> ShowS
forall a. Show a => MutableDeps a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> MutableDeps a -> ShowS
showsPrec :: Int -> MutableDeps a -> ShowS
$cshow :: forall a. Show a => MutableDeps a -> String
show :: MutableDeps a -> String
$cshowList :: forall a. Show a => [MutableDeps a] -> ShowS
showList :: [MutableDeps a] -> ShowS
Show, (forall x. MutableDeps a -> Rep (MutableDeps a) x)
-> (forall x. Rep (MutableDeps a) x -> MutableDeps a)
-> Generic (MutableDeps a)
forall x. Rep (MutableDeps a) x -> MutableDeps a
forall x. MutableDeps a -> Rep (MutableDeps a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (MutableDeps a) x -> MutableDeps a
forall a x. MutableDeps a -> Rep (MutableDeps a) x
$cfrom :: forall a x. MutableDeps a -> Rep (MutableDeps a) x
from :: forall x. MutableDeps a -> Rep (MutableDeps a) x
$cto :: forall a x. Rep (MutableDeps a) x -> MutableDeps a
to :: forall x. Rep (MutableDeps a) x -> MutableDeps a
Generic)
  deriving newtype (NonEmpty (MutableDeps a) -> MutableDeps a
MutableDeps a -> MutableDeps a -> MutableDeps a
(MutableDeps a -> MutableDeps a -> MutableDeps a)
-> (NonEmpty (MutableDeps a) -> MutableDeps a)
-> (forall b. Integral b => b -> MutableDeps a -> MutableDeps a)
-> Semigroup (MutableDeps a)
forall b. Integral b => b -> MutableDeps a -> MutableDeps a
forall a. NonEmpty (MutableDeps a) -> MutableDeps a
forall a. MutableDeps a -> MutableDeps a -> MutableDeps a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a b. Integral b => b -> MutableDeps a -> MutableDeps a
$c<> :: forall a. MutableDeps a -> MutableDeps a -> MutableDeps a
<> :: MutableDeps a -> MutableDeps a -> MutableDeps a
$csconcat :: forall a. NonEmpty (MutableDeps a) -> MutableDeps a
sconcat :: NonEmpty (MutableDeps a) -> MutableDeps a
$cstimes :: forall a b. Integral b => b -> MutableDeps a -> MutableDeps a
stimes :: forall b. Integral b => b -> MutableDeps a -> MutableDeps a
Semigroup, Semigroup (MutableDeps a)
MutableDeps a
Semigroup (MutableDeps a) =>
MutableDeps a
-> (MutableDeps a -> MutableDeps a -> MutableDeps a)
-> ([MutableDeps a] -> MutableDeps a)
-> Monoid (MutableDeps a)
[MutableDeps a] -> MutableDeps a
MutableDeps a -> MutableDeps a -> MutableDeps a
forall a. Semigroup (MutableDeps a)
forall a. MutableDeps a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. [MutableDeps a] -> MutableDeps a
forall a. MutableDeps a -> MutableDeps a -> MutableDeps a
$cmempty :: forall a. MutableDeps a
mempty :: MutableDeps a
$cmappend :: forall a. MutableDeps a -> MutableDeps a -> MutableDeps a
mappend :: MutableDeps a -> MutableDeps a -> MutableDeps a
$cmconcat :: forall a. [MutableDeps a] -> MutableDeps a
mconcat :: [MutableDeps a] -> MutableDeps a
Monoid, MutableDeps a -> Expr
(MutableDeps a -> Expr) -> EncodeNix (MutableDeps a)
forall a. EncodeNix a => MutableDeps a -> Expr
forall a. (a -> Expr) -> EncodeNix a
$cencodeNix :: forall a. EncodeNix a => MutableDeps a -> Expr
encodeNix :: MutableDeps a -> Expr
EncodeNix)

instance NMap (MutableDeps a) MutableDep a LookupMaybe where

instance Pretty a => Pretty (MutableDeps a) where
  pretty :: MutableDeps a -> Doc
pretty = MutableDeps a -> Doc
forall k v map sort.
(Pretty k, Pretty v, NMap map k v sort) =>
map -> Doc
nPretty

newtype MutableVersions =
  MutableVersions (Map MutableDep (Maybe Version))
  deriving stock (MutableVersions -> MutableVersions -> Bool
(MutableVersions -> MutableVersions -> Bool)
-> (MutableVersions -> MutableVersions -> Bool)
-> Eq MutableVersions
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MutableVersions -> MutableVersions -> Bool
== :: MutableVersions -> MutableVersions -> Bool
$c/= :: MutableVersions -> MutableVersions -> Bool
/= :: MutableVersions -> MutableVersions -> Bool
Eq, Int -> MutableVersions -> ShowS
[MutableVersions] -> ShowS
MutableVersions -> String
(Int -> MutableVersions -> ShowS)
-> (MutableVersions -> String)
-> ([MutableVersions] -> ShowS)
-> Show MutableVersions
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MutableVersions -> ShowS
showsPrec :: Int -> MutableVersions -> ShowS
$cshow :: MutableVersions -> String
show :: MutableVersions -> String
$cshowList :: [MutableVersions] -> ShowS
showList :: [MutableVersions] -> ShowS
Show, (forall x. MutableVersions -> Rep MutableVersions x)
-> (forall x. Rep MutableVersions x -> MutableVersions)
-> Generic MutableVersions
forall x. Rep MutableVersions x -> MutableVersions
forall x. MutableVersions -> Rep MutableVersions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MutableVersions -> Rep MutableVersions x
from :: forall x. MutableVersions -> Rep MutableVersions x
$cto :: forall x. Rep MutableVersions x -> MutableVersions
to :: forall x. Rep MutableVersions x -> MutableVersions
Generic)
  deriving newtype (NonEmpty MutableVersions -> MutableVersions
MutableVersions -> MutableVersions -> MutableVersions
(MutableVersions -> MutableVersions -> MutableVersions)
-> (NonEmpty MutableVersions -> MutableVersions)
-> (forall b.
    Integral b =>
    b -> MutableVersions -> MutableVersions)
-> Semigroup MutableVersions
forall b. Integral b => b -> MutableVersions -> MutableVersions
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: MutableVersions -> MutableVersions -> MutableVersions
<> :: MutableVersions -> MutableVersions -> MutableVersions
$csconcat :: NonEmpty MutableVersions -> MutableVersions
sconcat :: NonEmpty MutableVersions -> MutableVersions
$cstimes :: forall b. Integral b => b -> MutableVersions -> MutableVersions
stimes :: forall b. Integral b => b -> MutableVersions -> MutableVersions
Semigroup, Semigroup MutableVersions
MutableVersions
Semigroup MutableVersions =>
MutableVersions
-> (MutableVersions -> MutableVersions -> MutableVersions)
-> ([MutableVersions] -> MutableVersions)
-> Monoid MutableVersions
[MutableVersions] -> MutableVersions
MutableVersions -> MutableVersions -> MutableVersions
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: MutableVersions
mempty :: MutableVersions
$cmappend :: MutableVersions -> MutableVersions -> MutableVersions
mappend :: MutableVersions -> MutableVersions -> MutableVersions
$cmconcat :: [MutableVersions] -> MutableVersions
mconcat :: [MutableVersions] -> MutableVersions
Monoid, Int -> [Item MutableVersions] -> MutableVersions
[Item MutableVersions] -> MutableVersions
MutableVersions -> [Item MutableVersions]
([Item MutableVersions] -> MutableVersions)
-> (Int -> [Item MutableVersions] -> MutableVersions)
-> (MutableVersions -> [Item MutableVersions])
-> IsList MutableVersions
forall l.
([Item l] -> l)
-> (Int -> [Item l] -> l) -> (l -> [Item l]) -> IsList l
$cfromList :: [Item MutableVersions] -> MutableVersions
fromList :: [Item MutableVersions] -> MutableVersions
$cfromListN :: Int -> [Item MutableVersions] -> MutableVersions
fromListN :: Int -> [Item MutableVersions] -> MutableVersions
$ctoList :: MutableVersions -> [Item MutableVersions]
toList :: MutableVersions -> [Item MutableVersions]
IsList)

instance NMap MutableVersions MutableDep (Maybe Version) LookupMaybe where

instance Pretty MutableVersions where
  pretty :: MutableVersions -> Doc
pretty = (Maybe Version -> Doc) -> MutableVersions -> Doc
forall k map v sort.
(Pretty k, NMap map k v sort) =>
(v -> Doc) -> map -> Doc
nPrettyWith (Doc -> (Version -> Doc) -> Maybe Version -> Doc
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Doc
"[missing]" Version -> Doc
forall a. Pretty a => a -> Doc
pretty)

instance EncodeNix MutableVersions where
  encodeNix :: MutableVersions -> Expr
encodeNix = Versions -> Expr
forall a. EncodeNix a => a -> Expr
encodeNix (Versions -> Expr)
-> (MutableVersions -> Versions) -> MutableVersions -> Expr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MutableVersions -> Versions
mutRelaxVersions

newtype MutableBounds =
  MutableBounds (Map MutableDep VersionBounds)
  deriving stock (MutableBounds -> MutableBounds -> Bool
(MutableBounds -> MutableBounds -> Bool)
-> (MutableBounds -> MutableBounds -> Bool) -> Eq MutableBounds
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MutableBounds -> MutableBounds -> Bool
== :: MutableBounds -> MutableBounds -> Bool
$c/= :: MutableBounds -> MutableBounds -> Bool
/= :: MutableBounds -> MutableBounds -> Bool
Eq, Int -> MutableBounds -> ShowS
[MutableBounds] -> ShowS
MutableBounds -> String
(Int -> MutableBounds -> ShowS)
-> (MutableBounds -> String)
-> ([MutableBounds] -> ShowS)
-> Show MutableBounds
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MutableBounds -> ShowS
showsPrec :: Int -> MutableBounds -> ShowS
$cshow :: MutableBounds -> String
show :: MutableBounds -> String
$cshowList :: [MutableBounds] -> ShowS
showList :: [MutableBounds] -> ShowS
Show, (forall x. MutableBounds -> Rep MutableBounds x)
-> (forall x. Rep MutableBounds x -> MutableBounds)
-> Generic MutableBounds
forall x. Rep MutableBounds x -> MutableBounds
forall x. MutableBounds -> Rep MutableBounds x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MutableBounds -> Rep MutableBounds x
from :: forall x. MutableBounds -> Rep MutableBounds x
$cto :: forall x. Rep MutableBounds x -> MutableBounds
to :: forall x. Rep MutableBounds x -> MutableBounds
Generic)
  deriving newtype (NonEmpty MutableBounds -> MutableBounds
MutableBounds -> MutableBounds -> MutableBounds
(MutableBounds -> MutableBounds -> MutableBounds)
-> (NonEmpty MutableBounds -> MutableBounds)
-> (forall b. Integral b => b -> MutableBounds -> MutableBounds)
-> Semigroup MutableBounds
forall b. Integral b => b -> MutableBounds -> MutableBounds
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: MutableBounds -> MutableBounds -> MutableBounds
<> :: MutableBounds -> MutableBounds -> MutableBounds
$csconcat :: NonEmpty MutableBounds -> MutableBounds
sconcat :: NonEmpty MutableBounds -> MutableBounds
$cstimes :: forall b. Integral b => b -> MutableBounds -> MutableBounds
stimes :: forall b. Integral b => b -> MutableBounds -> MutableBounds
Semigroup, Semigroup MutableBounds
MutableBounds
Semigroup MutableBounds =>
MutableBounds
-> (MutableBounds -> MutableBounds -> MutableBounds)
-> ([MutableBounds] -> MutableBounds)
-> Monoid MutableBounds
[MutableBounds] -> MutableBounds
MutableBounds -> MutableBounds -> MutableBounds
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: MutableBounds
mempty :: MutableBounds
$cmappend :: MutableBounds -> MutableBounds -> MutableBounds
mappend :: MutableBounds -> MutableBounds -> MutableBounds
$cmconcat :: [MutableBounds] -> MutableBounds
mconcat :: [MutableBounds] -> MutableBounds
Monoid, Int -> [Item MutableBounds] -> MutableBounds
[Item MutableBounds] -> MutableBounds
MutableBounds -> [Item MutableBounds]
([Item MutableBounds] -> MutableBounds)
-> (Int -> [Item MutableBounds] -> MutableBounds)
-> (MutableBounds -> [Item MutableBounds])
-> IsList MutableBounds
forall l.
([Item l] -> l)
-> (Int -> [Item l] -> l) -> (l -> [Item l]) -> IsList l
$cfromList :: [Item MutableBounds] -> MutableBounds
fromList :: [Item MutableBounds] -> MutableBounds
$cfromListN :: Int -> [Item MutableBounds] -> MutableBounds
fromListN :: Int -> [Item MutableBounds] -> MutableBounds
$ctoList :: MutableBounds -> [Item MutableBounds]
toList :: MutableBounds -> [Item MutableBounds]
IsList, MutableBounds -> Expr
(MutableBounds -> Expr) -> EncodeNix MutableBounds
forall a. (a -> Expr) -> EncodeNix a
$cencodeNix :: MutableBounds -> Expr
encodeNix :: MutableBounds -> Expr
EncodeNix, [MutableBounds] -> Value
[MutableBounds] -> Encoding
MutableBounds -> Bool
MutableBounds -> Value
MutableBounds -> Encoding
(MutableBounds -> Value)
-> (MutableBounds -> Encoding)
-> ([MutableBounds] -> Value)
-> ([MutableBounds] -> Encoding)
-> (MutableBounds -> Bool)
-> ToJSON MutableBounds
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: MutableBounds -> Value
toJSON :: MutableBounds -> Value
$ctoEncoding :: MutableBounds -> Encoding
toEncoding :: MutableBounds -> Encoding
$ctoJSONList :: [MutableBounds] -> Value
toJSONList :: [MutableBounds] -> Value
$ctoEncodingList :: [MutableBounds] -> Encoding
toEncodingList :: [MutableBounds] -> Encoding
$comitField :: MutableBounds -> Bool
omitField :: MutableBounds -> Bool
ToJSON)

instance NMap MutableBounds MutableDep VersionBounds LookupMaybe where

instance Pretty MutableBounds where
  pretty :: MutableBounds -> Doc
pretty = MutableBounds -> Doc
forall k v map sort.
(Pretty k, Pretty v, NMap map k v sort) =>
map -> Doc
nPretty

newtype LocalBounds =
  LocalBounds (Map LocalPackage VersionBounds)
  deriving stock (LocalBounds -> LocalBounds -> Bool
(LocalBounds -> LocalBounds -> Bool)
-> (LocalBounds -> LocalBounds -> Bool) -> Eq LocalBounds
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LocalBounds -> LocalBounds -> Bool
== :: LocalBounds -> LocalBounds -> Bool
$c/= :: LocalBounds -> LocalBounds -> Bool
/= :: LocalBounds -> LocalBounds -> Bool
Eq, Int -> LocalBounds -> ShowS
[LocalBounds] -> ShowS
LocalBounds -> String
(Int -> LocalBounds -> ShowS)
-> (LocalBounds -> String)
-> ([LocalBounds] -> ShowS)
-> Show LocalBounds
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LocalBounds -> ShowS
showsPrec :: Int -> LocalBounds -> ShowS
$cshow :: LocalBounds -> String
show :: LocalBounds -> String
$cshowList :: [LocalBounds] -> ShowS
showList :: [LocalBounds] -> ShowS
Show, (forall x. LocalBounds -> Rep LocalBounds x)
-> (forall x. Rep LocalBounds x -> LocalBounds)
-> Generic LocalBounds
forall x. Rep LocalBounds x -> LocalBounds
forall x. LocalBounds -> Rep LocalBounds x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LocalBounds -> Rep LocalBounds x
from :: forall x. LocalBounds -> Rep LocalBounds x
$cto :: forall x. Rep LocalBounds x -> LocalBounds
to :: forall x. Rep LocalBounds x -> LocalBounds
Generic)
  deriving newtype (NonEmpty LocalBounds -> LocalBounds
LocalBounds -> LocalBounds -> LocalBounds
(LocalBounds -> LocalBounds -> LocalBounds)
-> (NonEmpty LocalBounds -> LocalBounds)
-> (forall b. Integral b => b -> LocalBounds -> LocalBounds)
-> Semigroup LocalBounds
forall b. Integral b => b -> LocalBounds -> LocalBounds
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: LocalBounds -> LocalBounds -> LocalBounds
<> :: LocalBounds -> LocalBounds -> LocalBounds
$csconcat :: NonEmpty LocalBounds -> LocalBounds
sconcat :: NonEmpty LocalBounds -> LocalBounds
$cstimes :: forall b. Integral b => b -> LocalBounds -> LocalBounds
stimes :: forall b. Integral b => b -> LocalBounds -> LocalBounds
Semigroup, Semigroup LocalBounds
LocalBounds
Semigroup LocalBounds =>
LocalBounds
-> (LocalBounds -> LocalBounds -> LocalBounds)
-> ([LocalBounds] -> LocalBounds)
-> Monoid LocalBounds
[LocalBounds] -> LocalBounds
LocalBounds -> LocalBounds -> LocalBounds
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: LocalBounds
mempty :: LocalBounds
$cmappend :: LocalBounds -> LocalBounds -> LocalBounds
mappend :: LocalBounds -> LocalBounds -> LocalBounds
$cmconcat :: [LocalBounds] -> LocalBounds
mconcat :: [LocalBounds] -> LocalBounds
Monoid, Int -> [Item LocalBounds] -> LocalBounds
[Item LocalBounds] -> LocalBounds
LocalBounds -> [Item LocalBounds]
([Item LocalBounds] -> LocalBounds)
-> (Int -> [Item LocalBounds] -> LocalBounds)
-> (LocalBounds -> [Item LocalBounds])
-> IsList LocalBounds
forall l.
([Item l] -> l)
-> (Int -> [Item l] -> l) -> (l -> [Item l]) -> IsList l
$cfromList :: [Item LocalBounds] -> LocalBounds
fromList :: [Item LocalBounds] -> LocalBounds
$cfromListN :: Int -> [Item LocalBounds] -> LocalBounds
fromListN :: Int -> [Item LocalBounds] -> LocalBounds
$ctoList :: LocalBounds -> [Item LocalBounds]
toList :: LocalBounds -> [Item LocalBounds]
IsList, LocalBounds -> Expr
(LocalBounds -> Expr) -> EncodeNix LocalBounds
forall a. (a -> Expr) -> EncodeNix a
$cencodeNix :: LocalBounds -> Expr
encodeNix :: LocalBounds -> Expr
EncodeNix)

instance NMap LocalBounds LocalPackage VersionBounds LookupMaybe where

instance Pretty LocalBounds where
  pretty :: LocalBounds -> Doc
pretty = LocalBounds -> Doc
forall k v map sort.
(Pretty k, Pretty v, NMap map k v sort) =>
map -> Doc
nPretty

newtype MutableRanges =
  MutableRanges (Map MutableDep VersionRange)
  deriving stock (MutableRanges -> MutableRanges -> Bool
(MutableRanges -> MutableRanges -> Bool)
-> (MutableRanges -> MutableRanges -> Bool) -> Eq MutableRanges
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MutableRanges -> MutableRanges -> Bool
== :: MutableRanges -> MutableRanges -> Bool
$c/= :: MutableRanges -> MutableRanges -> Bool
/= :: MutableRanges -> MutableRanges -> Bool
Eq, Int -> MutableRanges -> ShowS
[MutableRanges] -> ShowS
MutableRanges -> String
(Int -> MutableRanges -> ShowS)
-> (MutableRanges -> String)
-> ([MutableRanges] -> ShowS)
-> Show MutableRanges
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MutableRanges -> ShowS
showsPrec :: Int -> MutableRanges -> ShowS
$cshow :: MutableRanges -> String
show :: MutableRanges -> String
$cshowList :: [MutableRanges] -> ShowS
showList :: [MutableRanges] -> ShowS
Show, (forall x. MutableRanges -> Rep MutableRanges x)
-> (forall x. Rep MutableRanges x -> MutableRanges)
-> Generic MutableRanges
forall x. Rep MutableRanges x -> MutableRanges
forall x. MutableRanges -> Rep MutableRanges x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MutableRanges -> Rep MutableRanges x
from :: forall x. MutableRanges -> Rep MutableRanges x
$cto :: forall x. Rep MutableRanges x -> MutableRanges
to :: forall x. Rep MutableRanges x -> MutableRanges
Generic)
  deriving newtype (NonEmpty MutableRanges -> MutableRanges
MutableRanges -> MutableRanges -> MutableRanges
(MutableRanges -> MutableRanges -> MutableRanges)
-> (NonEmpty MutableRanges -> MutableRanges)
-> (forall b. Integral b => b -> MutableRanges -> MutableRanges)
-> Semigroup MutableRanges
forall b. Integral b => b -> MutableRanges -> MutableRanges
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: MutableRanges -> MutableRanges -> MutableRanges
<> :: MutableRanges -> MutableRanges -> MutableRanges
$csconcat :: NonEmpty MutableRanges -> MutableRanges
sconcat :: NonEmpty MutableRanges -> MutableRanges
$cstimes :: forall b. Integral b => b -> MutableRanges -> MutableRanges
stimes :: forall b. Integral b => b -> MutableRanges -> MutableRanges
Semigroup, Semigroup MutableRanges
MutableRanges
Semigroup MutableRanges =>
MutableRanges
-> (MutableRanges -> MutableRanges -> MutableRanges)
-> ([MutableRanges] -> MutableRanges)
-> Monoid MutableRanges
[MutableRanges] -> MutableRanges
MutableRanges -> MutableRanges -> MutableRanges
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: MutableRanges
mempty :: MutableRanges
$cmappend :: MutableRanges -> MutableRanges -> MutableRanges
mappend :: MutableRanges -> MutableRanges -> MutableRanges
$cmconcat :: [MutableRanges] -> MutableRanges
mconcat :: [MutableRanges] -> MutableRanges
Monoid, Int -> [Item MutableRanges] -> MutableRanges
[Item MutableRanges] -> MutableRanges
MutableRanges -> [Item MutableRanges]
([Item MutableRanges] -> MutableRanges)
-> (Int -> [Item MutableRanges] -> MutableRanges)
-> (MutableRanges -> [Item MutableRanges])
-> IsList MutableRanges
forall l.
([Item l] -> l)
-> (Int -> [Item l] -> l) -> (l -> [Item l]) -> IsList l
$cfromList :: [Item MutableRanges] -> MutableRanges
fromList :: [Item MutableRanges] -> MutableRanges
$cfromListN :: Int -> [Item MutableRanges] -> MutableRanges
fromListN :: Int -> [Item MutableRanges] -> MutableRanges
$ctoList :: MutableRanges -> [Item MutableRanges]
toList :: MutableRanges -> [Item MutableRanges]
IsList)

instance NMap MutableRanges MutableDep VersionRange LookupMaybe where

instance Pretty MutableRanges where
  pretty :: MutableRanges -> Doc
pretty = MutableRanges -> Doc
forall k v map sort.
(Pretty k, Pretty v, NMap map k v sort) =>
map -> Doc
nPretty

newtype LocalRanges =
  LocalRanges (Map LocalPackage VersionRange)
  deriving stock (LocalRanges -> LocalRanges -> Bool
(LocalRanges -> LocalRanges -> Bool)
-> (LocalRanges -> LocalRanges -> Bool) -> Eq LocalRanges
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LocalRanges -> LocalRanges -> Bool
== :: LocalRanges -> LocalRanges -> Bool
$c/= :: LocalRanges -> LocalRanges -> Bool
/= :: LocalRanges -> LocalRanges -> Bool
Eq, Int -> LocalRanges -> ShowS
[LocalRanges] -> ShowS
LocalRanges -> String
(Int -> LocalRanges -> ShowS)
-> (LocalRanges -> String)
-> ([LocalRanges] -> ShowS)
-> Show LocalRanges
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LocalRanges -> ShowS
showsPrec :: Int -> LocalRanges -> ShowS
$cshow :: LocalRanges -> String
show :: LocalRanges -> String
$cshowList :: [LocalRanges] -> ShowS
showList :: [LocalRanges] -> ShowS
Show, (forall x. LocalRanges -> Rep LocalRanges x)
-> (forall x. Rep LocalRanges x -> LocalRanges)
-> Generic LocalRanges
forall x. Rep LocalRanges x -> LocalRanges
forall x. LocalRanges -> Rep LocalRanges x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LocalRanges -> Rep LocalRanges x
from :: forall x. LocalRanges -> Rep LocalRanges x
$cto :: forall x. Rep LocalRanges x -> LocalRanges
to :: forall x. Rep LocalRanges x -> LocalRanges
Generic)
  deriving newtype (NonEmpty LocalRanges -> LocalRanges
LocalRanges -> LocalRanges -> LocalRanges
(LocalRanges -> LocalRanges -> LocalRanges)
-> (NonEmpty LocalRanges -> LocalRanges)
-> (forall b. Integral b => b -> LocalRanges -> LocalRanges)
-> Semigroup LocalRanges
forall b. Integral b => b -> LocalRanges -> LocalRanges
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: LocalRanges -> LocalRanges -> LocalRanges
<> :: LocalRanges -> LocalRanges -> LocalRanges
$csconcat :: NonEmpty LocalRanges -> LocalRanges
sconcat :: NonEmpty LocalRanges -> LocalRanges
$cstimes :: forall b. Integral b => b -> LocalRanges -> LocalRanges
stimes :: forall b. Integral b => b -> LocalRanges -> LocalRanges
Semigroup, Semigroup LocalRanges
LocalRanges
Semigroup LocalRanges =>
LocalRanges
-> (LocalRanges -> LocalRanges -> LocalRanges)
-> ([LocalRanges] -> LocalRanges)
-> Monoid LocalRanges
[LocalRanges] -> LocalRanges
LocalRanges -> LocalRanges -> LocalRanges
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: LocalRanges
mempty :: LocalRanges
$cmappend :: LocalRanges -> LocalRanges -> LocalRanges
mappend :: LocalRanges -> LocalRanges -> LocalRanges
$cmconcat :: [LocalRanges] -> LocalRanges
mconcat :: [LocalRanges] -> LocalRanges
Monoid, Int -> [Item LocalRanges] -> LocalRanges
[Item LocalRanges] -> LocalRanges
LocalRanges -> [Item LocalRanges]
([Item LocalRanges] -> LocalRanges)
-> (Int -> [Item LocalRanges] -> LocalRanges)
-> (LocalRanges -> [Item LocalRanges])
-> IsList LocalRanges
forall l.
([Item l] -> l)
-> (Int -> [Item l] -> l) -> (l -> [Item l]) -> IsList l
$cfromList :: [Item LocalRanges] -> LocalRanges
fromList :: [Item LocalRanges] -> LocalRanges
$cfromListN :: Int -> [Item LocalRanges] -> LocalRanges
fromListN :: Int -> [Item LocalRanges] -> LocalRanges
$ctoList :: LocalRanges -> [Item LocalRanges]
toList :: LocalRanges -> [Item LocalRanges]
IsList)

instance NMap LocalRanges LocalPackage VersionRange LookupMaybe where

instance Pretty LocalRanges where
  pretty :: LocalRanges -> Doc
pretty = LocalRanges -> Doc
forall k v map sort.
(Pretty k, Pretty v, NMap map k v sort) =>
map -> Doc
nPretty

mutLookup ::
  NMap map MutableDep v sort =>
  NLookup sort MutableDep v l =>
  PackageName ->
  map ->
  l
mutLookup :: forall map v sort l.
(NMap map MutableDep v sort, NLookup sort MutableDep v l) =>
PackageName -> map -> l
mutLookup PackageName
k map
m =
  map
m map -> MutableDep -> l
forall map k v sort l.
(NMap map k v sort, NLookup sort k v l) =>
map -> k -> l
!! (PackageName -> MutableDep
UnsafeMutableDep PackageName
k)

mutRestrictKeys ::
  NMap map MutableDep v sort =>
  Set PackageName ->
  map ->
  map
mutRestrictKeys :: forall map v sort.
NMap map MutableDep v sort =>
Set PackageName -> map -> map
mutRestrictKeys Set PackageName
keys =
  Set MutableDep -> map -> map
forall map k v sort. NMap map k v sort => Set k -> map -> map
nRestrictKeys ([MutableDep] -> Set MutableDep
forall a. Ord a => [a] -> Set a
Set.fromList (PackageName -> MutableDep
UnsafeMutableDep (PackageName -> MutableDep) -> [PackageName] -> [MutableDep]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Set PackageName -> [PackageName]
forall a. Set a -> [a]
Set.toList Set PackageName
keys))

mutReplace ::
  NMap map MutableDep v sort =>
  map ->
  map ->
  map
mutReplace :: forall map v sort. NMap map MutableDep v sort => map -> map -> map
mutReplace =
  (v -> v -> v) -> map -> map -> map
forall map1 map2 k v1 v2 s1 s2.
(NMap map1 k v1 s1, NMap map2 k v2 s2) =>
(v1 -> v2 -> v2) -> map1 -> map2 -> map2
nAmend \ v
new v
_ -> v
new

mutReplaceTargets ::
  NMap map MutableDep v sort =>
  Targets ->
  map ->
  Packages map ->
  Packages map
mutReplaceTargets :: forall map v sort.
NMap map MutableDep v sort =>
Targets -> map -> Packages map -> Packages map
mutReplaceTargets Targets
targets map
new =
  Targets -> (map -> map) -> Packages map -> Packages map
forall a. Targets -> (a -> a) -> Packages a -> Packages a
overTargets Targets
targets (map -> map -> map
forall map v sort. NMap map MutableDep v sort => map -> map -> map
mutReplace map
new)

mutUpdate ::
  NMap map1 MutableDep v1 s1 =>
  NMap map2 MutableDep v2 s2 =>
  (v1 -> v2 -> v2) ->
  map1 ->
  map2 ->
  map2
mutUpdate :: forall map1 v1 s1 map2 v2 s2.
(NMap map1 MutableDep v1 s1, NMap map2 MutableDep v2 s2) =>
(v1 -> v2 -> v2) -> map1 -> map2 -> map2
mutUpdate =
  (v1 -> v2 -> v2) -> map1 -> map2 -> map2
forall map1 map2 k v1 v2 s1 s2.
(NMap map1 k v1 s1, NMap map2 k v2 s2) =>
(v1 -> v2 -> v2) -> map1 -> map2 -> map2
nAmend

mutUpdateTargets ::
  NMap map1 MutableDep v1 s1 =>
  NMap map2 MutableDep v2 s2 =>
  Targets ->
  (v1 -> v2 -> v2) ->
  map1 ->
  Packages map2 ->
  Packages map2
mutUpdateTargets :: forall map1 v1 s1 map2 v2 s2.
(NMap map1 MutableDep v1 s1, NMap map2 MutableDep v2 s2) =>
Targets
-> (v1 -> v2 -> v2) -> map1 -> Packages map2 -> Packages map2
mutUpdateTargets Targets
targets v1 -> v2 -> v2
f map1
new =
  Targets -> (map2 -> map2) -> Packages map2 -> Packages map2
forall a. Targets -> (a -> a) -> Packages a -> Packages a
overTargets Targets
targets ((v1 -> v2 -> v2) -> map1 -> map2 -> map2
forall map1 v1 s1 map2 v2 s2.
(NMap map1 MutableDep v1 s1, NMap map2 MutableDep v2 s2) =>
(v1 -> v2 -> v2) -> map1 -> map2 -> map2
mutUpdate v1 -> v2 -> v2
f map1
new)

mutRelax ::
  NMap map1 MutableDep v s1 =>
  NMap map2 PackageName v s2 =>
  map1 ->
  map2
mutRelax :: forall map1 v s1 map2 s2.
(NMap map1 MutableDep v s1, NMap map2 PackageName v s2) =>
map1 -> map2
mutRelax =
  (MutableDep -> PackageName) -> map1 -> map2
forall map1 k1 v sort1 map2 k2 sort2.
(NMap map1 k1 v sort1, NMap map2 k2 v sort2) =>
(k1 -> k2) -> map1 -> map2
nMapKeys MutableDep -> PackageName
depName

mutRelaxVersions ::
  MutableVersions ->
  Versions
mutRelaxVersions :: MutableVersions -> Versions
mutRelaxVersions =
  (MutableDep -> Maybe Version -> Maybe (PackageName, Version))
-> MutableVersions -> Versions
forall map1 k1 v1 sort1 map2 k2 v2 sort2.
(NMap map1 k1 v1 sort1, NMap map2 k2 v2 sort2) =>
(k1 -> v1 -> Maybe (k2, v2)) -> map1 -> map2
nTransformMaybe \ MutableDep
dep -> (Version -> (PackageName, Version))
-> Maybe Version -> Maybe (PackageName, Version)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (MutableDep -> PackageName
depName MutableDep
dep,)

-- | Update a MutableDep map with a PackageName map, only where the original is defined.
mutUpdatePartial ::
  ∀ map1 map2 v1 v2 s1 s2 .
  NMap map1 PackageName v1 s1 =>
  NMap map2 MutableDep v2 s2 =>
  (v1 -> v2 -> v2) ->
  map1 ->
  map2 ->
  map2
mutUpdatePartial :: forall map1 map2 v1 v2 s1 s2.
(NMap map1 PackageName v1 s1, NMap map2 MutableDep v2 s2) =>
(v1 -> v2 -> v2) -> map1 -> map2 -> map2
mutUpdatePartial v1 -> v2 -> v2
f map1
map1 map2
map2 =
  (v1 -> v2 -> v2) -> MutableDeps v1 -> map2 -> map2
forall map1 map2 k v1 v2 s1 s2.
(NMap map1 k v1 s1, NMap map2 k v2 s2) =>
(v1 -> v2 -> v2) -> map1 -> map2 -> map2
nAmend v1 -> v2 -> v2
f ((PackageName -> MutableDep) -> map1 -> MutableDeps v1
forall map1 k1 v sort1 map2 k2 sort2.
(NMap map1 k1 v sort1, NMap map2 k2 v sort2) =>
(k1 -> k2) -> map1 -> map2
nMapKeys PackageName -> MutableDep
UnsafeMutableDep map1
map1 :: MutableDeps v1) map2
map2

-- | Replace entries in a MutableDep map with those from a PackageName map, only where the original is defined.
mutReplacePartial ::
  ∀ map1 map2 v1 s1 s2 .
  NMap map1 PackageName v1 s1 =>
  NMap map2 MutableDep v1 s2 =>
  map1 ->
  map2 ->
  map2
mutReplacePartial :: forall map1 map2 v1 s1 s2.
(NMap map1 PackageName v1 s1, NMap map2 MutableDep v1 s2) =>
map1 -> map2 -> map2
mutReplacePartial =
  (v1 -> v1 -> v1) -> map1 -> map2 -> map2
forall map1 map2 v1 v2 s1 s2.
(NMap map1 PackageName v1 s1, NMap map2 MutableDep v2 s2) =>
(v1 -> v2 -> v2) -> map1 -> map2 -> map2
mutUpdatePartial v1 -> v1 -> v1
forall a b. a -> b -> a
const

addBuildVersions :: Versions -> MutableVersions -> MutableVersions
addBuildVersions :: Versions -> MutableVersions -> MutableVersions
addBuildVersions Versions
versions =
  Deps (Maybe Version) -> MutableVersions -> MutableVersions
forall map1 map2 v1 s1 s2.
(NMap map1 PackageName v1 s1, NMap map2 MutableDep v1 s2) =>
map1 -> map2 -> map2
mutReplacePartial ((Version -> Maybe Version) -> Versions -> Deps (Maybe Version)
forall map1 k v1 sort1 map2 v2 sort2.
(NMap map1 k v1 sort1, NMap map2 k v2 sort2) =>
(v1 -> v2) -> map1 -> map2
nMap Version -> Maybe Version
forall a. a -> Maybe a
Just Versions
versions :: Deps (Maybe Version))

classifyPackageDep :: Set LocalPackage -> Dep -> Either (LocalPackage, VersionRange) (MutableDep, VersionRange)
classifyPackageDep :: Set LocalPackage
-> Dep
-> Either (LocalPackage, VersionRange) (MutableDep, VersionRange)
classifyPackageDep Set LocalPackage
locals Dep {PackageName
package :: PackageName
package :: Dep -> PackageName
package, VersionRange
version :: VersionRange
version :: Dep -> VersionRange
version}
  | LocalPackage -> Set LocalPackage -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.member LocalPackage
localName Set LocalPackage
locals
  = (LocalPackage, VersionRange)
-> Either (LocalPackage, VersionRange) (MutableDep, VersionRange)
forall a b. a -> Either a b
Left (LocalPackage
localName, VersionRange
version)
  | Bool
otherwise
  = (MutableDep, VersionRange)
-> Either (LocalPackage, VersionRange) (MutableDep, VersionRange)
forall a b. b -> Either a b
Right (PackageName -> MutableDep
UnsafeMutableDep PackageName
package, VersionRange
version)
  where
    localName :: LocalPackage
localName = PackageName -> LocalPackage
LocalPackage PackageName
package

mutFromSet ::
  NMap map MutableDep v sort =>
  Set MutableDep ->
  (MutableDep -> v) ->
  map
mutFromSet :: forall map v sort.
NMap map MutableDep v sort =>
Set MutableDep -> (MutableDep -> v) -> map
mutFromSet =
  Set MutableDep -> (MutableDep -> v) -> map
forall (t :: * -> *) map k v sort.
(Foldable t, NMap map k v sort) =>
t k -> (k -> v) -> map
nFromKeys