(Just -> pure)

Author: Anton-Latukha

main/Main.hs

@@ -51,7 +51,7 @@ main = do
   runWithBasicEffectsIO opts $ case readFrom opts of
     Just path -> do
       let file = addExtension (dropExtension path) "nixc"
-      process opts (Just file) =<< liftIO (readCache path)
+      process opts (pure file) =<< liftIO (readCache path)
     Nothing -> case expression opts of
       Just s  -> handleResult opts Nothing (parseNixTextLoc s)
       Nothing -> case fromFile opts of
@@ -68,7 +68,7 @@ main = do
  where
   processFile opts path = do
     eres <- parseNixFileLoc path
-    handleResult opts (Just path) eres
+    handleResult opts (pure path) eres
 
   handleResult opts mpath = \case
     Failure err ->
@@ -102,7 +102,7 @@ main = do
         if evaluate opts
           then do
             val <- Nix.nixEvalExprLoc mpath expr
-            withNixContext Nothing (Repl.main' $ Just val)
+            withNixContext Nothing (Repl.main' $ pure val)
           else withNixContext Nothing Repl.main
 
   process opts mpath expr
@@ -165,7 +165,7 @@ main = do
        where
         go prefix s = do
           xs <- forM (sortOn fst (M.toList s)) $ \(k, nv) -> case nv of
-            Free v -> pure (k, Just (Free v))
+            Free v -> pure (k, pure (Free v))
             Pure (StdThunk (extract -> Thunk _ _ ref)) -> do
               let path         = prefix <> Text.unpack k
                   (_, descend) = filterEntry path k
@@ -204,7 +204,7 @@ main = do
             _                              -> (True, True)
 
           forceEntry k v =
-            catch (Just <$> demand v pure) $ \(NixException frames) -> do
+            catch (pure <$> demand v pure) $ \(NixException frames) -> do
               liftIO
                 .   putStrLn
                 .   ("Exception forcing " <>)

main/Repl.hs

@@ -76,8 +76,8 @@ main' iniVal = initState iniVal >>= \s -> flip evalStateT s
         banner
         cmd
         options
-        (Just commandPrefix)
-        (Just "paste")
+        (pure commandPrefix)
+        (pure "paste")
         completion
         (rcFile >> greeter)
         finalizer
@@ -212,14 +212,14 @@ exec update source = do
           -- Update the interpreter state
           when (update && isBinding) $ do
             -- Set `replIt` to last entered expression
-            put st { replIt = Just expr }
+            put st { replIt = pure expr }
 
             -- If the result value is a set, update our context with it
             case val of
               NVSet xs _ -> put st { replCtx = Data.HashMap.Lazy.union xs (replCtx st) }
               _          -> pure ()
 
-          pure $ Just val
+          pure $ pure val
   where
     -- If parsing fails, turn the input into singleton attribute set
     -- and try again.
@@ -292,7 +292,7 @@ typeof
 typeof args = do
   st <- get
   mVal <- case Data.HashMap.Lazy.lookup line (replCtx st) of
-    Just val -> pure $ Just val
+    Just val -> pure $ pure val
     Nothing  -> do
       exec False line
 
@@ -329,7 +329,7 @@ completion
   :: (MonadNix e t f m, MonadIO m)
   => CompleterStyle (StateT (IState t f m) m)
 completion = System.Console.Repline.Prefix
-  (completeWordWithPrev (Just '\\') separators completeFunc)
+  (completeWordWithPrev (pure '\\') separators completeFunc)
   defaultMatcher
   where
     separators :: String

src/Nix/Builtins.hs

@@ -332,7 +332,7 @@ foldNixPath f z = do
                 | otherwise                = (x, PathEntryPath)
   go (x, ty) rest = case Text.splitOn "=" x of
     [p] -> f (Text.unpack p) Nothing ty rest
-    [n, p] -> f (Text.unpack p) (Just (Text.unpack n)) ty rest
+    [n, p] -> f (Text.unpack p) (pure (Text.unpack n)) ty rest
     _ -> throwError $ ErrorCall $ "Unexpected entry in NIX_PATH: " <> show x
 
 nixPath :: MonadNix e t f m => m (NValue t f m)
@@ -825,7 +825,7 @@ elem_ x = toValue <=< anyM (valueEqM x) <=< fromValue
 elemAt :: [a] -> Int -> Maybe a
 elemAt ls i = case drop i ls of
   []    -> Nothing
-  a : _ -> Just a
+  a : _ -> pure a
 
 elemAt_
   :: MonadNix e t f m
@@ -1108,7 +1108,7 @@ scopedImport asetArg pathArg = fromValue @(AttrSet (NValue t f m)) asetArg >>= \
         traceM $ "Current file being evaluated is: " <> show p'
         pure $ takeDirectory p' </> path
     clearScopes @(NValue t f m)
-      $ withNixContext (Just path')
+      $ withNixContext (pure path')
       $ pushScope s
       $ importPath @t @f @m path'
 

src/Nix/Convert.hs

@@ -98,7 +98,7 @@ instance ( Convertible e t f m
 instance Convertible e t f m
   => FromValue () m (NValue' t f m (NValue t f m)) where
   fromValueMay = \case
-    NVConstant' NNull -> pure $ Just ()
+    NVConstant' NNull -> pure $ pure ()
     _                 -> pure Nothing
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
@@ -107,7 +107,7 @@ instance Convertible e t f m
 instance Convertible e t f m
   => FromValue Bool m (NValue' t f m (NValue t f m)) where
   fromValueMay = \case
-    NVConstant' (NBool b) -> pure $ Just b
+    NVConstant' (NBool b) -> pure $ pure b
     _                     -> pure Nothing
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
@@ -116,7 +116,7 @@ instance Convertible e t f m
 instance Convertible e t f m
   => FromValue Int m (NValue' t f m (NValue t f m)) where
   fromValueMay = \case
-    NVConstant' (NInt b) -> pure $ Just (fromInteger b)
+    NVConstant' (NInt b) -> pure $ pure (fromInteger b)
     _                    -> pure Nothing
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
@@ -125,7 +125,7 @@ instance Convertible e t f m
 instance Convertible e t f m
   => FromValue Integer m (NValue' t f m (NValue t f m)) where
   fromValueMay = \case
-    NVConstant' (NInt b) -> pure $ Just b
+    NVConstant' (NInt b) -> pure $ pure b
     _                    -> pure Nothing
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
@@ -134,8 +134,8 @@ instance Convertible e t f m
 instance Convertible e t f m
   => FromValue Float m (NValue' t f m (NValue t f m)) where
   fromValueMay = \case
-    NVConstant' (NFloat b) -> pure $ Just b
-    NVConstant' (NInt   i) -> pure $ Just (fromInteger i)
+    NVConstant' (NFloat b) -> pure $ pure b
+    NVConstant' (NInt   i) -> pure $ pure (fromInteger i)
     _                      -> pure Nothing
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
@@ -147,9 +147,9 @@ instance ( Convertible e t f m
          )
   => FromValue NixString m (NValue' t f m (NValue t f m)) where
   fromValueMay = \case
-    NVStr' ns -> pure $ Just ns
+    NVStr' ns -> pure $ pure ns
     NVPath' p ->
-      Just
+      pure
         .   (\s -> makeNixStringWithSingletonContext s (StringContext s DirectPath))
         .   Text.pack
         .   unStorePath
@@ -179,7 +179,7 @@ instance ( Convertible e t f m
          )
   => FromValue Path m (NValue' t f m (NValue t f m)) where
   fromValueMay = \case
-    NVPath' p  -> pure $ Just (Path p)
+    NVPath' p  -> pure $ pure (Path p)
     NVStr'  ns -> pure $ Path . Text.unpack <$> getStringNoContext  ns
     NVSet' s _ -> case M.lookup "outPath" s of
       Nothing -> pure Nothing
@@ -192,7 +192,7 @@ instance ( Convertible e t f m
 instance Convertible e t f m
   => FromValue [NValue t f m] m (NValue' t f m (NValue t f m)) where
   fromValueMay = \case
-    NVList' l -> pure $ Just l
+    NVList' l -> pure $ pure l
     _         -> pure Nothing
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
@@ -212,7 +212,7 @@ instance ( Convertible e t f m
 instance Convertible e t f m
   => FromValue (AttrSet (NValue t f m)) m (NValue' t f m (NValue t f m)) where
   fromValueMay = \case
-    NVSet' s _ -> pure $ Just s
+    NVSet' s _ -> pure $ pure s
     _          -> pure Nothing
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
@@ -233,7 +233,7 @@ instance Convertible e t f m
   => FromValue (AttrSet (NValue t f m), AttrSet SourcePos) m
               (NValue' t f m (NValue t f m)) where
   fromValueMay = \case
-    NVSet' s p -> pure $ Just (s, p)
+    NVSet' s p -> pure $ pure (s, p)
     _          -> pure Nothing
   fromValue v = fromValueMay v >>= \case
     Just b -> pure b
@@ -352,17 +352,17 @@ instance (Convertible e t f m, ToValue a m (NValue t f m))
 instance Convertible e t f m
   => ToValue NixLikeContextValue m (NValue' t f m (NValue t f m)) where
   toValue nlcv = do
-    path <- if nlcvPath nlcv then Just <$> toValue True else pure Nothing
+    path <- if nlcvPath nlcv then pure <$> toValue True else pure Nothing
     allOutputs <- if nlcvAllOutputs nlcv
-      then Just <$> toValue True
+      then pure <$> toValue True
       else pure Nothing
     outputs <- do
       let outputs =
             makeNixStringWithoutContext <$> nlcvOutputs nlcv
       ts :: [NValue t f m] <- traverse toValue outputs
       case ts of
         [] -> pure Nothing
-        _  -> Just <$> toValue ts
+        _  -> pure <$> toValue ts
     pure $ flip nvSet' M.empty $ M.fromList $ catMaybes
       [ ("path",) <$> path
       , ("allOutputs",) <$> allOutputs

src/Nix/Effects/Basic.hs

@@ -107,7 +107,7 @@ findEnvPathM name = do
       then makeAbsolutePath @t @f $ absPath </> "default.nix"
       else return absPath
     exists <- doesFileExist absFile
-    pure $ if exists then Just absFile else Nothing
+    pure $ if exists then pure absFile else Nothing
 
 findPathBy
   :: forall e t f m
@@ -139,7 +139,7 @@ findPathBy finder ls name = do
           Just (nsPfx :: NixString) ->
             let pfx = stringIgnoreContext nsPfx
             in  if not (Text.null pfx)
-                  then tryPath path (Just (Text.unpack pfx))
+                  then tryPath path (pure (Text.unpack pfx))
                   else tryPath path Nothing
           _ -> tryPath path Nothing
 
@@ -222,7 +222,7 @@ findPathM = findPathBy existingPath
   existingPath path = do
     apath  <- makeAbsolutePath @t @f path
     exists <- doesPathExist apath
-    pure $ if exists then Just apath else Nothing
+    pure $ if exists then pure apath else Nothing
 
 defaultImportPath
   :: (MonadNix e t f m, MonadState (HashMap FilePath NExprLoc, b) m)

src/Nix/Effects/Derivation.hs

@@ -221,7 +221,7 @@ derivationParser = do
             [ht] ->      (ht, Flat)
             _ -> error $ "Unsupported hash type for output of fixed-output derivation in .drv file: " <> show fullOutputs
       in case Store.mkNamedDigest hashType hash of
-        Right digest -> (Just digest, hashMode)
+        Right digest -> (pure digest, hashMode)
         Left err -> error $ "Unsupported hash " <> show (hashType <> ":" <> hash) <> "in .drv file: " <> err
     _ -> (Nothing, Flat)
 
@@ -300,7 +300,7 @@ buildDerivationWithContext drvAttrs = do
       args        <- getAttrOr "args"              []      $ mapM (fromValue' >=> extractNixString)
       builder     <- getAttr   "builder"                   $ extractNixString
       platform    <- getAttr   "system"                    $ extractNoCtx >=> assertNonNull
-      mHash       <- getAttrOr "outputHash"        Nothing $ extractNoCtx >=> (return . Just)
+      mHash       <- getAttrOr "outputHash"        Nothing $ extractNoCtx >=> (return . pure)
       hashMode    <- getAttrOr "outputHashMode"    Flat    $ extractNoCtx >=> parseHashMode
       outputs     <- getAttrOr "outputs"           ["out"] $ mapM (fromValue' >=> extractNoCtx)
 
@@ -310,14 +310,14 @@ buildDerivationWithContext drvAttrs = do
           when (outputs /= ["out"]) $ lift $ throwError $ ErrorCall $ "Multiple outputs are not supported for fixed-output derivations"
           hashType <- getAttr "outputHashAlgo" $ extractNoCtx
           digest <- lift $ either (throwError . ErrorCall) return $ Store.mkNamedDigest hashType hash
-          return $ Just digest
+          return $ pure digest
 
       -- filter out null values if needed.
       attrs <- if not ignoreNulls
         then return drvAttrs
         else M.mapMaybe id <$> forM drvAttrs (demand' ?? (\case
             NVConstant NNull -> return Nothing
-            value -> return $ Just value
+            value -> return $ pure value
           ))
 
       env <- if useJson

src/Nix/Eval.hs

@@ -132,7 +132,7 @@ eval (NBinary NApp fun arg) = do
 eval (NBinary op   larg rarg) = larg >>= evalBinary op ?? rarg
 
 eval (NSelect aset attr alt ) = evalSelect aset attr >>= either go id
-  where go (s, ks) = fromMaybe (attrMissing ks (Just s)) alt
+  where go (s, ks) = fromMaybe (attrMissing ks (pure s)) alt
 
 eval (NHasAttr aset attr) = evalSelect aset attr >>= toValue . isRight
 
@@ -352,7 +352,7 @@ evalSetterKeyName
   => NKeyName (m v)
   -> m (Maybe Text)
 evalSetterKeyName = \case
-  StaticKey k -> pure (Just k)
+  StaticKey k -> pure (pure k)
   DynamicKey k ->
     runAntiquoted "\n" assembleString (>>= fromValueMay) k <&> \case
       Just ns -> Just (stringIgnoreContext ns)
@@ -370,7 +370,7 @@ assembleString = \case
   fromParts = fmap (fmap mconcat . sequence) . traverse go
 
   go = runAntiquoted "\n"
-                     (pure . Just . makeNixStringWithoutContext)
+                     (pure . pure . makeNixStringWithoutContext)
                      (>>= fromValueMay)
 
 buildArgument
@@ -398,25 +398,25 @@ buildArgument params arg = do
     -> Maybe (AttrSet v -> m v)
   assemble scope isVariadic k = \case
     That Nothing ->
-      Just
+      pure
         $  const
         $  evalError @v
         $  ErrorCall
         $  "Missing value for parameter: "
         <> show k
     That (Just f) ->
-      Just $ \args -> defer $ withScopes scope $ pushScope args f
+      pure $ \args -> defer $ withScopes scope $ pushScope args f
     This _
       | isVariadic
       -> Nothing
       | otherwise
-      -> Just
+      -> pure
         $  const
         $  evalError @v
         $  ErrorCall
         $  "Unexpected parameter: "
         <> show k
-    These x _ -> Just (const (pure x))
+    These x _ -> pure (const (pure x))
 
 addSourcePositions
   :: (MonadReader e m, Has e SrcSpan) => Transform NExprLocF (m a)