cfe8a70 · rel8 · git.iko.soy

git.iko.soy/rel8

Don't try to cram ADT into Rel8able

commitcfe8a70a226472ec8e6abf0d49ca521a860e9a22 authorShane O'Brien <shane.obrien@circuithub.com> dateWed 5 May 2021, 14:30 (6 years ago) parent666f0b9

9 files changed+148−234

compare with master

unifiedsplit

src/Rel8.hs+2−2 src/Rel8/Column.hs+6 src/Rel8/Column/ADT.hs+11−15 src/Rel8/Column/Lift.hs+5−5 src/Rel8/Generic/Rel8able.hs+20−97 src/Rel8/Generic/Rel8able/Test.hs−1 src/Rel8/Table/ADT.hs+80−15 src/Rel8/Table/HKD.hs+10−64 src/Rel8/Table/Rel8able.hs+14−35

src/Rel8.hs+2−2

@@ -106,7 +106,7 @@ module Rel8

106106 , some

107107

108108 -- ** @ADT@

109− , ADT

109+ , ADT, ADTable

110110 , ConstructADT, constructADT

111111 , DeconstructADT, deconstructADT

112112 , InsertADT, insertADT

@@ -114,7 +114,7 @@ module Rel8

114114 , AggregateADT, aggregateADT

115115

116116 -- ** @HKD@

117− , HKD

117+ , HKD, HKDable

118118 , ConstructHKD, constructHKD

119119 , DeconstructHKD, deconstructHKD

120120 , InsertHKD, insertHKD

src/Rel8/Column.hs+6

@@ -4,6 +4,7 @@

55module Rel8.Column

66 ( Column, Default

7+ , TColumn

78 )

89where

910

@@ -13,6 +14,7 @@ import Prelude ()

1314

1415-- rel8

1516import Rel8.Column.Field ( Field )

17+import Rel8.FCF ( Eval, Exp )

1618import Rel8.Kind.Necessity ( Necessity( Required, Optional ) )

1719import qualified Rel8.Schema.Kind as K

1820

@@ -27,3 +29,7 @@ type Column context a = Field context 'Required a

2729

2830type Default :: K.Context -> Type -> Type

2931type Default context a = Field context 'Optional a

32+

33+

34+data TColumn :: K.Context -> Type -> Exp Type

35+type instance Eval (TColumn f a) = Column f a

src/Rel8/Column/ADT.hs+11−15

@@ -15,11 +15,7 @@ import Data.Kind ( Type )

1515import Prelude

1616

1717-- rel8

18−import Rel8.Generic.Rel8able

19− ( Rel8able

20− , GColumnsADT, gfromColumnsADT, gtoColumnsADT

21− , greify, gunreify

22− )

18+import Rel8.Generic.Rel8able ( GColumns )

2319import Rel8.Kind.Context ( SContext(..), Reifiable, contextSing )

2420import Rel8.Schema.Context ( Col )

2521import qualified Rel8.Schema.Kind as K

@@ -29,7 +25,7 @@ import Rel8.Table

2925 ( Table, Columns, Context, fromColumns, toColumns

3026 , Unreify, reify, unreify

3127 )

32−import Rel8.Table.ADT ( ADT( ADT ) )

28+import Rel8.Table.ADT ( ADT( ADT ), ADTable, fromADT, toADT )

3329import Rel8.Table.Recontextualize ( Recontextualize )

3430

3531

@@ -44,11 +40,11 @@ type AHADT :: K.Context -> K.Rel8able -> Type

4440newtype AHADT context t = AHADT (HADT context t)

4541

4642

47−instance (Rel8able t, Reifiable context) =>

43+instance (ADTable t, Reifiable context) =>

4844 Table (Reify context) (AHADT context t)

4945 where

5046 type Context (AHADT context t) = Reify context

51− type Columns (AHADT context t) = GColumnsADT t

47+ type Columns (AHADT context t) = GColumns (ADT t)

5248 type Unreify (AHADT context t) = HADT context t

5349

5450 fromColumns = sfromColumnsADT contextSing

@@ -59,7 +55,7 @@ instance (Rel8able t, Reifiable context) =>

5955

6056instance

6157 ( Reifiable context, Reifiable context'

62− , Rel8able t, t ~ t'

58+ , ADTable t, t ~ t'

6359 )

6460 => Recontextualize

6561 (Reify context)

@@ -68,27 +64,27 @@ instance

6864 (AHADT context' t')

6965

7066

71−sfromColumnsADT :: Rel8able t

