Nix.Diff.Types

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

Constructors

Changed

Fields

• before :: a
• now :: a

Instances

Foldable Changed

Defined in Nix.Diff.Types

Methods

fold :: Monoid m => Changed m -> m

foldMap :: Monoid m => (a -> m) -> Changed a -> m

foldMap' :: Monoid m => (a -> m) -> Changed a -> m

foldr :: (a -> b -> b) -> b -> Changed a -> b

foldr' :: (a -> b -> b) -> b -> Changed a -> b

foldl :: (b -> a -> b) -> b -> Changed a -> b

foldl' :: (b -> a -> b) -> b -> Changed a -> b

foldr1 :: (a -> a -> a) -> Changed a -> a

foldl1 :: (a -> a -> a) -> Changed a -> a

toList :: Changed a -> [a]

null :: Changed a -> Bool

length :: Changed a -> Int

elem :: Eq a => a -> Changed a -> Bool

maximum :: Ord a => Changed a -> a

minimum :: Ord a => Changed a -> a

sum :: Num a => Changed a -> a

product :: Num a => Changed a -> a

Traversable Changed

Defined in Nix.Diff.Types

Methods

traverse :: Applicative f => (a -> f b) -> Changed a -> f (Changed b)

sequenceA :: Applicative f => Changed (f a) -> f (Changed a)

mapM :: Monad m => (a -> m b) -> Changed a -> m (Changed b)

sequence :: Monad m => Changed (m a) -> m (Changed a)

Functor Changed

Defined in Nix.Diff.Types

Methods

fmap :: (a -> b) -> Changed a -> Changed b

(<$) :: a -> Changed b -> Changed a

Arbitrary a => Arbitrary (Changed a)

Defined in Nix.Diff.Types

Methods

arbitrary :: Gen (Changed a)

shrink :: Changed a -> [Changed a]

FromJSON a => FromJSON (Changed a)

Defined in Nix.Diff.Types

Methods

parseJSON :: Value -> Parser (Changed a)

parseJSONList :: Value -> Parser [Changed a]

omittedField :: Maybe (Changed a)

ToJSON a => ToJSON (Changed a)

Defined in Nix.Diff.Types

Methods

toJSON :: Changed a -> Value

toEncoding :: Changed a -> Encoding

toJSONList :: [Changed a] -> Value

toEncodingList :: [Changed a] -> Encoding

omitField :: Changed a -> Bool

Data a => Data (Changed a)

Defined in Nix.Diff.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Changed a -> c (Changed a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Changed a)

toConstr :: Changed a -> Constr

dataTypeOf :: Changed a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Changed a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Changed a))

gmapT :: (forall b. Data b => b -> b) -> Changed a -> Changed a

