-- Needed for `deriving Arbitrary via GenericArbitrary DerivationDiff`:
{-# OPTIONS_GHC -fconstraint-solver-iterations=0 #-}
-- Needed for `deriving instance Data (DerivationOutput StorePath Text)`:
{-# OPTIONS_GHC -Wno-orphans #-}

module Nix.Diff.Types where

import Data.List.NonEmpty (NonEmpty(..))
import qualified Data.List.NonEmpty as NonEmpty
import Data.Map (Map)
import qualified Data.Map as Map
import Data.Set (Set)
import Data.Text (Text)
import Nix.Derivation (DerivationOutput (..))
import Nix.Diff.Store ( StorePath )

import qualified Patience
import GHC.Generics (Generic)
import Data.Foldable
import Data.Aeson
import Data.Aeson.Types
import Test.QuickCheck
import Test.QuickCheck.Instances ()
import Test.QuickCheck.Arbitrary.Generic (GenericArbitrary(..))
import Data.Data (Data)

{- ** NOTE: Lawless instances
   All the Arbitrary instances here are written to
   check if `decode . encode == id` rule was broken,
   so they don't respect to internal laws of these types,
   such as "Maps from `extraOutputs` must not have
   intersecting keys" and so on.
   If you want to test these invariants, you have to rewrite
   instances manually.
-}

data Changed a = Changed { forall a. Changed a -> a
before :: a, forall a. Changed a -> a
now :: a }
  deriving stock (Changed a -> Changed a -> Bool
(Changed a -> Changed a -> Bool)
-> (Changed a -> Changed a -> Bool) -> Eq (Changed a)
forall a. Eq a => Changed a -> Changed a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Changed a -> Changed a -> Bool
== :: Changed a -> Changed a -> Bool
$c/= :: forall a. Eq a => Changed a -> Changed a -> Bool
/= :: Changed a -> Changed a -> Bool
Eq, Int -> Changed a -> ShowS
[Changed a] -> ShowS
Changed a -> String
(Int -> Changed a -> ShowS)
-> (Changed a -> String)
-> ([Changed a] -> ShowS)
-> Show (Changed a)
forall a. Show a => Int -> Changed a -> ShowS
forall a. Show a => [Changed a] -> ShowS
forall a. Show a => Changed a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Changed a -> ShowS
showsPrec :: Int -> Changed a -> ShowS
$cshow :: forall a. Show a => Changed a -> String
show :: Changed a -> String
$cshowList :: forall a. Show a => [Changed a] -> ShowS
showList :: [Changed a] -> ShowS
Show, (forall a b. (a -> b) -> Changed a -> Changed b)
-> (forall a b. a -> Changed b -> Changed a) -> Functor Changed
forall a b. a -> Changed b -> Changed a
forall a b. (a -> b) -> Changed a -> Changed b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Changed a -> Changed b
fmap :: forall a b. (a -> b) -> Changed a -> Changed b
$c<$ :: forall a b. a -> Changed b -> Changed a
<$ :: forall a b. a -> Changed b -> Changed a
Functor, (forall m. Monoid m => Changed m -> m)
-> (forall m a. Monoid m => (a -> m) -> Changed a -> m)
-> (forall m a. Monoid m => (a -> m) -> Changed a -> m)
-> (forall a b. (a -> b -> b) -> b -> Changed a -> b)
-> (forall a b. (a -> b -> b) -> b -> Changed a -> b)
-> (forall b a. (b -> a -> b) -> b -> Changed a -> b)
-> (forall b a. (b -> a -> b) -> b -> Changed a -> b)
-> (forall a. (a -> a -> a) -> Changed a -> a)
-> (forall a. (a -> a -> a) -> Changed a -> a)
-> (forall a. Changed a -> [a])
-> (forall a. Changed a -> Bool)
-> (forall a. Changed a -> Int)
-> (forall a. Eq a => a -> Changed a -> Bool)
-> (forall a. Ord a => Changed a -> a)
-> (forall a. Ord a => Changed a -> a)
-> (forall a. Num a => Changed a -> a)
-> (forall a. Num a => Changed a -> a)
-> Foldable Changed
forall a. Eq a => a -> Changed a -> Bool
forall a. Num a => Changed a -> a
forall a. Ord a => Changed a -> a
forall m. Monoid m => Changed m -> m
forall a. Changed a -> Bool
forall a. Changed a -> Int
forall a. Changed a -> [a]
forall a. (a -> a -> a) -> Changed a -> a
forall m a. Monoid m => (a -> m) -> Changed a -> m
forall b a. (b -> a -> b) -> b -> Changed a -> b
forall a b. (a -> b -> b) -> b -> Changed a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Changed m -> m
fold :: forall m. Monoid m => Changed m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Changed a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Changed a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Changed a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Changed a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Changed a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Changed a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Changed a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Changed a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Changed a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Changed a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Changed a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Changed a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Changed a -> a
foldr1 :: forall a. (a -> a -> a) -> Changed a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Changed a -> a
foldl1 :: forall a. (a -> a -> a) -> Changed a -> a
$ctoList :: forall a. Changed a -> [a]
toList :: forall a. Changed a -> [a]
$cnull :: forall a. Changed a -> Bool
null :: forall a. Changed a -> Bool
$clength :: forall a. Changed a -> Int
length :: forall a. Changed a -> Int
$celem :: forall a. Eq a => a -> Changed a -> Bool
elem :: forall a. Eq a => a -> Changed a -> Bool
$cmaximum :: forall a. Ord a => Changed a -> a
maximum :: forall a. Ord a => Changed a -> a
$cminimum :: forall a. Ord a => Changed a -> a
minimum :: forall a. Ord a => Changed a -> a
$csum :: forall a. Num a => Changed a -> a
sum :: forall a. Num a => Changed a -> a
$cproduct :: forall a. Num a => Changed a -> a
product :: forall a. Num a => Changed a -> a
Foldable, Functor Changed
Foldable Changed
(Functor Changed, Foldable Changed) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Changed a -> f (Changed b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Changed (f a) -> f (Changed a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Changed a -> m (Changed b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Changed (m a) -> m (Changed a))
-> Traversable Changed
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Changed (m a) -> m (Changed a)
forall (f :: * -> *) a.
Applicative f =>
Changed (f a) -> f (Changed a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Changed a -> m (Changed b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Changed a -> f (Changed b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Changed a -> f (Changed b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Changed a -> f (Changed b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Changed (f a) -> f (Changed a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Changed (f a) -> f (Changed a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Changed a -> m (Changed b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Changed a -> m (Changed b)
$csequence :: forall (m :: * -> *) a. Monad m => Changed (m a) -> m (Changed a)
sequence :: forall (m :: * -> *) a. Monad m => Changed (m a) -> m (Changed a)
Traversable, (forall x. Changed a -> Rep (Changed a) x)
-> (forall x. Rep (Changed a) x -> Changed a)
-> Generic (Changed a)
forall x. Rep (Changed a) x -> Changed a
forall x. Changed a -> Rep (Changed a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Changed a) x -> Changed a
forall a x. Changed a -> Rep (Changed a) x
$cfrom :: forall a x. Changed a -> Rep (Changed a) x
from :: forall x. Changed a -> Rep (Changed a) x
$cto :: forall a x. Rep (Changed a) x -> Changed a
to :: forall x. Rep (Changed a) x -> Changed a
Generic, Typeable (Changed a)
Typeable (Changed a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Changed a -> c (Changed a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Changed a))
-> (Changed a -> Constr)
-> (Changed a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Changed a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Changed a)))
-> ((forall b. Data b => b -> b) -> Changed a -> Changed a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Changed a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Changed a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Changed a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Changed a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Changed a -> m (Changed a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Changed a -> m (Changed a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Changed a -> m (Changed a))
-> Data (Changed a)
Changed a -> Constr
Changed a -> DataType
(forall b. Data b => b -> b) -> Changed a -> Changed a
forall a. Data a => Typeable (Changed a)
forall a. Data a => Changed a -> Constr
forall a. Data a => Changed a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Changed a -> Changed a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Changed a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Changed a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Changed a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Changed a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Changed a -> m (Changed a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Changed a -> m (Changed a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Changed a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Changed a -> c (Changed a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Changed a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Changed a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Changed a -> u
forall u. (forall d. Data d => d -> u) -> Changed a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Changed a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Changed a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Changed a -> m (Changed a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Changed a -> m (Changed a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Changed a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Changed a -> c (Changed a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Changed a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Changed a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Changed a -> c (Changed a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Changed a -> c (Changed a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Changed a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Changed a)
$ctoConstr :: forall a. Data a => Changed a -> Constr
toConstr :: Changed a -> Constr
$cdataTypeOf :: forall a. Data a => Changed a -> DataType
dataTypeOf :: Changed a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Changed a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Changed a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Changed a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Changed a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Changed a -> Changed a
gmapT :: (forall b. Data b => b -> b) -> Changed a -> Changed a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Changed a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Changed a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Changed a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Changed a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Changed a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Changed a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Changed a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Changed a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Changed a -> m (Changed a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Changed a -> m (Changed a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Changed a -> m (Changed a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Changed a -> m (Changed a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Changed a -> m (Changed a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Changed a -> m (Changed a)
Data)

instance (Arbitrary a) => Arbitrary (Changed a) where
  arbitrary :: Gen (Changed a)
arbitrary = a -> a -> Changed a
forall a. a -> a -> Changed a
Changed (a -> a -> Changed a) -> Gen a -> Gen (a -> Changed a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen a
forall a. Arbitrary a => Gen a
arbitrary Gen (a -> Changed a) -> Gen a -> Gen (Changed a)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen a
forall a. Arbitrary a => Gen a
arbitrary
  shrink :: Changed a -> [Changed a]
shrink = Changed a -> [Changed a]
forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
a -> [a]
genericShrink

instance ToJSON a => ToJSON (Changed a) where
  toJSON :: Changed a -> Value
toJSON = (a -> Value) -> Changed a -> Value
forall a. (a -> Value) -> Changed a -> Value
changedToJSON a -> Value
forall a. ToJSON a => a -> Value
toJSON

instance FromJSON a => FromJSON (Changed a) where
  parseJSON :: Value -> Parser (Changed a)
parseJSON = (Value -> Parser a) -> Value -> Parser (Changed a)
forall a. (Value -> Parser a) -> Value -> Parser (Changed a)
changedFromJSON Value -> Parser a
forall a. FromJSON a => Value -> Parser a
parseJSON

newtype TextDiff = TextDiff {TextDiff -> [Item Text]
unTextDiff :: [Patience.Item Text]}
  deriving stock (TextDiff -> TextDiff -> Bool
(TextDiff -> TextDiff -> Bool)
-> (TextDiff -> TextDiff -> Bool) -> Eq TextDiff
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TextDiff -> TextDiff -> Bool
== :: TextDiff -> TextDiff -> Bool
$c/= :: TextDiff -> TextDiff -> Bool
/= :: TextDiff -> TextDiff -> Bool
Eq, Int -> TextDiff -> ShowS
[TextDiff] -> ShowS
TextDiff -> String
(Int -> TextDiff -> ShowS)
-> (TextDiff -> String) -> ([TextDiff] -> ShowS) -> Show TextDiff
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TextDiff -> ShowS
showsPrec :: Int -> TextDiff -> ShowS
$cshow :: TextDiff -> String
show :: TextDiff -> String
$cshowList :: [TextDiff] -> ShowS
showList :: [TextDiff] -> ShowS
Show, Typeable TextDiff
Typeable TextDiff =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TextDiff -> c TextDiff)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TextDiff)
-> (TextDiff -> Constr)
-> (TextDiff -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TextDiff))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TextDiff))
-> ((forall b. Data b => b -> b) -> TextDiff -> TextDiff)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TextDiff -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TextDiff -> r)
-> (forall u. (forall d. Data d => d -> u) -> TextDiff -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TextDiff -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TextDiff -> m TextDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TextDiff -> m TextDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TextDiff -> m TextDiff)
-> Data TextDiff
TextDiff -> Constr
TextDiff -> DataType
(forall b. Data b => b -> b) -> TextDiff -> TextDiff
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TextDiff -> u
forall u. (forall d. Data d => d -> u) -> TextDiff -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TextDiff -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TextDiff -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TextDiff -> m TextDiff
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TextDiff -> m TextDiff
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TextDiff
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TextDiff -> c TextDiff
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TextDiff)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TextDiff)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TextDiff -> c TextDiff
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TextDiff -> c TextDiff
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TextDiff
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TextDiff
$ctoConstr :: TextDiff -> Constr
toConstr :: TextDiff -> Constr
$cdataTypeOf :: TextDiff -> DataType
dataTypeOf :: TextDiff -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TextDiff)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TextDiff)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TextDiff)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TextDiff)
$cgmapT :: (forall b. Data b => b -> b) -> TextDiff -> TextDiff
gmapT :: (forall b. Data b => b -> b) -> TextDiff -> TextDiff
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TextDiff -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TextDiff -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TextDiff -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TextDiff -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TextDiff -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TextDiff -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TextDiff -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TextDiff -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TextDiff -> m TextDiff
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TextDiff -> m TextDiff
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TextDiff -> m TextDiff
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TextDiff -> m TextDiff
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TextDiff -> m TextDiff
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TextDiff -> m TextDiff
Data)

instance Arbitrary TextDiff where
  arbitrary :: Gen TextDiff
arbitrary = [Item Text] -> TextDiff
TextDiff ([Item Text] -> TextDiff) -> Gen [Item Text] -> Gen TextDiff
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Item Text) -> Gen [Item Text]
forall a. Gen a -> Gen [a]
listOf Gen (Item Text)
forall a. Arbitrary a => Gen (Item a)
arbitraryItem

instance ToJSON TextDiff where
  toJSON :: TextDiff -> Value
toJSON TextDiff
textDiff = (Item Text -> Value) -> [Item Text] -> Value
forall a. (a -> Value) -> [a] -> Value
listValue Item Text -> Value
forall v. ToJSON v => Item v -> Value
itemToJSON TextDiff
textDiff.unTextDiff

instance FromJSON TextDiff where
  parseJSON :: Value -> Parser TextDiff
parseJSON Value
v = [Item Text] -> TextDiff
TextDiff ([Item Text] -> TextDiff) -> Parser [Item Text] -> Parser TextDiff
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Value -> Parser (Item Text)) -> [Value] -> Parser [Item Text]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse Value -> Parser (Item Text)
forall v. FromJSON v => Value -> Parser (Item v)
itemFromJSON ([Value] -> Parser [Item Text])
-> Parser [Value] -> Parser [Item Text]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value -> Parser [Value]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v)

-- Helpful aliases

type OutputHash = Text

type Platform = Text

type Builder = Text

type Argument = Text

-- | A set of Nix derivation output names.
newtype OutputNames = OutputNames {OutputNames -> Set Text
unOutputNames :: Set Text}
  deriving newtype (OutputNames -> OutputNames -> Bool
(OutputNames -> OutputNames -> Bool)
-> (OutputNames -> OutputNames -> Bool) -> Eq OutputNames
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OutputNames -> OutputNames -> Bool
== :: OutputNames -> OutputNames -> Bool
$c/= :: OutputNames -> OutputNames -> Bool
/= :: OutputNames -> OutputNames -> Bool
Eq, Eq OutputNames
Eq OutputNames =>
(OutputNames -> OutputNames -> Ordering)
-> (OutputNames -> OutputNames -> Bool)
-> (OutputNames -> OutputNames -> Bool)
-> (OutputNames -> OutputNames -> Bool)
-> (OutputNames -> OutputNames -> Bool)
-> (OutputNames -> OutputNames -> OutputNames)
-> (OutputNames -> OutputNames -> OutputNames)
-> Ord OutputNames
OutputNames -> OutputNames -> Bool
OutputNames -> OutputNames -> Ordering
OutputNames -> OutputNames -> OutputNames
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 :: OutputNames -> OutputNames -> Ordering
compare :: OutputNames -> OutputNames -> Ordering
$c< :: OutputNames -> OutputNames -> Bool
< :: OutputNames -> OutputNames -> Bool
$c<= :: OutputNames -> OutputNames -> Bool
<= :: OutputNames -> OutputNames -> Bool
$c> :: OutputNames -> OutputNames -> Bool
> :: OutputNames -> OutputNames -> Bool
$c>= :: OutputNames -> OutputNames -> Bool
>= :: OutputNames -> OutputNames -> Bool
$cmax :: OutputNames -> OutputNames -> OutputNames
max :: OutputNames -> OutputNames -> OutputNames
$cmin :: OutputNames -> OutputNames -> OutputNames
min :: OutputNames -> OutputNames -> OutputNames
Ord, [OutputNames] -> Value
[OutputNames] -> Encoding
OutputNames -> Bool
OutputNames -> Value
OutputNames -> Encoding
(OutputNames -> Value)
-> (OutputNames -> Encoding)
-> ([OutputNames] -> Value)
-> ([OutputNames] -> Encoding)
-> (OutputNames -> Bool)
-> ToJSON OutputNames
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: OutputNames -> Value
toJSON :: OutputNames -> Value
$ctoEncoding :: OutputNames -> Encoding
toEncoding :: OutputNames -> Encoding
$ctoJSONList :: [OutputNames] -> Value
toJSONList :: [OutputNames] -> Value
$ctoEncodingList :: [OutputNames] -> Encoding
toEncodingList :: [OutputNames] -> Encoding
$comitField :: OutputNames -> Bool
omitField :: OutputNames -> Bool
ToJSON, Maybe OutputNames
Value -> Parser [OutputNames]
Value -> Parser OutputNames
(Value -> Parser OutputNames)
-> (Value -> Parser [OutputNames])
-> Maybe OutputNames
-> FromJSON OutputNames
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser OutputNames
parseJSON :: Value -> Parser OutputNames
$cparseJSONList :: Value -> Parser [OutputNames]
parseJSONList :: Value -> Parser [OutputNames]
$comittedField :: Maybe OutputNames
omittedField :: Maybe OutputNames
FromJSON)
  deriving stock (Int -> OutputNames -> ShowS
[OutputNames] -> ShowS
OutputNames -> String
(Int -> OutputNames -> ShowS)
-> (OutputNames -> String)
-> ([OutputNames] -> ShowS)
-> Show OutputNames
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OutputNames -> ShowS
showsPrec :: Int -> OutputNames -> ShowS
$cshow :: OutputNames -> String
show :: OutputNames -> String
$cshowList :: [OutputNames] -> ShowS
showList :: [OutputNames] -> ShowS
Show, (forall x. OutputNames -> Rep OutputNames x)
-> (forall x. Rep OutputNames x -> OutputNames)
-> Generic OutputNames
forall x. Rep OutputNames x -> OutputNames
forall x. OutputNames -> Rep OutputNames x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. OutputNames -> Rep OutputNames x
from :: forall x. OutputNames -> Rep OutputNames x
$cto :: forall x. Rep OutputNames x -> OutputNames
to :: forall x. Rep OutputNames x -> OutputNames
Generic, Typeable OutputNames
Typeable OutputNames =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OutputNames -> c OutputNames)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OutputNames)
-> (OutputNames -> Constr)
-> (OutputNames -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OutputNames))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c OutputNames))
-> ((forall b. Data b => b -> b) -> OutputNames -> OutputNames)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OutputNames -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OutputNames -> r)
-> (forall u. (forall d. Data d => d -> u) -> OutputNames -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> OutputNames -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OutputNames -> m OutputNames)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OutputNames -> m OutputNames)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OutputNames -> m OutputNames)
-> Data OutputNames
OutputNames -> Constr
OutputNames -> DataType
(forall b. Data b => b -> b) -> OutputNames -> OutputNames
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> OutputNames -> u
forall u. (forall d. Data d => d -> u) -> OutputNames -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OutputNames -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OutputNames -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OutputNames -> m OutputNames
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OutputNames -> m OutputNames
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OutputNames
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OutputNames -> c OutputNames
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OutputNames)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OutputNames)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OutputNames -> c OutputNames
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OutputNames -> c OutputNames
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OutputNames
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OutputNames
$ctoConstr :: OutputNames -> Constr
toConstr :: OutputNames -> Constr
$cdataTypeOf :: OutputNames -> DataType
dataTypeOf :: OutputNames -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OutputNames)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OutputNames)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OutputNames)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OutputNames)
$cgmapT :: (forall b. Data b => b -> b) -> OutputNames -> OutputNames
gmapT :: (forall b. Data b => b -> b) -> OutputNames -> OutputNames
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OutputNames -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OutputNames -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OutputNames -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OutputNames -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OutputNames -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> OutputNames -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OutputNames -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OutputNames -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OutputNames -> m OutputNames
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OutputNames -> m OutputNames
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OutputNames -> m OutputNames
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OutputNames -> m OutputNames
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OutputNames -> m OutputNames
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OutputNames -> m OutputNames
Data)
  deriving Gen OutputNames
