{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE ViewPatterns #-}
module NvFetcher.Types
(
Version (..),
SHA256 (..),
NixExpr,
VersionChange (..),
WithPackageKey (..),
Core (..),
VersionSource (..),
NvcheckerResult (..),
NixFetcher (..),
Prefetch (..),
PrefetchResult,
PackageName,
PackageFetcher,
Package (..),
PackageKey (..),
)
where
import qualified Data.Aeson as A
import Data.Coerce (coerce)
import Data.Maybe (fromMaybe)
import Data.String (IsString)
import Data.Text (Text)
import qualified Data.Text as T
import Development.Shake
import Development.Shake.Classes
import GHC.Generics (Generic)
newtype Version = Version Text
deriving newtype (Version -> Version -> Bool
(Version -> Version -> Bool)
-> (Version -> Version -> Bool) -> Eq Version
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Version -> Version -> Bool
$c/= :: Version -> Version -> Bool
== :: Version -> Version -> Bool
$c== :: Version -> Version -> Bool
Eq, Int -> Version -> ShowS
[Version] -> ShowS
Version -> String
(Int -> Version -> ShowS)
-> (Version -> String) -> ([Version] -> ShowS) -> Show Version
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Version] -> ShowS
$cshowList :: [Version] -> ShowS
show :: Version -> String
$cshow :: Version -> String
showsPrec :: Int -> Version -> ShowS
$cshowsPrec :: Int -> Version -> ShowS
Show, Eq Version
Eq Version
-> (Version -> Version -> Ordering)
-> (Version -> Version -> Bool)
-> (Version -> Version -> Bool)
-> (Version -> Version -> Bool)
-> (Version -> Version -> Bool)
-> (Version -> Version -> Version)
-> (Version -> Version -> Version)
-> Ord Version
Version -> Version -> Bool
Version -> Version -> Ordering
Version -> Version -> Version
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 :: Version -> Version -> Version
$cmin :: Version -> Version -> Version
max :: Version -> Version -> Version
$cmax :: Version -> Version -> Version
>= :: Version -> Version -> Bool
$c>= :: Version -> Version -> Bool
> :: Version -> Version -> Bool
$c> :: Version -> Version -> Bool
<= :: Version -> Version -> Bool
$c<= :: Version -> Version -> Bool
< :: Version -> Version -> Bool
$c< :: Version -> Version -> Bool
compare :: Version -> Version -> Ordering
$ccompare :: Version -> Version -> Ordering
$cp1Ord :: Eq Version
Ord, String -> Version
(String -> Version) -> IsString Version
forall a. (String -> a) -> IsString a
fromString :: String -> Version
$cfromString :: String -> Version
IsString, b -> Version -> Version
NonEmpty Version -> Version
Version -> Version -> Version
(Version -> Version -> Version)
-> (NonEmpty Version -> Version)
-> (forall b. Integral b => b -> Version -> Version)
-> Semigroup Version
forall b. Integral b => b -> Version -> Version
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> Version -> Version
$cstimes :: forall b. Integral b => b -> Version -> Version
sconcat :: NonEmpty Version -> Version
$csconcat :: NonEmpty Version -> Version
<> :: Version -> Version -> Version
$c<> :: Version -> Version -> Version
Semigroup, Semigroup Version
Version
Semigroup Version
-> Version
-> (Version -> Version -> Version)
-> ([Version] -> Version)
-> Monoid Version
[Version] -> Version
Version -> Version -> Version
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
mconcat :: [Version] -> Version
$cmconcat :: [Version] -> Version
mappend :: Version -> Version -> Version
$cmappend :: Version -> Version -> Version
mempty :: Version
$cmempty :: Version
$cp1Monoid :: Semigroup Version
Monoid, Value -> Parser [Version]
Value -> Parser Version
(Value -> Parser Version)
-> (Value -> Parser [Version]) -> FromJSON Version
forall a.
(Value -> Parser a) -> (Value -> Parser [a]) -> FromJSON a
parseJSONList :: Value -> Parser [Version]
$cparseJSONList :: Value -> Parser [Version]
parseJSON :: Value -> Parser Version
$cparseJSON :: Value -> Parser Version
A.FromJSON, [Version] -> Encoding
[Version] -> Value
Version -> Encoding
Version -> Value
(Version -> Value)
-> (Version -> Encoding)
-> ([Version] -> Value)
-> ([Version] -> Encoding)
-> ToJSON Version
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> ToJSON a
toEncodingList :: [Version] -> Encoding
$ctoEncodingList :: [Version] -> Encoding
toJSONList :: [Version] -> Value
$ctoJSONList :: [Version] -> Value
toEncoding :: Version -> Encoding
$ctoEncoding :: Version -> Encoding
toJSON :: Version -> Value
$ctoJSON :: Version -> Value
A.ToJSON)
deriving stock (Typeable, (forall x. Version -> Rep Version x)
-> (forall x. Rep Version x -> Version) -> Generic Version
forall x. Rep Version x -> Version
forall x. Version -> Rep Version x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Version x -> Version
$cfrom :: forall x. Version -> Rep Version x
Generic)
deriving anyclass (Int -> Version -> Int
Version -> Int
(Int -> Version -> Int) -> (Version -> Int) -> Hashable Version
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Version -> Int
$chash :: Version -> Int
hashWithSalt :: Int -> Version -> Int
$chashWithSalt :: Int -> Version -> Int
Hashable, Get Version
[Version] -> Put
Version -> Put
(Version -> Put)
-> Get Version -> ([Version] -> Put) -> Binary Version
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [Version] -> Put
$cputList :: [Version] -> Put
get :: Get Version
$cget :: Get Version
put :: Version -> Put
$cput :: Version -> Put
Binary, Version -> ()
(Version -> ()) -> NFData Version
forall a. (a -> ()) -> NFData a
rnf :: Version -> ()
$crnf :: Version -> ()
NFData)
newtype SHA256 = SHA256 Text
deriving newtype (Int -> SHA256 -> ShowS
[SHA256] -> ShowS
SHA256 -> String
(Int -> SHA256 -> ShowS)
-> (SHA256 -> String) -> ([SHA256] -> ShowS) -> Show SHA256
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SHA256] -> ShowS
$cshowList :: [SHA256] -> ShowS
show :: SHA256 -> String
$cshow :: SHA256 -> String
showsPrec :: Int -> SHA256 -> ShowS
$cshowsPrec :: Int -> SHA256 -> ShowS
Show, SHA256 -> SHA256 -> Bool
(SHA256 -> SHA256 -> Bool)
-> (SHA256 -> SHA256 -> Bool) -> Eq SHA256
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SHA256 -> SHA256 -> Bool
$c/= :: SHA256 -> SHA256 -> Bool
== :: SHA256 -> SHA256 -> Bool
$c== :: SHA256 -> SHA256 -> Bool
Eq)
deriving stock (Typeable, (forall x. SHA256 -> Rep SHA256 x)
-> (forall x. Rep SHA256 x -> SHA256) -> Generic SHA256
forall x. Rep SHA256 x -> SHA256
forall x. SHA256 -> Rep SHA256 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SHA256 x -> SHA256
$cfrom :: forall x. SHA256 -> Rep SHA256 x
Generic)
deriving anyclass (Int -> SHA256 -> Int
SHA256 -> Int
(Int -> SHA256 -> Int) -> (SHA256 -> Int) -> Hashable SHA256
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: SHA256 -> Int
$chash :: SHA256 -> Int
hashWithSalt :: Int -> SHA256 -> Int
$chashWithSalt :: Int -> SHA256 -> Int
Hashable, Get SHA256
[SHA256] -> Put
SHA256 -> Put
(SHA256 -> Put) -> Get SHA256 -> ([SHA256] -> Put) -> Binary SHA256
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [SHA256] -> Put
$cputList :: [SHA256] -> Put
get :: Get SHA256
$cget :: Get SHA256
put :: SHA256 -> Put
$cput :: SHA256 -> Put
Binary, SHA256 -> ()
(SHA256 -> ()) -> NFData SHA256
forall a. (a -> ()) -> NFData a
rnf :: SHA256 -> ()
$crnf :: SHA256 -> ()
NFData)
data VersionChange = VersionChange
{ VersionChange -> PackageName
vcName :: PackageName,
VersionChange -> Maybe Version
vcOld :: Maybe Version,
VersionChange -> Version
vcNew :: Version
}
deriving (VersionChange -> VersionChange -> Bool
(VersionChange -> VersionChange -> Bool)
-> (VersionChange -> VersionChange -> Bool) -> Eq VersionChange
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VersionChange -> VersionChange -> Bool
$c/= :: VersionChange -> VersionChange -> Bool
== :: VersionChange -> VersionChange -> Bool
$c== :: VersionChange -> VersionChange -> Bool
Eq)
instance Show VersionChange where
show :: VersionChange -> String
show VersionChange {Maybe Version
PackageName
Version
vcNew :: Version
vcOld :: Maybe Version
vcName :: PackageName
vcNew :: VersionChange -> Version
vcOld :: VersionChange -> Maybe Version
vcName :: VersionChange -> PackageName
..} =
PackageName -> String
T.unpack (PackageName -> String) -> PackageName -> String
forall a b. (a -> b) -> a -> b
$ PackageName
vcName PackageName -> PackageName -> PackageName
forall a. Semigroup a => a -> a -> a
<> PackageName
": " PackageName -> PackageName -> PackageName
forall a. Semigroup a => a -> a -> a
<> PackageName -> Maybe PackageName -> PackageName
forall a. a -> Maybe a -> a
fromMaybe PackageName
"∅" (Maybe Version -> Maybe PackageName
coerce Maybe Version
vcOld) PackageName -> PackageName -> PackageName
forall a. Semigroup a => a -> a -> a
<> PackageName
" → " PackageName -> PackageName -> PackageName
forall a. Semigroup a => a -> a -> a
<> Version -> PackageName
coerce Version
vcNew
type NixExpr = Text
data VersionSource
= GitHubRelease {VersionSource -> PackageName
owner :: Text, VersionSource -> PackageName
repo :: Text}
| Git {VersionSource -> PackageName
vurl :: Text}
| Pypi {VersionSource -> PackageName
pypi :: Text}
| ArchLinux {VersionSource -> PackageName
archpkg :: Text}
| Aur {VersionSource -> PackageName
aur :: Text}
| Manual {VersionSource -> PackageName
manual :: Text}
| Repology {VersionSource -> PackageName
repology :: Text, repo :: Text}
deriving (Int -> VersionSource -> ShowS
[VersionSource] -> ShowS
VersionSource -> String
(Int -> VersionSource -> ShowS)
-> (VersionSource -> String)
-> ([VersionSource] -> ShowS)
-> Show VersionSource
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VersionSource] -> ShowS
$cshowList :: [VersionSource] -> ShowS
show :: VersionSource -> String
$cshow :: VersionSource -> String
showsPrec :: Int -> VersionSource -> ShowS
$cshowsPrec :: Int -> VersionSource -> ShowS
Show, Typeable, VersionSource -> VersionSource -> Bool
(VersionSource -> VersionSource -> Bool)
-> (VersionSource -> VersionSource -> Bool) -> Eq VersionSource
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VersionSource -> VersionSource -> Bool
$c/= :: VersionSource -> VersionSource -> Bool
== :: VersionSource -> VersionSource -> Bool
$c== :: VersionSource -> VersionSource -> Bool
Eq, Eq VersionSource
Eq VersionSource
-> (VersionSource -> VersionSource -> Ordering)
-> (VersionSource -> VersionSource -> Bool)
-> (VersionSource -> VersionSource -> Bool)
-> (VersionSource -> VersionSource -> Bool)
-> (VersionSource -> VersionSource -> Bool)
-> (VersionSource -> VersionSource -> VersionSource)
-> (VersionSource -> VersionSource -> VersionSource)
-> Ord VersionSource
VersionSource -> VersionSource -> Bool
VersionSource -> VersionSource -> Ordering
VersionSource -> VersionSource -> VersionSource
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 :: VersionSource -> VersionSource -> VersionSource
$cmin :: VersionSource -> VersionSource -> VersionSource
max :: VersionSource -> VersionSource -> VersionSource
$cmax :: VersionSource -> VersionSource -> VersionSource
>= :: VersionSource -> VersionSource -> Bool
$c>= :: VersionSource -> VersionSource -> Bool
> :: VersionSource -> VersionSource -> Bool
$c> :: VersionSource -> VersionSource -> Bool
<= :: VersionSource -> VersionSource -> Bool
$c<= :: VersionSource -> VersionSource -> Bool
< :: VersionSource -> VersionSource -> Bool
$c< :: VersionSource -> VersionSource -> Bool
compare :: VersionSource -> VersionSource -> Ordering
$ccompare :: VersionSource -> VersionSource -> Ordering
$cp1Ord :: Eq VersionSource
Ord, (forall x. VersionSource -> Rep VersionSource x)
-> (forall x. Rep VersionSource x -> VersionSource)
-> Generic VersionSource
forall x. Rep VersionSource x -> VersionSource
forall x. VersionSource -> Rep VersionSource x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VersionSource x -> VersionSource
$cfrom :: forall x. VersionSource -> Rep VersionSource x
Generic, Int -> VersionSource -> Int
VersionSource -> Int
(Int -> VersionSource -> Int)
-> (VersionSource -> Int) -> Hashable VersionSource
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: VersionSource -> Int
$chash :: VersionSource -> Int
hashWithSalt :: Int -> VersionSource -> Int
$chashWithSalt :: Int -> VersionSource -> Int
Hashable, Get VersionSource
[VersionSource] -> Put
VersionSource -> Put
(VersionSource -> Put)
-> Get VersionSource
-> ([VersionSource] -> Put)
-> Binary VersionSource
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [VersionSource] -> Put
$cputList :: [VersionSource] -> Put
get :: Get VersionSource
$cget :: Get VersionSource
put :: VersionSource -> Put
$cput :: VersionSource -> Put
Binary, VersionSource -> ()
(VersionSource -> ()) -> NFData VersionSource
forall a. (a -> ()) -> NFData a
rnf :: VersionSource -> ()
$crnf :: VersionSource -> ()
NFData)
data NvcheckerResult = NvcheckerResult
{ NvcheckerResult -> Version
nvNow :: Version,
NvcheckerResult -> Maybe Version
nvOld :: Maybe Version
}
deriving (Int -> NvcheckerResult -> ShowS
[NvcheckerResult] -> ShowS
NvcheckerResult -> String
(Int -> NvcheckerResult -> ShowS)
-> (NvcheckerResult -> String)
-> ([NvcheckerResult] -> ShowS)
-> Show NvcheckerResult
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NvcheckerResult] -> ShowS
$cshowList :: [NvcheckerResult] -> ShowS
show :: NvcheckerResult -> String
$cshow :: NvcheckerResult -> String
showsPrec :: Int -> NvcheckerResult -> ShowS
$cshowsPrec :: Int -> NvcheckerResult -> ShowS
Show, Typeable, NvcheckerResult -> NvcheckerResult -> Bool
(NvcheckerResult -> NvcheckerResult -> Bool)
-> (NvcheckerResult -> NvcheckerResult -> Bool)
-> Eq NvcheckerResult
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NvcheckerResult -> NvcheckerResult -> Bool
$c/= :: NvcheckerResult -> NvcheckerResult -> Bool
== :: NvcheckerResult -> NvcheckerResult -> Bool
$c== :: NvcheckerResult -> NvcheckerResult -> Bool
Eq, (forall x. NvcheckerResult -> Rep NvcheckerResult x)
-> (forall x. Rep NvcheckerResult x -> NvcheckerResult)
-> Generic NvcheckerResult
forall x. Rep NvcheckerResult x -> NvcheckerResult
forall x. NvcheckerResult -> Rep NvcheckerResult x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NvcheckerResult x -> NvcheckerResult
$cfrom :: forall x. NvcheckerResult -> Rep NvcheckerResult x
Generic, Int -> NvcheckerResult -> Int
NvcheckerResult -> Int
(Int -> NvcheckerResult -> Int)
-> (NvcheckerResult -> Int) -> Hashable NvcheckerResult
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: NvcheckerResult -> Int
$chash :: NvcheckerResult -> Int
hashWithSalt :: Int -> NvcheckerResult -> Int
$chashWithSalt :: Int -> NvcheckerResult -> Int
Hashable, Get NvcheckerResult
[NvcheckerResult] -> Put
NvcheckerResult -> Put
(NvcheckerResult -> Put)
-> Get NvcheckerResult
-> ([NvcheckerResult] -> Put)
-> Binary NvcheckerResult
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [NvcheckerResult] -> Put
$cputList :: [NvcheckerResult] -> Put
get :: Get NvcheckerResult
$cget :: Get NvcheckerResult
put :: NvcheckerResult -> Put
$cput :: NvcheckerResult -> Put
Binary, NvcheckerResult -> ()
(NvcheckerResult -> ()) -> NFData NvcheckerResult
forall a. (a -> ()) -> NFData a
rnf :: NvcheckerResult -> ()
$crnf :: NvcheckerResult -> ()
NFData)
instance A.FromJSON NvcheckerResult where
parseJSON :: Value -> Parser NvcheckerResult
parseJSON = String
-> (Object -> Parser NvcheckerResult)
-> Value
-> Parser NvcheckerResult
forall a. String -> (Object -> Parser a) -> Value -> Parser a
A.withObject String
"NvcheckerResult" ((Object -> Parser NvcheckerResult)
-> Value -> Parser NvcheckerResult)
-> (Object -> Parser NvcheckerResult)
-> Value
-> Parser NvcheckerResult
forall a b. (a -> b) -> a -> b
$ \Object
o ->
Version -> Maybe Version -> NvcheckerResult
NvcheckerResult (Version -> Maybe Version -> NvcheckerResult)
-> Parser Version -> Parser (Maybe Version -> NvcheckerResult)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> PackageName -> Parser Version
forall a. FromJSON a => Object -> PackageName -> Parser a
A..: PackageName
"version" Parser (Maybe Version -> NvcheckerResult)
-> Parser (Maybe Version) -> Parser NvcheckerResult
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Version -> Parser (Maybe Version)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Version
forall a. Maybe a
Nothing
type instance RuleResult VersionSource = NvcheckerResult
data NixFetcher (k :: Prefetch)
= FetchGit
{ NixFetcher k -> PackageName
furl :: Text,
NixFetcher k -> Version
rev :: Version,
NixFetcher k -> Maybe PackageName
branch :: Maybe Text,
NixFetcher k -> Bool
deepClone :: Bool,
NixFetcher k -> Bool
fetchSubmodules :: Bool,
NixFetcher k -> Bool
leaveDotGit :: Bool,
NixFetcher k -> PrefetchResult k
sha256 :: PrefetchResult k
}
| FetchUrl {furl :: Text, sha256 :: PrefetchResult k}
deriving (Typeable, (forall x. NixFetcher k -> Rep (NixFetcher k) x)
-> (forall x. Rep (NixFetcher k) x -> NixFetcher k)
-> Generic (NixFetcher k)
forall x. Rep (NixFetcher k) x -> NixFetcher k
forall x. NixFetcher k -> Rep (NixFetcher k) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (k :: Prefetch) x. Rep (NixFetcher k) x -> NixFetcher k
forall (k :: Prefetch) x. NixFetcher k -> Rep (NixFetcher k) x
$cto :: forall (k :: Prefetch) x. Rep (NixFetcher k) x -> NixFetcher k
$cfrom :: forall (k :: Prefetch) x. NixFetcher k -> Rep (NixFetcher k) x
Generic)
data Prefetch = Fresh | Prefetched
type family PrefetchResult (k :: Prefetch) where
PrefetchResult Fresh = ()
PrefetchResult Prefetched = SHA256
type instance RuleResult (NixFetcher Fresh) = NixFetcher Prefetched
deriving instance Show (PrefetchResult k) => Show (NixFetcher k)
deriving instance Eq (PrefetchResult k) => Eq (NixFetcher k)
deriving instance Ord (PrefetchResult k) => Ord (NixFetcher k)
deriving instance Hashable (PrefetchResult k) => Hashable (NixFetcher k)
deriving instance Binary (PrefetchResult k) => Binary (NixFetcher k)
deriving instance NFData (PrefetchResult k) => NFData (NixFetcher k)
type PackageName = Text
type PackageFetcher = Version -> NixFetcher Fresh
data Package = Package
{ Package -> PackageName
pname :: PackageName,
Package -> VersionSource
pversion :: VersionSource,
Package -> PackageFetcher
pfetcher :: PackageFetcher
}
newtype PackageKey = PackageKey PackageName
deriving newtype (PackageKey -> PackageKey -> Bool
(PackageKey -> PackageKey -> Bool)
-> (PackageKey -> PackageKey -> Bool) -> Eq PackageKey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackageKey -> PackageKey -> Bool
$c/= :: PackageKey -> PackageKey -> Bool
== :: PackageKey -> PackageKey -> Bool
$c== :: PackageKey -> PackageKey -> Bool
Eq, Int -> PackageKey -> ShowS
[PackageKey] -> ShowS
PackageKey -> String
(Int -> PackageKey -> ShowS)
-> (PackageKey -> String)
-> ([PackageKey] -> ShowS)
-> Show PackageKey
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PackageKey] -> ShowS
$cshowList :: [PackageKey] -> ShowS
show :: PackageKey -> String
$cshow :: PackageKey -> String
showsPrec :: Int -> PackageKey -> ShowS
$cshowsPrec :: Int -> PackageKey -> ShowS
Show, Eq PackageKey
Eq PackageKey
-> (PackageKey -> PackageKey -> Ordering)
-> (PackageKey -> PackageKey -> Bool)
-> (PackageKey -> PackageKey -> Bool)
-> (PackageKey -> PackageKey -> Bool)
-> (PackageKey -> PackageKey -> Bool)
-> (PackageKey -> PackageKey -> PackageKey)
-> (PackageKey -> PackageKey -> PackageKey)
-> Ord PackageKey
PackageKey -> PackageKey -> Bool
PackageKey -> PackageKey -> Ordering
PackageKey -> PackageKey -> PackageKey
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 :: PackageKey -> PackageKey -> PackageKey
$cmin :: PackageKey -> PackageKey -> PackageKey
max :: PackageKey -> PackageKey -> PackageKey
$cmax :: PackageKey -> PackageKey -> PackageKey
>= :: PackageKey -> PackageKey -> Bool
$c>= :: PackageKey -> PackageKey -> Bool
> :: PackageKey -> PackageKey -> Bool
$c> :: PackageKey -> PackageKey -> Bool
<= :: PackageKey -> PackageKey -> Bool
$c<= :: PackageKey -> PackageKey -> Bool
< :: PackageKey -> PackageKey -> Bool
$c< :: PackageKey -> PackageKey -> Bool
compare :: PackageKey -> PackageKey -> Ordering
$ccompare :: PackageKey -> PackageKey -> Ordering
$cp1Ord :: Eq PackageKey
Ord)
deriving stock (Typeable, (forall x. PackageKey -> Rep PackageKey x)
-> (forall x. Rep PackageKey x -> PackageKey) -> Generic PackageKey
forall x. Rep PackageKey x -> PackageKey
forall x. PackageKey -> Rep PackageKey x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PackageKey x -> PackageKey
$cfrom :: forall x. PackageKey -> Rep PackageKey x
Generic)
deriving anyclass (Int -> PackageKey -> Int
PackageKey -> Int
(Int -> PackageKey -> Int)
-> (PackageKey -> Int) -> Hashable PackageKey
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: PackageKey -> Int
$chash :: PackageKey -> Int
hashWithSalt :: Int -> PackageKey -> Int
$chashWithSalt :: Int -> PackageKey -> Int
Hashable, Get PackageKey
[PackageKey] -> Put
PackageKey -> Put
(PackageKey -> Put)
-> Get PackageKey -> ([PackageKey] -> Put) -> Binary PackageKey
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [PackageKey] -> Put
$cputList :: [PackageKey] -> Put
get :: Get PackageKey
$cget :: Get PackageKey
put :: PackageKey -> Put
$cput :: PackageKey -> Put
Binary, PackageKey -> ()
(PackageKey -> ()) -> NFData PackageKey
forall a. (a -> ()) -> NFData a
rnf :: PackageKey -> ()
$crnf :: PackageKey -> ()
NFData)
data Core = Core
deriving (Core -> Core -> Bool
(Core -> Core -> Bool) -> (Core -> Core -> Bool) -> Eq Core
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Core -> Core -> Bool
$c/= :: Core -> Core -> Bool
== :: Core -> Core -> Bool
$c== :: Core -> Core -> Bool
Eq, Int -> Core -> ShowS
[Core] -> ShowS
Core -> String
(Int -> Core -> ShowS)
-> (Core -> String) -> ([Core] -> ShowS) -> Show Core
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Core] -> ShowS
$cshowList :: [Core] -> ShowS
show :: Core -> String
$cshow :: Core -> String
showsPrec :: Int -> Core -> ShowS
$cshowsPrec :: Int -> Core -> ShowS
Show, Eq Core
Eq Core
-> (Core -> Core -> Ordering)
-> (Core -> Core -> Bool)
-> (Core -> Core -> Bool)
-> (Core -> Core -> Bool)
-> (Core -> Core -> Bool)
-> (Core -> Core -> Core)
-> (Core -> Core -> Core)
-> Ord Core
Core -> Core -> Bool
Core -> Core -> Ordering
Core -> Core -> Core
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 :: Core -> Core -> Core
$cmin :: Core -> Core -> Core
max :: Core -> Core -> Core
$cmax :: Core -> Core -> Core
>= :: Core -> Core -> Bool
$c>= :: Core -> Core -> Bool
> :: Core -> Core -> Bool
$c> :: Core -> Core -> Bool
<= :: Core -> Core -> Bool
$c<= :: Core -> Core -> Bool
< :: Core -> Core -> Bool
$c< :: Core -> Core -> Bool
compare :: Core -> Core -> Ordering
$ccompare :: Core -> Core -> Ordering
$cp1Ord :: Eq Core
Ord, Typeable, (forall x. Core -> Rep Core x)
-> (forall x. Rep Core x -> Core) -> Generic Core
forall x. Rep Core x -> Core
forall x. Core -> Rep Core x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Core x -> Core
$cfrom :: forall x. Core -> Rep Core x
Generic, Int -> Core -> Int
Core -> Int
(Int -> Core -> Int) -> (Core -> Int) -> Hashable Core
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: Core -> Int
$chash :: Core -> Int
hashWithSalt :: Int -> Core -> Int
$chashWithSalt :: Int -> Core -> Int
Hashable, Get Core
[Core] -> Put
Core -> Put
(Core -> Put) -> Get Core -> ([Core] -> Put) -> Binary Core
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [Core] -> Put
$cputList :: [Core] -> Put
get :: Get Core
$cget :: Get Core
put :: Core -> Put
$cput :: Core -> Put
Binary, Core -> ()
(Core -> ()) -> NFData Core
forall a. (a -> ()) -> NFData a
rnf :: Core -> ()
$crnf :: Core -> ()
NFData)
type instance RuleResult Core = NixExpr
newtype WithPackageKey k = WithPackageKey (k, PackageKey)
deriving newtype (WithPackageKey k -> WithPackageKey k -> Bool
(WithPackageKey k -> WithPackageKey k -> Bool)
-> (WithPackageKey k -> WithPackageKey k -> Bool)
-> Eq (WithPackageKey k)
forall k. Eq k => WithPackageKey k -> WithPackageKey k -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WithPackageKey k -> WithPackageKey k -> Bool
$c/= :: forall k. Eq k => WithPackageKey k -> WithPackageKey k -> Bool
== :: WithPackageKey k -> WithPackageKey k -> Bool
$c== :: forall k. Eq k => WithPackageKey k -> WithPackageKey k -> Bool
Eq, Int -> WithPackageKey k -> Int
WithPackageKey k -> Int
(Int -> WithPackageKey k -> Int)
-> (WithPackageKey k -> Int) -> Hashable (WithPackageKey k)
forall k. Hashable k => Int -> WithPackageKey k -> Int
forall k. Hashable k => WithPackageKey k -> Int
forall a. (Int -> a -> Int) -> (a -> Int) -> Hashable a
hash :: WithPackageKey k -> Int
$chash :: forall k. Hashable k => WithPackageKey k -> Int
hashWithSalt :: Int -> WithPackageKey k -> Int
$chashWithSalt :: forall k. Hashable k => Int -> WithPackageKey k -> Int
Hashable, Get (WithPackageKey k)
[WithPackageKey k] -> Put
WithPackageKey k -> Put
(WithPackageKey k -> Put)
-> Get (WithPackageKey k)
-> ([WithPackageKey k] -> Put)
-> Binary (WithPackageKey k)
forall k. Binary k => Get (WithPackageKey k)
forall k. Binary k => [WithPackageKey k] -> Put
forall k. Binary k => WithPackageKey k -> Put
forall t. (t -> Put) -> Get t -> ([t] -> Put) -> Binary t
putList :: [WithPackageKey k] -> Put
$cputList :: forall k. Binary k => [WithPackageKey k] -> Put
get :: Get (WithPackageKey k)
$cget :: forall k. Binary k => Get (WithPackageKey k)
put :: WithPackageKey k -> Put
$cput :: forall k. Binary k => WithPackageKey k -> Put
Binary, WithPackageKey k -> ()
(WithPackageKey k -> ()) -> NFData (WithPackageKey k)
forall k. NFData k => WithPackageKey k -> ()
forall a. (a -> ()) -> NFData a
rnf :: WithPackageKey k -> ()
$crnf :: forall k. NFData k => WithPackageKey k -> ()
NFData)
instance Show k => Show (WithPackageKey k) where
show :: WithPackageKey k -> String
show (WithPackageKey (k
k, PackageKey
n)) = k -> String
forall a. Show a => a -> String
show k
k String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
" (" String -> ShowS
forall a. Semigroup a => a -> a -> a
<> PackageKey -> String
forall a. Show a => a -> String
show PackageKey
n String -> ShowS
forall a. Semigroup a => a -> a -> a
<> String
")"
type instance RuleResult (WithPackageKey k) = RuleResult k