gmapQl :: (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

gmapQ :: (forall d. Data d => d -> u) -> Changed a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Changed a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Changed a -> m (Changed a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Changed a -> m (Changed a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Changed a -> m (Changed a)

Generic (Changed a)

Defined in Nix.Diff.Types

Associated Types

type Rep (Changed a) :: Type -> Type

Methods

from :: Changed a -> Rep (Changed a) x

to :: Rep (Changed a) x -> Changed a

Show a => Show (Changed a)

Defined in Nix.Diff.Types

Methods

showsPrec :: Int -> Changed a -> ShowS

show :: Changed a -> String

showList :: [Changed a] -> ShowS

Eq a => Eq (Changed a)

Defined in Nix.Diff.Types

Methods

(==) :: Changed a -> Changed a -> Bool

(/=) :: Changed a -> Changed a -> Bool

type Rep (Changed a)

Defined in Nix.Diff.Types

type Rep (Changed a) = D1 ('MetaData "Changed" "Nix.Diff.Types" "nix-diff-1.0.21-9upfo2llU6vKJbTes5Z7ck" 'False) (C1 ('MetaCons "Changed" 'PrefixI 'True) (S1 ('MetaSel ('Just "before") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "now") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

newtype TextDiff

Constructors

TextDiff

Fields

• unTextDiff :: [Item Text]

Instances

Arbitrary TextDiff

Defined in Nix.Diff.Types

Methods

arbitrary :: Gen TextDiff

shrink :: TextDiff -> [TextDiff]

FromJSON TextDiff

Defined in Nix.Diff.Types

Methods

parseJSON :: Value -> Parser TextDiff

parseJSONList :: Value -> Parser [TextDiff]

omittedField :: Maybe TextDiff

ToJSON TextDiff

Defined in Nix.Diff.Types

Methods

toJSON :: TextDiff -> Value

toEncoding :: TextDiff -> Encoding

toJSONList :: [TextDiff] -> Value

toEncodingList :: [TextDiff] -> Encoding

omitField :: TextDiff -> Bool

Data TextDiff

Defined in Nix.Diff.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TextDiff -> c TextDiff

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TextDiff

toConstr :: TextDiff -> Constr

dataTypeOf :: TextDiff -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TextDiff)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TextDiff)

gmapT :: (forall b. Data b => b -> b) -> TextDiff -> TextDiff

gmapQl :: (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

gmapQ :: (forall d. Data d => d -> u) -> TextDiff -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TextDiff -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TextDiff -> m TextDiff

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TextDiff -> m TextDiff

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TextDiff -> m TextDiff

Show TextDiff

Defined in Nix.Diff.Types

Methods

showsPrec :: Int -> TextDiff -> ShowS

show :: TextDiff -> String

showList :: [TextDiff] -> ShowS

Eq TextDiff

Defined in Nix.Diff.Types

Methods

(==) :: TextDiff -> TextDiff -> Bool

(/=) :: TextDiff -> TextDiff -> Bool

type OutputHash = Text

type Platform = Text

type Builder = Text

type Argument = Text

newtype OutputNames

A set of Nix derivation output names.

Constructors

OutputNames

Fields

• unOutputNames :: Set Text

Instances

Arbitrary OutputNames

Defined in Nix.Diff.Types

Methods

arbitrary :: Gen OutputNames

shrink :: OutputNames -> [OutputNames]

FromJSON OutputNames

Defined in Nix.Diff.Types

Methods

parseJSON :: Value -> Parser OutputNames

parseJSONList :: Value -> Parser [OutputNames]

omittedField :: Maybe OutputNames

ToJSON OutputNames

Defined in Nix.Diff.Types

Methods

toJSON :: OutputNames -> Value

toEncoding :: OutputNames -> Encoding

toJSONList :: [OutputNames] -> Value

toEncodingList :: [OutputNames] -> Encoding

omitField :: OutputNames -> Bool

Data OutputNames

Defined in Nix.Diff.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OutputNames -> c OutputNames

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OutputNames

toConstr :: OutputNames -> Constr

dataTypeOf :: OutputNames -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OutputNames)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OutputNames)

gmapT :: (forall b. Data b => b -> b) -> OutputNames -> OutputNames

gmapQl :: (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

gmapQ :: (forall d. Data d => d -> u) -> OutputNames -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> OutputNames -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OutputNames -> m OutputNames

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OutputNames -> m OutputNames

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OutputNames -> m OutputNames

Generic OutputNames

Defined in Nix.Diff.Types

Associated Types

type Rep OutputNames :: Type -> Type

Methods

from :: OutputNames -> Rep OutputNames x

to :: Rep OutputNames x -> OutputNames

Show OutputNames

Defined in Nix.Diff.Types

Methods

showsPrec :: Int -> OutputNames -> ShowS

show :: OutputNames -> String

showList :: [OutputNames] -> ShowS

Eq OutputNames

Defined in Nix.Diff.Types

Methods

(==) :: OutputNames -> OutputNames -> Bool

(/=) :: OutputNames -> OutputNames -> Bool

Ord OutputNames

Defined in Nix.Diff.Types

Methods

compare :: OutputNames -> OutputNames -> Ordering

(<) :: OutputNames -> OutputNames -> Bool

(<=) :: OutputNames -> OutputNames -> Bool

(>) :: OutputNames -> OutputNames -> Bool

(>=) :: OutputNames -> OutputNames -> Bool

max :: OutputNames -> OutputNames -> OutputNames

min :: OutputNames -> OutputNames -> OutputNames

type Rep OutputNames

Defined in Nix.Diff.Types

type Rep OutputNames = D1 ('MetaData "OutputNames" "Nix.Diff.Types" "nix-diff-1.0.21-9upfo2llU6vKJbTes5Z7ck" 'True) (C1 ('MetaCons "OutputNames" 'PrefixI 'True) (S1 ('MetaSel ('Just "unOutputNames") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set Text))))

data DerivationDiff

Constructors

DerivationsAreTheSame

AlreadyCompared

OnlyAlreadyComparedBelow

Fields

• outputStructure :: Changed OutputStructure

NamesDontMatch

Fields

• outputStructure :: Changed OutputStructure

OutputsDontMatch

Fields

• outputStructure :: Changed OutputStructure

DerivationDiff

Fields

• outputStructure :: Changed OutputStructure
• outputsDiff :: OutputsDiff
• platformDiff :: Maybe (Changed Platform)

  Will be Nothing, if Platform does not change

• builderDiff :: Maybe (Changed Builder)

  Will be Nothing, if Builder does not change

• argumentsDiff :: Maybe ArgumentsDiff

  Will be Nothing, if arguments are equal

• sourcesDiff :: SourcesDiff
• inputsDiff :: InputsDiff
• envDiff :: Maybe EnvironmentDiff

  Will be Nothing, if environment comparison is skipped

Instances

Arbitrary DerivationDiff

Defined in Nix.Diff.Types

Methods

arbitrary :: Gen DerivationDiff

shrink :: DerivationDiff -> [DerivationDiff]

FromJSON DerivationDiff

Defined in Nix.Diff.Types

Methods

parseJSON :: Value -> Parser DerivationDiff

parseJSONList :: Value -> Parser [DerivationDiff]

omittedField :: Maybe DerivationDiff

ToJSON DerivationDiff

Defined in Nix.Diff.Types

Methods

toJSON :: DerivationDiff -> Value

toEncoding :: DerivationDiff -> Encoding

toJSONList :: [DerivationDiff] -> Value

toEncodingList :: [DerivationDiff] -> Encoding

omitField :: DerivationDiff -> Bool

Data DerivationDiff

Defined in Nix.Diff.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivationDiff -> c DerivationDiff

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DerivationDiff

toConstr :: DerivationDiff -> Constr

dataTypeOf :: DerivationDiff -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DerivationDiff)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DerivationDiff)

gmapT :: (forall b. Data b => b -> b) -> DerivationDiff -> DerivationDiff

gmapQl :: (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

gmapQ :: (forall d. Data d => d -> u) -> DerivationDiff -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivationDiff -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivationDiff -> m DerivationDiff

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivationDiff -> m DerivationDiff

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivationDiff -> m DerivationDiff

Generic DerivationDiff

Defined in Nix.Diff.Types

Associated Types

type Rep DerivationDiff :: Type -> Type

Methods

from :: DerivationDiff -> Rep DerivationDiff x

to :: Rep DerivationDiff x -> DerivationDiff

Show DerivationDiff

Defined in Nix.Diff.Types

Methods

showsPrec :: Int -> DerivationDiff -> ShowS

show :: DerivationDiff -> String

showList :: [DerivationDiff] -> ShowS

Eq DerivationDiff

Defined in Nix.Diff.Types

Methods

(==) :: DerivationDiff -> DerivationDiff -> Bool

(/=) :: DerivationDiff -> DerivationDiff -> Bool

type Rep DerivationDiff

Defined in Nix.Diff.Types

type Rep DerivationDiff = D1 ('MetaData "DerivationDiff" "Nix.Diff.Types" "nix-diff-1.0.21-9upfo2llU6vKJbTes5Z7ck" 'False) ((C1 ('MetaCons "DerivationsAreTheSame" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "AlreadyCompared" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "OnlyAlreadyComparedBelow" 'PrefixI 'True) (S1 ('MetaSel ('Just "outputStructure") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Changed OutputStructure))))) :+: (C1 ('MetaCons "NamesDontMatch" 'PrefixI 'True) (S1 ('MetaSel ('Just "outputStructure") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Changed OutputStructure))) :+: (C1 ('MetaCons "OutputsDontMatch" 'PrefixI 'True) (S1 ('MetaSel ('Just "outputStructure") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Changed OutputStructure))) :+: C1 ('MetaCons "DerivationDiff" 'PrefixI 'True) (((S1 ('MetaSel ('Just "outputStructure") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Changed OutputStructure)) :*: S1 ('MetaSel ('Just "outputsDiff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 OutputsDiff)) :*: (S1 ('MetaSel ('Just "platformDiff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Changed Platform))) :*: S1 ('MetaSel ('Just "builderDiff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Changed Builder))))) :*: ((S1 ('MetaSel ('Just "argumentsDiff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ArgumentsDiff)) :*: S1 ('MetaSel ('Just "sourcesDiff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SourcesDiff)) :*: (S1 ('MetaSel ('Just "inputsDiff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 InputsDiff) :*: S1 ('MetaSel ('Just "envDiff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe EnvironmentDiff))))))))

data OutputStructure

Constructors

OutputStructure

Fields

• derivationPath :: StorePath
• derivationOutputs :: OutputNames

Instances

Arbitrary OutputStructure

Defined in Nix.Diff.Types

Methods

arbitrary :: Gen OutputStructure

shrink :: OutputStructure -> [OutputStructure]

FromJSON OutputStructure

Defined in Nix.Diff.Types

Methods

parseJSON :: Value -> Parser OutputStructure

parseJSONList :: Value -> Parser [OutputStructure]

omittedField :: Maybe OutputStructure

ToJSON OutputStructure

Defined in Nix.Diff.Types

Methods

toJSON :: OutputStructure -> Value

toEncoding :: OutputStructure -> Encoding

toJSONList :: [OutputStructure] -> Value

toEncodingList :: [OutputStructure] -> Encoding

omitField :: OutputStructure -> Bool

Data OutputStructure

Defined in Nix.Diff.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OutputStructure -> c OutputStructure

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OutputStructure

toConstr :: OutputStructure -> Constr

dataTypeOf :: OutputStructure -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OutputStructure)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OutputStructure)

gmapT :: (forall b. Data b => b -> b) -> OutputStructure -> OutputStructure

gmapQl :: (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

gmapQ :: (forall d. Data d => d -> u) -> OutputStructure -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> OutputStructure -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OutputStructure -> m OutputStructure

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OutputStructure -> m OutputStructure

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OutputStructure -> m OutputStructure

Generic OutputStructure

Defined in Nix.Diff.Types

Associated Types

type Rep OutputStructure :: Type -> Type

Methods

from :: OutputStructure -> Rep OutputStructure x

to :: Rep OutputStructure x -> OutputStructure

Show OutputStructure

Defined in Nix.Diff.Types

Methods

showsPrec :: Int -> OutputStructure -> ShowS

show :: OutputStructure -> String

showList :: [OutputStructure] -> ShowS

Eq OutputStructure

Defined in Nix.Diff.Types

Methods

(==) :: OutputStructure -> OutputStructure -> Bool

(/=) :: OutputStructure -> OutputStructure -> Bool

type Rep OutputStructure

Defined in Nix.Diff.Types

type Rep OutputStructure = D1 ('MetaData "OutputStructure" "Nix.Diff.Types" "nix-diff-1.0.21-9upfo2llU6vKJbTes5Z7ck" 'False) (C1 ('MetaCons "OutputStructure" 'PrefixI 'True) (S1 ('MetaSel ('Just "derivationPath") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 StorePath) :*: S1 ('MetaSel ('Just "derivationOutputs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 OutputNames)))

Outputs diff

data OutputsDiff

Constructors

OutputsDiff

Fields

• extraOutputs :: Maybe (Changed (Map Text (DerivationOutput StorePath Text)))

  Map from derivation name to its outputs. Will be Nothing, if difference gives empty Maps for both new and old outputs

• outputHashDiff :: [OutputDiff]

  Difference of outputs with the same name. Will be empty, if all outputs are equal.

Instances

Arbitrary OutputsDiff

Defined in Nix.Diff.Types

Methods

arbitrary :: Gen OutputsDiff

shrink :: OutputsDiff -> [OutputsDiff]

FromJSON OutputsDiff

Defined in Nix.Diff.Types

Methods

parseJSON :: Value -> Parser OutputsDiff

parseJSONList :: Value -> Parser [OutputsDiff]

omittedField :: Maybe OutputsDiff

ToJSON OutputsDiff

Defined in Nix.Diff.Types

Methods

toJSON :: OutputsDiff -> Value

toEncoding :: OutputsDiff -> Encoding

toJSONList :: [OutputsDiff] -> Value

toEncodingList :: [OutputsDiff] -> Encoding

omitField :: OutputsDiff -> Bool

Data OutputsDiff

Defined in Nix.Diff.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OutputsDiff -> c OutputsDiff

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OutputsDiff

toConstr :: OutputsDiff -> Constr

dataTypeOf :: OutputsDiff -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OutputsDiff)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OutputsDiff)

gmapT :: (forall b. Data b => b -> b) -> OutputsDiff -> OutputsDiff

gmapQl :: (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

gmapQ :: (forall d. Data d => d -> u) -> OutputsDiff -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> OutputsDiff -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OutputsDiff -> m OutputsDiff

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OutputsDiff -> m OutputsDiff

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OutputsDiff -> m OutputsDiff

Show OutputsDiff

Defined in Nix.Diff.Types

Methods

showsPrec :: Int -> OutputsDiff -> ShowS

show :: OutputsDiff -> String

showList :: [OutputsDiff] -> ShowS

Eq OutputsDiff

Defined in Nix.Diff.Types

Methods

(==) :: OutputsDiff -> OutputsDiff -> Bool

(/=) :: OutputsDiff -> OutputsDiff -> Bool

data OutputDiff

Constructors

OutputDiff

Fields

• outputName :: Text
• hashDifference :: Changed OutputHash

Instances

Arbitrary OutputDiff

Defined in Nix.Diff.Types

Methods

arbitrary :: Gen OutputDiff

shrink :: OutputDiff -> [OutputDiff]

FromJSON OutputDiff

Defined in Nix.Diff.Types

Methods

parseJSON :: Value -> Parser OutputDiff

parseJSONList :: Value -> Parser [OutputDiff]

omittedField :: Maybe OutputDiff

ToJSON OutputDiff

Defined in Nix.Diff.Types

Methods

toJSON :: OutputDiff -> Value

toEncoding :: OutputDiff -> Encoding

toJSONList :: [OutputDiff] -> Value

toEncodingList :: [OutputDiff] -> Encoding

omitField :: OutputDiff -> Bool

Data OutputDiff

Defined in Nix.Diff.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OutputDiff -> c OutputDiff

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OutputDiff

toConstr :: OutputDiff -> Constr

dataTypeOf :: OutputDiff -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OutputDiff)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OutputDiff)

gmapT :: (forall b. Data b => b -> b) -> OutputDiff -> OutputDiff

gmapQl :: (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

gmapQ :: (forall d. Data d => d -> u) -> OutputDiff -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> OutputDiff -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OutputDiff -> m OutputDiff

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OutputDiff -> m OutputDiff

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OutputDiff -> m OutputDiff

Generic OutputDiff

Defined in Nix.Diff.Types

Associated Types

type Rep OutputDiff :: Type -> Type

Methods

from :: OutputDiff -> Rep OutputDiff x

to :: Rep OutputDiff x -> OutputDiff

Show OutputDiff

Defined in Nix.Diff.Types

Methods

showsPrec :: Int -> OutputDiff -> ShowS

show :: OutputDiff -> String

showList :: [OutputDiff] -> ShowS

Eq OutputDiff

Defined in Nix.Diff.Types

Methods

(==) :: OutputDiff -> OutputDiff -> Bool

(/=) :: OutputDiff -> OutputDiff -> Bool

type Rep OutputDiff

Defined in Nix.Diff.Types

type Rep OutputDiff = D1 ('MetaData "OutputDiff" "Nix.Diff.Types" "nix-diff-1.0.21-9upfo2llU6vKJbTes5Z7ck" 'False) (C1 ('MetaCons "OutputDiff" 'PrefixI 'True) (S1 ('MetaSel ('Just "outputName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text) :*: S1 ('MetaSel ('Just "hashDifference") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Changed OutputHash))))

Arguments diff

newtype ArgumentsDiff

Constructors

ArgumentsDiff

Fields

• unArgumetsDiff :: NonEmpty (Item Argument)

Instances

Arbitrary ArgumentsDiff

Defined in Nix.Diff.Types

Methods

arbitrary :: Gen ArgumentsDiff

shrink :: ArgumentsDiff -> [ArgumentsDiff]

FromJSON ArgumentsDiff

Defined in Nix.Diff.Types

Methods

parseJSON :: Value -> Parser ArgumentsDiff

parseJSONList :: Value -> Parser [ArgumentsDiff]

omittedField :: Maybe ArgumentsDiff

ToJSON ArgumentsDiff

Defined in Nix.Diff.Types

Methods

toJSON :: ArgumentsDiff -> Value

toEncoding :: ArgumentsDiff -> Encoding

toJSONList :: [ArgumentsDiff] -> Value

toEncodingList :: [ArgumentsDiff] -> Encoding

omitField :: ArgumentsDiff -> Bool

Data ArgumentsDiff

Defined in Nix.Diff.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ArgumentsDiff -> c ArgumentsDiff

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ArgumentsDiff

toConstr :: ArgumentsDiff -> Constr

dataTypeOf :: ArgumentsDiff -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ArgumentsDiff)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArgumentsDiff)

gmapT :: (forall b. Data b => b -> b) -> ArgumentsDiff -> ArgumentsDiff

gmapQl :: (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

gmapQ :: (forall d. Data d => d -> u) -> ArgumentsDiff -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ArgumentsDiff -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ArgumentsDiff -> m ArgumentsDiff

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgumentsDiff -> m ArgumentsDiff

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgumentsDiff -> m ArgumentsDiff

Show ArgumentsDiff

Defined in Nix.Diff.Types

Methods

showsPrec :: Int -> ArgumentsDiff -> ShowS

show :: ArgumentsDiff -> String

showList :: [ArgumentsDiff] -> ShowS

Eq ArgumentsDiff

Defined in Nix.Diff.Types

Methods

(==) :: ArgumentsDiff -> ArgumentsDiff -> Bool

(/=) :: ArgumentsDiff -> ArgumentsDiff -> Bool

Sources diff

data SourcesDiff

Constructors

SourcesDiff

Fields

• extraSrcNames :: Maybe (Changed (Set Text))

  Will be Nothing, if there is no extra source names

• srcFilesDiff :: [SourceFileDiff]

Instances

Arbitrary SourcesDiff

Defined in Nix.Diff.Types

Methods

arbitrary :: Gen SourcesDiff

shrink :: SourcesDiff -> [SourcesDiff]

FromJSON SourcesDiff

Defined in Nix.Diff.Types

Methods

parseJSON :: Value -> Parser SourcesDiff

parseJSONList :: Value -> Parser [SourcesDiff]

omittedField :: Maybe SourcesDiff

ToJSON SourcesDiff

Defined in Nix.Diff.Types

Methods

toJSON :: SourcesDiff -> Value

toEncoding :: SourcesDiff -> Encoding

toJSONList :: [SourcesDiff] -> Value

toEncodingList :: [SourcesDiff] -> Encoding

omitField :: SourcesDiff -> Bool

Data SourcesDiff

Defined in Nix.Diff.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourcesDiff -> c SourcesDiff

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourcesDiff

toConstr :: SourcesDiff -> Constr

dataTypeOf :: SourcesDiff -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourcesDiff)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourcesDiff)

gmapT :: (forall b. Data b => b -> b) -> SourcesDiff -> SourcesDiff

gmapQl :: (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

gmapQ :: (forall d. Data d => d -> u) -> SourcesDiff -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SourcesDiff -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourcesDiff -> m SourcesDiff

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourcesDiff -> m SourcesDiff

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourcesDiff -> m SourcesDiff

Generic SourcesDiff

Defined in Nix.Diff.Types

Associated Types

type Rep SourcesDiff :: Type -> Type

Methods

from :: SourcesDiff -> Rep SourcesDiff x

to :: Rep SourcesDiff x -> SourcesDiff

Show SourcesDiff

Defined in Nix.Diff.Types

Methods

showsPrec :: Int -> SourcesDiff -> ShowS

show :: SourcesDiff -> String

showList :: [SourcesDiff] -> ShowS

Eq SourcesDiff

Defined in Nix.Diff.Types

Methods

(==) :: SourcesDiff -> SourcesDiff -> Bool

(/=) :: SourcesDiff -> SourcesDiff -> Bool

type Rep SourcesDiff

Defined in Nix.Diff.Types

type Rep SourcesDiff = D1 ('MetaData "SourcesDiff" "Nix.Diff.Types" "nix-diff-1.0.21-9upfo2llU6vKJbTes5Z7ck" 'False) (C1 ('MetaCons "SourcesDiff" 'PrefixI 'True) (S1 ('MetaSel ('Just "extraSrcNames") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Changed (Set Text)))) :*: S1 ('MetaSel ('Just "srcFilesDiff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [SourceFileDiff])))

data SourceFileDiff

Constructors

OneSourceFileDiff

Fields

• srcName :: Text
• srcContentDiff :: Maybe TextDiff

  Will be Nothing, if any of source files not exists

SomeSourceFileDiff

Fields

• srcName :: Text
• srcFileDiff :: Changed [StorePath]

Instances

Arbitrary SourceFileDiff

Defined in Nix.Diff.Types

Methods

arbitrary :: Gen SourceFileDiff

shrink :: SourceFileDiff -> [SourceFileDiff]

FromJSON SourceFileDiff

Defined in Nix.Diff.Types

Methods

parseJSON :: Value -> Parser SourceFileDiff

parseJSONList :: Value -> Parser [SourceFileDiff]

omittedField :: Maybe SourceFileDiff

ToJSON SourceFileDiff

Defined in Nix.Diff.Types

Methods

toJSON :: SourceFileDiff -> Value

toEncoding :: SourceFileDiff -> Encoding

toJSONList :: [SourceFileDiff] -> Value

toEncodingList :: [SourceFileDiff] -> Encoding

omitField :: SourceFileDiff -> Bool

Data SourceFileDiff

Defined in Nix.Diff.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceFileDiff -> c SourceFileDiff

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceFileDiff

toConstr :: SourceFileDiff -> Constr

dataTypeOf :: SourceFileDiff -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceFileDiff)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceFileDiff)

gmapT :: (forall b. Data b => b -> b) -> SourceFileDiff -> SourceFileDiff

gmapQl :: (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

gmapQ :: (forall d. Data d => d -> u) -> SourceFileDiff -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceFileDiff -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceFileDiff -> m SourceFileDiff

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceFileDiff -> m SourceFileDiff

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceFileDiff -> m SourceFileDiff

Generic SourceFileDiff

Defined in Nix.Diff.Types

Associated Types

type Rep SourceFileDiff :: Type -> Type

Methods

from :: SourceFileDiff -> Rep SourceFileDiff x

to :: Rep SourceFileDiff x -> SourceFileDiff

Show SourceFileDiff

Defined in Nix.Diff.Types

Methods

showsPrec :: Int -> SourceFileDiff -> ShowS

show :: SourceFileDiff -> String

showList :: [SourceFileDiff] -> ShowS

Eq SourceFileDiff

Defined in Nix.Diff.Types

Methods

(==) :: SourceFileDiff -> SourceFileDiff -> Bool

(/=) :: SourceFileDiff -> SourceFileDiff -> Bool

type Rep SourceFileDiff

Defined in Nix.Diff.Types

type Rep SourceFileDiff = D1 ('MetaData "SourceFileDiff" "Nix.Diff.Types" "nix-diff-1.0.21-9upfo2llU6vKJbTes5Z7ck" 'False) (C1 ('MetaCons "OneSourceFileDiff" 'PrefixI 'True) (S1 ('MetaSel ('Just "srcName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text) :*: S1 ('MetaSel ('Just "srcContentDiff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe TextDiff))) :+: C1 ('MetaCons "SomeSourceFileDiff" 'PrefixI 'True) (S1 ('MetaSel ('Just "srcName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text) :*: S1 ('MetaSel ('Just "srcFileDiff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Changed [StorePath]))))

Inputs diff

data InputsDiff

Constructors

InputsDiff

Fields

• inputExtraNames :: Maybe (Changed (Set Text))

  Will be Nothing, if there is no extra input names

• inputDerivationDiffs :: [InputDerivationsDiff]

Instances

Arbitrary InputsDiff

Defined in Nix.Diff.Types

Methods

arbitrary :: Gen InputsDiff

shrink :: InputsDiff -> [InputsDiff]

FromJSON InputsDiff

Defined in Nix.Diff.Types

Methods

parseJSON :: Value -> Parser InputsDiff

parseJSONList :: Value -> Parser [InputsDiff]

omittedField :: Maybe InputsDiff

ToJSON InputsDiff

Defined in Nix.Diff.Types

Methods

toJSON :: InputsDiff -> Value

toEncoding :: InputsDiff -> Encoding

toJSONList :: [InputsDiff] -> Value

toEncodingList :: [InputsDiff] -> Encoding

omitField :: InputsDiff -> Bool

Data InputsDiff

Defined in Nix.Diff.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InputsDiff -> c InputsDiff

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InputsDiff

toConstr :: InputsDiff -> Constr

dataTypeOf :: InputsDiff -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c InputsDiff)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InputsDiff)

gmapT :: (forall b. Data b => b -> b) -> InputsDiff -> InputsDiff

gmapQl :: (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

gmapQ :: (forall d. Data d => d -> u) -> InputsDiff -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> InputsDiff -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InputsDiff -> m InputsDiff

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InputsDiff -> m InputsDiff

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InputsDiff -> m InputsDiff

Generic InputsDiff

Defined in Nix.Diff.Types

Associated Types

type Rep InputsDiff :: Type -> Type

Methods

from :: InputsDiff -> Rep InputsDiff x

to :: Rep InputsDiff x -> InputsDiff

Show InputsDiff

Defined in Nix.Diff.Types

Methods

showsPrec :: Int -> InputsDiff -> ShowS

show :: InputsDiff -> String

showList :: [InputsDiff] -> ShowS

Eq InputsDiff

Defined in Nix.Diff.Types

Methods

(==) :: InputsDiff -> InputsDiff -> Bool

(/=) :: InputsDiff -> InputsDiff -> Bool

type Rep InputsDiff

Defined in Nix.Diff.Types

type Rep InputsDiff = D1 ('MetaData "InputsDiff" "Nix.Diff.Types" "nix-diff-1.0.21-9upfo2llU6vKJbTes5Z7ck" 'False) (C1 ('MetaCons "InputsDiff" 'PrefixI 'True) (S1 ('MetaSel ('Just "inputExtraNames") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Changed (Set Text)))) :*: S1 ('MetaSel ('Just "inputDerivationDiffs") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [InputDerivationsDiff])))

data InputDerivationsDiff

Constructors

OneDerivationDiff

Fields

• drvName :: Text
• drvDiff :: DerivationDiff

SomeDerivationsDiff

Fields

• drvName :: Text
• extraPartsDiff :: Changed (Map StorePath OutputNames)

ManyDerivationsAlreadyComparedDiff

Many input derivations differ, but they've all already been compared.

Fields

• drvNames :: Set Text

Instances

Arbitrary InputDerivationsDiff

Defined in Nix.Diff.Types

Methods

arbitrary :: Gen InputDerivationsDiff

shrink :: InputDerivationsDiff -> [InputDerivationsDiff]

FromJSON InputDerivationsDiff

Defined in Nix.Diff.Types

Methods

parseJSON :: Value -> Parser InputDerivationsDiff

parseJSONList :: Value -> Parser [InputDerivationsDiff]

omittedField :: Maybe InputDerivationsDiff

ToJSON InputDerivationsDiff

Defined in Nix.Diff.Types

Methods

toJSON :: InputDerivationsDiff -> Value

toEncoding :: InputDerivationsDiff -> Encoding

toJSONList :: [InputDerivationsDiff] -> Value

toEncodingList :: [InputDerivationsDiff] -> Encoding

omitField :: InputDerivationsDiff -> Bool

Data InputDerivationsDiff

Defined in Nix.Diff.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InputDerivationsDiff -> c InputDerivationsDiff

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InputDerivationsDiff

toConstr :: InputDerivationsDiff -> Constr

dataTypeOf :: InputDerivationsDiff -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c InputDerivationsDiff)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InputDerivationsDiff)

gmapT :: (forall b. Data b => b -> b) -> InputDerivationsDiff -> InputDerivationsDiff

gmapQl :: (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

gmapQ :: (forall d. Data d => d -> u) -> InputDerivationsDiff -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> InputDerivationsDiff -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InputDerivationsDiff -> m InputDerivationsDiff

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InputDerivationsDiff -> m InputDerivationsDiff

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InputDerivationsDiff -> m InputDerivationsDiff

Generic InputDerivationsDiff

Defined in Nix.Diff.Types

Associated Types

type Rep InputDerivationsDiff :: Type -> Type

Methods

from :: InputDerivationsDiff -> Rep InputDerivationsDiff x

to :: Rep InputDerivationsDiff x -> InputDerivationsDiff

Show InputDerivationsDiff

Defined in Nix.Diff.Types

Methods

showsPrec :: Int -> InputDerivationsDiff -> ShowS

show :: InputDerivationsDiff -> String

showList :: [InputDerivationsDiff] -> ShowS

Eq InputDerivationsDiff

Defined in Nix.Diff.Types

Methods

(==) :: InputDerivationsDiff -> InputDerivationsDiff -> Bool

(/=) :: InputDerivationsDiff -> InputDerivationsDiff -> Bool

type Rep InputDerivationsDiff

Defined in Nix.Diff.Types

type Rep InputDerivationsDiff = D1 ('MetaData "InputDerivationsDiff" "Nix.Diff.Types" "nix-diff-1.0.21-9upfo2llU6vKJbTes5Z7ck" 'False) (C1 ('MetaCons "OneDerivationDiff" 'PrefixI 'True) (S1 ('MetaSel ('Just "drvName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text) :*: S1 ('MetaSel ('Just "drvDiff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DerivationDiff)) :+: (C1 ('MetaCons "SomeDerivationsDiff" 'PrefixI 'True) (S1 ('MetaSel ('Just "drvName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text) :*: S1 ('MetaSel ('Just "extraPartsDiff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Changed (Map StorePath OutputNames)))) :+: C1 ('MetaCons "ManyDerivationsAlreadyComparedDiff" 'PrefixI 'True) (S1 ('MetaSel ('Just "drvNames") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set Text)))))

Environment diff

data EnvironmentDiff

Constructors

EnvironmentsAreEqual

EnvironmentDiff

Fields

• extraEnvDiff :: Changed (Map Text Text)
• envContentDiff :: [EnvVarDiff]

Instances

Arbitrary EnvironmentDiff

Defined in Nix.Diff.Types

Methods

arbitrary :: Gen EnvironmentDiff

shrink :: EnvironmentDiff -> [EnvironmentDiff]

FromJSON EnvironmentDiff

Defined in Nix.Diff.Types

Methods

parseJSON :: Value -> Parser EnvironmentDiff

parseJSONList :: Value -> Parser [EnvironmentDiff]

omittedField :: Maybe EnvironmentDiff

ToJSON EnvironmentDiff

Defined in Nix.Diff.Types

Methods

toJSON :: EnvironmentDiff -> Value

toEncoding :: EnvironmentDiff -> Encoding

toJSONList :: [EnvironmentDiff] -> Value

toEncodingList :: [EnvironmentDiff] -> Encoding

omitField :: EnvironmentDiff -> Bool

Data EnvironmentDiff

Defined in Nix.Diff.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EnvironmentDiff -> c EnvironmentDiff

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EnvironmentDiff

toConstr :: EnvironmentDiff -> Constr

dataTypeOf :: EnvironmentDiff -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c EnvironmentDiff)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnvironmentDiff)

gmapT :: (forall b. Data b => b -> b) -> EnvironmentDiff -> EnvironmentDiff

gmapQl :: (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

gmapQ :: (forall d. Data d => d -> u) -> EnvironmentDiff -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> EnvironmentDiff -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> EnvironmentDiff -> m EnvironmentDiff

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EnvironmentDiff -> m EnvironmentDiff

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EnvironmentDiff -> m EnvironmentDiff

Generic EnvironmentDiff

Defined in Nix.Diff.Types

Associated Types

type Rep EnvironmentDiff :: Type -> Type

Methods

from :: EnvironmentDiff -> Rep EnvironmentDiff x

to :: Rep EnvironmentDiff x -> EnvironmentDiff

Show EnvironmentDiff

Defined in Nix.Diff.Types

Methods

showsPrec :: Int -> EnvironmentDiff -> ShowS

show :: EnvironmentDiff -> String

showList :: [EnvironmentDiff] -> ShowS

Eq EnvironmentDiff

Defined in Nix.Diff.Types

Methods

(==) :: EnvironmentDiff -> EnvironmentDiff -> Bool

(/=) :: EnvironmentDiff -> EnvironmentDiff -> Bool

type Rep EnvironmentDiff

Defined in Nix.Diff.Types

type Rep EnvironmentDiff = D1 ('MetaData "EnvironmentDiff" "Nix.Diff.Types" "nix-diff-1.0.21-9upfo2llU6vKJbTes5Z7ck" 'False) (C1 ('MetaCons "EnvironmentsAreEqual" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EnvironmentDiff" 'PrefixI 'True) (S1 ('MetaSel ('Just "extraEnvDiff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Changed (Map Text Text))) :*: S1 ('MetaSel ('Just "envContentDiff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [EnvVarDiff])))

data EnvVarDiff

Constructors

EnvVarDiff

Fields

• envKey :: Text
• envValueDiff :: TextDiff

Instances

Arbitrary EnvVarDiff

Defined in Nix.Diff.Types

Methods

arbitrary :: Gen EnvVarDiff

shrink :: EnvVarDiff -> [EnvVarDiff]

FromJSON EnvVarDiff

Defined in Nix.Diff.Types

Methods

parseJSON :: Value -> Parser EnvVarDiff

parseJSONList :: Value -> Parser [EnvVarDiff]

omittedField :: Maybe EnvVarDiff

ToJSON EnvVarDiff

Defined in Nix.Diff.Types

Methods

toJSON :: EnvVarDiff -> Value

toEncoding :: EnvVarDiff -> Encoding

toJSONList :: [EnvVarDiff] -> Value

toEncodingList :: [EnvVarDiff] -> Encoding

omitField :: EnvVarDiff -> Bool

Data EnvVarDiff

Defined in Nix.Diff.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EnvVarDiff -> c EnvVarDiff

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EnvVarDiff

toConstr :: EnvVarDiff -> Constr

dataTypeOf :: EnvVarDiff -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c EnvVarDiff)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EnvVarDiff)

gmapT :: (forall b. Data b => b -> b) -> EnvVarDiff -> EnvVarDiff

gmapQl :: (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

gmapQ :: (forall d. Data d => d -> u) -> EnvVarDiff -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> EnvVarDiff -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> EnvVarDiff -> m EnvVarDiff

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EnvVarDiff -> m EnvVarDiff

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EnvVarDiff -> m EnvVarDiff

Generic EnvVarDiff

Defined in Nix.Diff.Types

Associated Types

type Rep EnvVarDiff :: Type -> Type

Methods

from :: EnvVarDiff -> Rep EnvVarDiff x

to :: Rep EnvVarDiff x -> EnvVarDiff

Show EnvVarDiff

Defined in Nix.Diff.Types

Methods

showsPrec :: Int -> EnvVarDiff -> ShowS

show :: EnvVarDiff -> String

showList :: [EnvVarDiff] -> ShowS

Eq EnvVarDiff

Defined in Nix.Diff.Types

Methods

(==) :: EnvVarDiff -> EnvVarDiff -> Bool

(/=) :: EnvVarDiff -> EnvVarDiff -> Bool

type Rep EnvVarDiff

Defined in Nix.Diff.Types

type Rep EnvVarDiff = D1 ('MetaData "EnvVarDiff" "Nix.Diff.Types" "nix-diff-1.0.21-9upfo2llU6vKJbTes5Z7ck" 'False) (C1 ('MetaCons "EnvVarDiff" 'PrefixI 'True) (S1 ('MetaSel ('Just "envKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text) :*: S1 ('MetaSel ('Just "envValueDiff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TextDiff)))

Helpers

changedToJSON :: (a -> Value) -> Changed a -> Value

changedFromJSON :: (Value -> Parser a) -> Value -> Parser (Changed a)

itemToJSON :: ToJSON v => Item v -> Value

itemFromJSON :: FromJSON v => Value -> Parser (Item v)

arbitraryItem :: Arbitrary a => Gen (Item a)

arbitraryDerivationOutput :: (Arbitrary fp, Arbitrary txt) => Gen (DerivationOutput fp txt)

Orphan instances

Data (DerivationOutput StorePath Text)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivationOutput StorePath Text -> c (DerivationOutput StorePath Text)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivationOutput StorePath Text)

toConstr :: DerivationOutput StorePath Text -> Constr

dataTypeOf :: DerivationOutput StorePath Text -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivationOutput StorePath Text))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DerivationOutput StorePath Text))

gmapT :: (forall b. Data b => b -> b) -> DerivationOutput StorePath Text -> DerivationOutput StorePath Text

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivationOutput StorePath Text -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivationOutput StorePath Text -> r

gmapQ :: (forall d. Data d => d -> u) -> DerivationOutput StorePath Text -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivationOutput StorePath Text -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivationOutput StorePath Text -> m (DerivationOutput StorePath Text)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivationOutput StorePath Text -> m (DerivationOutput StorePath Text)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivationOutput StorePath Text -> m (DerivationOutput StorePath Text)