Gen OutputNames
-> (OutputNames -> [OutputNames]) -> Arbitrary OutputNames
OutputNames -> [OutputNames]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen OutputNames
arbitrary :: Gen OutputNames
$cshrink :: OutputNames -> [OutputNames]
shrink :: OutputNames -> [OutputNames]
Arbitrary via GenericArbitrary OutputNames

-- Derivation diff

data DerivationDiff
  = DerivationsAreTheSame
  | AlreadyCompared
  | OnlyAlreadyComparedBelow { DerivationDiff -> Changed OutputStructure
outputStructure :: Changed OutputStructure}
  | NamesDontMatch           { outputStructure :: Changed OutputStructure}
  | OutputsDontMatch         { outputStructure :: Changed OutputStructure}
  | DerivationDiff
      { outputStructure :: Changed OutputStructure
      , DerivationDiff -> OutputsDiff
outputsDiff     :: OutputsDiff
      , DerivationDiff -> Maybe (Changed Text)
platformDiff    :: Maybe (Changed Platform)
        -- ^ Will be Nothing, if Platform does not change
      , DerivationDiff -> Maybe (Changed Text)
builderDiff     :: Maybe (Changed Builder)
        -- ^ Will be Nothing, if Builder does not change
      , DerivationDiff -> Maybe ArgumentsDiff
argumentsDiff   :: Maybe ArgumentsDiff
        -- ^ Will be Nothing, if arguments are equal
      , DerivationDiff -> SourcesDiff
sourcesDiff     :: SourcesDiff
      , DerivationDiff -> InputsDiff
inputsDiff      :: InputsDiff
      , DerivationDiff -> Maybe EnvironmentDiff
envDiff         :: Maybe EnvironmentDiff
        -- ^ Will be Nothing, if environment comparison is skipped
      }
  deriving stock (DerivationDiff -> DerivationDiff -> Bool
(DerivationDiff -> DerivationDiff -> Bool)
-> (DerivationDiff -> DerivationDiff -> Bool) -> Eq DerivationDiff
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DerivationDiff -> DerivationDiff -> Bool
== :: DerivationDiff -> DerivationDiff -> Bool
$c/= :: DerivationDiff -> DerivationDiff -> Bool
/= :: DerivationDiff -> DerivationDiff -> Bool
Eq, Int -> DerivationDiff -> ShowS
[DerivationDiff] -> ShowS
DerivationDiff -> String
(Int -> DerivationDiff -> ShowS)
-> (DerivationDiff -> String)
-> ([DerivationDiff] -> ShowS)
-> Show DerivationDiff
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DerivationDiff -> ShowS
showsPrec :: Int -> DerivationDiff -> ShowS
$cshow :: DerivationDiff -> String
show :: DerivationDiff -> String
$cshowList :: [DerivationDiff] -> ShowS
showList :: [DerivationDiff] -> ShowS
Show, (forall x. DerivationDiff -> Rep DerivationDiff x)
-> (forall x. Rep DerivationDiff x -> DerivationDiff)
-> Generic DerivationDiff
forall x. Rep DerivationDiff x -> DerivationDiff
forall x. DerivationDiff -> Rep DerivationDiff x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DerivationDiff -> Rep DerivationDiff x
from :: forall x. DerivationDiff -> Rep DerivationDiff x
$cto :: forall x. Rep DerivationDiff x -> DerivationDiff
to :: forall x. Rep DerivationDiff x -> DerivationDiff
Generic, Typeable DerivationDiff
Typeable DerivationDiff =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DerivationDiff -> c DerivationDiff)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DerivationDiff)
-> (DerivationDiff -> Constr)
-> (DerivationDiff -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DerivationDiff))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c DerivationDiff))
-> ((forall b. Data b => b -> b)
    -> DerivationDiff -> DerivationDiff)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivationDiff -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DerivationDiff -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> DerivationDiff -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> DerivationDiff -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> DerivationDiff -> m DerivationDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DerivationDiff -> m DerivationDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> DerivationDiff -> m DerivationDiff)
-> Data DerivationDiff
DerivationDiff -> Constr
DerivationDiff -> DataType
(forall b. Data b => b -> b) -> DerivationDiff -> DerivationDiff
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> DerivationDiff -> u
forall u. (forall d. Data d => d -> u) -> DerivationDiff -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivationDiff -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivationDiff -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivationDiff -> m DerivationDiff
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivationDiff -> m DerivationDiff
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivationDiff
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivationDiff -> c DerivationDiff
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivationDiff)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivationDiff)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivationDiff -> c DerivationDiff
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DerivationDiff -> c DerivationDiff
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivationDiff
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DerivationDiff
$ctoConstr :: DerivationDiff -> Constr
toConstr :: DerivationDiff -> Constr
$cdataTypeOf :: DerivationDiff -> DataType
dataTypeOf :: DerivationDiff -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivationDiff)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DerivationDiff)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivationDiff)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c DerivationDiff)
$cgmapT :: (forall b. Data b => b -> b) -> DerivationDiff -> DerivationDiff
gmapT :: (forall b. Data b => b -> b) -> DerivationDiff -> DerivationDiff
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivationDiff -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DerivationDiff -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivationDiff -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DerivationDiff -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DerivationDiff -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DerivationDiff -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DerivationDiff -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> DerivationDiff -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivationDiff -> m DerivationDiff
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> DerivationDiff -> m DerivationDiff
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivationDiff -> m DerivationDiff
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivationDiff -> m DerivationDiff
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivationDiff -> m DerivationDiff
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> DerivationDiff -> m DerivationDiff
Data)
  deriving anyclass ([DerivationDiff] -> Value
[DerivationDiff] -> Encoding
DerivationDiff -> Bool
DerivationDiff -> Value
DerivationDiff -> Encoding
(DerivationDiff -> Value)
-> (DerivationDiff -> Encoding)
-> ([DerivationDiff] -> Value)
-> ([DerivationDiff] -> Encoding)
-> (DerivationDiff -> Bool)
-> ToJSON DerivationDiff
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: DerivationDiff -> Value
toJSON :: DerivationDiff -> Value
$ctoEncoding :: DerivationDiff -> Encoding
toEncoding :: DerivationDiff -> Encoding
$ctoJSONList :: [DerivationDiff] -> Value
toJSONList :: [DerivationDiff] -> Value
$ctoEncodingList :: [DerivationDiff] -> Encoding
toEncodingList :: [DerivationDiff] -> Encoding
$comitField :: DerivationDiff -> Bool
omitField :: DerivationDiff -> Bool
ToJSON, Maybe DerivationDiff
Value -> Parser [DerivationDiff]
Value -> Parser DerivationDiff
(Value -> Parser DerivationDiff)
-> (Value -> Parser [DerivationDiff])
-> Maybe DerivationDiff
-> FromJSON DerivationDiff
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser DerivationDiff
parseJSON :: Value -> Parser DerivationDiff
$cparseJSONList :: Value -> Parser [DerivationDiff]
parseJSONList :: Value -> Parser [DerivationDiff]
$comittedField :: Maybe DerivationDiff
omittedField :: Maybe DerivationDiff
FromJSON)
  deriving Gen DerivationDiff