67+sfromColumnsADT :: ADTable t

7268 => SContext context

73− -> GColumnsADT t (Col (Reify context))

69+ -> GColumns (ADT t) (Col (Reify context))

7470 -> AHADT context t

7571sfromColumnsADT = \case

7672 SAggregate -> AHADT . ADT . hunreify

7773 SExpr -> AHADT . ADT . hunreify

7874 SInsert -> AHADT . ADT . hunreify

7975 SName -> AHADT . ADT . hunreify

80− SResult -> AHADT . gunreify . gfromColumnsADT

76+ SResult -> AHADT . fromADT . ADT . hunreify

8177 SReify context -> AHADT . sfromColumnsADT context . hunreify

8278

8379

84−stoColumnsADT :: Rel8able t

80+stoColumnsADT :: ADTable t

8581 => SContext context

8682 -> AHADT context t

87− -> GColumnsADT t (Col (Reify context))

83+ -> GColumns (ADT t) (Col (Reify context))

8884stoColumnsADT = \case

8985 SAggregate -> hreify . (\(AHADT (ADT a)) -> a)

9086 SExpr -> hreify . (\(AHADT (ADT a)) -> a)

9187 SInsert -> hreify . (\(AHADT (ADT a)) -> a)

9288 SName -> hreify . (\(AHADT (ADT a)) -> a)

93− SResult -> gtoColumnsADT . greify . (\(AHADT a) -> a)

89+ SResult -> hreify . (\(ADT a) -> a) . toADT . (\(AHADT a) -> a)

9490 SReify context -> hreify . stoColumnsADT context . (\(AHADT a) -> a)

src/Rel8/Column/Lift.hs+5−5

@@ -25,7 +25,7 @@ import Rel8.Table

2525 , Unreify, reify, unreify

2626 )

2727import Rel8.Table.Rel8able ()

28−import Rel8.Table.HKD ( HKD( HKD ), GHKD, fromHKD, toHKD )

28+import Rel8.Table.HKD ( HKD( HKD ), HKDable, fromHKD, toHKD )

2929import Rel8.Table.Recontextualize ( Recontextualize )

3030

3131

@@ -42,7 +42,7 @@ newtype ALift context a = ALift

4242 }

4343

4444

45−instance (Reifiable context, GHKD a) =>

45+instance (Reifiable context, HKDable a) =>

4646 Table (Reify context) (ALift context a)

4747 where

4848 type Context (ALift context a) = Reify context

@@ -55,7 +55,7 @@ instance (Reifiable context, GHKD a) =>

5555 unreify _ (ALift a) = a

5656

5757

