Utils: add dup; Thunk.Basic: further: define with a dup

We saw that `further` does not even need to strictly pattern match on a thunk,
since the results of bothe matches would be the same, so we can skip matching.

src/Nix/Thunk/Basic.hs

@@ -25,7 +25,9 @@ import           Control.Monad.Catch            ( MonadCatch(..)
                                                 )
 import           Nix.Thunk
 import           Nix.Var
-import           Nix.Utils                      ( bool )
+import           Nix.Utils                      ( bool
+                                                , dup
+                                                )
 
 data Deferred m v = Computed v | Deferred (m v)
   deriving (Functor, Foldable, Traversable)
@@ -115,12 +117,7 @@ instance (MonadBasicThunk m, MonadCatch m)
       _ <-
         atomicModifyVar
           ref
-          (\ x ->
-             deferred
-               (const (x, x))
-               (const (x, x))
-               x
-          )
+          dup
       pure t
 
 

src/Nix/Utils.hs

@@ -283,3 +283,9 @@ for_ = flip traverse_
 both :: (a -> b) -> (a, a) -> (b, b)
 both f (x,y) = (f x, f y)
 {-# inline both #-}
+
+
+-- | Duplicates object into a tuple.
+dup :: a -> (a, a)
+dup x = (x, x)
+{-# inline dup #-}