Gen DerivationDiff
-> (DerivationDiff -> [DerivationDiff]) -> Arbitrary DerivationDiff
DerivationDiff -> [DerivationDiff]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen DerivationDiff
arbitrary :: Gen DerivationDiff
$cshrink :: DerivationDiff -> [DerivationDiff]
shrink :: DerivationDiff -> [DerivationDiff]
Arbitrary via GenericArbitrary DerivationDiff

-- Output structure

data OutputStructure = OutputStructure
  { OutputStructure -> StorePath
derivationPath :: StorePath
  , OutputStructure -> OutputNames
derivationOutputs :: OutputNames
  }
  deriving stock (OutputStructure -> OutputStructure -> Bool
(OutputStructure -> OutputStructure -> Bool)
-> (OutputStructure -> OutputStructure -> Bool)
-> Eq OutputStructure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OutputStructure -> OutputStructure -> Bool
== :: OutputStructure -> OutputStructure -> Bool
$c/= :: OutputStructure -> OutputStructure -> Bool
/= :: OutputStructure -> OutputStructure -> Bool
Eq, Int -> OutputStructure -> ShowS
[OutputStructure] -> ShowS
OutputStructure -> String
(Int -> OutputStructure -> ShowS)
-> (OutputStructure -> String)
-> ([OutputStructure] -> ShowS)
-> Show OutputStructure
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OutputStructure -> ShowS
showsPrec :: Int -> OutputStructure -> ShowS
$cshow :: OutputStructure -> String
show :: OutputStructure -> String
$cshowList :: [OutputStructure] -> ShowS
showList :: [OutputStructure] -> ShowS
Show, (forall x. OutputStructure -> Rep OutputStructure x)
-> (forall x. Rep OutputStructure x -> OutputStructure)
-> Generic OutputStructure
forall x. Rep OutputStructure x -> OutputStructure
forall x. OutputStructure -> Rep OutputStructure x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. OutputStructure -> Rep OutputStructure x
from :: forall x. OutputStructure -> Rep OutputStructure x
$cto :: forall x. Rep OutputStructure x -> OutputStructure
to :: forall x. Rep OutputStructure x -> OutputStructure
Generic, Typeable OutputStructure
Typeable OutputStructure =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OutputStructure -> c OutputStructure)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OutputStructure)
-> (OutputStructure -> Constr)
-> (OutputStructure -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OutputStructure))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c OutputStructure))
-> ((forall b. Data b => b -> b)
    -> OutputStructure -> OutputStructure)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OutputStructure -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OutputStructure -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> OutputStructure -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> OutputStructure -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> OutputStructure -> m OutputStructure)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> OutputStructure -> m OutputStructure)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> OutputStructure -> m OutputStructure)
-> Data OutputStructure
OutputStructure -> Constr
OutputStructure -> DataType
(forall b. Data b => b -> b) -> OutputStructure -> OutputStructure
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> OutputStructure -> u
forall u. (forall d. Data d => d -> u) -> OutputStructure -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OutputStructure -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OutputStructure -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> OutputStructure -> m OutputStructure
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OutputStructure -> m OutputStructure
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OutputStructure
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OutputStructure -> c OutputStructure
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OutputStructure)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OutputStructure)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OutputStructure -> c OutputStructure
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OutputStructure -> c OutputStructure
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OutputStructure
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OutputStructure
$ctoConstr :: OutputStructure -> Constr
toConstr :: OutputStructure -> Constr
$cdataTypeOf :: OutputStructure -> DataType
dataTypeOf :: OutputStructure -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OutputStructure)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OutputStructure)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OutputStructure)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OutputStructure)
$cgmapT :: (forall b. Data b => b -> b) -> OutputStructure -> OutputStructure
gmapT :: (forall b. Data b => b -> b) -> OutputStructure -> OutputStructure
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OutputStructure -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OutputStructure -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OutputStructure -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OutputStructure -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OutputStructure -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> OutputStructure -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> OutputStructure -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> OutputStructure -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> OutputStructure -> m OutputStructure
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> OutputStructure -> m OutputStructure
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OutputStructure -> m OutputStructure
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OutputStructure -> m OutputStructure
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OutputStructure -> m OutputStructure
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OutputStructure -> m OutputStructure
Data)
  deriving anyclass ([OutputStructure] -> Value
[OutputStructure] -> Encoding
OutputStructure -> Bool
OutputStructure -> Value
OutputStructure -> Encoding
(OutputStructure -> Value)
-> (OutputStructure -> Encoding)
-> ([OutputStructure] -> Value)
-> ([OutputStructure] -> Encoding)
-> (OutputStructure -> Bool)
-> ToJSON OutputStructure
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: OutputStructure -> Value
toJSON :: OutputStructure -> Value
$ctoEncoding :: OutputStructure -> Encoding
toEncoding :: OutputStructure -> Encoding
$ctoJSONList :: [OutputStructure] -> Value
toJSONList :: [OutputStructure] -> Value
$ctoEncodingList :: [OutputStructure] -> Encoding
toEncodingList :: [OutputStructure] -> Encoding
$comitField :: OutputStructure -> Bool
omitField :: OutputStructure -> Bool
ToJSON, Maybe OutputStructure
Value -> Parser [OutputStructure]
Value -> Parser OutputStructure
(Value -> Parser OutputStructure)
-> (Value -> Parser [OutputStructure])
-> Maybe OutputStructure
-> FromJSON OutputStructure
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser OutputStructure
parseJSON :: Value -> Parser OutputStructure
$cparseJSONList :: Value -> Parser [OutputStructure]
parseJSONList :: Value -> Parser [OutputStructure]
$comittedField :: Maybe OutputStructure
omittedField :: Maybe OutputStructure
FromJSON)
  deriving Gen OutputStructure
Gen OutputStructure
-> (OutputStructure -> [OutputStructure])
-> Arbitrary OutputStructure
OutputStructure -> [OutputStructure]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen OutputStructure
arbitrary :: Gen OutputStructure
$cshrink :: OutputStructure -> [OutputStructure]
shrink :: OutputStructure -> [OutputStructure]
Arbitrary via GenericArbitrary OutputStructure

-- ** Outputs diff

data OutputsDiff = OutputsDiff
  { OutputsDiff
-> Maybe (Changed (Map Text (DerivationOutput StorePath Text)))
extraOutputs :: Maybe (Changed (Map Text (DerivationOutput StorePath Text)))
    -- ^ Map from derivation name to its outputs.
    --   Will be Nothing, if `Data.Map.difference` gives
    --   empty Maps for both new and old outputs
  , OutputsDiff -> [OutputDiff]
outputHashDiff :: [OutputDiff]
    -- ^ Difference of outputs with the same name.
    --   Will be empty, if all outputs are equal.
  }
  deriving stock (OutputsDiff -> OutputsDiff -> Bool
(OutputsDiff -> OutputsDiff -> Bool)
-> (OutputsDiff -> OutputsDiff -> Bool) -> Eq OutputsDiff
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OutputsDiff -> OutputsDiff -> Bool
== :: OutputsDiff -> OutputsDiff -> Bool
$c/= :: OutputsDiff -> OutputsDiff -> Bool
/= :: OutputsDiff -> OutputsDiff -> Bool
Eq, Int -> OutputsDiff -> ShowS
[OutputsDiff] -> ShowS
OutputsDiff -> String
(Int -> OutputsDiff -> ShowS)
-> (OutputsDiff -> String)
-> ([OutputsDiff] -> ShowS)
-> Show OutputsDiff
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OutputsDiff -> ShowS
showsPrec :: Int -> OutputsDiff -> ShowS
$cshow :: OutputsDiff -> String
show :: OutputsDiff -> String
$cshowList :: [OutputsDiff] -> ShowS
showList :: [OutputsDiff] -> ShowS
Show, Typeable OutputsDiff
Typeable OutputsDiff =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OutputsDiff -> c OutputsDiff)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OutputsDiff)
-> (OutputsDiff -> Constr)
-> (OutputsDiff -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OutputsDiff))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c OutputsDiff))
-> ((forall b. Data b => b -> b) -> OutputsDiff -> OutputsDiff)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OutputsDiff -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OutputsDiff -> r)
-> (forall u. (forall d. Data d => d -> u) -> OutputsDiff -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> OutputsDiff -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OutputsDiff -> m OutputsDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OutputsDiff -> m OutputsDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OutputsDiff -> m OutputsDiff)
-> Data OutputsDiff
OutputsDiff -> Constr
OutputsDiff -> DataType
(forall b. Data b => b -> b) -> OutputsDiff -> OutputsDiff
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> OutputsDiff -> u
forall u. (forall d. Data d => d -> u) -> OutputsDiff -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OutputsDiff -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OutputsDiff -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OutputsDiff -> m OutputsDiff
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OutputsDiff -> m OutputsDiff
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OutputsDiff
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OutputsDiff -> c OutputsDiff
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OutputsDiff)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OutputsDiff)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OutputsDiff -> c OutputsDiff
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OutputsDiff -> c OutputsDiff
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OutputsDiff
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OutputsDiff
$ctoConstr :: OutputsDiff -> Constr
toConstr :: OutputsDiff -> Constr
$cdataTypeOf :: OutputsDiff -> DataType
dataTypeOf :: OutputsDiff -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OutputsDiff)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OutputsDiff)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OutputsDiff)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OutputsDiff)
$cgmapT :: (forall b. Data b => b -> b) -> OutputsDiff -> OutputsDiff
gmapT :: (forall b. Data b => b -> b) -> OutputsDiff -> OutputsDiff
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OutputsDiff -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OutputsDiff -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OutputsDiff -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OutputsDiff -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OutputsDiff -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> OutputsDiff -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OutputsDiff -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OutputsDiff -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OutputsDiff -> m OutputsDiff
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OutputsDiff -> m OutputsDiff
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OutputsDiff -> m OutputsDiff
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OutputsDiff -> m OutputsDiff
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OutputsDiff -> m OutputsDiff
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OutputsDiff -> m OutputsDiff
Data)

deriving instance Data (DerivationOutput StorePath Text)

instance Arbitrary OutputsDiff where
  arbitrary :: Gen OutputsDiff
arbitrary = Maybe (Changed (Map Text (DerivationOutput StorePath Text)))
-> [OutputDiff] -> OutputsDiff
OutputsDiff (Maybe (Changed (Map Text (DerivationOutput StorePath Text)))
 -> [OutputDiff] -> OutputsDiff)
-> Gen
     (Maybe (Changed (Map Text (DerivationOutput StorePath Text))))
-> Gen ([OutputDiff] -> OutputsDiff)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Maybe (Changed (Map Text (DerivationOutput StorePath Text))))
arbitraryExtraOutputs  Gen ([OutputDiff] -> OutputsDiff)
-> Gen [OutputDiff] -> Gen OutputsDiff
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen [OutputDiff]
forall a. Arbitrary a => Gen a
arbitrary
    where
      arbitraryExtraOutputs :: Gen (Maybe (Changed (Map Text (DerivationOutput StorePath Text))))
arbitraryExtraOutputs =
        [Gen
   (Maybe (Changed (Map Text (DerivationOutput StorePath Text))))]
-> Gen
     (Maybe (Changed (Map Text (DerivationOutput StorePath Text))))
forall a. [Gen a] -> Gen a
oneof [Maybe (Changed (Map Text (DerivationOutput StorePath Text)))
-> Gen
     (Maybe (Changed (Map Text (DerivationOutput StorePath Text))))
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Changed (Map Text (DerivationOutput StorePath Text)))
forall a. Maybe a
Nothing, Changed (Map Text (DerivationOutput StorePath Text))
-> Maybe (Changed (Map Text (DerivationOutput StorePath Text)))
forall a. a -> Maybe a
Just (Changed (Map Text (DerivationOutput StorePath Text))
 -> Maybe (Changed (Map Text (DerivationOutput StorePath Text))))
-> Gen (Changed (Map Text (DerivationOutput StorePath Text)))
-> Gen
     (Maybe (Changed (Map Text (DerivationOutput StorePath Text))))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Changed (Map Text (DerivationOutput StorePath Text)))