58−instance (Reifiable context, Reifiable context', GHKD a) =>

58+instance (Reifiable context, Reifiable context', HKDable a) =>

5959 Recontextualize

6060 (Reify context)

6161 (Reify context')

@@ -63,7 +63,7 @@ instance (Reifiable context, Reifiable context', GHKD a) =>

6363 (ALift context' a)

6464

6565

66−sfromColumnsLift :: GHKD a

66+sfromColumnsLift :: HKDable a

6767 => SContext context

6868 -> GColumns (HKD a) (Col (Reify context))

6969 -> ALift context a

@@ -76,7 +76,7 @@ sfromColumnsLift = \case

7676 SReify context -> ALift . sfromColumnsLift context . hunreify

7777

7878

79−stoColumnsLift :: GHKD a

79+stoColumnsLift :: HKDable a

8080 => SContext context

8181 -> ALift context a

8282 -> GColumns (HKD a) (Col (Reify context))

src/Rel8/Generic/Rel8able.hs+20−97

@@ -14,8 +14,7 @@ module Rel8.Generic.Rel8able

1414 ( KRel8able, Rel8able

1515 , Algebra

1616 , GRep

17− , GColumns, GContext, gfromColumns, gtoColumns

18− , GColumnsADT, gfromColumnsADT, gtoColumnsADT

17+ , GColumns, gfromColumns, gtoColumns

1918 , greify, gunreify

2019 , TUnreifyContext

2120 )

@@ -33,18 +32,14 @@ import Rel8.Kind.Context ( Reifiable )

3332import Rel8.FCF ( Eval, Exp )

3433import Rel8.Generic.Map ( GMap, GMappable, gmap, gunmap )

3534import Rel8.Generic.Record ( Record(..) )

36−import Rel8.Generic.Table

37− ( GGTable, GGColumns, GGContext, ggfromColumns, ggtoColumns

38− , GAlgebra

39− )

40−import qualified Rel8.Generic.Table.ADT as G

41−import Rel8.Kind.Algebra ( KnownAlgebra )

35+import Rel8.Generic.Table ( GAlgebra )

36+import qualified Rel8.Generic.Table.Record as G

4237import qualified Rel8.Kind.Algebra as K ( Algebra(..) )

4338import Rel8.Schema.Context ( Col )

4439import Rel8.Schema.Context.Label ( Labelable )

4540import Rel8.Schema.HTable ( HTable )

4641import qualified Rel8.Schema.Kind as K

47−import Rel8.Schema.Reify ( Col( Reify ), Reify, UnwrapReify )

42+import Rel8.Schema.Reify ( Reify, UnwrapReify )

4843import Rel8.Schema.Result ( Result )

4944import Rel8.Table

5045 ( fromColumns, toColumns, reify, unreify

@@ -99,123 +94,48 @@ type KRel8able = K.Rel8able

9994-- deriving ( GHC.Generics.Generic, Rel8able )

10095-- @

10196type Rel8able :: K.Rel8able -> Constraint

102−class

103− ( HTable (GColumns t)

104− , HTable (GColumnsADT t)

105− , GContext t Result ~ Result

106− )

107− => Rel8able t

108− where

109− type Algebra t :: K.Algebra

110−

111− type GRep t (context :: K.Context) :: Type -> Type

112−

97+class HTable (GColumns t) => Rel8able t where

11398 type GColumns t :: K.HTable

11499

115− type GContext t (context :: K.Context) :: K.Context

116−

117− gfromColumns :: (Labelable context, Reifiable context, GContext t context ~ context)

100+ gfromColumns :: (Labelable context, Reifiable context)

118101 => GColumns t (Col (Reify context)) -> t (Reify context)

119102

120− gtoColumns :: (Labelable context, Reifiable context, GContext t context ~ context)

103+ gtoColumns :: (Labelable context, Reifiable context)

121104 => t (Reify context) -> GColumns t (Col (Reify context))

122105

123− gfromColumnsADT :: GColumnsADT t (Col (Reify Result)) -> t (Reify Result)

124−

125− gtoColumnsADT :: t (Reify Result) -> GColumnsADT t (Col (Reify Result))

126−

127106 greify :: (Labelable context, Reifiable context)

128107 => t context -> t (Reify context)

129108

130109 gunreify :: (Labelable context, Reifiable context)

131110 => t (Reify context) -> t context

132111

133− type Algebra t = GAlgebra (GRep t (Reify Result))

134−

135− type GRep t context = Rep (Record (t context))

136−

137− type GColumns t = Eval (GGColumns (Algebra t) TColumns (GRep t (Reify Result)))

138−

139− type GContext t context =

140− Eval (GGContext (Algebra t) TUnreifyContext (GRep t (Reify context)))

112+ type GColumns t = G.GColumns TColumns (GRep t (Reify Result))

141113

142114 default gfromColumns :: forall context.

143115 ( Generic (Record (t (Reify context)))

144− , GRep t (Reify context) ~ Rep (Record (t (Reify context)))

145− , KnownAlgebra (Algebra t)

146− , Eval (GGTable (Algebra t) (TTable (Reify context)) TColumns (Col (Reify context)) (GRep t (Reify context)))

147− , Eval (GGColumns (Algebra t) TColumns (GRep t (Reify context))) ~ GColumns t

148− , Eval (GGContext (Algebra t) TUnreifyContext (GRep t (Reify context))) ~ context

116+ , G.GTable (TTable (Reify context)) TColumns (Col (Reify context)) (GRep t (Reify context))

117+ , G.GColumns TColumns (GRep t (Reify context)) ~ GColumns t

149118 )

150119 => GColumns t (Col (Reify context)) -> t (Reify context)

151120 gfromColumns =

152121 unrecord .

153122 to .

154− ggfromColumns

155− @(Algebra t)

156− @(TTable (Reify context))

157− @TColumns

158− (\(Reify a) -> a)

159− Reify

160− fromColumns

123+ G.gfromColumns @(TTable (Reify context)) @TColumns fromColumns

161124

162125 default gtoColumns :: forall context.

163126 ( Generic (Record (t (Reify context)))

164− , GRep t (Reify context) ~ Rep (Record (t (Reify context)))

165− , KnownAlgebra (Algebra t)

166− , Eval (GGTable (Algebra t) (TTable (Reify context)) TColumns (Col (Reify context)) (GRep t (Reify context)))

167− , Eval (GGColumns (Algebra t) TColumns (GRep t (Reify context))) ~ GColumns t

168− , Eval (GGContext (Algebra t) TUnreifyContext (GRep t (Reify context))) ~ context

127+ , G.GTable (TTable (Reify context)) TColumns (Col (Reify context)) (GRep t (Reify context))

128+ , G.GColumns TColumns (GRep t (Reify context)) ~ GColumns t

169129 )

170130 => t (Reify context) -> GColumns t (Col (Reify context))

171131 gtoColumns =

172− ggtoColumns

173− @(Algebra t)

174− @(TTable (Reify context))

175− @TColumns

176− (\(Reify a) -> a)

177− Reify

178− toColumns .

179− from .

180− Record

181−

182− default gfromColumnsADT ::

183− ( Generic (Record (t (Reify Result)))

184− , GRep t (Reify Result) ~ Rep (Record (t (Reify Result)))

185− , G.GTableADT (TTable (Reify Result)) TColumns (Col (Reify Result)) (GRep t (Reify Result))

186− )

187− => GColumnsADT t (Col (Reify Result)) -> t (Reify Result)

188− gfromColumnsADT =

189− unrecord .

190− to .

191− G.gfromColumnsADT

192− @(TTable (Reify Result))

193− @TColumns

194− (\(Reify a) -> a)

195− Reify

196− fromColumns

197−

198− default gtoColumnsADT ::

199− ( Generic (Record (t (Reify Result)))

200− , GRep t (Reify Result) ~ Rep (Record (t (Reify Result)))

201− , G.GTableADT (TTable (Reify Result)) TColumns (Col (Reify Result)) (GRep t (Reify Result))

202− )

203− => t (Reify Result) -> GColumnsADT t (Col (Reify Result))

204− gtoColumnsADT =

205− G.gtoColumnsADT

206− @(TTable (Reify Result))

207− @TColumns

208− (\(Reify a) -> a)

209− Reify

210− toColumns .

132+ G.gtoColumns @(TTable (Reify context)) @TColumns toColumns .

211133 from .

212134 Record

213135

214136 default greify :: forall context.

215137 ( Generic (Record (t context))

216− , GRep t context ~ Rep (Record (t context))

217138 , Generic (Record (t (Reify context)))

218− , GRep t (Reify context) ~ Rep (Record (t (Reify context)))

219139 , GMappable (TTable (Reify context)) (GRep t (Reify context))

220140 , GRep t context ~ GMap TUnreify (GRep t (Reify context))

221141 )

@@ -229,9 +149,7 @@ class

229149

230150 default gunreify :: forall context.

231151 ( Generic (Record (t context))

232− , GRep t context ~ Rep (Record (t context))

233152 , Generic (Record (t (Reify context)))

234− , GRep t (Reify context) ~ Rep (Record (t (Reify context)))

235153 , GMappable (TTable (Reify context)) (GRep t (Reify context))

236154 , GRep t context ~ GMap TUnreify (GRep t (Reify context))

237155 )

@@ -244,7 +162,12 @@ class

244162 Record

245163

246164

247−type GColumnsADT t = G.GColumnsADT TColumns (GRep t (Reify Result))

165+type Algebra :: K.Rel8able -> K.Algebra

166+type Algebra t = GAlgebra (GRep t (Reify Result))

167+

168+

169+type GRep :: K.Rel8able -> K.Context -> Type -> Type

170+type GRep t context = Rep (Record (t context))

248171

249172

250173data TUnreifyContext :: Type -> Exp K.Context

src/Rel8/Generic/Rel8able/Test.hs−1

@@ -129,7 +129,6 @@ data TableSum f

129129 | TableSumB

130130 | TableSumC (Column f Text)

131131 deriving stock Generic

132− deriving anyclass Rel8able

133132

134133

135134data TableProduct f = TableProduct

src/Rel8/Table/ADT.hs+80−15

@@ -12,6 +12,7 @@

1212

1313module Rel8.Table.ADT

1414 ( ADT( ADT )

15+ , ADTable, fromADT, toADT

1516 , ConstructableADT

1617 , ConstructADT, constructADT

1718 , DeconstructADT, deconstructADT

@@ -24,7 +25,10 @@ where

2425

2526-- base

2627import Data.Kind ( Constraint, Type )

27−import Prelude ()

28+import Data.Proxy ( Proxy( Proxy ) )

29+import Data.Type.Equality ( (:~:)( Refl ) )

30+import GHC.Generics ( Generic, Rep, from, to )

31+import Prelude

2832

2933-- rel8

3034import Rel8.Aggregate ( Aggregate )

@@ -38,43 +42,100 @@ import Rel8.Generic.Construction

3842 , GGName, ggname

3943 , GGAggregate, ggaggregate

4044 )

45+import Rel8.Generic.Map ( GMappable, GMap, gmap, gunmap )

46+import Rel8.Generic.Record ( GRecordable, GRecord, grecord, gunrecord )

4147import Rel8.Generic.Rel8able

42− ( Rel8able, Algebra

43− , GRep, GColumns, GContext, gfromColumns, gtoColumns

44− , GColumnsADT, gfromColumnsADT, gtoColumnsADT

48+ ( Rel8able

49+ , GRep, GColumns, gfromColumns, gtoColumns

4550 , greify, gunreify

4651 )

52+import qualified Rel8.Generic.Table.ADT as G

4753import qualified Rel8.Kind.Algebra as K

4854import Rel8.Schema.Context ( Col )

55+import Rel8.Schema.HTable ( HTable )

4956import Rel8.Schema.Insert ( Insert )

5057import qualified Rel8.Schema.Kind as K

5158import Rel8.Schema.Name ( Name )

52−import Rel8.Schema.Reify ( hreify, hunreify )

53−import Rel8.Table ( Table )

59+import Rel8.Schema.Reify ( Col( Reify ), Reify, hreify, hunreify )

60+import Rel8.Schema.Result ( Result )

61+import Rel8.Table

62+ ( Table

63+ , fromColumns, toColumns, reify, unreify

64+ , TTable, TColumns, TUnreify

65+ )

5466

5567

5668type ADT :: K.Rel8able -> K.Rel8able

5769newtype ADT t context = ADT (GColumnsADT t (Col context))

5870

5971

60−instance Rel8able t => Rel8able (ADT t) where

61− type Algebra (ADT t) = 'K.Product

62−

63− type GRep (ADT t) context = GRep t context

64−

72+instance ADTable t => Rel8able (ADT t) where

6573 type GColumns (ADT t) = GColumnsADT t

66− type GContext (ADT t) context = context

6774

6875 gfromColumns = ADT

6976 gtoColumns (ADT a) = a

7077

71− gfromColumnsADT = ADT

72− gtoColumnsADT (ADT a) = a

73−

7478 greify (ADT a) = ADT (hreify a)

7579 gunreify (ADT a) = ADT (hunreify a)

7680

7781

82+instance (ADTable t, context ~ Result) => Generic (ADT t context) where

83+ type Rep (ADT t context) = Rep (t context)

84+

85+ from =

86+ gmap @(TTable (Reify Result)) (Proxy @TUnreify) (unreify Refl) .

87+ gunrecord @(Rep (t (Reify Result))) .

88+ G.gfromColumnsADT

89+ @(TTable (Reify Result))

90+ @TColumns

91+ (\(Reify a) -> a)

92+ Reify

93+ fromColumns .

94+ hreify .

95+ (\(ADT a) -> a)

96+

97+ to =

98+ ADT .

99+ hunreify .

100+ G.gtoColumnsADT

101+ @(TTable (Reify Result))

102+ @TColumns

103+ (\(Reify a) -> a)

104+ Reify

105+ toColumns .

106+ grecord @(Rep (t (Reify Result))) .

107+ gunmap @(TTable (Reify Result)) (Proxy @TUnreify) (reify Refl)

108+

109+

110+fromADT :: ADTable t => ADT t Result -> t Result

111+fromADT = to . from

112+

113+

114+toADT :: ADTable t => t Result -> ADT t Result

115+toADT = to . from

116+

117+

118+type ADTable :: K.Rel8able -> Constraint

119+class

120+ ( Generic (t Result)

121+ , HTable (GColumnsADT t)

122+ , G.GTableADT (TTable (Reify Result)) TColumns (Col (Reify Result)) (GRecord (Rep (t (Reify Result))))

123+ , GRecordable (Rep (t (Reify Result)))

124+ , GMappable (TTable (Reify Result)) (Rep (t (Reify Result)))

125+ , GMap TUnreify (Rep (t (Reify Result))) ~ Rep (t Result)

126+ )

127+ => ADTable t

128+instance

129+ ( Generic (t Result)

130+ , HTable (GColumnsADT t)

131+ , G.GTableADT (TTable (Reify Result)) TColumns (Col (Reify Result)) (GRecord (Rep (t (Reify Result))))

132+ , GRecordable (Rep (t (Reify Result)))

133+ , GMappable (TTable (Reify Result)) (Rep (t (Reify Result)))

134+ , GMap TUnreify (Rep (t (Reify Result))) ~ Rep (t Result)

135+ )

136+ => ADTable t

137+

138+

78139type ConstructableADT :: K.Rel8able -> Constraint

79140class GGConstructable 'K.Sum (ADTRep t) => ConstructableADT t

80141instance GGConstructable 'K.Sum (ADTRep t) => ConstructableADT t

@@ -126,3 +187,7 @@ aggregateADT f =

126187

127188data ADTRep :: K.Rel8able -> K.Context -> Exp (Type -> Type)

128189type instance Eval (ADTRep t context) = GRep t context

190+

191+

192+type GColumnsADT :: K.Rel8able -> K.HTable

193+type GColumnsADT t = G.GColumnsADT TColumns (GRep t (Reify Result))

src/Rel8/Table/HKD.hs+10−64

@@ -13,7 +13,7 @@

1313

1414module Rel8.Table.HKD

1515 ( HKD( HKD )

16− , HKDT(..), fromHKD, toHKD, GHKD

16+ , HKDable, fromHKD, toHKD, HKDT(..)

1717 , ConstructableHKD

1818 , ConstructHKD, constructHKD

1919 , DeconstructHKD, deconstructHKD

@@ -33,11 +33,10 @@ import Prelude

3333

3434-- rel8

3535import Rel8.Aggregate ( Aggregate )

36−import Rel8.Column ( Column )

36+import Rel8.Column ( TColumn )

3737import Rel8.Expr ( Expr )

3838import Rel8.FCF ( Eval, Exp )

3939import Rel8.Kind.Algebra ( KnownAlgebra )

40−import qualified Rel8.Kind.Algebra as K

4140import Rel8.Generic.Construction

4241 ( GGConstructable

4342 , GGConstruct, ggconstruct

@@ -49,9 +48,8 @@ import Rel8.Generic.Construction

4948import Rel8.Generic.Map ( GMap, GMappable, gmap, gunmap )

5049import Rel8.Generic.Record ( GRecord, GRecordable, grecord, gunrecord )

5150import Rel8.Generic.Rel8able

52− ( Rel8able, Algebra

53− , GRep, GColumns, GContext, gfromColumns, gtoColumns

54− , GColumnsADT, gfromColumnsADT, gtoColumnsADT

51+ ( Rel8able

52+ , GColumns, gfromColumns, gtoColumns

5553 , greify, gunreify

5654 , TUnreifyContext

5755 )

@@ -59,7 +57,6 @@ import Rel8.Generic.Table

5957 ( GGTable, GGColumns, GGContext, ggfromColumns, ggtoColumns

6058 , GAlgebra

6159 )

62−import qualified Rel8.Generic.Table.ADT as G

6360import Rel8.Schema.Context ( Col )

6461import qualified Rel8.Schema.Kind as K

6562import Rel8.Schema.HTable ( HTable )

@@ -75,10 +72,6 @@ import Rel8.Table

7572import Rel8.Table.Serialize ( ToExprs, fromResult, toResult )

7673

7774

78−data TColumn :: K.Context -> Type -> Exp Type

79−type instance Eval (TColumn f a) = Column f a

80−

81−

8275type GColumnsHKD :: Type -> K.HTable

8376type GColumnsHKD a =

8477 Eval (GGColumns (GAlgebra (Rep a)) TColumns (GRecord (GMap (TColumn (Reify Result)) (Rep a))))

@@ -88,53 +81,12 @@ type HKD :: Type -> K.Rel8able

8881newtype HKD a f = HKD (GColumnsHKD a (Col f))

8982

9083

91−instance GHKD a => Rel8able (HKD a) where

92− type Algebra (HKD a) = 'K.Product

93−

94− type GRep (HKD a) f = GRecord (GMap (TColumn f) (Rep a))

95−

84+instance HKDable a => Rel8able (HKD a) where

9685 type GColumns (HKD a) = GColumnsHKD a

97− type GContext (HKD a) context = context

9886

9987 gfromColumns = HKD

10088 gtoColumns (HKD a) = a

10189

102− gfromColumnsADT =

103− HKD .

104− ggtoColumns

105− @(GAlgebra (Rep a))

106− @(TTable (Reify Result))

107− @TColumns

108− (\(Reify a) -> a)

109− Reify

110− toColumns .

111− G.gfromColumnsADT

112− @(TTable (Reify Result))

113− @TColumns

114− @(Col (Reify Result))

115− @(GRep (HKD a) (Reify Result))

116− (\(Reify a) -> a)

117− Reify

118− fromColumns

119−

120− gtoColumnsADT =

121− G.gtoColumnsADT

122− @(TTable (Reify Result))

123− @TColumns

124− @(Col (Reify Result))

125− @(GRep (HKD a) (Reify Result))

126− (\(Reify a) -> a)

127− Reify

128− toColumns .

129− ggfromColumns

130− @(GAlgebra (Rep a))

131− @(TTable (Reify Result))

132− @TColumns

133− (\(Reify a) -> a)

134− Reify

135− fromColumns .

136− (\(HKD a) -> a)

137−

13890 greify (HKD a) = HKD (hreify a)

13991 gunreify (HKD a) = HKD (hunreify a)

14092

@@ -189,7 +141,7 @@ newtype HKDT a = HKDT

189141instance

190142 ( Table Expr (HKD a Expr)

191143 , Columns (HKD a Expr) ~ GColumns (HKD a)

192− , GHKD a

144+ , HKDable a

193145 , x ~ HKD a Expr

194146 )

195147 => ToExprs x (HKDT a)

@@ -198,11 +150,11 @@ instance

198150 fromResult = HKDT . fromHKD . HKD

199151

200152

201−fromHKD :: GHKD a => HKD a Result -> a

153+fromHKD :: HKDable a => HKD a Result -> a

202154fromHKD = to . gunmap @Top (Proxy @(TColumn Result)) id . from

203155

204156

205−toHKD :: GHKD a => a -> HKD a Result

157+toHKD :: HKDable a => a -> HKD a Result

206158toHKD = to . gmap @Top (Proxy @(TColumn Result)) id . from

207159

208160

@@ -217,33 +169,27 @@ type instance Eval (Top _) = Top_

217169class

218170 ( Generic a

219171 , HTable (GColumns (HKD a))

220− , HTable (GColumnsADT (HKD a))

221172 , KnownAlgebra (GAlgebra (Rep a))

222173 , Eval (GGTable (GAlgebra (Rep a)) (TTable (Reify Result)) TColumns (Col (Reify Result)) (GRecord (GMap (TColumn (Reify Result)) (Rep a))))

223− , Eval (GGColumns (GAlgebra (Rep a)) TColumns (GRecord (GMap (TColumn (Reify Result)) (Rep a)))) ~ GColumnsHKD a

224174 , Eval (GGContext (GAlgebra (Rep a)) TUnreifyContext (GRecord (GMap (TColumn (Reify Result)) (Rep a)))) ~ Result

225− , G.GTableADT (TTable (Reify Result)) TColumns (Col (Reify Result)) (GRecord (GMap (TColumn (Reify Result)) (Rep a)))

226175 , GRecordable (GMap (TColumn (Reify Result)) (Rep a))

227176 , GMappable Top (Rep a)

228177 , GMappable (TTable (Reify Result)) (GMap (TColumn (Reify Result)) (Rep a))

229178 , GMap TUnreify (GMap (TColumn (Reify Result)) (Rep a)) ~ GMap (TColumn Result) (Rep a)

230179 )

231− => GHKD a

180+ => HKDable a

232181instance

233182 ( Generic a

234183 , HTable (GColumns (HKD a))

235− , HTable (GColumnsADT (HKD a))

236184 , KnownAlgebra (GAlgebra (Rep a))

237185 , Eval (GGTable (GAlgebra (Rep a)) (TTable (Reify Result)) TColumns (Col (Reify Result)) (GRecord (GMap (TColumn (Reify Result)) (Rep a))))

238− , Eval (GGColumns (GAlgebra (Rep a)) TColumns (GRecord (GMap (TColumn (Reify Result)) (Rep a)))) ~ GColumnsHKD a

239186 , Eval (GGContext (GAlgebra (Rep a)) TUnreifyContext (GRecord (GMap (TColumn (Reify Result)) (Rep a)))) ~ Result

240− , G.GTableADT (TTable (Reify Result)) TColumns (Col (Reify Result)) (GRecord (GMap (TColumn (Reify Result)) (Rep a)))

241187 , GRecordable (GMap (TColumn (Reify Result)) (Rep a))

242188 , GMappable Top (Rep a)

243189 , GMappable (TTable (Reify Result)) (GMap (TColumn (Reify Result)) (Rep a))

244190 , GMap TUnreify (GMap (TColumn (Reify Result)) (Rep a)) ~ GMap (TColumn Result) (Rep a)

245191 )

246− => GHKD a

192+ => HKDable a

247193

248194

249195type ConstructableHKD :: Type -> Constraint

src/Rel8/Table/Rel8able.hs+14−35

@@ -29,8 +29,7 @@ import Rel8.Kind.Context

2929 )

3030import Rel8.Generic.Rel8able

3131 ( Rel8able, Algebra

32− , GColumns, GContext, gfromColumns, gtoColumns

33− , gfromColumnsADT, gtoColumnsADT

32+ , GColumns, gfromColumns, gtoColumns

3433 , greify, gunreify

3534 )

3635import Rel8.Schema.Context ( Col )

@@ -45,7 +44,7 @@ import Rel8.Table

4544 , Unreify, reify, unreify

4645 )

4746import Rel8.Schema.Spec.ConstrainDBType ( ConstrainDBType )

48−import Rel8.Table.ADT ( ADT )

47+import Rel8.Table.ADT ( ADT( ADT ), ADTable, fromADT, toADT )

4948import Rel8.Table.Eq ( EqTable, eqTable )

5049import Rel8.Table.HKD ( HKD )

5150import Rel8.Table.Ord ( OrdTable, ordTable )

@@ -55,13 +54,8 @@ import Rel8.Type.Eq ( DBEq )

5554import Rel8.Type.Ord ( DBOrd )

5655

5756

58−instance

59− ( Rel8able t

60− , GContext t context ~ context

61− , Labelable context

62− , Reifiable context

63− )

64− => Table context (t context)

57+instance (Rel8able t, Labelable context, Reifiable context) =>

58+ Table context (t context)

6559 where

6660 type Columns (t context) = GColumns t

6761 type Context (t context) = context

@@ -83,8 +77,8 @@ instance

8377

8478instance

8579 ( Rel8able t

86− , Labelable from, Reifiable from, GContext t from ~ from

87− , Labelable to, Reifiable to, GContext t to ~ to

80+ , Labelable from, Reifiable from

81+ , Labelable to, Reifiable to

8882 , Congruent (t from) (t to)

8983 )

9084 => Recontextualize from to (t from) (t to)

@@ -93,7 +87,6 @@ instance

9387instance

9488 ( context ~ Expr

9589 , Rel8able t

96− , GContext t context ~ context

9790 , HConstrainTable (Columns (t context)) (ConstrainDBType DBEq)

9891 )

9992 => EqTable (t context)

@@ -104,7 +97,6 @@ instance

10497instance

10598 ( context ~ Expr

10699 , Rel8able t

107− , GContext t context ~ context

108100 , HConstrainTable (Columns (t context)) (ConstrainDBType DBEq)

109101 , HConstrainTable (Columns (t context)) (ConstrainDBType DBOrd)

110102 )

@@ -135,35 +127,22 @@ type family FromExprs' t where

135127

136128

137129type ToExprs' :: K.Algebra -> K.Rel8able -> K.Rel8able -> Constraint

138−class

139− ( algebra ~ Algebra t

140− , Rel8able t'

141− , GContext t' Expr ~ Expr

142− )

143− => ToExprs' algebra t' t | algebra t -> t'

130+class (algebra ~ Algebra t, Rel8able t') =>

131+ ToExprs' algebra t' t | algebra t -> t'

144132 where

145133 fromResult' :: GColumns t' (Col Result) -> t Result

146134 toResult' :: t Result -> GColumns t' (Col Result)

147135

148136

149−instance

150− ( Algebra t ~ 'K.Product

151− , Rel8able t

152− , GContext t Expr ~ Expr

153− , t ~ t'

154− )

155− => ToExprs' 'K.Product t' t

137+instance (Algebra t ~ 'K.Product, Rel8able t, t ~ t') =>

138+ ToExprs' 'K.Product t' t

156139 where

157140 fromResult' = fromColumns

158141 toResult' = toColumns

159142

160143

161−instance

162− ( Algebra t ~ 'K.Sum

163− , Rel8able t

164− , t' ~ ADT t

165− )

166− => ToExprs' 'K.Sum t' t

144+instance (Algebra t ~ 'K.Sum, ADTable t, t' ~ ADT t) =>

145+ ToExprs' 'K.Sum t' t

167146 where

168− fromResult' = gunreify . gfromColumnsADT . hreify

169− toResult' = hunreify . gtoColumnsADT . greify

147+ fromResult' = fromADT . ADT

148+ toResult' = (\(ADT a) -> a) . toADT