{-# language DataKinds #-}
{-# language DeriveFunctor #-}
{-# language DerivingStrategies #-}
{-# language FlexibleContexts #-}
{-# language FlexibleInstances #-}
{-# language MultiParamTypeClasses #-}
{-# language NamedFieldPuns #-}
{-# language RecordWildCards #-}
{-# language ScopedTypeVariables #-}
{-# language StandaloneKindSignatures #-}
{-# language TupleSections #-}
{-# language TypeApplications #-}
{-# language TypeFamilies #-}
{-# language UndecidableInstances #-}

{-# options_ghc -fno-warn-orphans #-}

module Rel8.Table.These
  ( TheseTable(..)
  , theseTable, thisTable, thatTable, thoseTable
  , isThisTable, isThatTable, isThoseTable
  , hasHereTable, hasThereTable
  , justHereTable, justThereTable
  , nameTheseTable
  )
where

-- base
import Control.Applicative ( liftA2 )
import Data.Bifunctor ( Bifunctor, bimap )
import Data.Functor.Identity ( runIdentity )
import Data.Kind ( Type )
import Prelude hiding ( undefined )

-- rel8
import Rel8.Expr ( Expr )
import Rel8.Expr.Bool ( (&&.), not_ )
import Rel8.Expr.Null ( isNonNull )
import Rel8.Schema.Context.Label
  ( Labelable
  , HLabelable, hlabeler, hunlabeler
  )
import Rel8.Schema.Context.Nullify
  ( Nullifiable, ConstrainTag
  , HNullifiable, HConstrainTag
  , hencodeTag, hdecodeTag
  , hnullifier, hunnullifier
  )
import Rel8.Schema.HTable ( HTable )
import Rel8.Schema.HTable.Label ( hlabel, hunlabel )
import Rel8.Schema.HTable.Identity ( HIdentity(..) )
import Rel8.Schema.HTable.Nullify ( hnullify, hunnullify )
import Rel8.Schema.HTable.These ( HTheseTable(..) )
import Rel8.Schema.Name ( Name )
import Rel8.Table
  ( Table, Columns, Context, fromColumns, toColumns
  , reify, unreify
  )
import Rel8.Table.Eq ( EqTable, eqTable )
import Rel8.Table.Maybe
  ( MaybeTable(..)
  , maybeTable, justTable, nothingTable
  , isJustTable
  , nameMaybeTable
  )
import Rel8.Table.Ord ( OrdTable, ordTable )
import Rel8.Table.Recontextualize ( Recontextualize )
import Rel8.Table.Serialize ( FromExprs, ToExprs, fromResult, toResult )
import Rel8.Table.Tag ( Tag(..) )
import Rel8.Table.Undefined ( undefined )
import Rel8.Type.Tag ( MaybeTag )

-- semigroupoids
import Data.Functor.Apply ( Apply, (<.>) )
import Data.Functor.Bind ( Bind, (>>-) )

-- these
import Data.These ( These )


-- | @TheseTable a b@ is a Rel8 table that contains either the table @a@, the
-- table @b@, or both tables @a@ and @b@. You can construct @TheseTable@s using
-- 'thisTable', 'thatTable' and 'thoseTable'. @TheseTable@s can be
-- eliminated/pattern matched using 'theseTable'.
--
-- @TheseTable@ is operationally the same as Haskell's 'These' type, but
-- adapted to work with Rel8.
type TheseTable :: Type -> Type -> Type
data TheseTable a b = TheseTable
  { TheseTable a b -> MaybeTable a
here :: MaybeTable a
  , TheseTable a b -> MaybeTable b
there :: MaybeTable b
  }
  deriving stock a -> TheseTable a b -> TheseTable a a
(a -> b) -> TheseTable a a -> TheseTable a b
(forall a b. (a -> b) -> TheseTable a a -> TheseTable a b)
-> (forall a b. a -> TheseTable a b -> TheseTable a a)
-> Functor (TheseTable a)
forall a b. a -> TheseTable a b -> TheseTable a a
forall a b. (a -> b) -> TheseTable a a -> TheseTable a b
forall a a b. a -> TheseTable a b -> TheseTable a a
forall a a b. (a -> b) -> TheseTable a a -> TheseTable a b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> TheseTable a b -> TheseTable a a
$c<$ :: forall a a b. a -> TheseTable a b -> TheseTable a a
fmap :: (a -> b) -> TheseTable a a -> TheseTable a b
$cfmap :: forall a a b. (a -> b) -> TheseTable a a -> TheseTable a b
Functor


instance Bifunctor TheseTable where
  bimap :: (a -> b) -> (c -> d) -> TheseTable a c -> TheseTable b d
bimap a -> b
f c -> d
g (TheseTable MaybeTable a
a MaybeTable c
b) = MaybeTable b -> MaybeTable d -> TheseTable b d
forall a b. MaybeTable a -> MaybeTable b -> TheseTable a b
TheseTable ((a -> b) -> MaybeTable a -> MaybeTable b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f MaybeTable a
a) ((c -> d) -> MaybeTable c -> MaybeTable d
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap c -> d
g MaybeTable c
b)


instance (Table Expr a, Semigroup a) => Apply (TheseTable a) where
  TheseTable a (a -> b)
fs <.> :: TheseTable a (a -> b) -> TheseTable a a -> TheseTable a b
<.> TheseTable a a
as = TheseTable :: forall a b. MaybeTable a -> MaybeTable b -> TheseTable a b
TheseTable
    { here :: MaybeTable a
here = TheseTable a (a -> b) -> MaybeTable a
forall a b. TheseTable a b -> MaybeTable a
here TheseTable a (a -> b)
fs MaybeTable a -> MaybeTable a -> MaybeTable a
forall a. Semigroup a => a -> a -> a
<> TheseTable a a -> MaybeTable a
forall a b. TheseTable a b -> MaybeTable a
here TheseTable a a
as
    , there :: MaybeTable b
there = TheseTable a (a -> b) -> MaybeTable (a -> b)
forall a b. TheseTable a b -> MaybeTable b
there TheseTable a (a -> b)
fs MaybeTable (a -> b) -> MaybeTable a -> MaybeTable b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
<.> TheseTable a a -> MaybeTable a
forall a b. TheseTable a b -> MaybeTable b
there TheseTable a a
as
    }


instance (Table Expr a, Semigroup a) => Applicative (TheseTable a)
 where
  pure :: a -> TheseTable a a
pure = a -> TheseTable a a
forall a b. Table Expr a => b -> TheseTable a b
thatTable
  <*> :: TheseTable a (a -> b) -> TheseTable a a -> TheseTable a b
(<*>) = TheseTable a (a -> b) -> TheseTable a a -> TheseTable a b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
(<.>)


instance (Table Expr a, Semigroup a) => Bind (TheseTable a) where
  TheseTable MaybeTable a
here1 MaybeTable a
ma >>- :: TheseTable a a -> (a -> TheseTable a b) -> TheseTable a b
>>- a -> TheseTable a b
f = case MaybeTable a
ma MaybeTable a
-> (a -> MaybeTable (MaybeTable a, b))
-> MaybeTable (MaybeTable a, b)
forall (m :: * -> *) a b. Bind m => m a -> (a -> m b) -> m b
>>- a -> MaybeTable (MaybeTable a, b)
f' of
    MaybeTable (MaybeTable a, b)
mtb -> TheseTable :: forall a b. MaybeTable a -> MaybeTable b -> TheseTable a b
TheseTable
      { here :: MaybeTable a
here = MaybeTable a
-> ((MaybeTable a, b) -> MaybeTable a)
-> MaybeTable (MaybeTable a, b)
-> MaybeTable a
forall b a. Table Expr b => b -> (a -> b) -> MaybeTable a -> b
maybeTable MaybeTable a
here1 ((MaybeTable a
here1 MaybeTable a -> MaybeTable a -> MaybeTable a
forall a. Semigroup a => a -> a -> a
<>) (MaybeTable a -> MaybeTable a)
-> ((MaybeTable a, b) -> MaybeTable a)
-> (MaybeTable a, b)
-> MaybeTable a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MaybeTable a, b) -> MaybeTable a
forall a b. (a, b) -> a
fst) MaybeTable (MaybeTable a, b)
mtb
      , there :: MaybeTable b
there = (MaybeTable a, b) -> b
forall a b. (a, b) -> b
snd ((MaybeTable a, b) -> b)
-> MaybeTable (MaybeTable a, b) -> MaybeTable b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MaybeTable (MaybeTable a, b)
mtb
      }
    where
      f' :: a -> MaybeTable (MaybeTable a, b)
f' a
a = case a -> TheseTable a b
f a
a of
        TheseTable MaybeTable a
here2 MaybeTable b
mb -> (MaybeTable a
here2,) (b -> (MaybeTable a, b))
-> MaybeTable b -> MaybeTable (MaybeTable a, b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MaybeTable b
mb


instance (Table Expr a, Semigroup a) => Monad (TheseTable a) where
  >>= :: TheseTable a a -> (a -> TheseTable a b) -> TheseTable a b
(>>=) = TheseTable a a -> (a -> TheseTable a b) -> TheseTable a b
forall (m :: * -> *) a b. Bind m => m a -> (a -> m b) -> m b
(>>-)


instance (Table Expr a, Table Expr b, Semigroup a, Semigroup b) =>
  Semigroup (TheseTable a b)
 where
  TheseTable a b
a <> :: TheseTable a b -> TheseTable a b -> TheseTable a b
<> TheseTable a b
b = TheseTable :: forall a b. MaybeTable a -> MaybeTable b -> TheseTable a b
TheseTable
    { here :: MaybeTable a
here = TheseTable a b -> MaybeTable a
forall a b. TheseTable a b -> MaybeTable a
here TheseTable a b
a MaybeTable a -> MaybeTable a -> MaybeTable a
forall a. Semigroup a => a -> a -> a
<> TheseTable a b -> MaybeTable a
forall a b. TheseTable a b -> MaybeTable a
here TheseTable a b
b
    , there :: MaybeTable b
there = TheseTable a b -> MaybeTable b
forall a b. TheseTable a b -> MaybeTable b
there TheseTable a b
a MaybeTable b -> MaybeTable b -> MaybeTable b
forall a. Semigroup a => a -> a -> a
<> TheseTable a b -> MaybeTable b
forall a b. TheseTable a b -> MaybeTable b
there TheseTable a b
b
    }


instance
  ( Table context a, Table context b
  , Labelable context, Nullifiable context, ConstrainTag context MaybeTag
  ) => Table context (TheseTable a b)
 where
  type Columns (TheseTable a b) = HTheseTable (Columns a) (Columns b)
  type Context (TheseTable a b) = Context a

  toColumns :: TheseTable a b -> Columns (TheseTable a b) (Col context)
toColumns = (a -> Columns a (Col context))
-> (b -> Columns b (Col context))
-> TheseTable a b
-> HTheseTable (Columns a) (Columns b) (Col context)
forall (t :: HTable) (u :: HTable) (context :: HContext) a b.
(HTable t, HTable u, HConstrainTag context MaybeTag,
 HLabelable context, HNullifiable context) =>
(a -> t context)
-> (b -> u context) -> TheseTable a b -> HTheseTable t u context
toColumns2 a -> Columns a (Col context)
forall (context :: Context) a.
Table context a =>
a -> Columns a (Col context)
toColumns b -> Columns b (Col context)
forall (context :: Context) a.
Table context a =>
a -> Columns a (Col context)
toColumns
  fromColumns :: Columns (TheseTable a b) (Col context) -> TheseTable a b
fromColumns = (Columns a (Col context) -> a)
-> (Columns b (Col context) -> b)
-> HTheseTable (Columns a) (Columns b) (Col context)
-> TheseTable a b
forall (t :: HTable) (u :: HTable) (context :: HContext) a b.
(HTable t, HTable u, HConstrainTag context MaybeTag,
 HLabelable context, HNullifiable context) =>
(t context -> a)
-> (u context -> b) -> HTheseTable t u context -> TheseTable a b
fromColumns2 Columns a (Col context) -> a
forall (context :: Context) a.
Table context a =>
Columns a (Col context) -> a
fromColumns Columns b (Col context) -> b
forall (context :: Context) a.
Table context a =>
Columns a (Col context) -> a
fromColumns
  reify :: (context :~: Reify ctx)
-> Unreify (TheseTable a b) -> TheseTable a b
reify = ((Unreify a -> a)
 -> (Unreify b -> b)
 -> TheseTable (Unreify a) (Unreify b)
 -> TheseTable a b)
-> ((context :~: Reify ctx) -> Unreify a -> a)
-> ((context :~: Reify ctx) -> Unreify b -> b)
-> (context :~: Reify ctx)
-> TheseTable (Unreify a) (Unreify b)
-> TheseTable a b
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (Unreify a -> a)
-> (Unreify b -> b)
-> TheseTable (Unreify a) (Unreify b)
-> TheseTable a b
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap (context :~: Reify ctx) -> Unreify a -> a
forall (context :: Context) a (ctx :: Context).
Table context a =>
(context :~: Reify ctx) -> Unreify a -> a
reify (context :~: Reify ctx) -> Unreify b -> b
forall (context :: Context) a (ctx :: Context).
Table context a =>
(context :~: Reify ctx) -> Unreify a -> a
reify
  unreify :: (context :~: Reify ctx)
-> TheseTable a b -> Unreify (TheseTable a b)
unreify = ((a -> Unreify a)
 -> (b -> Unreify b)
 -> TheseTable a b
 -> TheseTable (Unreify a) (Unreify b))
-> ((context :~: Reify ctx) -> a -> Unreify a)
-> ((context :~: Reify ctx) -> b -> Unreify b)
-> (context :~: Reify ctx)
-> TheseTable a b
-> TheseTable (Unreify a) (Unreify b)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (a -> Unreify a)
-> (b -> Unreify b)
-> TheseTable a b
-> TheseTable (Unreify a) (Unreify b)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap (context :~: Reify ctx) -> a -> Unreify a
forall (context :: Context) a (ctx :: Context).
Table context a =>
(context :~: Reify ctx) -> a -> Unreify a
unreify (context :~: Reify ctx) -> b -> Unreify b
forall (context :: Context) a (ctx :: Context).
Table context a =>
(context :~: Reify ctx) -> a -> Unreify a
unreify


instance
  ( Labelable from, Nullifiable from, ConstrainTag from MaybeTag
  , Labelable to, Nullifiable to, ConstrainTag to MaybeTag
  , Recontextualize from to a1 b1
  , Recontextualize from to a2 b2
  ) =>
  Recontextualize from to (TheseTable a1 a2) (TheseTable b1 b2)


instance (EqTable a, EqTable b) => EqTable (TheseTable a b) where
  eqTable :: Columns (TheseTable a b) (Dict (ConstrainDBType DBEq))
eqTable = (Columns a (Dict (ConstrainDBType DBEq))
 -> Columns a (Dict (ConstrainDBType DBEq)))
-> (Columns b (Dict (ConstrainDBType DBEq))
    -> Columns b (Dict (ConstrainDBType DBEq)))
-> TheseTable
     (Columns a (Dict (ConstrainDBType DBEq)))
     (Columns b (Dict (ConstrainDBType DBEq)))
-> HTheseTable
     (Columns a) (Columns b) (Dict (ConstrainDBType DBEq))
forall (t :: HTable) (u :: HTable) (context :: HContext) a b.
(HTable t, HTable u, HConstrainTag context MaybeTag,
 HLabelable context, HNullifiable context) =>
(a -> t context)
-> (b -> u context) -> TheseTable a b -> HTheseTable t u context
toColumns2 Columns a (Dict (ConstrainDBType DBEq))
-> Columns a (Dict (ConstrainDBType DBEq))
forall a. a -> a
id Columns b (Dict (ConstrainDBType DBEq))
-> Columns b (Dict (ConstrainDBType DBEq))
forall a. a -> a
id (Columns a (Dict (ConstrainDBType DBEq))
-> Columns b (Dict (ConstrainDBType DBEq))
-> TheseTable
     (Columns a (Dict (ConstrainDBType DBEq)))
     (Columns b (Dict (ConstrainDBType DBEq)))
forall a b. a -> b -> TheseTable a b
thoseTable (EqTable a => Columns a (Dict (ConstrainDBType DBEq))
forall a. EqTable a => Columns a (Dict (ConstrainDBType DBEq))
eqTable @a) (EqTable b => Columns b (Dict (ConstrainDBType DBEq))
forall a. EqTable a => Columns a (Dict (ConstrainDBType DBEq))
eqTable @b))


instance (OrdTable a, OrdTable b) => OrdTable (TheseTable a b) where
  ordTable :: Columns (TheseTable a b) (Dict (ConstrainDBType DBOrd))
ordTable = (Columns a (Dict (ConstrainDBType DBOrd))
 -> Columns a (Dict (ConstrainDBType DBOrd)))
-> (Columns b (Dict (ConstrainDBType DBOrd))
    -> Columns b (Dict (ConstrainDBType DBOrd)))
-> TheseTable
     (Columns a (Dict (ConstrainDBType DBOrd)))
     (Columns b (Dict (ConstrainDBType DBOrd)))
-> HTheseTable
     (Columns a) (Columns b) (Dict (ConstrainDBType DBOrd))
forall (t :: HTable) (u :: HTable) (context :: HContext) a b.
(HTable t, HTable u, HConstrainTag context MaybeTag,
 HLabelable context, HNullifiable context) =>
(a -> t context)
-> (b -> u context) -> TheseTable a b -> HTheseTable t u context
toColumns2 Columns a (Dict (ConstrainDBType DBOrd))
-> Columns a (Dict (ConstrainDBType DBOrd))
forall a. a -> a
id Columns b (Dict (ConstrainDBType DBOrd))
-> Columns b (Dict (ConstrainDBType DBOrd))
forall a. a -> a
id (Columns a (Dict (ConstrainDBType DBOrd))
-> Columns b (Dict (ConstrainDBType DBOrd))
-> TheseTable
     (Columns a (Dict (ConstrainDBType DBOrd)))
     (Columns b (Dict (ConstrainDBType DBOrd)))
forall a b. a -> b -> TheseTable a b
thoseTable (OrdTable a => Columns a (Dict (ConstrainDBType DBOrd))
forall a. OrdTable a => Columns a (Dict (ConstrainDBType DBOrd))
ordTable @a) (OrdTable b => Columns b (Dict (ConstrainDBType DBOrd))
forall a. OrdTable a => Columns a (Dict (ConstrainDBType DBOrd))
ordTable @b))


type instance FromExprs (TheseTable a b) = These (FromExprs a) (FromExprs b)


instance (ToExprs exprs1 a, ToExprs exprs2 b, x ~ TheseTable exprs1 exprs2) =>
  ToExprs x (These a b)
 where
  fromResult :: Columns x (Col Result) -> These a b
fromResult =
    (Columns exprs1 (Col Result) -> a)
-> (Columns exprs2 (Col Result) -> b)
-> These
     (Columns exprs1 (Col Result)) (Columns exprs2 (Col Result))
-> These a b
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap (forall a. ToExprs exprs1 a => Columns exprs1 (Col Result) -> a
forall exprs a. ToExprs exprs a => Columns exprs (Col Result) -> a
fromResult @exprs1) (forall a. ToExprs exprs2 a => Columns exprs2 (Col Result) -> a
forall exprs a. ToExprs exprs a => Columns exprs (Col Result) -> a
fromResult @exprs2) (These (Columns exprs1 (Col Result)) (Columns exprs2 (Col Result))
 -> These a b)
-> (HTheseTable (Columns exprs1) (Columns exprs2) (Col Result)
    -> These
         (Columns exprs1 (Col Result)) (Columns exprs2 (Col Result)))
-> HTheseTable (Columns exprs1) (Columns exprs2) (Col Result)
-> These a b
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    HTheseTable (Columns exprs1) (Columns exprs2) (Col Result)
-> These
     (Columns exprs1 (Col Result)) (Columns exprs2 (Col Result))
forall (context :: Context) a.
Table context a =>
Columns a (Col context) -> a
fromColumns
  toResult :: These a b -> Columns x (Col Result)
toResult =
    These (Columns exprs1 (Col Result)) (Columns exprs2 (Col Result))
-> HTheseTable (Columns exprs1) (Columns exprs2) (Col Result)
forall (context :: Context) a.
Table context a =>
a -> Columns a (Col context)
toColumns (These (Columns exprs1 (Col Result)) (Columns exprs2 (Col Result))
 -> HTheseTable (Columns exprs1) (Columns exprs2) (Col Result))
-> (These a b
    -> These
         (Columns exprs1 (Col Result)) (Columns exprs2 (Col Result)))
-> These a b
-> HTheseTable (Columns exprs1) (Columns exprs2) (Col Result)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    (a -> Columns exprs1 (Col Result))
-> (b -> Columns exprs2 (Col Result))
-> These a b
-> These
     (Columns exprs1 (Col Result)) (Columns exprs2 (Col Result))
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap (forall a. ToExprs exprs1 a => a -> Columns exprs1 (Col Result)
forall exprs a. ToExprs exprs a => a -> Columns exprs (Col Result)
toResult @exprs1) (forall a. ToExprs exprs2 a => a -> Columns exprs2 (Col Result)
forall exprs a. ToExprs exprs a => a -> Columns exprs (Col Result)
toResult @exprs2)


toHereTag :: Tag "isJust" a -> Tag "hasHere" a
toHereTag :: Tag "isJust" a -> Tag "hasHere" a
toHereTag Tag {Maybe Aggregator
Expr a
Name a
name :: forall (label :: Symbol) a. Tag label a -> Name a
aggregator :: forall (label :: Symbol) a. Tag label a -> Maybe Aggregator
expr :: forall (label :: Symbol) a. Tag label a -> Expr a
name :: Name a
aggregator :: Maybe Aggregator
expr :: Expr a
..} = Tag :: forall (label :: Symbol) a.
Expr a -> Maybe Aggregator -> Name a -> Tag label a
Tag {Maybe Aggregator
Expr a
Name a
name :: Name a
aggregator :: Maybe Aggregator
expr :: Expr a
name :: Name a
aggregator :: Maybe Aggregator
expr :: Expr a
..}


toThereTag :: Tag "isJust" a -> Tag "hasThere" a
toThereTag :: Tag "isJust" a -> Tag "hasThere" a
toThereTag Tag {Maybe Aggregator
Expr a
Name a
name :: Name a
aggregator :: Maybe Aggregator
expr :: Expr a
name :: forall (label :: Symbol) a. Tag label a -> Name a
aggregator :: forall (label :: Symbol) a. Tag label a -> Maybe Aggregator
expr :: forall (label :: Symbol) a. Tag label a -> Expr a
..} = Tag :: forall (label :: Symbol) a.
Expr a -> Maybe Aggregator -> Name a -> Tag label a
Tag {Maybe Aggregator
Expr a
Name a
name :: Name a
aggregator :: Maybe Aggregator
expr :: Expr a
name :: Name a
aggregator :: Maybe Aggregator
expr :: Expr a
..}


-- | Test if a 'TheseTable' was constructed with 'thisTable'.
--
-- Corresponds to 'Data.These.Combinators.isThis'.
isThisTable :: TheseTable a b -> Expr Bool
isThisTable :: TheseTable a b -> Expr Bool
isThisTable TheseTable a b
a = TheseTable a b -> Expr Bool
forall a b. TheseTable a b -> Expr Bool
hasHereTable TheseTable a b
a Expr Bool -> Expr Bool -> Expr Bool
&&. Expr Bool -> Expr Bool
not_ (TheseTable a b -> Expr Bool
forall a b. TheseTable a b -> Expr Bool
hasThereTable TheseTable a b
a)


-- | Test if a 'TheseTable' was constructed with 'thatTable'.
--
-- Corresponds to 'Data.These.Combinators.isThat'.
isThatTable :: TheseTable a b -> Expr Bool
isThatTable :: TheseTable a b -> Expr Bool
isThatTable TheseTable a b
a = Expr Bool -> Expr Bool
not_ (TheseTable a b -> Expr Bool
forall a b. TheseTable a b -> Expr Bool
hasHereTable TheseTable a b
a) Expr Bool -> Expr Bool -> Expr Bool
&&. TheseTable a b -> Expr Bool
forall a b. TheseTable a b -> Expr Bool
hasThereTable TheseTable a b
a


-- | Test if a 'TheseTable' was constructed with 'thoseTable'.
--
-- Corresponds to 'Data.These.Combinators.isThese'.
isThoseTable :: TheseTable a b -> Expr Bool
isThoseTable :: TheseTable a b -> Expr Bool
isThoseTable TheseTable a b
a = TheseTable a b -> Expr Bool
forall a b. TheseTable a b -> Expr Bool
hasHereTable TheseTable a b
a Expr Bool -> Expr Bool -> Expr Bool
&&. TheseTable a b -> Expr Bool
forall a b. TheseTable a b -> Expr Bool
hasThereTable TheseTable a b
a


-- | Test if the @a@ side of @TheseTable a b@ is present.
--
-- Corresponds to 'Data.These.Combinators.hasHere'.
hasHereTable :: TheseTable a b -> Expr Bool
hasHereTable :: TheseTable a b -> Expr Bool
hasHereTable TheseTable {MaybeTable a
here :: MaybeTable a
here :: forall a b. TheseTable a b -> MaybeTable a
here} = MaybeTable a -> Expr Bool
forall a. MaybeTable a -> Expr Bool
isJustTable MaybeTable a
here


-- | Test if the @b@ table of @TheseTable a b@ is present.
--
-- Corresponds to 'Data.These.Combinators.hasThere'.
hasThereTable :: TheseTable a b -> Expr Bool
hasThereTable :: TheseTable a b -> Expr Bool
hasThereTable TheseTable {MaybeTable b
there :: MaybeTable b
there :: forall a b. TheseTable a b -> MaybeTable b
there} = MaybeTable b -> Expr Bool
forall a. MaybeTable a -> Expr Bool
isJustTable MaybeTable b
there


-- | Attempt to project out the @a@ table of a @TheseTable a b@.
--
-- Corresponds to 'Data.These.Combinators.justHere'.
justHereTable :: TheseTable a b -> MaybeTable a
justHereTable :: TheseTable a b -> MaybeTable a
justHereTable = TheseTable a b -> MaybeTable a
forall a b. TheseTable a b -> MaybeTable a
here


-- | Attempt to project out the @b@ table of a @TheseTable a b@.
--
-- Corresponds to 'Data.These.Combinators.justThere'.
justThereTable :: TheseTable a b -> MaybeTable b
justThereTable :: TheseTable a b -> MaybeTable b
justThereTable = TheseTable a b -> MaybeTable b
forall a b. TheseTable a b -> MaybeTable b
there


-- | Construct a @TheseTable@. Corresponds to 'This'.
thisTable :: Table Expr b => a -> TheseTable a b
thisTable :: a -> TheseTable a b
thisTable a
a = MaybeTable a -> MaybeTable b -> TheseTable a b
forall a b. MaybeTable a -> MaybeTable b -> TheseTable a b
TheseTable (a -> MaybeTable a
forall a. a -> MaybeTable a
justTable a
a) MaybeTable b
forall a. Table Expr a => MaybeTable a
nothingTable


-- | Construct a @TheseTable@. Corresponds to 'That'.
thatTable :: Table Expr a => b -> TheseTable a b
thatTable :: b -> TheseTable a b
thatTable b
b = MaybeTable a -> MaybeTable b -> TheseTable a b
forall a b. MaybeTable a -> MaybeTable b -> TheseTable a b
TheseTable MaybeTable a
forall a. Table Expr a => MaybeTable a
nothingTable (b -> MaybeTable b
forall a. a -> MaybeTable a
justTable b
b)


-- | Construct a @TheseTable@. Corresponds to 'These'.
thoseTable :: a -> b -> TheseTable a b
thoseTable :: a -> b -> TheseTable a b
thoseTable a
a b
b = MaybeTable a -> MaybeTable b -> TheseTable a b
forall a b. MaybeTable a -> MaybeTable b -> TheseTable a b
TheseTable (a -> MaybeTable a
forall a. a -> MaybeTable a
justTable a
a) (b -> MaybeTable b
forall a. a -> MaybeTable a
justTable b
b)


-- | Pattern match on a 'TheseTable'. Corresponds to 'these'.
theseTable :: Table Expr c
  => (a -> c) -> (b -> c) -> (a -> b -> c) -> TheseTable a b -> c
theseTable :: (a -> c) -> (b -> c) -> (a -> b -> c) -> TheseTable a b -> c
theseTable a -> c
f b -> c
g a -> b -> c
h TheseTable {MaybeTable a
here :: MaybeTable a
here :: forall a b. TheseTable a b -> MaybeTable a
here, MaybeTable b
there :: MaybeTable b
there :: forall a b. TheseTable a b -> MaybeTable b
there} =
  c -> (b -> c) -> MaybeTable b -> c
forall b a. Table Expr b => b -> (a -> b) -> MaybeTable a -> b
maybeTable
    (c -> (a -> c) -> MaybeTable a -> c
forall b a. Table Expr b => b -> (a -> b) -> MaybeTable a -> b
maybeTable c
forall a. Table Expr a => a
undefined a -> c
f MaybeTable a
here)
    (\b
b -> c -> (a -> c) -> MaybeTable a -> c
forall b a. Table Expr b => b -> (a -> b) -> MaybeTable a -> b
maybeTable (b -> c
g b
b) (a -> b -> c
`h` b
b) MaybeTable a
here)
    MaybeTable b
there


-- | Construct a 'TheseTable' in the 'Name' context. This can be useful if you
-- have a 'TheseTable' that you are storing in a table and need to construct a
-- 'TableSchema'.
nameTheseTable :: ()
  => Name (Maybe MaybeTag)
     -- ^ The name of the column to track the presence of the @a@ table.
  -> Name (Maybe MaybeTag)
     -- ^ The name of the column to track the presence of the @b@ table.
  -> a
     -- ^ Names of the columns in the @a@ table.
  -> b
     -- ^ Names of the columns in the @b@ table.
  -> TheseTable a b
nameTheseTable :: Name (Maybe MaybeTag)
-> Name (Maybe MaybeTag) -> a -> b -> TheseTable a b
nameTheseTable Name (Maybe MaybeTag)
here Name (Maybe MaybeTag)
there a
a b
b =
  TheseTable :: forall a b. MaybeTable a -> MaybeTable b -> TheseTable a b
TheseTable
    { here :: MaybeTable a
here = Name (Maybe MaybeTag) -> a -> MaybeTable a
forall a. Name (Maybe MaybeTag) -> a -> MaybeTable a
nameMaybeTable Name (Maybe MaybeTag)
here a
a
    , there :: MaybeTable b
there = Name (Maybe MaybeTag) -> b -> MaybeTable b
forall a. Name (Maybe MaybeTag) -> a -> MaybeTable a
nameMaybeTable Name (Maybe MaybeTag)
there b
b
    }


toColumns2 ::
  ( HTable t
  , HTable u
  , HConstrainTag context MaybeTag
  , HLabelable context
  , HNullifiable context
  )
  => (a -> t context)
  -> (b -> u context)
  -> TheseTable a b
  -> HTheseTable t u context
toColumns2 :: (a -> t context)
-> (b -> u context) -> TheseTable a b -> HTheseTable t u context
toColumns2 a -> t context
f b -> u context
g TheseTable {MaybeTable a
here :: MaybeTable a
here :: forall a b. TheseTable a b -> MaybeTable a
here, MaybeTable b
there :: MaybeTable b
there :: forall a b. TheseTable a b -> MaybeTable b
there} = HTheseTable :: forall (here :: HTable) (there :: HTable) (context :: HContext).
HIdentity ('Spec '["hasHere"] (Maybe MaybeTag)) context
-> HLabel "Here" (HNullify here) context
-> HIdentity ('Spec '["hasThere"] (Maybe MaybeTag)) context
-> HLabel "There" (HNullify there) context
-> HTheseTable here there context
HTheseTable
  { hhereTag :: HIdentity ('Spec '["hasHere"] (Maybe MaybeTag)) context
hhereTag = context ('Spec '["hasHere"] (Maybe MaybeTag))
-> HIdentity ('Spec '["hasHere"] (Maybe MaybeTag)) context
forall (spec :: Spec) (context :: HContext).
context spec -> HIdentity spec context
HIdentity (context ('Spec '["hasHere"] (Maybe MaybeTag))
 -> HIdentity ('Spec '["hasHere"] (Maybe MaybeTag)) context)
-> context ('Spec '["hasHere"] (Maybe MaybeTag))
-> HIdentity ('Spec '["hasHere"] (Maybe MaybeTag)) context
forall a b. (a -> b) -> a -> b
$ Tag "hasHere" (Maybe MaybeTag)
-> context ('Spec '["hasHere"] (Maybe MaybeTag))
forall (context :: HContext) a (label :: Symbol)
       (labels :: Labels).
(HNullifiable context, Sql (HConstrainTag context) a,
 KnownSymbol label, Taggable a) =>
Tag label a -> context ('Spec labels a)
hencodeTag (Tag "isJust" (Maybe MaybeTag) -> Tag "hasHere" (Maybe MaybeTag)
forall a. Tag "isJust" a -> Tag "hasHere" a
toHereTag (MaybeTable a -> Tag "isJust" (Maybe MaybeTag)
forall a. MaybeTable a -> Tag "isJust" (Maybe MaybeTag)
tag MaybeTable a
here))
  , hhere :: HLabel "Here" (HNullify t) context
hhere =
      (forall (labels :: Labels) a.
 context ('Spec labels a) -> context ('Spec ("Here" : labels) a))
-> HNullify t context -> HLabel "Here" (HNullify t) context
forall (t :: HTable) (label :: Symbol) (context :: HContext).
(HTable t, KnownSymbol label) =>
(forall (labels :: Labels) a.
 context ('Spec labels a) -> context ('Spec (label : labels) a))
-> t context -> HLabel label t context
hlabel forall (labels :: Labels) a.
context ('Spec labels a) -> context ('Spec ("Here" : labels) a)
forall (context :: HContext) (labels :: Labels) a
       (label :: Symbol).
HLabelable context =>
context ('Spec labels a) -> context ('Spec (label : labels) a)
hlabeler (HNullify t context -> HLabel "Here" (HNullify t) context)
-> HNullify t context -> HLabel "Here" (HNullify t) context
forall a b. (a -> b) -> a -> b
$ (forall (labels :: Labels) a.
 SSpec ('Spec labels a)
 -> context ('Spec labels a) -> context ('Spec labels (Nullify a)))
-> t context -> HNullify t context
forall (t :: HTable) (context :: HContext).
HTable t =>
(forall (labels :: Labels) a.
 SSpec ('Spec labels a)
 -> context ('Spec labels a) -> context ('Spec labels (Nullify a)))
-> t context -> HNullify t context
hnullify (Tag "isJust" (Maybe MaybeTag)
-> (Expr (Maybe MaybeTag) -> Expr Bool)
-> SSpec ('Spec labels a)
-> context ('Spec labels a)
-> context ('Spec labels (Nullify a))
forall (context :: HContext) (label :: Symbol) a (labels :: Labels)
       x.
HNullifiable context =>
Tag label a
-> (Expr a -> Expr Bool)
-> SSpec ('Spec labels x)
-> context ('Spec labels x)
-> context ('Spec labels (Nullify x))
hnullifier (MaybeTable a -> Tag "isJust" (Maybe MaybeTag)
forall a. MaybeTable a -> Tag "isJust" (Maybe MaybeTag)
tag MaybeTable a
here) Expr (Maybe MaybeTag) -> Expr Bool
forall a. Expr (Maybe a) -> Expr Bool
isNonNull) (t context -> HNullify t context)
-> t context -> HNullify t context
forall a b. (a -> b) -> a -> b
$ a -> t context
f (MaybeTable a -> a
forall a. MaybeTable a -> a
just MaybeTable a
here)
  , hthereTag :: HIdentity ('Spec '["hasThere"] (Maybe MaybeTag)) context
hthereTag = context ('Spec '["hasThere"] (Maybe MaybeTag))
-> HIdentity ('Spec '["hasThere"] (Maybe MaybeTag)) context
forall (spec :: Spec) (context :: HContext).
context spec -> HIdentity spec context
HIdentity (context ('Spec '["hasThere"] (Maybe MaybeTag))
 -> HIdentity ('Spec '["hasThere"] (Maybe MaybeTag)) context)
-> context ('Spec '["hasThere"] (Maybe MaybeTag))
-> HIdentity ('Spec '["hasThere"] (Maybe MaybeTag)) context
forall a b. (a -> b) -> a -> b
$ Tag "hasThere" (Maybe MaybeTag)
-> context ('Spec '["hasThere"] (Maybe MaybeTag))
forall (context :: HContext) a (label :: Symbol)
       (labels :: Labels).
(HNullifiable context, Sql (HConstrainTag context) a,
 KnownSymbol label, Taggable a) =>
Tag label a -> context ('Spec labels a)
hencodeTag (Tag "isJust" (Maybe MaybeTag) -> Tag "hasThere" (Maybe MaybeTag)
forall a. Tag "isJust" a -> Tag "hasThere" a
toThereTag (MaybeTable b -> Tag "isJust" (Maybe MaybeTag)
forall a. MaybeTable a -> Tag "isJust" (Maybe MaybeTag)
tag MaybeTable b
there))
  , hthere :: HLabel "There" (HNullify u) context
hthere =
      (forall (labels :: Labels) a.
 context ('Spec labels a) -> context ('Spec ("There" : labels) a))
-> HNullify u context -> HLabel "There" (HNullify u) context
forall (t :: HTable) (label :: Symbol) (context :: HContext).
(HTable t, KnownSymbol label) =>
(forall (labels :: Labels) a.
 context ('Spec labels a) -> context ('Spec (label : labels) a))
-> t context -> HLabel label t context
hlabel forall (labels :: Labels) a.
context ('Spec labels a) -> context ('Spec ("There" : labels) a)
forall (context :: HContext) (labels :: Labels) a
       (label :: Symbol).
HLabelable context =>
context ('Spec labels a) -> context ('Spec (label : labels) a)
hlabeler (HNullify u context -> HLabel "There" (HNullify u) context)
-> HNullify u context -> HLabel "There" (HNullify u) context
forall a b. (a -> b) -> a -> b
$ (forall (labels :: Labels) a.
 SSpec ('Spec labels a)
 -> context ('Spec labels a) -> context ('Spec labels (Nullify a)))
-> u context -> HNullify u context
forall (t :: HTable) (context :: HContext).
HTable t =>
(forall (labels :: Labels) a.
 SSpec ('Spec labels a)
 -> context ('Spec labels a) -> context ('Spec labels (Nullify a)))
-> t context -> HNullify t context
hnullify (Tag "isJust" (Maybe MaybeTag)
-> (Expr (Maybe MaybeTag) -> Expr Bool)
-> SSpec ('Spec labels a)
-> context ('Spec labels a)
-> context ('Spec labels (Nullify a))
forall (context :: HContext) (label :: Symbol) a (labels :: Labels)
       x.
HNullifiable context =>
Tag label a
-> (Expr a -> Expr Bool)
-> SSpec ('Spec labels x)
-> context ('Spec labels x)
-> context ('Spec labels (Nullify x))
hnullifier (MaybeTable b -> Tag "isJust" (Maybe MaybeTag)
forall a. MaybeTable a -> Tag "isJust" (Maybe MaybeTag)
tag MaybeTable b
there) Expr (Maybe MaybeTag) -> Expr Bool
forall a. Expr (Maybe a) -> Expr Bool
isNonNull) (u context -> HNullify u context)
-> u context -> HNullify u context
forall a b. (a -> b) -> a -> b
$ b -> u context
g (MaybeTable b -> b
forall a. MaybeTable a -> a
just MaybeTable b
there)
  }


fromColumns2 ::
  ( HTable t
  , HTable u
  , HConstrainTag context MaybeTag
  , HLabelable context
  , HNullifiable context
  )
  => (t context -> a)
  -> (u context -> b)
  -> HTheseTable t u context
  -> TheseTable a b
fromColumns2 :: (t context -> a)
-> (u context -> b) -> HTheseTable t u context -> TheseTable a b
fromColumns2 t context -> a
f u context -> b
g HTheseTable {HIdentity ('Spec '["hasHere"] (Maybe MaybeTag)) context
hhereTag :: HIdentity ('Spec '["hasHere"] (Maybe MaybeTag)) context
hhereTag :: forall (here :: HTable) (there :: HTable) (context :: HContext).
HTheseTable here there context
-> HIdentity ('Spec '["hasHere"] (Maybe MaybeTag)) context
hhereTag, HLabel "Here" (HNullify t) context
hhere :: HLabel "Here" (HNullify t) context
hhere :: forall (here :: HTable) (there :: HTable) (context :: HContext).
HTheseTable here there context
-> HLabel "Here" (HNullify here) context
hhere, HIdentity ('Spec '["hasThere"] (Maybe MaybeTag)) context
hthereTag :: HIdentity ('Spec '["hasThere"] (Maybe MaybeTag)) context
hthereTag :: forall (here :: HTable) (there :: HTable) (context :: HContext).
HTheseTable here there context
-> HIdentity ('Spec '["hasThere"] (Maybe MaybeTag)) context
hthereTag, HLabel "There" (HNullify u) context
hthere :: HLabel "There" (HNullify u) context
hthere :: forall (here :: HTable) (there :: HTable) (context :: HContext).
HTheseTable here there context
-> HLabel "There" (HNullify there) context
hthere} = TheseTable :: forall a b. MaybeTable a -> MaybeTable b -> TheseTable a b
TheseTable
  { here :: MaybeTable a
here =
      let
        tag :: Tag "isJust" (Maybe MaybeTag)
tag = context ('Spec '["hasHere"] (Maybe MaybeTag))
-> Tag "isJust" (Maybe MaybeTag)
forall (context :: HContext) a (label :: Symbol)
       (labels :: Labels).
(HNullifiable context, Sql (HConstrainTag context) a,
 KnownSymbol label, Taggable a) =>
context ('Spec labels a) -> Tag label a
hdecodeTag (context ('Spec '["hasHere"] (Maybe MaybeTag))
 -> Tag "isJust" (Maybe MaybeTag))
-> context ('Spec '["hasHere"] (Maybe MaybeTag))
-> Tag "isJust" (Maybe MaybeTag)
forall a b. (a -> b) -> a -> b
$ HIdentity ('Spec '["hasHere"] (Maybe MaybeTag)) context
-> context ('Spec '["hasHere"] (Maybe MaybeTag))
forall (spec :: Spec) (context :: HContext).
HIdentity spec context -> context spec
unHIdentity HIdentity ('Spec '["hasHere"] (Maybe MaybeTag)) context
hhereTag
      in
        MaybeTable :: forall a. Tag "isJust" (Maybe MaybeTag) -> a -> MaybeTable a
MaybeTable
          { Tag "isJust" (Maybe MaybeTag)
tag :: Tag "isJust" (Maybe MaybeTag)
tag :: Tag "isJust" (Maybe MaybeTag)
tag
          , just :: a
just = t context -> a
f (t context -> a) -> t context -> a
forall a b. (a -> b) -> a -> b
$
              Identity (t context) -> t context
forall a. Identity a -> a
runIdentity (Identity (t context) -> t context)
-> Identity (t context) -> t context
forall a b. (a -> b) -> a -> b
$
              (forall (labels :: Labels) a.
 SSpec ('Spec labels a)
 -> context ('Spec labels (Nullify a))
 -> Identity (context ('Spec labels a)))
-> HNullify t context -> Identity (t context)
forall (t :: HTable) (m :: * -> *) (context :: HContext).
(HTable t, Apply m) =>
(forall (labels :: Labels) a.
 SSpec ('Spec labels a)
 -> context ('Spec labels (Nullify a))
 -> m (context ('Spec labels a)))
-> HNullify t context -> m (t context)
hunnullify (\SSpec ('Spec labels a)
a -> context ('Spec labels a) -> Identity (context ('Spec labels a))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (context ('Spec labels a) -> Identity (context ('Spec labels a)))
-> (context ('Spec labels (Nullify a)) -> context ('Spec labels a))
-> context ('Spec labels (Nullify a))
-> Identity (context ('Spec labels a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SSpec ('Spec labels a)
-> context ('Spec labels (Nullify a)) -> context ('Spec labels a)
forall (context :: HContext) (labels :: Labels) x.
HNullifiable context =>
SSpec ('Spec labels x)
-> context ('Spec labels (Nullify x)) -> context ('Spec labels x)
hunnullifier SSpec ('Spec labels a)
a) (HNullify t context -> Identity (t context))
-> HNullify t context -> Identity (t context)
forall a b. (a -> b) -> a -> b
$
              (forall (labels :: Labels) a.
 context ('Spec ("Here" : labels) a) -> context ('Spec labels a))
-> HLabel "Here" (HNullify t) context -> HNullify t context
forall (t :: HTable) (label :: Symbol) (context :: HContext).
(HTable t, KnownSymbol label) =>
(forall (labels :: Labels) a.
 context ('Spec (label : labels) a) -> context ('Spec labels a))
-> HLabel label t context -> t context
hunlabel forall (labels :: Labels) a.
context ('Spec ("Here" : labels) a) -> context ('Spec labels a)
forall (context :: HContext) (label :: Symbol) (labels :: Labels)
       a.
HLabelable context =>
context ('Spec (label : labels) a) -> context ('Spec labels a)
hunlabeler
              HLabel "Here" (HNullify t) context
hhere
          }
  , there :: MaybeTable b
there =
      let
        tag :: Tag "isJust" (Maybe MaybeTag)
tag = context ('Spec '["hasThere"] (Maybe MaybeTag))
-> Tag "isJust" (Maybe MaybeTag)
forall (context :: HContext) a (label :: Symbol)
       (labels :: Labels).
(HNullifiable context, Sql (HConstrainTag context) a,
 KnownSymbol label, Taggable a) =>
context ('Spec labels a) -> Tag label a
hdecodeTag (context ('Spec '["hasThere"] (Maybe MaybeTag))
 -> Tag "isJust" (Maybe MaybeTag))
-> context ('Spec '["hasThere"] (Maybe MaybeTag))
-> Tag "isJust" (Maybe MaybeTag)
forall a b. (a -> b) -> a -> b
$ HIdentity ('Spec '["hasThere"] (Maybe MaybeTag)) context
-> context ('Spec '["hasThere"] (Maybe MaybeTag))
forall (spec :: Spec) (context :: HContext).
HIdentity spec context -> context spec
unHIdentity HIdentity ('Spec '["hasThere"] (Maybe MaybeTag)) context
hthereTag
      in
        MaybeTable :: forall a. Tag "isJust" (Maybe MaybeTag) -> a -> MaybeTable a
MaybeTable
          { Tag "isJust" (Maybe MaybeTag)
tag :: Tag "isJust" (Maybe MaybeTag)
tag :: Tag "isJust" (Maybe MaybeTag)
tag
          , just :: b
just = u context -> b
g (u context -> b) -> u context -> b
forall a b. (a -> b) -> a -> b
$
              Identity (u context) -> u context
forall a. Identity a -> a
runIdentity (Identity (u context) -> u context)
-> Identity (u context) -> u context
forall a b. (a -> b) -> a -> b
$
              (forall (labels :: Labels) a.
 SSpec ('Spec labels a)
 -> context ('Spec labels (Nullify a))
 -> Identity (context ('Spec labels a)))
-> HNullify u context -> Identity (u context)
forall (t :: HTable) (m :: * -> *) (context :: HContext).
(HTable t, Apply m) =>
(forall (labels :: Labels) a.
 SSpec ('Spec labels a)
 -> context ('Spec labels (Nullify a))
 -> m (context ('Spec labels a)))
-> HNullify t context -> m (t context)
hunnullify (\SSpec ('Spec labels a)
a -> context ('Spec labels a) -> Identity (context ('Spec labels a))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (context ('Spec labels a) -> Identity (context ('Spec labels a)))
-> (context ('Spec labels (Nullify a)) -> context ('Spec labels a))
-> context ('Spec labels (Nullify a))
-> Identity (context ('Spec labels a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SSpec ('Spec labels a)
-> context ('Spec labels (Nullify a)) -> context ('Spec labels a)
forall (context :: HContext) (labels :: Labels) x.
HNullifiable context =>
SSpec ('Spec labels x)
-> context ('Spec labels (Nullify x)) -> context ('Spec labels x)
hunnullifier SSpec ('Spec labels a)
a) (HNullify u context -> Identity (u context))
-> HNullify u context -> Identity (u context)
forall a b. (a -> b) -> a -> b
$
              (forall (labels :: Labels) a.
 context ('Spec ("There" : labels) a) -> context ('Spec labels a))
-> HLabel "There" (HNullify u) context -> HNullify u context
forall (t :: HTable) (label :: Symbol) (context :: HContext).
(HTable t, KnownSymbol label) =>
(forall (labels :: Labels) a.
 context ('Spec (label : labels) a) -> context ('Spec labels a))
-> HLabel label t context -> t context
hunlabel forall (labels :: Labels) a.
context ('Spec ("There" : labels) a) -> context ('Spec labels a)
forall (context :: HContext) (label :: Symbol) (labels :: Labels)
       a.
HLabelable context =>
context ('Spec (label : labels) a) -> context ('Spec labels a)
hunlabeler
              HLabel "There" (HNullify u) context
hthere
          }
  }