arbitraryChangedMap]

      arbitraryChangedMap :: Gen (Changed (Map Text (DerivationOutput StorePath Text)))
arbitraryChangedMap =
        Map Text (DerivationOutput StorePath Text)
-> Map Text (DerivationOutput StorePath Text)
-> Changed (Map Text (DerivationOutput StorePath Text))
forall a. a -> a -> Changed a
Changed (Map Text (DerivationOutput StorePath Text)
 -> Map Text (DerivationOutput StorePath Text)
 -> Changed (Map Text (DerivationOutput StorePath Text)))
-> Gen (Map Text (DerivationOutput StorePath Text))
-> Gen
     (Map Text (DerivationOutput StorePath Text)
      -> Changed (Map Text (DerivationOutput StorePath Text)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Map Text (DerivationOutput StorePath Text))
arbitraryMap Gen
  (Map Text (DerivationOutput StorePath Text)
   -> Changed (Map Text (DerivationOutput StorePath Text)))
-> Gen (Map Text (DerivationOutput StorePath Text))
-> Gen (Changed (Map Text (DerivationOutput StorePath Text)))
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (Map Text (DerivationOutput StorePath Text))
arbitraryMap

      arbitraryMap :: Gen (Map Text (DerivationOutput StorePath Text))
arbitraryMap = [(Text, DerivationOutput StorePath Text)]
-> Map Text (DerivationOutput StorePath Text)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(Text, DerivationOutput StorePath Text)]
 -> Map Text (DerivationOutput StorePath Text))
-> Gen [(Text, DerivationOutput StorePath Text)]
-> Gen (Map Text (DerivationOutput StorePath Text))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
        Gen (Text, DerivationOutput StorePath Text)
-> Gen [(Text, DerivationOutput StorePath Text)]
forall a. Gen a -> Gen [a]
listOf ((,) (Text
 -> DerivationOutput StorePath Text
 -> (Text, DerivationOutput StorePath Text))
-> Gen Text
-> Gen
     (DerivationOutput StorePath Text
      -> (Text, DerivationOutput StorePath Text))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Text
forall a. Arbitrary a => Gen a
arbitrary Gen
  (DerivationOutput StorePath Text
   -> (Text, DerivationOutput StorePath Text))
-> Gen (DerivationOutput StorePath Text)
-> Gen (Text, DerivationOutput StorePath Text)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (DerivationOutput StorePath Text)
forall fp txt.
(Arbitrary fp, Arbitrary txt) =>
Gen (DerivationOutput fp txt)
arbitraryDerivationOutput)

instance ToJSON OutputsDiff where
  toJSON :: OutputsDiff -> Value
toJSON OutputsDiff{[OutputDiff]
Maybe (Changed (Map Text (DerivationOutput StorePath Text)))
$sel:extraOutputs:OutputsDiff :: OutputsDiff
-> Maybe (Changed (Map Text (DerivationOutput StorePath Text)))
$sel:outputHashDiff:OutputsDiff :: OutputsDiff -> [OutputDiff]
extraOutputs :: Maybe (Changed (Map Text (DerivationOutput StorePath Text)))
outputHashDiff :: [OutputDiff]
..} = [Pair] -> Value
object
    [ Key
"extraOutputs" Key -> Maybe Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Changed (Map Text (DerivationOutput StorePath Text)) -> Value)
-> Maybe (Changed (Map Text (DerivationOutput StorePath Text)))
-> Maybe Value
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Map Text (DerivationOutput StorePath Text) -> Value)
-> Changed (Map Text (DerivationOutput StorePath Text)) -> Value
forall a. (a -> Value) -> Changed a -> Value
changedToJSON Map Text (DerivationOutput StorePath Text) -> Value
extraOutputsToJSON) Maybe (Changed (Map Text (DerivationOutput StorePath Text)))
extraOutputs
    , Key
"outputHashDiff" Key -> [OutputDiff] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [OutputDiff]
outputHashDiff
    ]
    where
    extraOutputsToJSON :: Map Text (DerivationOutput StorePath Text) -> Value
    extraOutputsToJSON :: Map Text (DerivationOutput StorePath Text) -> Value
extraOutputsToJSON = Map Text Value -> Value
forall a. ToJSON a => a -> Value
toJSON (Map Text Value -> Value)
-> (Map Text (DerivationOutput StorePath Text) -> Map Text Value)
-> Map Text (DerivationOutput StorePath Text)
-> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DerivationOutput StorePath Text -> Value)
-> Map Text (DerivationOutput StorePath Text) -> Map Text Value
forall a b. (a -> b) -> Map Text a -> Map Text b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DerivationOutput StorePath Text -> Value
derivationOutputToJSON

    derivationOutputToJSON :: DerivationOutput StorePath Text -> Value
    derivationOutputToJSON :: DerivationOutput StorePath Text -> Value
derivationOutputToJSON DerivationOutput{Text
StorePath
path :: StorePath
hashAlgo :: Text
hash :: Text
path :: forall fp txt. DerivationOutput fp txt -> fp
hashAlgo :: forall fp txt. DerivationOutput fp txt -> txt
hash :: forall fp txt. DerivationOutput fp txt -> txt
..} = [Pair] -> Value
object
      [ Key
"path" Key -> StorePath -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= StorePath
path
      , Key
"hashAlgo" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
hashAlgo
      , Key
"hash" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
hash
      ]

instance FromJSON OutputsDiff where
  parseJSON :: Value -> Parser OutputsDiff
parseJSON = String
-> (Object -> Parser OutputsDiff) -> Value -> Parser OutputsDiff
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"OutputsDiff" \Object
o -> do
    Maybe (Changed (Map Text Value))
extraOutputsWithoutParsingDerivationOutputs <- Object
o Object -> Key -> Parser (Maybe (Changed (Map Text Value)))
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"extraOutputs"
    [OutputDiff]
ohd <- Object
o Object -> Key -> Parser [OutputDiff]
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"outputHashDiff"
    Maybe (Changed (Map Text (DerivationOutput StorePath Text)))
eo <- ((Changed (Map Text Value)
 -> Parser (Changed (Map Text (DerivationOutput StorePath Text))))
-> Maybe (Changed (Map Text Value))
-> Parser
     (Maybe (Changed (Map Text (DerivationOutput StorePath Text))))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse ((Changed (Map Text Value)
  -> Parser (Changed (Map Text (DerivationOutput StorePath Text))))
 -> Maybe (Changed (Map Text Value))
 -> Parser
      (Maybe (Changed (Map Text (DerivationOutput StorePath Text)))))
-> ((Value -> Parser (DerivationOutput StorePath Text))
    -> Changed (Map Text Value)
    -> Parser (Changed (Map Text (DerivationOutput StorePath Text))))
-> (Value -> Parser (DerivationOutput StorePath Text))
-> Maybe (Changed (Map Text Value))
-> Parser
     (Maybe (Changed (Map Text (DerivationOutput StorePath Text))))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Map Text Value
 -> Parser (Map Text (DerivationOutput StorePath Text)))
-> Changed (Map Text Value)
-> Parser (Changed (Map Text (DerivationOutput StorePath Text)))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Changed a -> f (Changed b)
traverse ((Map Text Value
  -> Parser (Map Text (DerivationOutput StorePath Text)))
 -> Changed (Map Text Value)
 -> Parser (Changed (Map Text (DerivationOutput StorePath Text))))
-> ((Value -> Parser (DerivationOutput StorePath Text))
    -> Map Text Value
    -> Parser (Map Text (DerivationOutput StorePath Text)))
-> (Value -> Parser (DerivationOutput StorePath Text))
-> Changed (Map Text Value)
-> Parser (Changed (Map Text (DerivationOutput StorePath Text)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Value -> Parser (DerivationOutput StorePath Text))
-> Map Text Value
-> Parser (Map Text (DerivationOutput StorePath Text))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Map Text a -> f (Map Text b)
traverse)
      Value -> Parser (DerivationOutput StorePath Text)
derivationOutputFromJSON
      Maybe (Changed (Map Text Value))
extraOutputsWithoutParsingDerivationOutputs
    pure $ Maybe (Changed (Map Text (DerivationOutput StorePath Text)))
-> [OutputDiff] -> OutputsDiff
OutputsDiff Maybe (Changed (Map Text (DerivationOutput StorePath Text)))
eo [OutputDiff]
ohd
    where

      derivationOutputFromJSON :: Value -> Parser (DerivationOutput StorePath Text)
      derivationOutputFromJSON :: Value -> Parser (DerivationOutput StorePath Text)
derivationOutputFromJSON = String
-> (Object -> Parser (DerivationOutput StorePath Text))
-> Value
-> Parser (DerivationOutput StorePath Text)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"DerivationOutput" \Object
o ->
        StorePath -> Text -> Text -> DerivationOutput StorePath Text
forall fp txt. fp -> txt -> txt -> DerivationOutput fp txt
DerivationOutput (StorePath -> Text -> Text -> DerivationOutput StorePath Text)
-> Parser StorePath
-> Parser (Text -> Text -> DerivationOutput StorePath Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
o Object -> Key -> Parser StorePath
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"path" Parser (Text -> Text -> DerivationOutput StorePath Text)
-> Parser Text -> Parser (Text -> DerivationOutput StorePath Text)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"hashAlgo" Parser (Text -> DerivationOutput StorePath Text)
-> Parser Text -> Parser (DerivationOutput StorePath Text)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"hash"

data OutputDiff = OutputDiff
  { OutputDiff -> Text
outputName :: Text
  , OutputDiff -> Changed Text
hashDifference :: Changed OutputHash
  }
  deriving stock (OutputDiff -> OutputDiff -> Bool
(OutputDiff -> OutputDiff -> Bool)
-> (OutputDiff -> OutputDiff -> Bool) -> Eq OutputDiff
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OutputDiff -> OutputDiff -> Bool
== :: OutputDiff -> OutputDiff -> Bool
$c/= :: OutputDiff -> OutputDiff -> Bool
/= :: OutputDiff -> OutputDiff -> Bool
Eq, Int -> OutputDiff -> ShowS
[OutputDiff] -> ShowS
OutputDiff -> String
(Int -> OutputDiff -> ShowS)
-> (OutputDiff -> String)
-> ([OutputDiff] -> ShowS)
-> Show OutputDiff
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OutputDiff -> ShowS
showsPrec :: Int -> OutputDiff -> ShowS
$cshow :: OutputDiff -> String
show :: OutputDiff -> String
$cshowList :: [OutputDiff] -> ShowS
showList :: [OutputDiff] -> ShowS
Show, (forall x. OutputDiff -> Rep OutputDiff x)
-> (forall x. Rep OutputDiff x -> OutputDiff) -> Generic OutputDiff
forall x. Rep OutputDiff x -> OutputDiff
forall x. OutputDiff -> Rep OutputDiff x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. OutputDiff -> Rep OutputDiff x
from :: forall x. OutputDiff -> Rep OutputDiff x
$cto :: forall x. Rep OutputDiff x -> OutputDiff
to :: forall x. Rep OutputDiff x -> OutputDiff
Generic, Typeable OutputDiff
Typeable OutputDiff =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OutputDiff -> c OutputDiff)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OutputDiff)
-> (OutputDiff -> Constr)
-> (OutputDiff -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OutputDiff))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c OutputDiff))
-> ((forall b. Data b => b -> b) -> OutputDiff -> OutputDiff)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OutputDiff -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OutputDiff -> r)
-> (forall u. (forall d. Data d => d -> u) -> OutputDiff -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> OutputDiff -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OutputDiff -> m OutputDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OutputDiff -> m OutputDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OutputDiff -> m OutputDiff)
-> Data OutputDiff
OutputDiff -> Constr
OutputDiff -> DataType
(forall b. Data b => b -> b) -> OutputDiff -> OutputDiff
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> OutputDiff -> u
forall u. (forall d. Data d => d -> u) -> OutputDiff -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OutputDiff -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OutputDiff -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OutputDiff -> m OutputDiff
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OutputDiff -> m OutputDiff
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OutputDiff
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OutputDiff -> c OutputDiff
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OutputDiff)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OutputDiff)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OutputDiff -> c OutputDiff
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OutputDiff -> c OutputDiff
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OutputDiff
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OutputDiff
$ctoConstr :: OutputDiff -> Constr
toConstr :: OutputDiff -> Constr
$cdataTypeOf :: OutputDiff -> DataType
dataTypeOf :: OutputDiff -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OutputDiff)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OutputDiff)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OutputDiff)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OutputDiff)
$cgmapT :: (forall b. Data b => b -> b) -> OutputDiff -> OutputDiff
gmapT :: (forall b. Data b => b -> b) -> OutputDiff -> OutputDiff
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OutputDiff -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OutputDiff -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OutputDiff -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OutputDiff -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OutputDiff -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> OutputDiff -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OutputDiff -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OutputDiff -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OutputDiff -> m OutputDiff
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OutputDiff -> m OutputDiff
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OutputDiff -> m OutputDiff
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OutputDiff -> m OutputDiff
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OutputDiff -> m OutputDiff
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OutputDiff -> m OutputDiff
Data)
  deriving anyclass ([OutputDiff] -> Value
[OutputDiff] -> Encoding
OutputDiff -> Bool
OutputDiff -> Value
OutputDiff -> Encoding
(OutputDiff -> Value)
-> (OutputDiff -> Encoding)
-> ([OutputDiff] -> Value)
-> ([OutputDiff] -> Encoding)
-> (OutputDiff -> Bool)
-> ToJSON OutputDiff
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: OutputDiff -> Value
toJSON :: OutputDiff -> Value
$ctoEncoding :: OutputDiff -> Encoding
toEncoding :: OutputDiff -> Encoding
$ctoJSONList :: [OutputDiff] -> Value
toJSONList :: [OutputDiff] -> Value
$ctoEncodingList :: [OutputDiff] -> Encoding
toEncodingList :: [OutputDiff] -> Encoding
$comitField :: OutputDiff -> Bool
omitField :: OutputDiff -> Bool
ToJSON, Maybe OutputDiff
Value -> Parser [OutputDiff]
Value -> Parser OutputDiff
(Value -> Parser OutputDiff)
-> (Value -> Parser [OutputDiff])
-> Maybe OutputDiff
-> FromJSON OutputDiff
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser OutputDiff
parseJSON :: Value -> Parser OutputDiff
$cparseJSONList :: Value -> Parser [OutputDiff]
parseJSONList :: Value -> Parser [OutputDiff]
$comittedField :: Maybe OutputDiff
omittedField :: Maybe OutputDiff
FromJSON)
  deriving Gen OutputDiff
