commit 811fe1fb26404329d105b547b7ea968ac32c6f04
parent 01719e7037df80215b5de677206f63e01c3b9b51
Author: Robert Russell <robert@rr3.xyz>
Date: Mon, 5 Oct 2026 09:53:55 -0700
Haskell: reorganize tuples; add type/pattern constructors
Diffstat:
4 files changed, 187 insertions(+), 53 deletions(-)
diff --git a/src/Lude/Haskell.hs b/src/Lude/Haskell.hs
@@ -12,6 +12,7 @@ import Lude.Haskell.Core as X
import Lude.Haskell.Equality as X
import Lude.Haskell.Functional as X
import Lude.Haskell.Generic as X hiding (Rep, Rep1, from, from1, to, to1)
+import Lude.Haskell.Tuple as X
import Lude.Haskell.Type as X
-- TODO: Data.Coerce
diff --git a/src/Lude/Haskell/Constraint.hs b/src/Lude/Haskell/Constraint.hs
@@ -38,6 +38,7 @@ type Relation i j = Constraint2 i j
--------------------------------------------------------------------------------
+-- TODO: Synchronize with type tuples.
type All :: forall {k}. k -> Constraint
type family All _ where
All () = GHC.CTuple0
diff --git a/src/Lude/Haskell/Tuple.hs b/src/Lude/Haskell/Tuple.hs
@@ -0,0 +1,185 @@
+module Lude.Haskell.Tuple (
+ Tuple0#,
+ Tuple1#,
+ Tuple2#,
+ Tuple3#,
+ Tuple4#,
+ Tuple5#,
+ Tuple6#,
+ Tuple7#,
+ Tuple8#,
+ Tuple9#,
+ Tuple0,
+ MkTuple0,
+ pattern MkTuple0,
+ Tuple1,
+ MkTuple1,
+ pattern MkTuple1,
+ Tuple2,
+ MkTuple2,
+ pattern MkTuple2,
+ Tuple3,
+ MkTuple3,
+ pattern MkTuple3,
+ Tuple4,
+ MkTuple4,
+ pattern MkTuple4,
+ Tuple5,
+ MkTuple5,
+ pattern MkTuple5,
+ Tuple6,
+ MkTuple6,
+ pattern MkTuple6,
+ Tuple7,
+ MkTuple7,
+ pattern MkTuple7,
+ Tuple8,
+ MkTuple8,
+ pattern MkTuple8,
+ Tuple9,
+ MkTuple9,
+ pattern MkTuple9,
+ Tuple#,
+ Tuple,
+) where
+
+import Data.Tuple.Experimental (
+ Tuple0,
+ Tuple0#,
+ Tuple1,
+ Tuple1#,
+ Tuple2,
+ Tuple2#,
+ Tuple3,
+ Tuple3#,
+ Tuple4,
+ Tuple4#,
+ Tuple5,
+ Tuple5#,
+ Tuple6,
+ Tuple6#,
+ Tuple7,
+ Tuple7#,
+ Tuple8,
+ Tuple8#,
+ Tuple9,
+ Tuple9#,
+ )
+
+import Data.Tuple.Experimental qualified as GHC
+
+import Lude.Haskell.Core
+import Lude.Haskell.Repr qualified as Repr
+import Lude.Haskell.Type
+
+-- TODO: Rename so that we don't have # in names?
+
+--------------------------------------------------------------------------------
+
+type MkTuple0 :: Tuple0
+type MkTuple0 = ()
+pattern MkTuple0 :: Tuple0
+pattern MkTuple0 = ()
+{-# COMPLETE MkTuple0 #-}
+
+type MkTuple1 :: a -> Tuple1 a
+type MkTuple1 = GHC.MkSolo
+pattern MkTuple1 :: a -> Tuple1 a
+pattern MkTuple1 a = GHC.MkSolo a
+{-# COMPLETE MkTuple1 #-}
+
+type MkTuple2 :: a -> b -> Tuple2 a b
+type MkTuple2 = (,)
+pattern MkTuple2 :: a -> b -> Tuple2 a b
+pattern MkTuple2 a b = (a, b)
+{-# COMPLETE MkTuple2 #-}
+
+type MkTuple3 :: a -> b -> c -> Tuple3 a b c
+type MkTuple3 = (,,)
+pattern MkTuple3 :: a -> b -> c -> Tuple3 a b c
+pattern MkTuple3 a b c = (a, b, c)
+{-# COMPLETE MkTuple3 #-}
+
+type MkTuple4 :: a -> b -> c -> d -> Tuple4 a b c d
+type MkTuple4 = (,,,)
+pattern MkTuple4 :: a -> b -> c -> d -> Tuple4 a b c d
+pattern MkTuple4 a b c d = (a, b, c, d)
+{-# COMPLETE MkTuple4 #-}
+
+type MkTuple5 :: a -> b -> c -> d -> e -> Tuple5 a b c d e
+type MkTuple5 = (,,,,)
+pattern MkTuple5 :: a -> b -> c -> d -> e -> Tuple5 a b c d e
+pattern MkTuple5 a b c d e = (a, b, c, d, e)
+{-# COMPLETE MkTuple5 #-}
+
+type MkTuple6 :: a -> b -> c -> d -> e -> f -> Tuple6 a b c d e f
+type MkTuple6 = (,,,,,)
+pattern MkTuple6 :: a -> b -> c -> d -> e -> f -> Tuple6 a b c d e f
+pattern MkTuple6 a b c d e f = (a, b, c, d, e, f)
+{-# COMPLETE MkTuple6 #-}
+
+type MkTuple7 :: a -> b -> c -> d -> e -> f -> g -> Tuple7 a b c d e f g
+type MkTuple7 = (,,,,,,)
+pattern MkTuple7 :: a -> b -> c -> d -> e -> f -> g -> Tuple7 a b c d e f g
+pattern MkTuple7 a b c d e f g = (a, b, c, d, e, f, g)
+{-# COMPLETE MkTuple7 #-}
+
+type MkTuple8 :: a -> b -> c -> d -> e -> f -> g -> h -> Tuple8 a b c d e f g h
+type MkTuple8 = (,,,,,,,)
+pattern MkTuple8 :: a -> b -> c -> d -> e -> f -> g -> h -> Tuple8 a b c d e f g h
+pattern MkTuple8 a b c d e f g h = (a, b, c, d, e, f, g, h)
+{-# COMPLETE MkTuple8 #-}
+
+type MkTuple9 :: a -> b -> c -> d -> e -> f -> g -> h -> i -> Tuple9 a b c d e f g h i
+type MkTuple9 = (,,,,,,,,)
+pattern MkTuple9 :: a -> b -> c -> d -> e -> f -> g -> h -> i -> Tuple9 a b c d e f g h i
+pattern MkTuple9 a b c d e f g h i = (a, b, c, d, e, f, g, h, i)
+{-# COMPLETE MkTuple9 #-}
+
+--------------------------------------------------------------------------------
+
+type R :: forall {r :: Repr}. Type# r -> Repr
+type family R _ where
+ R (_ :: Type# r) = r
+
+type TupleRepr :: forall {k}. k -> Repr
+type family TupleRepr _ where
+ TupleRepr () = Repr.Tuple []
+ TupleRepr (a) = Repr.Tuple [R a]
+ TupleRepr (a, b) = Repr.Tuple [R a, R b]
+ TupleRepr (a, b, c) = Repr.Tuple [R a, R b, R c]
+ TupleRepr (a, b, c, d) = Repr.Tuple [R a, R b, R c, R d]
+ TupleRepr (a, b, c, d, e) = Repr.Tuple [R a, R b, R c, R d, R e]
+ TupleRepr (a, b, c, d, e, f) = Repr.Tuple [R a, R b, R c, R d, R e, R f]
+ TupleRepr (a, b, c, d, e, f, g) = Repr.Tuple [R a, R b, R c, R d, R e, R f, R g]
+ TupleRepr (a, b, c, d, e, f, g, h) = Repr.Tuple [R a, R b, R c, R d, R e, R f, R g, R h]
+ TupleRepr (a, b, c, d, e, f, g, h, i) = Repr.Tuple [R a, R b, R c, R d, R e, R f, R g, R h, R i]
+ TupleRepr (GHC.MkSolo a) = Repr.Tuple [R a]
+
+type Tuple# :: forall {k}. forall (a :: k) -> Type# (TupleRepr a)
+type family Tuple# _ where
+ Tuple# () = GHC.Tuple0#
+ Tuple# (a) = GHC.Tuple1# a
+ Tuple# (a, b) = GHC.Tuple2# a b
+ Tuple# (a, b, c) = GHC.Tuple3# a b c
+ Tuple# (a, b, c, d) = GHC.Tuple4# a b c d
+ Tuple# (a, b, c, d, e) = GHC.Tuple5# a b c d e
+ Tuple# (a, b, c, d, e, f) = GHC.Tuple6# a b c d e f
+ Tuple# (a, b, c, d, e, f, g) = GHC.Tuple7# a b c d e f g
+ Tuple# (a, b, c, d, e, f, g, h) = GHC.Tuple8# a b c d e f g h
+ Tuple# (a, b, c, d, e, f, g, h, i) = GHC.Tuple9# a b c d e f g h i
+ Tuple# (GHC.MkSolo a) = GHC.Tuple1# a
+
+type Tuple :: forall {k}. k -> Type
+type family Tuple _ where
+ Tuple () = GHC.Tuple0
+ Tuple (a) = GHC.Tuple1 a
+ Tuple (a, b) = GHC.Tuple2 a b
+ Tuple (a, b, c) = GHC.Tuple3 a b c
+ Tuple (a, b, c, d) = GHC.Tuple4 a b c d
+ Tuple (a, b, c, d, e) = GHC.Tuple5 a b c d e
+ Tuple (a, b, c, d, e, f) = GHC.Tuple6 a b c d e f
+ Tuple (a, b, c, d, e, f, g) = GHC.Tuple7 a b c d e f g
+ Tuple (a, b, c, d, e, f, g, h) = GHC.Tuple8 a b c d e f g h
+ Tuple (a, b, c, d, e, f, g, h, i) = GHC.Tuple9 a b c d e f g h i
+ Tuple (GHC.MkSolo a) = GHC.Tuple1 a
diff --git a/src/Lude/Haskell/Type.hs b/src/Lude/Haskell/Type.hs
@@ -2,11 +2,8 @@ module Lude.Haskell.Type (
Type#,
Type,
Type1,
- Tuple#,
- Tuple,
) where
-import Data.Tuple.Experimental qualified as GHC
import GHC.Exts qualified as GHC
import Lude.Haskell.Core
@@ -22,53 +19,3 @@ type Type = Type# Repr.BoxL
type Type1 :: Kind -> Kind
type Type1 i = i -> Type
-
---------------------------------------------------------------------------------
--- Tuples
-
-type R :: forall {r :: Repr}. Type# r -> Repr
-type family R _ where
- R (_ :: Type# r) = r
-
-type TupleRepr :: forall {k}. k -> Repr
-type family TupleRepr _ where
- TupleRepr () = Repr.Tuple []
- TupleRepr (a) = Repr.Tuple [R a]
- TupleRepr (a, b) = Repr.Tuple [R a, R b]
- TupleRepr (a, b, c) = Repr.Tuple [R a, R b, R c]
- TupleRepr (a, b, c, d) = Repr.Tuple [R a, R b, R c, R d]
- TupleRepr (a, b, c, d, e) = Repr.Tuple [R a, R b, R c, R d, R e]
- TupleRepr (a, b, c, d, e, f) = Repr.Tuple [R a, R b, R c, R d, R e, R f]
- TupleRepr (a, b, c, d, e, f, g) = Repr.Tuple [R a, R b, R c, R d, R e, R f, R g]
- TupleRepr (a, b, c, d, e, f, g, h) = Repr.Tuple [R a, R b, R c, R d, R e, R f, R g, R h]
- TupleRepr (a, b, c, d, e, f, g, h, i) = Repr.Tuple [R a, R b, R c, R d, R e, R f, R g, R h, R i]
- TupleRepr (GHC.MkSolo a) = Repr.Tuple [R a]
-
--- TODO: Rename so that it doesn't have a # in the name.
-type Tuple# :: forall {k}. forall (a :: k) -> Type# (TupleRepr a)
-type family Tuple# _ where
- Tuple# () = GHC.Tuple0#
- Tuple# (a) = GHC.Tuple1# a
- Tuple# (a, b) = GHC.Tuple2# a b
- Tuple# (a, b, c) = GHC.Tuple3# a b c
- Tuple# (a, b, c, d) = GHC.Tuple4# a b c d
- Tuple# (a, b, c, d, e) = GHC.Tuple5# a b c d e
- Tuple# (a, b, c, d, e, f) = GHC.Tuple6# a b c d e f
- Tuple# (a, b, c, d, e, f, g) = GHC.Tuple7# a b c d e f g
- Tuple# (a, b, c, d, e, f, g, h) = GHC.Tuple8# a b c d e f g h
- Tuple# (a, b, c, d, e, f, g, h, i) = GHC.Tuple9# a b c d e f g h i
- Tuple# (GHC.MkSolo a) = GHC.Tuple1# a
-
-type Tuple :: forall {k}. k -> Type
-type family Tuple _ where
- Tuple () = GHC.Tuple0
- Tuple (a) = GHC.Tuple1 a
- Tuple (a, b) = GHC.Tuple2 a b
- Tuple (a, b, c) = GHC.Tuple3 a b c
- Tuple (a, b, c, d) = GHC.Tuple4 a b c d
- Tuple (a, b, c, d, e) = GHC.Tuple5 a b c d e
- Tuple (a, b, c, d, e, f) = GHC.Tuple6 a b c d e f
- Tuple (a, b, c, d, e, f, g) = GHC.Tuple7 a b c d e f g
- Tuple (a, b, c, d, e, f, g, h) = GHC.Tuple8 a b c d e f g h
- Tuple (a, b, c, d, e, f, g, h, i) = GHC.Tuple9 a b c d e f g h i
- Tuple (GHC.MkSolo a) = GHC.Tuple1 a
