Work on type inference for functions that take attr sets

src/Nix/Eval.hs

@@ -36,7 +36,6 @@ import           Data.Text (Text)
 import qualified Data.Text as Text
 import           Data.These
 import           Data.Traversable (for)
-import           Data.Void
 import           Nix.Atoms
 import           Nix.Convert
 import           Nix.Expr
@@ -63,7 +62,7 @@ class (Show v, Monad m) => MonadEval v m | v -> m where
     evalIf          :: v -> m v -> m v -> m v
     evalAssert      :: v -> m v -> m v
     evalApp         :: v -> m v -> m v
-    evalAbs         :: Params Void -> (m v -> m v) -> m v
+    evalAbs         :: Params (m v) -> (m v -> m v) -> m v
 
 {-
     evalSelect     :: v -> NonEmpty Text -> Maybe (m v) -> m v
@@ -171,14 +170,10 @@ eval (NAbs params body) = do
     -- we defer here so the present scope is restored when the parameters and
     -- body are forced during application.
     scope <- currentScopes @_ @t
-    evalAbs (clearDefaults params) $ \arg ->
+    evalAbs params $ \arg ->
         withScopes @t scope $ do
             args <- buildArgument params arg
             pushScope args body
-  where
-    clearDefaults :: Params r -> Params Void
-    clearDefaults (Param name) = Param name
-    clearDefaults (ParamSet xs b mv) = ParamSet (map (Nothing <$) xs) b mv
 
 -- | If you know that the 'scope' action will result in an 'AttrSet t', then
 --   this implementation may be used as an implementation for 'evalWith'.

src/Nix/Exec.hs

@@ -46,7 +46,6 @@ import           Data.List.Split
 import           Data.Text (Text)
 import qualified Data.Text as Text
 import           Data.Typeable
-import           Data.Void
 import           Nix.Atoms
 import           Nix.Context
 import           Nix.Convert
@@ -224,7 +223,7 @@ instance MonadNix e m => MonadEval (NValue m) m where
     evalAbs p b = do
         scope <- currentScopes
         span  <- currentPos
-        pure $ nvClosureP (Provenance scope (NAbs_ span (fmap absurd p) Nothing)) p b
+        pure $ nvClosureP (Provenance scope (NAbs_ span (Nothing <$ p) Nothing)) (void p) b
 
     evalError = throwError
 

src/Nix/Lint.hs

@@ -38,7 +38,6 @@ import           Data.List
 import           Data.STRef
 import           Data.Text (Text)
 import qualified Data.Text as Text
-import           Data.Void
 import           Nix.Atoms
 import           Nix.Context
 import           Nix.Convert
@@ -65,7 +64,7 @@ data NTypeF (m :: * -> *) r
     | TStr
     | TList r
     | TSet (Maybe (HashMap Text r))
-    | TClosure (Params Void) (m (Symbolic m) -> m (Symbolic m))
+    | TClosure (Params ()) (m (Symbolic m) -> m (Symbolic m))
     | TPath
     | TBuiltin String (SThunk m -> m (Symbolic m))
     deriving Functor
@@ -311,7 +310,7 @@ instance MonadLint e m => MonadEval (Symbolic m) m where
         pure body'
 
     evalApp = (fmap snd .) . lintApp (NBinary NApp () ())
-    evalAbs params body = mkSymbolic [TClosure params body]
+    evalAbs params body = mkSymbolic [TClosure (void params) body]
 
     evalError = throwError
 

src/Nix/Type/Infer.hs

@@ -396,7 +396,26 @@ instance MonadEval (Judgment s) (Infer s) where
             (cs ++ [EqConst t' tv | t' <- As.lookup x as])
             (tv `TArr` t)
 
-    evalAbs (ParamSet p variadic mname) e = undefined
+    evalAbs (ParamSet ps _variadic _mname) e = do
+        js <- fmap concat $ forM ps $ \(name, mdef) -> case mdef of
+            Just _ -> pure []
+            Nothing -> do
+                tv <- fresh
+                pure [(name, tv)]
+        let (env, tys) = (\f -> foldl' f (As.empty, M.empty) js)
+                $ \(as1, t1) (k, t) ->
+                    (as1 `As.merge` As.singleton k t, M.insert k t t1)
+            names = map fst js
+        Judgment as cs t <-
+            (\f -> foldr f (e (pure (Judgment env [] (TSet True tys)))) js)
+                $ \(_, TVar a) rest -> extendMSet a rest
+        return $ Judgment
+            (foldl' As.remove as names)
+            (cs ++ [ EqConst t' (tys M.! x)
+                   | x  <- names
+                   , t' <- As.lookup x as])
+            -- jww (2018-05-01): How do we recover the actual args used?
+            (t `TArr` t)
 
     evalError = throwError . EvaluationError
 

src/Nix/Value.hs

@@ -35,7 +35,6 @@ import           Data.Monoid (appEndo)
 import           Data.Text (Text)
 import           Data.These
 import           Data.Typeable (Typeable)
-import           Data.Void
 import           GHC.Generics
 import           Nix.Atoms
 import           Nix.Expr.Types
@@ -56,7 +55,7 @@ data NValueF m r
     | NVPathF FilePath
     | NVListF [r]
     | NVSetF (AttrSet r) (AttrSet SourcePos)
-    | NVClosureF (Params Void) (m (NValue m) -> m (NValue m))
+    | NVClosureF (Params ()) (m (NValue m) -> m (NValue m))
       -- ^ A function is a closed set of parameters representing the "call
       --   signature", used at application time to check the type of arguments
       --   passed to the function. Since it supports default values which may