Rename the singleton tuple GHC.Tuple.Unit to GHC.Tuple.Solo

10 files changed, 40 insertions, 40 deletions

diff --git a/testsuite/tests/deriving/should_fail/T15073.stderr b/testsuite/tests/deriving/should_fail/T15073.stderr
index 5c1d99768f..129efe496d 100644
--- a/testsuite/tests/deriving/should_fail/T15073.stderr
+++ b/testsuite/tests/deriving/should_fail/T15073.stderr
@@ -3,7 +3,7 @@ T15073.hs:8:12: error:
     • Illegal unboxed tuple type as function argument: (# Foo a #)
       Perhaps you intended to use UnboxedTuples
     • In the type signature:
-        p :: Foo a -> Unit# @'GHC.Types.LiftedRep (Foo a)
+        p :: Foo a -> Solo# @'GHC.Types.LiftedRep (Foo a)
       When typechecking the code for ‘p’
         in a derived instance for ‘P (Foo a)’:
         To see the code I am typechecking, use -ddump-deriv
diff --git a/testsuite/tests/ghc-api/annotations/parseTree.stdout b/testsuite/tests/ghc-api/annotations/parseTree.stdout
index 2a53f37342..8d629fb90a 100644
--- a/testsuite/tests/ghc-api/annotations/parseTree.stdout
+++ b/testsuite/tests/ghc-api/annotations/parseTree.stdout
@@ -1,11 +1,11 @@
-[(AnnotationTuple.hs:14:20, [p], Unit 1),
- (AnnotationTuple.hs:14:23-29, [p], Unit "hello"),
- (AnnotationTuple.hs:14:35-37, [p], Unit 6.5),
+[(AnnotationTuple.hs:14:20, [p], Solo 1),
+ (AnnotationTuple.hs:14:23-29, [p], Solo "hello"),
+ (AnnotationTuple.hs:14:35-37, [p], Solo 6.5),
  (AnnotationTuple.hs:14:39, [m], ()),
- (AnnotationTuple.hs:14:41-52, [p], Unit [5, 5, 6, 7]),
- (AnnotationTuple.hs:16:8, [p], Unit 1),
- (AnnotationTuple.hs:16:11-17, [p], Unit "hello"),
- (AnnotationTuple.hs:16:20-22, [p], Unit 6.5),
+ (AnnotationTuple.hs:14:41-52, [p], Solo [5, 5, 6, 7]),
+ (AnnotationTuple.hs:16:8, [p], Solo 1),
+ (AnnotationTuple.hs:16:11-17, [p], Solo "hello"),
+ (AnnotationTuple.hs:16:20-22, [p], Solo 6.5),
  (AnnotationTuple.hs:16:24, [m], ()),
  (AnnotationTuple.hs:16:25, [m], ()),
  (AnnotationTuple.hs:16:26, [m], ()), (<no location info>, [m], ())]
diff --git a/testsuite/tests/th/T17380.stderr b/testsuite/tests/th/T17380.stderr
index 85724eb549..358e7f34f2 100644
--- a/testsuite/tests/th/T17380.stderr
+++ b/testsuite/tests/th/T17380.stderr
@@ -1,39 +1,39 @@
 
 T17380.hs:9:7: error:
-    • Couldn't match expected type ‘Unit (Maybe String)’
+    • Couldn't match expected type ‘Solo (Maybe String)’
                   with actual type ‘Maybe [Char]’
     • In the expression: Just "wat"
       In an equation for ‘foo’: foo = Just "wat"
 
 T17380.hs:12:8: error:
     • Couldn't match expected type ‘Maybe String’
-                  with actual type ‘Unit (Maybe [Char])’
-    • In the expression: Unit Just "wat"
-      In an equation for ‘bar’: bar = (Unit Just "wat")
+                  with actual type ‘Solo (Maybe [Char])’
+    • In the expression: Solo Just "wat"
+      In an equation for ‘bar’: bar = (Solo Just "wat")
 
 T17380.hs:15:6: error:
-    • Couldn't match expected type ‘Unit (Maybe String)’
+    • Couldn't match expected type ‘Solo (Maybe String)’
                   with actual type ‘Maybe [Char]’
     • In the pattern: Just "wat"
       In an equation for ‘baz’: baz (Just "wat") = Just "frerf"
 
 T17380.hs:18:7: error:
     • Couldn't match expected type ‘Maybe String’
-                  with actual type ‘Unit (Maybe [Char])’
-    • In the pattern: Unit(Just "wat")
-      In an equation for ‘quux’: quux (Unit(Just "wat")) = Just "frerf"
+                  with actual type ‘Solo (Maybe [Char])’
+    • In the pattern: Solo(Just "wat")
+      In an equation for ‘quux’: quux (Solo(Just "wat")) = Just "frerf"
 
 T17380.hs:21:8: error:
-    • Couldn't match type ‘Maybe String’ with ‘'Unit (Maybe String)’
-      Expected type: Proxy ('Unit (Maybe String))
+    • Couldn't match type ‘Maybe String’ with ‘'Solo (Maybe String)’
+      Expected type: Proxy ('Solo (Maybe String))
         Actual type: Proxy (Maybe String)
     • In the expression: Proxy :: Proxy (Maybe String)
       In an equation for ‘quuz’: quuz = Proxy :: Proxy (Maybe String)
 
 T17380.hs:24:8: error:
-    • Couldn't match type ‘'Unit (Maybe String)’ with ‘Maybe String’
+    • Couldn't match type ‘'Solo (Maybe String)’ with ‘Maybe String’
       Expected type: Proxy (Maybe String)
-        Actual type: Proxy ('Unit (Maybe String))
-    • In the expression: Proxy :: Proxy ('Unit Maybe String)
+        Actual type: Proxy ('Solo (Maybe String))
+    • In the expression: Proxy :: Proxy ('Solo Maybe String)
       In an equation for ‘fred’:
-          fred = Proxy :: Proxy ('Unit Maybe String)
+          fred = Proxy :: Proxy ('Solo Maybe String)
diff --git a/testsuite/tests/th/T18097.hs b/testsuite/tests/th/T18097.hs
index 2263dfe018..2f905d9627 100644
--- a/testsuite/tests/th/T18097.hs
+++ b/testsuite/tests/th/T18097.hs
@@ -4,11 +4,11 @@ module T18097 where
 import Language.Haskell.TH
 import GHC.Tuple
 
-f = case $( tupE [ [| "ok" |] ] ) of Unit x -> putStrLn x
-g = case Unit "ok" of $( tupP [ [p| x |] ] ) -> putStrLn x
+f = case $( tupE [ [| "ok" |] ] ) of Solo x -> putStrLn x
+g = case Solo "ok" of $( tupP [ [p| x |] ] ) -> putStrLn x
 
 h :: $( tupleT 1 ) String
-h = Unit "ok"
+h = Solo "ok"
 
-i :: Unit String
+i :: Solo String
 i = $( tupE [ [| "ok" |] ] )
diff --git a/testsuite/tests/th/T8761.stderr b/testsuite/tests/th/T8761.stderr
index 79163dec51..eb45ff46eb 100644
--- a/testsuite/tests/th/T8761.stderr
+++ b/testsuite/tests/th/T8761.stderr
@@ -1,5 +1,5 @@
 pattern Q1 x1_0 x2_1 x3_2 <- ((x1_0, x2_1), [x3_2], _, _)
-pattern x1_0 Q2 x2_1 = GHC.Tuple.Unit (x1_0, x2_1)
+pattern x1_0 Q2 x2_1 = GHC.Tuple.Solo (x1_0, x2_1)
 pattern Q3 {qx3, qy3, qz3} <- ((qx3, qy3), [qz3]) where
                                   Q3 qx3 qy3 qz3 = ((qx3, qy3), [qz3])
 T8761.hs:(16,1)-(39,13): Splicing declarations
@@ -28,7 +28,7 @@ T8761.hs:(16,1)-(39,13): Splicing declarations
        return pats
   ======>
     pattern Q1 x1 x2 x3 <- ((x1, x2), [x3], _, _)
-    pattern x1 `Q2` x2 = Unit(x1, x2)
+    pattern x1 `Q2` x2 = Solo(x1, x2)
     pattern Q3{qx3, qy3, qz3} <- ((qx3, qy3), [qz3]) where
                                 Q3 qx3 qy3 qz3 = ((qx3, qy3), [qz3])
 T8761.hs:(42,1)-(46,29): Splicing declarations
diff --git a/testsuite/tests/th/TH_1tuple.stderr b/testsuite/tests/th/TH_1tuple.stderr
index 07b6584242..fad311b0c8 100644
--- a/testsuite/tests/th/TH_1tuple.stderr
+++ b/testsuite/tests/th/TH_1tuple.stderr
@@ -1,7 +1,7 @@
 
 TH_1tuple.hs:11:6: error:
-    • Expecting one more argument to ‘Unit’
-      Expected a type, but ‘Unit’ has kind ‘* -> *’
-    • In an expression type signature: Unit
-      In the expression: 1 :: Unit
-      In an equation for ‘y’: y = (1 :: Unit)
+    • Expecting one more argument to ‘Solo’
+      Expected a type, but ‘Solo’ has kind ‘* -> *’
+    • In an expression type signature: Solo
+      In the expression: 1 :: Solo
+      In an equation for ‘y’: y = (1 :: Solo)
diff --git a/testsuite/tests/th/TH_Promoted1Tuple.stderr b/testsuite/tests/th/TH_Promoted1Tuple.stderr
index d75a6260fa..bd71507e2e 100644
--- a/testsuite/tests/th/TH_Promoted1Tuple.stderr
+++ b/testsuite/tests/th/TH_Promoted1Tuple.stderr
@@ -1,3 +1,3 @@
 
 TH_Promoted1Tuple.hs:7:2: error:
-    Illegal type: ‘'Unit Int’ Perhaps you intended to use DataKinds
+    Illegal type: ‘'Solo Int’ Perhaps you intended to use DataKinds
diff --git a/testsuite/tests/th/TH_tuple1.stdout b/testsuite/tests/th/TH_tuple1.stdout
index 7e35530f6c..e681bf8b3b 100644
--- a/testsuite/tests/th/TH_tuple1.stdout
+++ b/testsuite/tests/th/TH_tuple1.stdout
@@ -1,10 +1,10 @@
 SigE (AppE (AppE (ConE GHC.Tuple.(,)) (LitE (IntegerL 1))) (LitE (IntegerL 2))) (AppT (AppT (ConT GHC.Tuple.(,)) (ConT GHC.Integer.Type.Integer)) (ConT GHC.Integer.Type.Integer))
 GHC.Tuple.(,) 1 2 :: GHC.Tuple.(,) GHC.Integer.Type.Integer
                                    GHC.Integer.Type.Integer
-SigE (AppE (ConE GHC.Tuple.Unit) (LitE (IntegerL 1))) (AppT (ConT GHC.Tuple.Unit) (ConT GHC.Integer.Type.Integer))
-GHC.Tuple.Unit 1 :: GHC.Tuple.Unit GHC.Integer.Type.Integer
+SigE (AppE (ConE GHC.Tuple.Solo) (LitE (IntegerL 1))) (AppT (ConT GHC.Tuple.Solo) (ConT GHC.Integer.Type.Integer))
+GHC.Tuple.Solo 1 :: GHC.Tuple.Solo GHC.Integer.Type.Integer
 SigE (AppE (AppE (ConE GHC.Tuple.(#,#)) (LitE (IntegerL 1))) (LitE (IntegerL 2))) (AppT (AppT (ConT GHC.Tuple.(#,#)) (ConT GHC.Integer.Type.Integer)) (ConT GHC.Integer.Type.Integer))
 GHC.Tuple.(#,#) 1 2 :: GHC.Tuple.(#,#) GHC.Integer.Type.Integer
                                        GHC.Integer.Type.Integer
-SigE (AppE (ConE GHC.Tuple.Unit#) (LitE (IntegerL 1))) (AppT (ConT GHC.Tuple.Unit#) (ConT GHC.Integer.Type.Integer))
-GHC.Tuple.Unit# 1 :: GHC.Tuple.Unit# GHC.Integer.Type.Integer
+SigE (AppE (ConE GHC.Tuple.Solo#) (LitE (IntegerL 1))) (AppT (ConT GHC.Tuple.Solo#) (ConT GHC.Integer.Type.Integer))
+GHC.Tuple.Solo# 1 :: GHC.Tuple.Solo# GHC.Integer.Type.Integer
diff --git a/testsuite/tests/typecheck/should_compile/holes.stderr b/testsuite/tests/typecheck/should_compile/holes.stderr
index ec5e1bf229..9f4422909f 100644
--- a/testsuite/tests/typecheck/should_compile/holes.stderr
+++ b/testsuite/tests/typecheck/should_compile/holes.stderr
@@ -90,7 +90,7 @@ holes.hs:11:15: warning: [-Wtyped-holes (in -Wdefault)]
         Nothing :: forall a. Maybe a
         Just :: forall a. a -> Maybe a
         [] :: forall a. [a]
-        Unit :: forall a. a -> Unit a
+        Solo :: forall a. a -> Solo a
         asTypeOf :: forall a. a -> a -> a
         id :: forall a. a -> a
         until :: forall a. (a -> Bool) -> (a -> a) -> a -> a
diff --git a/testsuite/tests/typecheck/should_compile/holes3.stderr b/testsuite/tests/typecheck/should_compile/holes3.stderr
index fa9590663b..fe6aaf391e 100644
--- a/testsuite/tests/typecheck/should_compile/holes3.stderr
+++ b/testsuite/tests/typecheck/should_compile/holes3.stderr
@@ -93,7 +93,7 @@ holes3.hs:11:15: error:
         Nothing :: forall a. Maybe a
         Just :: forall a. a -> Maybe a
         [] :: forall a. [a]
-        Unit :: forall a. a -> Unit a
+        Solo :: forall a. a -> Solo a
         asTypeOf :: forall a. a -> a -> a
         id :: forall a. a -> a
         until :: forall a. (a -> Bool) -> (a -> a) -> a -> a