Gen OutputDiff
-> (OutputDiff -> [OutputDiff]) -> Arbitrary OutputDiff
OutputDiff -> [OutputDiff]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen OutputDiff
arbitrary :: Gen OutputDiff
$cshrink :: OutputDiff -> [OutputDiff]
shrink :: OutputDiff -> [OutputDiff]
Arbitrary via GenericArbitrary OutputDiff

-- ** Arguments diff

newtype ArgumentsDiff = ArgumentsDiff
  { ArgumentsDiff -> NonEmpty (Item Text)
unArgumetsDiff :: NonEmpty (Patience.Item Argument)
  }
  deriving stock (ArgumentsDiff -> ArgumentsDiff -> Bool
(ArgumentsDiff -> ArgumentsDiff -> Bool)
-> (ArgumentsDiff -> ArgumentsDiff -> Bool) -> Eq ArgumentsDiff
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ArgumentsDiff -> ArgumentsDiff -> Bool
== :: ArgumentsDiff -> ArgumentsDiff -> Bool
$c/= :: ArgumentsDiff -> ArgumentsDiff -> Bool
/= :: ArgumentsDiff -> ArgumentsDiff -> Bool
Eq, Int -> ArgumentsDiff -> ShowS
[ArgumentsDiff] -> ShowS
ArgumentsDiff -> String
(Int -> ArgumentsDiff -> ShowS)
-> (ArgumentsDiff -> String)
-> ([ArgumentsDiff] -> ShowS)
-> Show ArgumentsDiff
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ArgumentsDiff -> ShowS
showsPrec :: Int -> ArgumentsDiff -> ShowS
$cshow :: ArgumentsDiff -> String
show :: ArgumentsDiff -> String
$cshowList :: [ArgumentsDiff] -> ShowS
showList :: [ArgumentsDiff] -> ShowS
Show, Typeable ArgumentsDiff
Typeable ArgumentsDiff =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ArgumentsDiff -> c ArgumentsDiff)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ArgumentsDiff)
-> (ArgumentsDiff -> Constr)
-> (ArgumentsDiff -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ArgumentsDiff))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ArgumentsDiff))
-> ((forall b. Data b => b -> b) -> ArgumentsDiff -> ArgumentsDiff)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ArgumentsDiff -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ArgumentsDiff -> r)
-> (forall u. (forall d. Data d => d -> u) -> ArgumentsDiff -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ArgumentsDiff -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ArgumentsDiff -> m ArgumentsDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ArgumentsDiff -> m ArgumentsDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ArgumentsDiff -> m ArgumentsDiff)
-> Data ArgumentsDiff
ArgumentsDiff -> Constr
ArgumentsDiff -> DataType
(forall b. Data b => b -> b) -> ArgumentsDiff -> ArgumentsDiff
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ArgumentsDiff -> u
forall u. (forall d. Data d => d -> u) -> ArgumentsDiff -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArgumentsDiff -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArgumentsDiff -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArgumentsDiff -> m ArgumentsDiff
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArgumentsDiff -> m ArgumentsDiff
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArgumentsDiff
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArgumentsDiff -> c ArgumentsDiff
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArgumentsDiff)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ArgumentsDiff)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArgumentsDiff -> c ArgumentsDiff
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArgumentsDiff -> c ArgumentsDiff
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArgumentsDiff
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArgumentsDiff
$ctoConstr :: ArgumentsDiff -> Constr
toConstr :: ArgumentsDiff -> Constr
$cdataTypeOf :: ArgumentsDiff -> DataType
dataTypeOf :: ArgumentsDiff -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArgumentsDiff)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArgumentsDiff)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ArgumentsDiff)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ArgumentsDiff)
$cgmapT :: (forall b. Data b => b -> b) -> ArgumentsDiff -> ArgumentsDiff
gmapT :: (forall b. Data b => b -> b) -> ArgumentsDiff -> ArgumentsDiff
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArgumentsDiff -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArgumentsDiff -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArgumentsDiff -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArgumentsDiff -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ArgumentsDiff -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ArgumentsDiff -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ArgumentsDiff -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ArgumentsDiff -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArgumentsDiff -> m ArgumentsDiff
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArgumentsDiff -> m ArgumentsDiff
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArgumentsDiff -> m ArgumentsDiff
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArgumentsDiff -> m ArgumentsDiff
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArgumentsDiff -> m ArgumentsDiff
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArgumentsDiff -> m ArgumentsDiff
Data)

instance Arbitrary ArgumentsDiff where
  arbitrary :: Gen ArgumentsDiff
arbitrary = NonEmpty (Item Text) -> ArgumentsDiff
ArgumentsDiff (NonEmpty (Item Text) -> ArgumentsDiff)
-> ([Item Text] -> NonEmpty (Item Text))
-> [Item Text]
-> ArgumentsDiff
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Item Text] -> NonEmpty (Item Text)
forall a. HasCallStack => [a] -> NonEmpty a
NonEmpty.fromList ([Item Text] -> ArgumentsDiff)
-> Gen [Item Text] -> Gen ArgumentsDiff
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Item Text) -> Gen [Item Text]
forall a. Gen a -> Gen [a]
listOf1 Gen (Item Text)
forall a. Arbitrary a => Gen (Item a)
arbitraryItem

instance ToJSON ArgumentsDiff where
  toJSON :: ArgumentsDiff -> Value
toJSON ArgumentsDiff
argumentsDiff = (Item Text -> Value) -> [Item Text] -> Value
forall a. (a -> Value) -> [a] -> Value
listValue Item Text -> Value
forall v. ToJSON v => Item v -> Value
itemToJSON (NonEmpty (Item Text) -> [Item Text]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList ArgumentsDiff
argumentsDiff.unArgumetsDiff)

instance FromJSON ArgumentsDiff where
  parseJSON :: Value -> Parser ArgumentsDiff
parseJSON Value
v = NonEmpty (Item Text) -> ArgumentsDiff
ArgumentsDiff (NonEmpty (Item Text) -> ArgumentsDiff)
-> Parser (NonEmpty (Item Text)) -> Parser ArgumentsDiff
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Value -> Parser (Item Text))
-> NonEmpty Value -> Parser (NonEmpty (Item Text))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NonEmpty a -> f (NonEmpty b)
traverse Value -> Parser (Item Text)
forall v. FromJSON v => Value -> Parser (Item v)
itemFromJSON (NonEmpty Value -> Parser (NonEmpty (Item Text)))
-> Parser (NonEmpty Value) -> Parser (NonEmpty (Item Text))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value -> Parser (NonEmpty Value)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v)

-- ** Sources diff

data SourcesDiff = SourcesDiff
  { SourcesDiff -> Maybe (Changed (Set Text))
extraSrcNames :: Maybe (Changed (Set Text))
    -- ^ Will be Nothing, if there is no extra source names
  , SourcesDiff -> [SourceFileDiff]
srcFilesDiff :: [SourceFileDiff]
  }
  deriving stock (SourcesDiff -> SourcesDiff -> Bool
(SourcesDiff -> SourcesDiff -> Bool)
-> (SourcesDiff -> SourcesDiff -> Bool) -> Eq SourcesDiff
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SourcesDiff -> SourcesDiff -> Bool
== :: SourcesDiff -> SourcesDiff -> Bool
$c/= :: SourcesDiff -> SourcesDiff -> Bool
/= :: SourcesDiff -> SourcesDiff -> Bool
Eq, Int -> SourcesDiff -> ShowS
[SourcesDiff] -> ShowS
SourcesDiff -> String
(Int -> SourcesDiff -> ShowS)
-> (SourcesDiff -> String)
-> ([SourcesDiff] -> ShowS)
-> Show SourcesDiff
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SourcesDiff -> ShowS
showsPrec :: Int -> SourcesDiff -> ShowS
$cshow :: SourcesDiff -> String
show :: SourcesDiff -> String
$cshowList :: [SourcesDiff] -> ShowS
showList :: [SourcesDiff] -> ShowS
Show, (forall x. SourcesDiff -> Rep SourcesDiff x)
-> (forall x. Rep SourcesDiff x -> SourcesDiff)
-> Generic SourcesDiff
forall x. Rep SourcesDiff x -> SourcesDiff
forall x. SourcesDiff -> Rep SourcesDiff x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SourcesDiff -> Rep SourcesDiff x
from :: forall x. SourcesDiff -> Rep SourcesDiff x
$cto :: forall x. Rep SourcesDiff x -> SourcesDiff
to :: forall x. Rep SourcesDiff x -> SourcesDiff
Generic, Typeable SourcesDiff
Typeable SourcesDiff =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SourcesDiff -> c SourcesDiff)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SourcesDiff)
-> (SourcesDiff -> Constr)
-> (SourcesDiff -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SourcesDiff))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SourcesDiff))
-> ((forall b. Data b => b -> b) -> SourcesDiff -> SourcesDiff)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SourcesDiff -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SourcesDiff -> r)
-> (forall u. (forall d. Data d => d -> u) -> SourcesDiff -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SourcesDiff -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SourcesDiff -> m SourcesDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SourcesDiff -> m SourcesDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SourcesDiff -> m SourcesDiff)
-> Data SourcesDiff
SourcesDiff -> Constr
SourcesDiff -> DataType
(forall b. Data b => b -> b) -> SourcesDiff -> SourcesDiff
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SourcesDiff -> u
forall u. (forall d. Data d => d -> u) -> SourcesDiff -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourcesDiff -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourcesDiff -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SourcesDiff -> m SourcesDiff
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourcesDiff -> m SourcesDiff
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourcesDiff
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourcesDiff -> c SourcesDiff
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourcesDiff)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourcesDiff)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourcesDiff -> c SourcesDiff
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourcesDiff -> c SourcesDiff
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourcesDiff
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourcesDiff
$ctoConstr :: SourcesDiff -> Constr
toConstr :: SourcesDiff -> Constr
$cdataTypeOf :: SourcesDiff -> DataType
dataTypeOf :: SourcesDiff -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourcesDiff)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourcesDiff)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourcesDiff)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourcesDiff)
$cgmapT :: (forall b. Data b => b -> b) -> SourcesDiff -> SourcesDiff
gmapT :: (forall b. Data b => b -> b) -> SourcesDiff -> SourcesDiff
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourcesDiff -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourcesDiff -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourcesDiff -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourcesDiff -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SourcesDiff -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SourcesDiff -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SourcesDiff -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SourcesDiff -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SourcesDiff -> m SourcesDiff
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SourcesDiff -> m SourcesDiff
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourcesDiff -> m SourcesDiff
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourcesDiff -> m SourcesDiff
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourcesDiff -> m SourcesDiff
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourcesDiff -> m SourcesDiff
Data)
  deriving anyclass ([SourcesDiff] -> Value
[SourcesDiff] -> Encoding
SourcesDiff -> Bool
SourcesDiff -> Value
SourcesDiff -> Encoding
(SourcesDiff -> Value)
-> (SourcesDiff -> Encoding)
-> ([SourcesDiff] -> Value)
-> ([SourcesDiff] -> Encoding)
-> (SourcesDiff -> Bool)
-> ToJSON SourcesDiff
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: SourcesDiff -> Value
toJSON :: SourcesDiff -> Value
$ctoEncoding :: SourcesDiff -> Encoding
toEncoding :: SourcesDiff -> Encoding
$ctoJSONList :: [SourcesDiff] -> Value
toJSONList :: [SourcesDiff] -> Value
$ctoEncodingList :: [SourcesDiff] -> Encoding
toEncodingList :: [SourcesDiff] -> Encoding
$comitField :: SourcesDiff -> Bool
omitField :: SourcesDiff -> Bool
ToJSON, Maybe SourcesDiff
Value -> Parser [SourcesDiff]
Value -> Parser SourcesDiff
(Value -> Parser SourcesDiff)
-> (Value -> Parser [SourcesDiff])
-> Maybe SourcesDiff
-> FromJSON SourcesDiff
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser SourcesDiff
parseJSON :: Value -> Parser SourcesDiff
$cparseJSONList :: Value -> Parser [SourcesDiff]
parseJSONList :: Value -> Parser [SourcesDiff]
$comittedField :: Maybe SourcesDiff
omittedField :: Maybe SourcesDiff
FromJSON)
  deriving Gen SourcesDiff
