INLINABLE more things (#2164)

* INLINABLE more things

I found these by building dhall with -Wall-missing-specialisations.

I suspect that at least some of these might be useful, but I didn't
do any benchmarking.

* INLINABLE Dhall.Eval.toVHPi

Co-authored-by: Gabriel Gonzalez <[email protected]>

Author: sjakobi

dhall/src/Dhall/Core.hs

@@ -142,6 +142,7 @@ censorSrc (Src { srcText = oldText, .. }) = Src { srcText = newText, .. }
 throws :: (Exception e, MonadIO io) => Either e a -> io a
 throws (Left  e) = liftIO (Control.Exception.throwIO e)
 throws (Right r) = return r
+{-# INLINABLE throws #-}
 
 {- $setup
 >>> import qualified Codec.Serialise

dhall/src/Dhall/Eval.hs

@@ -144,6 +144,7 @@ toVHPi :: Eq a => Val a -> Maybe (Text, Val a, Val a -> Val a)
 toVHPi (VPi a b@(Closure x _ _)) = Just (x, a, instantiate b)
 toVHPi (VHPi x a b             ) = Just (x, a, b)
 toVHPi  _                        = Nothing
+{-# INLINABLE toVHPi #-}
 
 data Val a
     = VConst !Const
@@ -1025,6 +1026,7 @@ conv !env t0 t0' =
 judgmentallyEqual :: Eq a => Expr s a -> Expr t a -> Bool
 judgmentallyEqual (Syntax.denote -> t) (Syntax.denote -> u) =
     conv Empty (eval Empty t) (eval Empty u)
+{-# INLINABLE judgmentallyEqual #-}
 
 data Names
   = EmptyNames
@@ -1226,6 +1228,7 @@ nf !env = Syntax.renote . quote (envNames env) . eval env . Syntax.denote
 
 normalize :: Eq a => Expr s a -> Expr t a
 normalize = nf Empty
+{-# INLINABLE normalize #-}
 
 alphaNormalize :: Expr s a -> Expr s a
 alphaNormalize = goEnv EmptyNames

dhall/src/Dhall/Import.hs

@@ -1254,6 +1254,7 @@ instance Show ImportResolutionDisabled where
 assertNoImports :: MonadIO io => Expr Src Import -> io (Expr Src Void)
 assertNoImports expression =
     Core.throws (traverse (\_ -> Left ImportResolutionDisabled) expression)
+{-# INLINABLE assertNoImports #-}
 
 {-| This function is used by the @--transitive@ option of the
     @dhall {freeze,format,lint}@ subcommands to determine which dependencies

dhall/src/Dhall/Normalize.hs

@@ -160,6 +160,7 @@ normalize = Eval.normalize
 normalizeWith :: Eq a => Maybe (ReifiedNormalizer a) -> Expr s a -> Expr t a
 normalizeWith (Just ctx) t = runIdentity (normalizeWithM (getReifiedNormalizer ctx) t)
 normalizeWith _          t = Eval.normalize t
+{-# INLINABLE normalizeWith #-}
 
 {-| This function generalizes `normalizeWith` by allowing the custom normalizer
     to use an arbitrary `Monad`
@@ -940,6 +941,7 @@ variable@(V var i) `freeIn` expression =
     denote' = Syntax.denote
 
     strippedExpression = denote' expression
+{-# INLINABLE freeIn #-}
 
 {- $setup
 >>> import Dhall.Syntax (Const(..))

dhall/src/Dhall/Syntax.hs

@@ -890,6 +890,7 @@ recordFieldExprs f (RecordField s0 e s1 s2) =
         <*> f e
         <*> pure s1
         <*> pure s2
+{-# INLINABLE recordFieldExprs #-}
 
 {-| Traverse over the immediate 'Expr' children in a 'FunctionBinding'.
 -}
@@ -904,6 +905,7 @@ functionBindingExprs f (FunctionBinding s0 label s1 s2 type_) =
         <*> pure s1
         <*> pure s2
         <*> f type_
+{-# INLINABLE functionBindingExprs #-}
 
 -- | A traversal over the immediate sub-expressions in 'Chunks'.
 chunkExprs