Expr: Types: Annotated: pattern NUnary(_->AnnF)

Author: Anton-Latukha

src/Nix/Exec.hs

@@ -324,7 +324,7 @@ execUnaryOp scope span op arg = do
     _x ->
       throwError $ ErrorCall $ "argument to unary operator must evaluate to an atomic type: " <> show _x
  where
-  unaryOp = pure . nvConstantP (Provenance scope $ NUnary_ span op $ pure arg)
+  unaryOp = pure . nvConstantP (Provenance scope $ NUnaryAnnF span op $ pure arg)
 
 execBinaryOp
   :: forall e t f m

src/Nix/Expr/Types/Annotated.hs

@@ -216,8 +216,8 @@ pattern NLiteralPathAnnF ann x = AnnF ann (NLiteralPath x)
 pattern NEnvPathAnnF :: SrcSpan -> Path -> NExprLocF r
 pattern NEnvPathAnnF ann x = AnnF ann (NEnvPath x)
 
-pattern NUnary_ :: SrcSpan -> NUnaryOp -> r -> NExprLocF r
-pattern NUnary_ ann op x = AnnF ann (NUnary op x)
+pattern NUnaryAnnF :: SrcSpan -> NUnaryOp -> r -> NExprLocF r
+pattern NUnaryAnnF ann op x = AnnF ann (NUnary op x)
 
 pattern NBinary_ :: SrcSpan -> NBinaryOp -> r -> r -> NExprLocF r
 pattern NBinary_ ann op x y = AnnF ann (NBinary op x y)
@@ -245,7 +245,7 @@ pattern NAssert_ ann x y = AnnF ann (NAssert x y)
 
 pattern NSynHole_ :: SrcSpan -> VarName -> NExprLocF r
 pattern NSynHole_ ann x = AnnF ann (NSynHole x)
-{-# complete NConstantAnnF, NStrAnnF, NSymAnnF, NListAnnF, NSetAnnF, NLiteralPathAnnF, NEnvPathAnnF, NUnary_, NBinary_, NSelect_, NHasAttr_, NAbs_, NLet_, NIf_, NWith_, NAssert_, NSynHole_ #-}
+{-# complete NConstantAnnF, NStrAnnF, NSymAnnF, NListAnnF, NSetAnnF, NLiteralPathAnnF, NEnvPathAnnF, NUnaryAnnF, NBinary_, NSelect_, NHasAttr_, NAbs_, NLet_, NIf_, NWith_, NAssert_, NSynHole_ #-}
 
 
 pattern PNConstant :: SrcSpan -> NAtom -> NExprLoc

src/Nix/Reduce.hs

@@ -155,14 +155,14 @@ reduce (NSymAnnF ann var) =
   fromMaybe (Fix (NSymAnnF ann var)) <$> lookupVar var
 
 -- | Reduce binary and integer negation.
-reduce (NUnary_ uann op arg) =
+reduce (NUnaryAnnF uann op arg) =
   do
     x <- arg
     pure $ Fix $
       case (op, x) of
         (NNeg, Fix (NConstantAnnF cann (NInt  n))) -> NConstantAnnF cann $ NInt $ negate n
         (NNot, Fix (NConstantAnnF cann (NBool b))) -> NConstantAnnF cann $ NBool $ not b
-        _                                       -> NUnary_    uann op x
+        _                                       -> NUnaryAnnF    uann op x
 
 -- | Reduce function applications.
 --