Gen SourcesDiff
-> (SourcesDiff -> [SourcesDiff]) -> Arbitrary SourcesDiff
SourcesDiff -> [SourcesDiff]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen SourcesDiff
arbitrary :: Gen SourcesDiff
$cshrink :: SourcesDiff -> [SourcesDiff]
shrink :: SourcesDiff -> [SourcesDiff]
Arbitrary via GenericArbitrary SourcesDiff

data SourceFileDiff
  = OneSourceFileDiff
      { SourceFileDiff -> Text
srcName :: Text
      , SourceFileDiff -> Maybe TextDiff
srcContentDiff :: Maybe TextDiff
      -- ^ Will be Nothing, if any of source files not exists
      }
  | SomeSourceFileDiff
      { srcName :: Text
      , SourceFileDiff -> Changed [StorePath]
srcFileDiff :: Changed [StorePath]
      }
  deriving stock (SourceFileDiff -> SourceFileDiff -> Bool
(SourceFileDiff -> SourceFileDiff -> Bool)
-> (SourceFileDiff -> SourceFileDiff -> Bool) -> Eq SourceFileDiff
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SourceFileDiff -> SourceFileDiff -> Bool
== :: SourceFileDiff -> SourceFileDiff -> Bool
$c/= :: SourceFileDiff -> SourceFileDiff -> Bool
/= :: SourceFileDiff -> SourceFileDiff -> Bool
Eq, Int -> SourceFileDiff -> ShowS
[SourceFileDiff] -> ShowS
SourceFileDiff -> String
(Int -> SourceFileDiff -> ShowS)
-> (SourceFileDiff -> String)
-> ([SourceFileDiff] -> ShowS)
-> Show SourceFileDiff
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SourceFileDiff -> ShowS
showsPrec :: Int -> SourceFileDiff -> ShowS
$cshow :: SourceFileDiff -> String
show :: SourceFileDiff -> String
$cshowList :: [SourceFileDiff] -> ShowS
showList :: [SourceFileDiff] -> ShowS
Show, (forall x. SourceFileDiff -> Rep SourceFileDiff x)
-> (forall x. Rep SourceFileDiff x -> SourceFileDiff)
-> Generic SourceFileDiff
forall x. Rep SourceFileDiff x -> SourceFileDiff
forall x. SourceFileDiff -> Rep SourceFileDiff x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SourceFileDiff -> Rep SourceFileDiff x
from :: forall x. SourceFileDiff -> Rep SourceFileDiff x
$cto :: forall x. Rep SourceFileDiff x -> SourceFileDiff
to :: forall x. Rep SourceFileDiff x -> SourceFileDiff
Generic, Typeable SourceFileDiff
Typeable SourceFileDiff =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SourceFileDiff -> c SourceFileDiff)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SourceFileDiff)
-> (SourceFileDiff -> Constr)
-> (SourceFileDiff -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SourceFileDiff))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SourceFileDiff))
-> ((forall b. Data b => b -> b)
    -> SourceFileDiff -> SourceFileDiff)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceFileDiff -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceFileDiff -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SourceFileDiff -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SourceFileDiff -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SourceFileDiff -> m SourceFileDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SourceFileDiff -> m SourceFileDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SourceFileDiff -> m SourceFileDiff)
-> Data SourceFileDiff
SourceFileDiff -> Constr
SourceFileDiff -> DataType
(forall b. Data b => b -> b) -> SourceFileDiff -> SourceFileDiff
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> SourceFileDiff -> u
forall u. (forall d. Data d => d -> u) -> SourceFileDiff -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceFileDiff -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceFileDiff -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SourceFileDiff -> m SourceFileDiff
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SourceFileDiff -> m SourceFileDiff
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceFileDiff
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceFileDiff -> c SourceFileDiff
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceFileDiff)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourceFileDiff)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceFileDiff -> c SourceFileDiff
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceFileDiff -> c SourceFileDiff
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceFileDiff
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceFileDiff
$ctoConstr :: SourceFileDiff -> Constr
toConstr :: SourceFileDiff -> Constr
$cdataTypeOf :: SourceFileDiff -> DataType
dataTypeOf :: SourceFileDiff -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceFileDiff)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceFileDiff)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourceFileDiff)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SourceFileDiff)
$cgmapT :: (forall b. Data b => b -> b) -> SourceFileDiff -> SourceFileDiff
gmapT :: (forall b. Data b => b -> b) -> SourceFileDiff -> SourceFileDiff
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceFileDiff -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceFileDiff -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceFileDiff -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceFileDiff -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SourceFileDiff -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SourceFileDiff -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SourceFileDiff -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SourceFileDiff -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SourceFileDiff -> m SourceFileDiff
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SourceFileDiff -> m SourceFileDiff
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SourceFileDiff -> m SourceFileDiff
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SourceFileDiff -> m SourceFileDiff
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SourceFileDiff -> m SourceFileDiff
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SourceFileDiff -> m SourceFileDiff
Data)
  deriving anyclass ([SourceFileDiff] -> Value
[SourceFileDiff] -> Encoding
SourceFileDiff -> Bool
SourceFileDiff -> Value
SourceFileDiff -> Encoding
(SourceFileDiff -> Value)
-> (SourceFileDiff -> Encoding)
-> ([SourceFileDiff] -> Value)
-> ([SourceFileDiff] -> Encoding)
-> (SourceFileDiff -> Bool)
-> ToJSON SourceFileDiff
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: SourceFileDiff -> Value
toJSON :: SourceFileDiff -> Value
$ctoEncoding :: SourceFileDiff -> Encoding
toEncoding :: SourceFileDiff -> Encoding
$ctoJSONList :: [SourceFileDiff] -> Value
toJSONList :: [SourceFileDiff] -> Value
$ctoEncodingList :: [SourceFileDiff] -> Encoding
toEncodingList :: [SourceFileDiff] -> Encoding
$comitField :: SourceFileDiff -> Bool
omitField :: SourceFileDiff -> Bool
ToJSON, Maybe SourceFileDiff
Value -> Parser [SourceFileDiff]
Value -> Parser SourceFileDiff
(Value -> Parser SourceFileDiff)
-> (Value -> Parser [SourceFileDiff])
-> Maybe SourceFileDiff
-> FromJSON SourceFileDiff
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser SourceFileDiff
parseJSON :: Value -> Parser SourceFileDiff
$cparseJSONList :: Value -> Parser [SourceFileDiff]
parseJSONList :: Value -> Parser [SourceFileDiff]
$comittedField :: Maybe SourceFileDiff
omittedField :: Maybe SourceFileDiff
FromJSON)
  deriving Gen SourceFileDiff
Gen SourceFileDiff
-> (SourceFileDiff -> [SourceFileDiff]) -> Arbitrary SourceFileDiff
SourceFileDiff -> [SourceFileDiff]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen SourceFileDiff
arbitrary :: Gen SourceFileDiff
$cshrink :: SourceFileDiff -> [SourceFileDiff]
shrink :: SourceFileDiff -> [SourceFileDiff]
Arbitrary via GenericArbitrary SourceFileDiff

-- ** Inputs diff

data InputsDiff = InputsDiff
  { InputsDiff -> Maybe (Changed (Set Text))
inputExtraNames :: Maybe (Changed (Set Text))
    -- ^ Will be Nothing, if there is no extra input names
  , InputsDiff -> [InputDerivationsDiff]
inputDerivationDiffs :: [InputDerivationsDiff]
  }
  deriving stock (InputsDiff -> InputsDiff -> Bool
(InputsDiff -> InputsDiff -> Bool)
-> (InputsDiff -> InputsDiff -> Bool) -> Eq InputsDiff
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InputsDiff -> InputsDiff -> Bool
== :: InputsDiff -> InputsDiff -> Bool
$c/= :: InputsDiff -> InputsDiff -> Bool
/= :: InputsDiff -> InputsDiff -> Bool
Eq, Int -> InputsDiff -> ShowS
[InputsDiff] -> ShowS
InputsDiff -> String
(Int -> InputsDiff -> ShowS)
-> (InputsDiff -> String)
-> ([InputsDiff] -> ShowS)
-> Show InputsDiff
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InputsDiff -> ShowS
showsPrec :: Int -> InputsDiff -> ShowS
$cshow :: InputsDiff -> String
show :: InputsDiff -> String
$cshowList :: [InputsDiff] -> ShowS
showList :: [InputsDiff] -> ShowS
Show, (forall x. InputsDiff -> Rep InputsDiff x)
-> (forall x. Rep InputsDiff x -> InputsDiff) -> Generic InputsDiff
forall x. Rep InputsDiff x -> InputsDiff
forall x. InputsDiff -> Rep InputsDiff x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. InputsDiff -> Rep InputsDiff x
from :: forall x. InputsDiff -> Rep InputsDiff x
$cto :: forall x. Rep InputsDiff x -> InputsDiff
to :: forall x. Rep InputsDiff x -> InputsDiff
Generic, Typeable InputsDiff
Typeable InputsDiff =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> InputsDiff -> c InputsDiff)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c InputsDiff)
-> (InputsDiff -> Constr)
-> (InputsDiff -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c InputsDiff))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c InputsDiff))
-> ((forall b. Data b => b -> b) -> InputsDiff -> InputsDiff)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InputsDiff -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InputsDiff -> r)
-> (forall u. (forall d. Data d => d -> u) -> InputsDiff -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> InputsDiff -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> InputsDiff -> m InputsDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InputsDiff -> m InputsDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> InputsDiff -> m InputsDiff)
-> Data InputsDiff
InputsDiff -> Constr
InputsDiff -> DataType
(forall b. Data b => b -> b) -> InputsDiff -> InputsDiff
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> InputsDiff -> u
forall u. (forall d. Data d => d -> u) -> InputsDiff -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InputsDiff -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InputsDiff -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InputsDiff -> m InputsDiff
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InputsDiff -> m InputsDiff
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InputsDiff
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InputsDiff -> c InputsDiff
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InputsDiff)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InputsDiff)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InputsDiff -> c InputsDiff
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> InputsDiff -> c InputsDiff
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InputsDiff
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InputsDiff
$ctoConstr :: InputsDiff -> Constr
toConstr :: InputsDiff -> Constr
$cdataTypeOf :: InputsDiff -> DataType
dataTypeOf :: InputsDiff -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InputsDiff)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InputsDiff)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InputsDiff)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InputsDiff)
$cgmapT :: (forall b. Data b => b -> b) -> InputsDiff -> InputsDiff
gmapT :: (forall b. Data b => b -> b) -> InputsDiff -> InputsDiff
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InputsDiff -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InputsDiff -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InputsDiff -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InputsDiff -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> InputsDiff -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> InputsDiff -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InputsDiff -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> InputsDiff -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InputsDiff -> m InputsDiff
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> InputsDiff -> m InputsDiff
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InputsDiff -> m InputsDiff
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InputsDiff -> m InputsDiff
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InputsDiff -> m InputsDiff
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> InputsDiff -> m InputsDiff
Data)
  deriving anyclass ([InputsDiff] -> Value
[InputsDiff] -> Encoding
InputsDiff -> Bool
InputsDiff -> Value
InputsDiff -> Encoding
(InputsDiff -> Value)
-> (InputsDiff -> Encoding)
-> ([InputsDiff] -> Value)
-> ([InputsDiff] -> Encoding)
-> (InputsDiff -> Bool)
-> ToJSON InputsDiff
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: InputsDiff -> Value
toJSON :: InputsDiff -> Value
$ctoEncoding :: InputsDiff -> Encoding
toEncoding :: InputsDiff -> Encoding
$ctoJSONList :: [InputsDiff] -> Value
toJSONList :: [InputsDiff] -> Value
$ctoEncodingList :: [InputsDiff] -> Encoding
toEncodingList :: [InputsDiff] -> Encoding
$comitField :: InputsDiff -> Bool
omitField :: InputsDiff -> Bool
ToJSON, Maybe InputsDiff
Value -> Parser [InputsDiff]
Value -> Parser InputsDiff
(Value -> Parser InputsDiff)
-> (Value -> Parser [InputsDiff])
-> Maybe InputsDiff
-> FromJSON InputsDiff
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser InputsDiff
parseJSON :: Value -> Parser InputsDiff
$cparseJSONList :: Value -> Parser [InputsDiff]
parseJSONList :: Value -> Parser [InputsDiff]
$comittedField :: Maybe InputsDiff
omittedField :: Maybe InputsDiff
FromJSON)
  deriving Gen InputsDiff
Gen InputsDiff
-> (InputsDiff -> [InputsDiff]) -> Arbitrary InputsDiff
InputsDiff -> [InputsDiff]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen InputsDiff
arbitrary :: Gen InputsDiff
$cshrink :: InputsDiff -> [InputsDiff]
shrink :: InputsDiff -> [InputsDiff]
Arbitrary via GenericArbitrary InputsDiff

data InputDerivationsDiff
  = OneDerivationDiff
      { InputDerivationsDiff -> Text
drvName :: Text
      , InputDerivationsDiff -> DerivationDiff
drvDiff :: DerivationDiff
      }
  | SomeDerivationsDiff
      { drvName :: Text
      , InputDerivationsDiff -> Changed (Map StorePath OutputNames)
extraPartsDiff :: Changed (Map StorePath OutputNames)
      }
  | -- | Many input derivations differ, but they've all already been compared.
    ManyDerivationsAlreadyComparedDiff
      { InputDerivationsDiff -> Set Text
drvNames :: Set Text
      }
  deriving stock (InputDerivationsDiff -> InputDerivationsDiff -> Bool
(InputDerivationsDiff -> InputDerivationsDiff -> Bool)
-> (InputDerivationsDiff -> InputDerivationsDiff -> Bool)
-> Eq InputDerivationsDiff
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InputDerivationsDiff -> InputDerivationsDiff -> Bool
== :: InputDerivationsDiff -> InputDerivationsDiff -> Bool
$c/= :: InputDerivationsDiff -> InputDerivationsDiff -> Bool
/= :: InputDerivationsDiff -> InputDerivationsDiff -> Bool
Eq, Int -> InputDerivationsDiff -> ShowS
[InputDerivationsDiff] -> ShowS
InputDerivationsDiff -> String
(Int -> InputDerivationsDiff -> ShowS)
-> (InputDerivationsDiff -> String)
-> ([InputDerivationsDiff] -> ShowS)
-> Show InputDerivationsDiff
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> InputDerivationsDiff -> ShowS
showsPrec :: Int -> InputDerivationsDiff -> ShowS
$cshow :: InputDerivationsDiff -> String
show :: InputDerivationsDiff -> String
$cshowList :: [InputDerivationsDiff] -> ShowS
showList :: [InputDerivationsDiff] -> ShowS
Show, (forall x. InputDerivationsDiff -> Rep InputDerivationsDiff x)
-> (forall x. Rep InputDerivationsDiff x -> InputDerivationsDiff)
-> Generic InputDerivationsDiff
forall x. Rep InputDerivationsDiff x -> InputDerivationsDiff
forall x. InputDerivationsDiff -> Rep InputDerivationsDiff x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. InputDerivationsDiff -> Rep InputDerivationsDiff x
from :: forall x. InputDerivationsDiff -> Rep InputDerivationsDiff x
$cto :: forall x. Rep InputDerivationsDiff x -> InputDerivationsDiff
to :: forall x. Rep InputDerivationsDiff x -> InputDerivationsDiff
Generic, Typeable InputDerivationsDiff
Typeable InputDerivationsDiff =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> InputDerivationsDiff
 -> c InputDerivationsDiff)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c InputDerivationsDiff)
-> (InputDerivationsDiff -> Constr)
-> (InputDerivationsDiff -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c InputDerivationsDiff))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c InputDerivationsDiff))
-> ((forall b. Data b => b -> b)
    -> InputDerivationsDiff -> InputDerivationsDiff)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InputDerivationsDiff -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InputDerivationsDiff -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> InputDerivationsDiff -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> InputDerivationsDiff -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> InputDerivationsDiff -> m InputDerivationsDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InputDerivationsDiff -> m InputDerivationsDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InputDerivationsDiff -> m InputDerivationsDiff)
-> Data InputDerivationsDiff
InputDerivationsDiff -> Constr
InputDerivationsDiff -> DataType
(forall b. Data b => b -> b)
-> InputDerivationsDiff -> InputDerivationsDiff
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> InputDerivationsDiff -> u
forall u.
(forall d. Data d => d -> u) -> InputDerivationsDiff -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InputDerivationsDiff -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InputDerivationsDiff -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> InputDerivationsDiff -> m InputDerivationsDiff
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InputDerivationsDiff -> m InputDerivationsDiff
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InputDerivationsDiff
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> InputDerivationsDiff
-> c InputDerivationsDiff
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InputDerivationsDiff)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InputDerivationsDiff)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> InputDerivationsDiff
-> c InputDerivationsDiff
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> InputDerivationsDiff
-> c InputDerivationsDiff
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InputDerivationsDiff
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c InputDerivationsDiff
$ctoConstr :: InputDerivationsDiff -> Constr
toConstr :: InputDerivationsDiff -> Constr
$cdataTypeOf :: InputDerivationsDiff -> DataType
dataTypeOf :: InputDerivationsDiff -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InputDerivationsDiff)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c InputDerivationsDiff)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InputDerivationsDiff)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c InputDerivationsDiff)
$cgmapT :: (forall b. Data b => b -> b)
-> InputDerivationsDiff -> InputDerivationsDiff
gmapT :: (forall b. Data b => b -> b)
-> InputDerivationsDiff -> InputDerivationsDiff
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InputDerivationsDiff -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InputDerivationsDiff -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InputDerivationsDiff -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InputDerivationsDiff -> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> InputDerivationsDiff -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> InputDerivationsDiff -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> InputDerivationsDiff -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> InputDerivationsDiff -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> InputDerivationsDiff -> m InputDerivationsDiff
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> InputDerivationsDiff -> m InputDerivationsDiff
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InputDerivationsDiff -> m InputDerivationsDiff
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InputDerivationsDiff -> m InputDerivationsDiff
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InputDerivationsDiff -> m InputDerivationsDiff
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InputDerivationsDiff -> m InputDerivationsDiff
Data)
  deriving anyclass ([InputDerivationsDiff] -> Value
[InputDerivationsDiff] -> Encoding
InputDerivationsDiff -> Bool
InputDerivationsDiff -> Value
InputDerivationsDiff -> Encoding
(InputDerivationsDiff -> Value)
-> (InputDerivationsDiff -> Encoding)
-> ([InputDerivationsDiff] -> Value)
-> ([InputDerivationsDiff] -> Encoding)
-> (InputDerivationsDiff -> Bool)
-> ToJSON InputDerivationsDiff
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: InputDerivationsDiff -> Value
toJSON :: InputDerivationsDiff -> Value
$ctoEncoding :: InputDerivationsDiff -> Encoding
toEncoding :: InputDerivationsDiff -> Encoding
$ctoJSONList :: [InputDerivationsDiff] -> Value
toJSONList :: [InputDerivationsDiff] -> Value
$ctoEncodingList :: [InputDerivationsDiff] -> Encoding
toEncodingList :: [InputDerivationsDiff] -> Encoding
$comitField :: InputDerivationsDiff -> Bool
omitField :: InputDerivationsDiff -> Bool
ToJSON, Maybe InputDerivationsDiff
Value -> Parser [InputDerivationsDiff]
Value -> Parser InputDerivationsDiff
(Value -> Parser InputDerivationsDiff)
-> (Value -> Parser [InputDerivationsDiff])
-> Maybe InputDerivationsDiff
-> FromJSON InputDerivationsDiff
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser InputDerivationsDiff
parseJSON :: Value -> Parser InputDerivationsDiff
$cparseJSONList :: Value -> Parser [InputDerivationsDiff]
parseJSONList :: Value -> Parser [InputDerivationsDiff]
$comittedField :: Maybe InputDerivationsDiff
omittedField :: Maybe InputDerivationsDiff
FromJSON)
  deriving Gen InputDerivationsDiff
Gen InputDerivationsDiff
-> (InputDerivationsDiff -> [InputDerivationsDiff])
-> Arbitrary InputDerivationsDiff
InputDerivationsDiff -> [InputDerivationsDiff]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen InputDerivationsDiff
arbitrary :: Gen InputDerivationsDiff
$cshrink :: InputDerivationsDiff -> [InputDerivationsDiff]
shrink :: InputDerivationsDiff -> [InputDerivationsDiff]
Arbitrary via GenericArbitrary InputDerivationsDiff

-- ** Environment diff

data EnvironmentDiff
  = EnvironmentsAreEqual
  | EnvironmentDiff
      { EnvironmentDiff -> Changed (Map Text Text)
extraEnvDiff :: Changed (Map Text Text)
      , EnvironmentDiff -> [EnvVarDiff]
envContentDiff :: [EnvVarDiff]
      }
  deriving stock (EnvironmentDiff -> EnvironmentDiff -> Bool
(EnvironmentDiff -> EnvironmentDiff -> Bool)
-> (EnvironmentDiff -> EnvironmentDiff -> Bool)
-> Eq EnvironmentDiff
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EnvironmentDiff -> EnvironmentDiff -> Bool
== :: EnvironmentDiff -> EnvironmentDiff -> Bool
$c/= :: EnvironmentDiff -> EnvironmentDiff -> Bool
/= :: EnvironmentDiff -> EnvironmentDiff -> Bool
Eq, Int -> EnvironmentDiff -> ShowS
[EnvironmentDiff] -> ShowS
EnvironmentDiff -> String
(Int -> EnvironmentDiff -> ShowS)
-> (EnvironmentDiff -> String)
-> ([EnvironmentDiff] -> ShowS)
-> Show EnvironmentDiff
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EnvironmentDiff -> ShowS
showsPrec :: Int -> EnvironmentDiff -> ShowS
$cshow :: EnvironmentDiff -> String
show :: EnvironmentDiff -> String
$cshowList :: [EnvironmentDiff] -> ShowS
showList :: [EnvironmentDiff] -> ShowS
Show, (forall x. EnvironmentDiff -> Rep EnvironmentDiff x)
-> (forall x. Rep EnvironmentDiff x -> EnvironmentDiff)
-> Generic EnvironmentDiff
forall x. Rep EnvironmentDiff x -> EnvironmentDiff
forall x. EnvironmentDiff -> Rep EnvironmentDiff x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EnvironmentDiff -> Rep EnvironmentDiff x
from :: forall x. EnvironmentDiff -> Rep EnvironmentDiff x
$cto :: forall x. Rep EnvironmentDiff x -> EnvironmentDiff
to :: forall x. Rep EnvironmentDiff x -> EnvironmentDiff
Generic, Typeable EnvironmentDiff
Typeable EnvironmentDiff =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> EnvironmentDiff -> c EnvironmentDiff)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EnvironmentDiff)
-> (EnvironmentDiff -> Constr)
-> (EnvironmentDiff -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EnvironmentDiff))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EnvironmentDiff))
-> ((forall b. Data b => b -> b)
    -> EnvironmentDiff -> EnvironmentDiff)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EnvironmentDiff -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EnvironmentDiff -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> EnvironmentDiff -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> EnvironmentDiff -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> EnvironmentDiff -> m EnvironmentDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EnvironmentDiff -> m EnvironmentDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EnvironmentDiff -> m EnvironmentDiff)
-> Data EnvironmentDiff
EnvironmentDiff -> Constr
EnvironmentDiff -> DataType
(forall b. Data b => b -> b) -> EnvironmentDiff -> EnvironmentDiff
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> EnvironmentDiff -> u
forall u. (forall d. Data d => d -> u) -> EnvironmentDiff -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnvironmentDiff -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnvironmentDiff -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EnvironmentDiff -> m EnvironmentDiff
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnvironmentDiff -> m EnvironmentDiff
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnvironmentDiff
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnvironmentDiff -> c EnvironmentDiff
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnvironmentDiff)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnvironmentDiff)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnvironmentDiff -> c EnvironmentDiff
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnvironmentDiff -> c EnvironmentDiff
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnvironmentDiff
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnvironmentDiff
$ctoConstr :: EnvironmentDiff -> Constr
toConstr :: EnvironmentDiff -> Constr
$cdataTypeOf :: EnvironmentDiff -> DataType
dataTypeOf :: EnvironmentDiff -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnvironmentDiff)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnvironmentDiff)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnvironmentDiff)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EnvironmentDiff)
$cgmapT :: (forall b. Data b => b -> b) -> EnvironmentDiff -> EnvironmentDiff
gmapT :: (forall b. Data b => b -> b) -> EnvironmentDiff -> EnvironmentDiff
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnvironmentDiff -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnvironmentDiff -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnvironmentDiff -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnvironmentDiff -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EnvironmentDiff -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> EnvironmentDiff -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> EnvironmentDiff -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> EnvironmentDiff -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EnvironmentDiff -> m EnvironmentDiff
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EnvironmentDiff -> m EnvironmentDiff
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnvironmentDiff -> m EnvironmentDiff
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnvironmentDiff -> m EnvironmentDiff
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnvironmentDiff -> m EnvironmentDiff
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EnvironmentDiff -> m EnvironmentDiff
Data)
  deriving anyclass ([EnvironmentDiff] -> Value
[EnvironmentDiff] -> Encoding
EnvironmentDiff -> Bool
EnvironmentDiff -> Value
EnvironmentDiff -> Encoding
(EnvironmentDiff -> Value)
-> (EnvironmentDiff -> Encoding)
-> ([EnvironmentDiff] -> Value)
-> ([EnvironmentDiff] -> Encoding)
-> (EnvironmentDiff -> Bool)
-> ToJSON EnvironmentDiff
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: EnvironmentDiff -> Value
toJSON :: EnvironmentDiff -> Value
$ctoEncoding :: EnvironmentDiff -> Encoding
toEncoding :: EnvironmentDiff -> Encoding
$ctoJSONList :: [EnvironmentDiff] -> Value
toJSONList :: [EnvironmentDiff] -> Value
$ctoEncodingList :: [EnvironmentDiff] -> Encoding
toEncodingList :: [EnvironmentDiff] -> Encoding
$comitField :: EnvironmentDiff -> Bool
omitField :: EnvironmentDiff -> Bool
ToJSON, Maybe EnvironmentDiff
Value -> Parser [EnvironmentDiff]
Value -> Parser EnvironmentDiff
(Value -> Parser EnvironmentDiff)
-> (Value -> Parser [EnvironmentDiff])
-> Maybe EnvironmentDiff
-> FromJSON EnvironmentDiff
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser EnvironmentDiff
parseJSON :: Value -> Parser EnvironmentDiff
$cparseJSONList :: Value -> Parser [EnvironmentDiff]
parseJSONList :: Value -> Parser [EnvironmentDiff]
$comittedField :: Maybe EnvironmentDiff
omittedField :: Maybe EnvironmentDiff
FromJSON)
  deriving Gen EnvironmentDiff
Gen EnvironmentDiff
-> (EnvironmentDiff -> [EnvironmentDiff])
-> Arbitrary EnvironmentDiff
EnvironmentDiff -> [EnvironmentDiff]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen EnvironmentDiff
arbitrary :: Gen EnvironmentDiff
$cshrink :: EnvironmentDiff -> [EnvironmentDiff]
shrink :: EnvironmentDiff -> [EnvironmentDiff]
Arbitrary via GenericArbitrary EnvironmentDiff

data EnvVarDiff = EnvVarDiff
  { EnvVarDiff -> Text
envKey :: Text
  , EnvVarDiff -> TextDiff
envValueDiff :: TextDiff
  }
  deriving stock (EnvVarDiff -> EnvVarDiff -> Bool
(EnvVarDiff -> EnvVarDiff -> Bool)
-> (EnvVarDiff -> EnvVarDiff -> Bool) -> Eq EnvVarDiff
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EnvVarDiff -> EnvVarDiff -> Bool
== :: EnvVarDiff -> EnvVarDiff -> Bool
$c/= :: EnvVarDiff -> EnvVarDiff -> Bool
/= :: EnvVarDiff -> EnvVarDiff -> Bool
Eq, Int -> EnvVarDiff -> ShowS
[EnvVarDiff] -> ShowS
EnvVarDiff -> String
(Int -> EnvVarDiff -> ShowS)
-> (EnvVarDiff -> String)
-> ([EnvVarDiff] -> ShowS)
-> Show EnvVarDiff
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EnvVarDiff -> ShowS
showsPrec :: Int -> EnvVarDiff -> ShowS
$cshow :: EnvVarDiff -> String
show :: EnvVarDiff -> String
$cshowList :: [EnvVarDiff] -> ShowS
showList :: [EnvVarDiff] -> ShowS
Show, (forall x. EnvVarDiff -> Rep EnvVarDiff x)
-> (forall x. Rep EnvVarDiff x -> EnvVarDiff) -> Generic EnvVarDiff
forall x. Rep EnvVarDiff x -> EnvVarDiff
forall x. EnvVarDiff -> Rep EnvVarDiff x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EnvVarDiff -> Rep EnvVarDiff x
from :: forall x. EnvVarDiff -> Rep EnvVarDiff x
$cto :: forall x. Rep EnvVarDiff x -> EnvVarDiff
to :: forall x. Rep EnvVarDiff x -> EnvVarDiff
Generic, Typeable EnvVarDiff
Typeable EnvVarDiff =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> EnvVarDiff -> c EnvVarDiff)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EnvVarDiff)
-> (EnvVarDiff -> Constr)
-> (EnvVarDiff -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EnvVarDiff))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EnvVarDiff))
-> ((forall b. Data b => b -> b) -> EnvVarDiff -> EnvVarDiff)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EnvVarDiff -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EnvVarDiff -> r)
-> (forall u. (forall d. Data d => d -> u) -> EnvVarDiff -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> EnvVarDiff -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> EnvVarDiff -> m EnvVarDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EnvVarDiff -> m EnvVarDiff)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> EnvVarDiff -> m EnvVarDiff)
-> Data EnvVarDiff
EnvVarDiff -> Constr
EnvVarDiff -> DataType
(forall b. Data b => b -> b) -> EnvVarDiff -> EnvVarDiff
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> EnvVarDiff -> u
forall u. (forall d. Data d => d -> u) -> EnvVarDiff -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnvVarDiff -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnvVarDiff -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnvVarDiff -> m EnvVarDiff
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnvVarDiff -> m EnvVarDiff
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnvVarDiff
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnvVarDiff -> c EnvVarDiff
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnvVarDiff)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnvVarDiff)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnvVarDiff -> c EnvVarDiff
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EnvVarDiff -> c EnvVarDiff
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnvVarDiff
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EnvVarDiff
$ctoConstr :: EnvVarDiff -> Constr
toConstr :: EnvVarDiff -> Constr
$cdataTypeOf :: EnvVarDiff -> DataType
dataTypeOf :: EnvVarDiff -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnvVarDiff)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EnvVarDiff)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnvVarDiff)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnvVarDiff)
$cgmapT :: (forall b. Data b => b -> b) -> EnvVarDiff -> EnvVarDiff
gmapT :: (forall b. Data b => b -> b) -> EnvVarDiff -> EnvVarDiff
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnvVarDiff -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EnvVarDiff -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnvVarDiff -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EnvVarDiff -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EnvVarDiff -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> EnvVarDiff -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EnvVarDiff -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> EnvVarDiff -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnvVarDiff -> m EnvVarDiff
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> EnvVarDiff -> m EnvVarDiff
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnvVarDiff -> m EnvVarDiff
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnvVarDiff -> m EnvVarDiff
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnvVarDiff -> m EnvVarDiff
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> EnvVarDiff -> m EnvVarDiff
Data)
  deriving anyclass ([EnvVarDiff] -> Value
[EnvVarDiff] -> Encoding
EnvVarDiff -> Bool
EnvVarDiff -> Value
EnvVarDiff -> Encoding
(EnvVarDiff -> Value)
-> (EnvVarDiff -> Encoding)
-> ([EnvVarDiff] -> Value)
-> ([EnvVarDiff] -> Encoding)
-> (EnvVarDiff -> Bool)
-> ToJSON EnvVarDiff
forall a.
(a -> Value)
-> (a -> Encoding)
-> ([a] -> Value)
-> ([a] -> Encoding)
-> (a -> Bool)
-> ToJSON a
$ctoJSON :: EnvVarDiff -> Value
toJSON :: EnvVarDiff -> Value
$ctoEncoding :: EnvVarDiff -> Encoding
toEncoding :: EnvVarDiff -> Encoding
$ctoJSONList :: [EnvVarDiff] -> Value
toJSONList :: [EnvVarDiff] -> Value
$ctoEncodingList :: [EnvVarDiff] -> Encoding
toEncodingList :: [EnvVarDiff] -> Encoding
$comitField :: EnvVarDiff -> Bool
omitField :: EnvVarDiff -> Bool
ToJSON, Maybe EnvVarDiff
Value -> Parser [EnvVarDiff]
Value -> Parser EnvVarDiff
(Value -> Parser EnvVarDiff)
-> (Value -> Parser [EnvVarDiff])
-> Maybe EnvVarDiff
-> FromJSON EnvVarDiff
forall a.
(Value -> Parser a)
-> (Value -> Parser [a]) -> Maybe a -> FromJSON a
$cparseJSON :: Value -> Parser EnvVarDiff
parseJSON :: Value -> Parser EnvVarDiff
$cparseJSONList :: Value -> Parser [EnvVarDiff]
parseJSONList :: Value -> Parser [EnvVarDiff]
$comittedField :: Maybe EnvVarDiff
omittedField :: Maybe EnvVarDiff
FromJSON)
  deriving Gen EnvVarDiff
Gen EnvVarDiff
-> (EnvVarDiff -> [EnvVarDiff]) -> Arbitrary EnvVarDiff
EnvVarDiff -> [EnvVarDiff]
forall a. Gen a -> (a -> [a]) -> Arbitrary a
$carbitrary :: Gen EnvVarDiff
arbitrary :: Gen EnvVarDiff
$cshrink :: EnvVarDiff -> [EnvVarDiff]
shrink :: EnvVarDiff -> [EnvVarDiff]
Arbitrary via GenericArbitrary EnvVarDiff

-- ** Helpers

changedToJSON :: (a -> Value) -> Changed a -> Value
changedToJSON :: forall a. (a -> Value) -> Changed a -> Value
changedToJSON a -> Value
converter Changed{a
$sel:before:Changed :: forall a. Changed a -> a
$sel:now:Changed :: forall a. Changed a -> a
before :: a
now :: a
..} = [Pair] -> Value
object
  [ Key
"before" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= a -> Value
converter a
before
  , Key
"now" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= a -> Value
converter a
now
  ]

changedFromJSON :: (Value -> Parser a) -> Value -> Parser (Changed a)
changedFromJSON :: forall a. (Value -> Parser a) -> Value -> Parser (Changed a)
changedFromJSON Value -> Parser a
innerParser = String
-> (Object -> Parser (Changed a)) -> Value -> Parser (Changed a)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Changed" \Object
o -> do
  Value
b <- Object
o Object -> Key -> Parser Value
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"before"
  Value
n <- Object
o Object -> Key -> Parser Value
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"now"
  a -> a -> Changed a
forall a. a -> a -> Changed a
Changed (a -> a -> Changed a) -> Parser a -> Parser (a -> Changed a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser a
innerParser Value
b Parser (a -> Changed a) -> Parser a -> Parser (Changed a)
forall a b. Parser (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Value -> Parser a
innerParser Value
n

itemToJSON :: ToJSON v => Patience.Item v -> Value
itemToJSON :: forall v. ToJSON v => Item v -> Value
itemToJSON (Patience.Old v
a)    = [Pair] -> Value
object
  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"Old" :: Text), Key
"content" Key -> v -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= v
a]
itemToJSON (Patience.New v
a)    = [Pair] -> Value
object
  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"New" :: Text), Key
"content" Key -> v -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= v
a]
itemToJSON (Patience.Both v
a v
_) = [Pair] -> Value
object
  [ Key
"type" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"Both" :: Text), Key
"content" Key -> v -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= v
a]

itemFromJSON :: FromJSON v => Value -> Parser (Patience.Item v)
itemFromJSON :: forall v. FromJSON v => Value -> Parser (Item v)
itemFromJSON = String -> (Object -> Parser (Item v)) -> Value -> Parser (Item v)
forall a. String -> (Object -> Parser a) -> Value -> Parser a
withObject String
"Item" \Object
o -> do
  Text
t <- Object
o Object -> Key -> Parser Text
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"type"
  v
c <- Object
o Object -> Key -> Parser v
forall a. FromJSON a => Object -> Key -> Parser a
.: Key
"content"
  case Text
t :: Text of
    Text
"Old" -> Item v -> Parser (Item v)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Item v -> Parser (Item v)) -> Item v -> Parser (Item v)
forall a b. (a -> b) -> a -> b
$ v -> Item v
forall a. a -> Item a
Patience.Old v
c
    Text
"New" -> Item v -> Parser (Item v)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Item v -> Parser (Item v)) -> Item v -> Parser (Item v)
forall a b. (a -> b) -> a -> b
$ v -> Item v
forall a. a -> Item a
Patience.New v
c
    Text
"Both" -> Item v -> Parser (Item v)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Item v -> Parser (Item v)) -> Item v -> Parser (Item v)
forall a b. (a -> b) -> a -> b
$ v -> v -> Item v
forall a. a -> a -> Item a
Patience.Both v
c v
c
    Text
_ -> String -> Parser (Item v)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Item: unexpected type"

arbitraryItem :: Arbitrary a => Gen (Patience.Item a)
arbitraryItem :: forall a. Arbitrary a => Gen (Item a)
arbitraryItem =  do
  a
t <- Gen a
forall a. Arbitrary a => Gen a
arbitrary
  a -> Item a
ctr <- [a -> Item a] -> Gen (a -> Item a)
forall a. [a] -> Gen a
elements [a -> Item a
forall a. a -> Item a
old, a -> Item a
forall a. a -> Item a
new, a -> Item a
forall a. a -> Item a
both]
  pure (a -> Item a
ctr a
t)
  where
    old :: a -> Item a
old = a -> Item a
forall a. a -> Item a
Patience.Old
    new :: a -> Item a
new = a -> Item a
forall a. a -> Item a
Patience.New
    both :: a -> Item a
both a
x = a -> a -> Item a
forall a. a -> a -> Item a
Patience.Both a
x a
x

arbitraryDerivationOutput :: (Arbitrary fp, Arbitrary txt) => Gen (DerivationOutput fp txt)
arbitraryDerivationOutput :: forall fp txt.
(Arbitrary fp, Arbitrary txt) =>
Gen (DerivationOutput fp txt)
arbitraryDerivationOutput = fp -> txt -> txt -> DerivationOutput fp txt
forall fp txt. fp -> txt -> txt -> DerivationOutput fp txt
DerivationOutput (fp -> txt -> txt -> DerivationOutput fp txt)
-> Gen fp -> Gen (txt -> txt -> DerivationOutput fp txt)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen fp
forall a. Arbitrary a => Gen a
arbitrary Gen (txt -> txt -> DerivationOutput fp txt)
-> Gen txt -> Gen (txt -> DerivationOutput fp txt)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen txt
forall a. Arbitrary a => Gen a
arbitrary Gen (txt -> DerivationOutput fp txt)
-> Gen txt -> Gen (DerivationOutput fp txt)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen txt
forall a. Arbitrary a => Gen a
arbitrary