Safe Haskell	None
Language	GHC2024

Napkin.Untyped.Monad

Synopsis

data RefStore = RefStore {
- feed :: NonEmpty Text
- blacklist :: Set Text
}
class HasRefStore s where
- refRepo :: Lens' s RefStore
letters :: [Char]
newRefStore :: RefStore
newRef :: forall {k} s m (a :: k). (HasRefStore s, MonadState s m) => m (Ref a)
newQState :: QState
data QState = QState {
- vars :: RefStore
- query :: Query
}
newtype Q a = Q {
- runQ :: State QState a
}
runQ :: Q a -> (a, Query)
mkQ :: Q a -> Query
evalQ :: Q c -> c
modQ :: Query -> Q a -> Query
asQuery :: Iso' (Q ()) Query
with_ :: Query -> Q (Ref Relation)
withQ_ :: Q a -> Q (Ref Relation)
withQ'_ :: Q a -> Q (Ref Relation, Query)
withQ :: Q a -> Q (Ref Relation, Query, a)
withQAs_ :: Ref Query -> Q a -> Q (Ref Table)
withAs_ :: Selected Query -> Q (Ref Table)
withAs_' :: Selected Query -> NonEmpty (Ref SExp) -> Q (Ref Table)
withOptionAs_ :: Bool -> Maybe (NonEmpty (Ref SExp)) -> Selected Query -> Q (Ref Table)
withRecursiveAs_ :: Selected Query -> Q (Ref Table)
withAsUnique :: Selected Query -> Q (Ref Table)
select_ :: SExp -> Q (Ref SExp)
selectAs_ :: Selected SExp -> Q (Ref SExp)
selectsAs_ :: [Selected SExp] -> Q [Ref SExp]
selectAs_' :: Alias SExp -> Q (Maybe (Ref SExp))
selectsAs_' :: [Alias SExp] -> Q [Maybe (Ref SExp)]
addComment :: Text -> Ref SExp -> Q (Ref SExp)
annotateJson :: ToJSON a => a -> Ref SExp -> Q (Ref SExp)
selectsGroupsAs_ :: [Selected SExp] -> Q ()
selectsGroupsAsRef_ :: [Selected SExp] -> Q ()
selectNonEmptyGroups :: [Selected SExp] -> Q ()
from_ :: Relation -> Q (Ref Relation)
fromIfNecessary :: Relation -> Q (Ref Relation)
fromSelected_ :: Selected Relation -> Q (Ref Relation)
fromAlias_ :: Alias Relation -> Q (Ref Relation)
fromRef_ :: Ref Relation -> Q (Ref Relation)
fromRel :: AsRelation r => r -> Q (Ref Relation)
fromSpecified :: Q Bool
fromOrJoin :: Alias Relation -> Either (Ref Relation -> Maybe SExp) [Ref SExp] -> Q (Ref Relation)
join_ :: JoinType -> Relation -> (Ref Relation -> Maybe SExp) -> Q (Ref Relation)
joinUsing_ :: JoinType -> Relation -> [Ref SExp] -> Q (Ref Relation)
joinRef_ :: JoinType -> Ref Relation -> (Ref Relation -> Maybe SExp) -> Q (Ref Relation)
joinSelected_ :: JoinType -> Selected Relation -> Either (Ref Relation -> Maybe SExp) [Ref SExp] -> Q (Ref Relation)
joinAlias_ :: JoinType -> Alias Relation -> Either (Ref Relation -> Maybe SExp) [Ref SExp] -> Q (Ref Relation)
joinOn_ :: JoinType -> Relation -> (Ref Relation -> SExp) -> Q (Ref Relation)
innerJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation)
crossJoin :: Relation -> Q (Ref Relation)
leftJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation)
rightJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation)
outerJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation)
having :: MonadState QState m => SExp -> m ()
havingL :: Applicative f => (Maybe SExp -> f (Maybe SExp)) -> QState -> f QState
where_ :: SExp -> Q ()
whereL :: (Maybe SExp -> Identity (Maybe SExp)) -> QState -> Identity QState
tableOperator_ :: ParensOperator -> Q ()
tableOperatorL :: (Maybe ParensOperator -> Identity (Maybe ParensOperator)) -> QState -> Identity QState
whereAdd :: MonadState QState m => SExp -> m ()
whereAddIn :: MonadState QState m => SExp -> [SExp] -> m ()
whereAddNotIn :: MonadState QState m => SExp -> [SExp] -> m ()
groupBy_ :: [SExp] -> Q ()
orderBy_ :: Order -> Q ()
limit_ :: MonadState QState m => Int -> m ()
offset_ :: MonadState QState m => Int -> m ()
mdef :: a -> Iso' (Maybe a) a
fromQuery :: Q a -> Relation
scopeRelation :: SExp -> Relation -> Relation
selectEverything :: [(Ref Relation, DefinedQuery)] -> Q ()
explicitSelectStarWith :: s -> Ref Relation -> Getting (Endo [Ref SExp]) s (Ref SExp) -> (Selected SExp -> Selected SExp) -> Q ()
explicitSelectStar :: HasDefinition s => s -> Ref Relation -> Q ()
explicitMapSelectStar :: HasDefinition s => s -> Ref Relation -> (Selected SExp -> Selected SExp) -> Q ()
selectStar :: Ref Relation -> Q (Ref Relation)
selectNonDuplicates :: Foldable t => t (Ref SExp) -> Q ()
mapSelectNonDuplicates :: Foldable t => t (Ref SExp) -> (Selected SExp -> Selected SExp) -> Q ()
union_ :: UnionType -> Query -> Query -> WithClauses -> Q ()
data UState = UState {
- vars :: RefStore
- query :: UpdateQuery
}
newtype U a = U {
- runU :: State UState a
}
mkU :: Alias (Ref Table) -> (Ref Relation -> U a) -> UpdateQuery
updateWhereAdd :: MonadState UState m => SExp -> m ()
updateJoin_ :: JoinType -> Relation -> (Ref Relation -> Maybe SExp) -> U (Ref Relation)
updateJoinOn_ :: JoinType -> Relation -> (Ref Relation -> SExp) -> U (Ref Relation)
updateInnerJoin_ :: Relation -> (Ref Relation -> SExp) -> U (Ref Relation)
updateSet_ :: Name -> SExp -> U ()
qsQuery :: Lens' QState Query
qsVars :: Lens' UState RefStore

Documentation

data RefStore #

Supply of fresh reference names to be used in monadic contexts where you need an infinite-ish supply.

Constructors

RefStore
Fields feed :: NonEmpty Text blacklist :: Set Text

Instances

Instances details

Data RefStore #

Instance details

Defined in Napkin.Untyped.Monad

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RefStore -> c RefStore #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RefStore #

toConstr :: RefStore -> Constr #

dataTypeOf :: RefStore -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RefStore) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RefStore) #

gmapT :: (forall b. Data b => b -> b) -> RefStore -> RefStore #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RefStore -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RefStore -> r #

gmapQ :: (forall d. Data d => d -> u) -> RefStore -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RefStore -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RefStore -> m RefStore #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RefStore -> m RefStore #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RefStore -> m RefStore #

Generic RefStore #

Instance details

Defined in Napkin.Untyped.Monad

Associated Types

type Rep RefStore

Instance details

Defined in Napkin.Untyped.Monad

type Rep RefStore = D1 ('MetaData "RefStore" "Napkin.Untyped.Monad" "napkin-spec-2.0.0-7NH5JHRFo7V8BQP5NCfMo1" 'False) (C1 ('MetaCons "RefStore" 'PrefixI 'True) (S1 ('MetaSel ('Just "feed") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty Text)) :*: S1 ('MetaSel ('Just "blacklist") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set Text))))

Methods

from :: RefStore -> Rep RefStore x #

to :: Rep RefStore x -> RefStore #

Show RefStore #

Instance details

Defined in Napkin.Untyped.Monad

Methods

showsPrec :: Int -> RefStore -> ShowS #

show :: RefStore -> String #

showList :: [RefStore] -> ShowS #

Eq RefStore #

Instance details

Defined in Napkin.Untyped.Monad

Methods

(==) :: RefStore -> RefStore -> Bool #

(/=) :: RefStore -> RefStore -> Bool #

Ord RefStore #

Instance details

Defined in Napkin.Untyped.Monad

Methods

compare :: RefStore -> RefStore -> Ordering #

(<) :: RefStore -> RefStore -> Bool #

(<=) :: RefStore -> RefStore -> Bool #

(>) :: RefStore -> RefStore -> Bool #

(>=) :: RefStore -> RefStore -> Bool #

max :: RefStore -> RefStore -> RefStore #

min :: RefStore -> RefStore -> RefStore #

HasRefStore RefStore #

Instance details

Defined in Napkin.Untyped.Monad

Methods

refRepo :: Lens' RefStore RefStore #

type Rep RefStore #

Instance details

Defined in Napkin.Untyped.Monad

type Rep RefStore = D1 ('MetaData "RefStore" "Napkin.Untyped.Monad" "napkin-spec-2.0.0-7NH5JHRFo7V8BQP5NCfMo1" 'False) (C1 ('MetaCons "RefStore" 'PrefixI 'True) (S1 ('MetaSel ('Just "feed") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty Text)) :*: S1 ('MetaSel ('Just "blacklist") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Set Text))))

class HasRefStore s where #

Methods

refRepo :: Lens' s RefStore #

Instances

Instances details

HasRefStore QState #
Instance details Defined in Napkin.Untyped.Monad Methods refRepo :: Lens' QState RefStore #
HasRefStore RefStore #
Instance details Defined in Napkin.Untyped.Monad Methods refRepo :: Lens' RefStore RefStore #
HasRefStore UState #
Instance details Defined in Napkin.Untyped.Monad Methods refRepo :: Lens' UState RefStore #

letters :: [Char] #

newRefStore :: RefStore #

newRef :: forall {k} s m (a :: k). (HasRefStore s, MonadState s m) => m (Ref a) #

newQState :: QState #

data QState #

Constructors

QState
Fields vars :: RefStore query :: Query

Instances

Instances details

Data QState #

Instance details

Defined in Napkin.Untyped.Monad

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QState -> c QState #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c QState #

toConstr :: QState -> Constr #

dataTypeOf :: QState -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c QState) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QState) #

gmapT :: (forall b. Data b => b -> b) -> QState -> QState #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QState -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QState -> r #

gmapQ :: (forall d. Data d => d -> u) -> QState -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QState -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QState -> m QState #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QState -> m QState #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QState -> m QState #

Generic QState #

Instance details

Defined in Napkin.Untyped.Monad

Associated Types

type Rep QState

Instance details

Defined in Napkin.Untyped.Monad

type Rep QState = D1 ('MetaData "QState" "Napkin.Untyped.Monad" "napkin-spec-2.0.0-7NH5JHRFo7V8BQP5NCfMo1" 'False) (C1 ('MetaCons "QState" 'PrefixI 'True) (S1 ('MetaSel ('Just "vars") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RefStore) :*: S1 ('MetaSel ('Just "query") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Query)))

Methods

from :: QState -> Rep QState x #

to :: Rep QState x -> QState #

Show QState #

Instance details

Defined in Napkin.Untyped.Monad

Methods

showsPrec :: Int -> QState -> ShowS #

show :: QState -> String #

showList :: [QState] -> ShowS #

Eq QState #

Instance details

Defined in Napkin.Untyped.Monad

Methods

(==) :: QState -> QState -> Bool #

(/=) :: QState -> QState -> Bool #

HasRefStore QState #

Instance details

Defined in Napkin.Untyped.Monad

Methods

refRepo :: Lens' QState RefStore #

MonadState QState Q #

Instance details

Defined in Napkin.Untyped.Monad

Methods

get :: Q QState #

put :: QState -> Q () #

state :: (QState -> (a, QState)) -> Q a #

type Rep QState #

Instance details

Defined in Napkin.Untyped.Monad

type Rep QState = D1 ('MetaData "QState" "Napkin.Untyped.Monad" "napkin-spec-2.0.0-7NH5JHRFo7V8BQP5NCfMo1" 'False) (C1 ('MetaCons "QState" 'PrefixI 'True) (S1 ('MetaSel ('Just "vars") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RefStore) :*: S1 ('MetaSel ('Just "query") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Query)))

newtype Q a #

Constructors

Q
Fields runQ :: State QState a

Instances

Instances details

Applicative Q #
Instance details Defined in Napkin.Untyped.Monad Methods pure :: a -> Q a # (<>) :: Q (a -> b) -> Q a -> Q b # liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c # (>) :: Q a -> Q b -> Q b # (<*) :: Q a -> Q b -> Q a #
Functor Q #
Instance details Defined in Napkin.Untyped.Monad Methods fmap :: (a -> b) -> Q a -> Q b # (<$) :: a -> Q b -> Q a #
Monad Q #
Instance details Defined in Napkin.Untyped.Monad Methods (>>=) :: Q a -> (a -> Q b) -> Q b # (>>) :: Q a -> Q b -> Q b # return :: a -> Q a #
MonadState QState Q #
Instance details Defined in Napkin.Untyped.Monad Methods get :: Q QState # put :: QState -> Q () # state :: (QState -> (a, QState)) -> Q a #
RenderSql Query backend => RenderSql (Q a) (backend :: k) #	Monadic query interface
Instance details Defined in Napkin.Render.Types Methods renderSql :: Proxy backend -> Q a -> ME Doc #
AsRelation (Q a) #
Instance details Defined in Napkin.Untyped.Monad Methods asRelation :: Q a -> Relation #
HasDefinition (Q ()) #
Instance details Defined in Napkin.Untyped.Monad Methods defQuery :: Lens (Q ()) (Q ()) Query Query #
MaybeQuery (Q ()) #
Instance details Defined in Napkin.Untyped.Monad Methods getQuery :: Q () -> Maybe Query #

runQ :: Q a -> (a, Query) #

mkQ :: Q a -> Query #

evalQ :: Q c -> c #

modQ :: Query -> Q a -> Query #

Alter a pre-existing Query monadically.

asQuery :: Iso' (Q ()) Query #

with_ :: Query -> Q (Ref Relation) #

withQ_ :: Q a -> Q (Ref Relation) #

Define a subquery using the WITH syntax. Note that this does not automatically include this table in a SELECT; you need to additionally include the resulting relation from withQ_ using the from_ operator.

withQ'_ :: Q a -> Q (Ref Relation, Query) #

Define a WITH subquery, returning the reference and the query.

withQ :: Q a -> Q (Ref Relation, Query, a) #

Define a WITH subquery, returning the reference, the query, and the result of running the Q block.

withQAs_ :: Ref Query -> Q a -> Q (Ref Table) #

withAs_ :: Selected Query -> Q (Ref Table) #

Define a WITH subquery while retaining and re-using its given name. Useful in some scenarios where you want to keep the original name in further referring to the newly introduced subquery table.

withAs_' :: Selected Query -> NonEmpty (Ref SExp) -> Q (Ref Table) #

withOptionAs_ :: Bool -> Maybe (NonEmpty (Ref SExp)) -> Selected Query -> Q (Ref Table) #

withRecursiveAs_ :: Selected Query -> Q (Ref Table) #

withAsUnique :: Selected Query -> Q (Ref Table) #

Use unique naming scheme along with Ref Relation to construct the WITH macro's name. This is useful when ensuring unique naming while not throwing out some human-readable information.

select_ :: SExp -> Q (Ref SExp) #

Smart selector that will use the variable's name if expression is a variable and assign a fresh variable name if it's something else without a name.

selectAs_ :: Selected SExp -> Q (Ref SExp) #

selectsAs_ :: [Selected SExp] -> Q [Ref SExp] #

selectAs_' :: Alias SExp -> Q (Maybe (Ref SExp)) #

Add optional aliasing to the Q.

selectsAs_' :: [Alias SExp] -> Q [Maybe (Ref SExp)] #

addComment :: Text -> Ref SExp -> Q (Ref SExp) #

annotateJson :: ToJSON a => a -> Ref SExp -> Q (Ref SExp) #

selectsGroupsAs_ :: [Selected SExp] -> Q () #

Select a field and also include it in GROUP BY. Do this intelligently, referring to it by its given name in most cases but by its direct expression definition in case of external functions to prevent overlap with fields that may already exist.

selectsGroupsAsRef_ :: [Selected SExp] -> Q () #

Like selectsGroupsAs_ but will use the name you gave to each field in the group by statement. Some backends like BigQuery require this while others like Redshift don't like it.

selectNonEmptyGroups :: [Selected SExp] -> Q () #

Special convenience case: Select and group while demanding that none of the group values is null.

from_ :: Relation -> Q (Ref Relation) #

fromIfNecessary :: Relation -> Q (Ref Relation) #

Add a from clause unless the relation is already in place.

fromSelected_ :: Selected Relation -> Q (Ref Relation) #

fromAlias_ :: Alias Relation -> Q (Ref Relation) #

fromRef_ :: Ref Relation -> Q (Ref Relation) #

Use a name directly and don't alias it one more time. | This can fail to create a proper alias if the Ref includes multiple names.

fromRel :: AsRelation r => r -> Q (Ref Relation) #

fromSpecified :: Q Bool #

Returns True iff the current Query already has an initial From table available.

fromOrJoin :: Alias Relation -> Either (Ref Relation -> Maybe SExp) [Ref SExp] -> Q (Ref Relation) #

join_ :: JoinType -> Relation -> (Ref Relation -> Maybe SExp) -> Q (Ref Relation) #

joinUsing_ :: JoinType -> Relation -> [Ref SExp] -> Q (Ref Relation) #

joinRef_ :: JoinType -> Ref Relation -> (Ref Relation -> Maybe SExp) -> Q (Ref Relation) #

joinSelected_ :: JoinType -> Selected Relation -> Either (Ref Relation -> Maybe SExp) [Ref SExp] -> Q (Ref Relation) #

joinAlias_ :: JoinType -> Alias Relation -> Either (Ref Relation -> Maybe SExp) [Ref SExp] -> Q (Ref Relation) #

joinOn_ :: JoinType -> Relation -> (Ref Relation -> SExp) -> Q (Ref Relation) #

innerJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation) #

crossJoin :: Relation -> Q (Ref Relation) #

leftJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation) #

rightJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation) #

outerJoin :: Relation -> (Ref Relation -> SExp) -> Q (Ref Relation) #

having :: MonadState QState m => SExp -> m () #

havingL :: Applicative f => (Maybe SExp -> f (Maybe SExp)) -> QState -> f QState #

where_ :: SExp -> Q () #

whereL :: (Maybe SExp -> Identity (Maybe SExp)) -> QState -> Identity QState #

tableOperator_ :: ParensOperator -> Q () #

tableOperatorL :: (Maybe ParensOperator -> Identity (Maybe ParensOperator)) -> QState -> Identity QState #

whereAdd :: MonadState QState m => SExp -> m () #

whereAddIn :: MonadState QState m => SExp -> [SExp] -> m () #

where x in y

whereAddNotIn :: MonadState QState m => SExp -> [SExp] -> m () #

where x not in y

groupBy_ :: [SExp] -> Q () #

orderBy_ :: Order -> Q () #

limit_ :: MonadState QState m => Int -> m () #

offset_ :: MonadState QState m => Int -> m () #

mdef :: a -> Iso' (Maybe a) a #

fromQuery :: Q a -> Relation #

Turn query into relation

scopeRelation :: SExp -> Relation -> Relation #

Make a query relation that applies predicate on the given relation in a subquery.

selectEverything :: [(Ref Relation, DefinedQuery)] -> Q () #

Introspects the given list of Queryies, along with their references in the current context, and selects every named field in them within the current context, while deduplicating repeat fields (by name). Good for the common case of joining tables and selecting everything possible in them.

explicitSelectStarWith #

Arguments

:: s	Object containing definitions
-> Ref Relation	Concrete reference within the context
-> Getting (Endo [Ref SExp]) s (Ref SExp)	Traversal to get field definitions from the object
-> (Selected SExp -> Selected SExp)	A function to modify the final selection
-> Q ()

explicitSelectStar :: HasDefinition s => s -> Ref Relation -> Q () #

Instead of doing a select * that's impossible to introspect, explicitly select all fields from something that contains a definition - e.g. a Query.

explicitMapSelectStar :: HasDefinition s => s -> Ref Relation -> (Selected SExp -> Selected SExp) -> Q () #

Instead of doing a select * that's impossible to introspect, explicitly select all fields from something that contains a definition - e.g. a Query.

selectStar :: Ref Relation -> Q (Ref Relation) #

select * from x

selectNonDuplicates :: Foldable t => t (Ref SExp) -> Q () #

Given a list of references, select those that have not yet been selected in current monadic block.

mapSelectNonDuplicates :: Foldable t => t (Ref SExp) -> (Selected SExp -> Selected SExp) -> Q () #

Given a list of references, select those that have not yet been selected in current monadic block with option to modify the finalized selection.

union_ :: UnionType -> Query -> Query -> WithClauses -> Q () #

data UState #

Constructors

UState
Fields vars :: RefStore query :: UpdateQuery

Instances

Instances details

Data UState #

Instance details

Defined in Napkin.Untyped.Monad

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UState -> c UState #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UState #

toConstr :: UState -> Constr #

dataTypeOf :: UState -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UState) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UState) #

gmapT :: (forall b. Data b => b -> b) -> UState -> UState #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UState -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UState -> r #

gmapQ :: (forall d. Data d => d -> u) -> UState -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UState -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UState -> m UState #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UState -> m UState #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UState -> m UState #

Generic UState #

Instance details

Defined in Napkin.Untyped.Monad

Associated Types

type Rep UState

Instance details

Defined in Napkin.Untyped.Monad

type Rep UState = D1 ('MetaData "UState" "Napkin.Untyped.Monad" "napkin-spec-2.0.0-7NH5JHRFo7V8BQP5NCfMo1" 'False) (C1 ('MetaCons "UState" 'PrefixI 'True) (S1 ('MetaSel ('Just "vars") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RefStore) :*: S1 ('MetaSel ('Just "query") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 UpdateQuery)))

Methods

from :: UState -> Rep UState x #

to :: Rep UState x -> UState #

Show UState #

Instance details

Defined in Napkin.Untyped.Monad

Methods

showsPrec :: Int -> UState -> ShowS #

show :: UState -> String #

showList :: [UState] -> ShowS #

Eq UState #

Instance details

Defined in Napkin.Untyped.Monad

Methods

(==) :: UState -> UState -> Bool #

(/=) :: UState -> UState -> Bool #

HasRefStore UState #

Instance details

Defined in Napkin.Untyped.Monad

Methods

refRepo :: Lens' UState RefStore #

MonadState UState U #

Instance details

Defined in Napkin.Untyped.Monad

Methods

get :: U UState #

put :: UState -> U () #

state :: (UState -> (a, UState)) -> U a #

type Rep UState #

Instance details

Defined in Napkin.Untyped.Monad

type Rep UState = D1 ('MetaData "UState" "Napkin.Untyped.Monad" "napkin-spec-2.0.0-7NH5JHRFo7V8BQP5NCfMo1" 'False) (C1 ('MetaCons "UState" 'PrefixI 'True) (S1 ('MetaSel ('Just "vars") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RefStore) :*: S1 ('MetaSel ('Just "query") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 UpdateQuery)))

newtype U a #

Constructors

U
Fields runU :: State UState a

Instances

Instances details

Applicative U #
Instance details Defined in Napkin.Untyped.Monad Methods pure :: a -> U a # (<>) :: U (a -> b) -> U a -> U b # liftA2 :: (a -> b -> c) -> U a -> U b -> U c # (>) :: U a -> U b -> U b # (<*) :: U a -> U b -> U a #
Functor U #
Instance details Defined in Napkin.Untyped.Monad Methods fmap :: (a -> b) -> U a -> U b # (<$) :: a -> U b -> U a #
Monad U #
Instance details Defined in Napkin.Untyped.Monad Methods (>>=) :: U a -> (a -> U b) -> U b # (>>) :: U a -> U b -> U b # return :: a -> U a #
MonadState UState U #
Instance details Defined in Napkin.Untyped.Monad Methods get :: U UState # put :: UState -> U () # state :: (UState -> (a, UState)) -> U a #

mkU :: Alias (Ref Table) -> (Ref Relation -> U a) -> UpdateQuery #

updateWhereAdd :: MonadState UState m => SExp -> m () #

updateJoin_ :: JoinType -> Relation -> (Ref Relation -> Maybe SExp) -> U (Ref Relation) #

updateJoinOn_ :: JoinType -> Relation -> (Ref Relation -> SExp) -> U (Ref Relation) #

updateInnerJoin_ :: Relation -> (Ref Relation -> SExp) -> U (Ref Relation) #

updateSet_ :: Name -> SExp -> U () #

qsQuery :: Lens' QState Query #

qsVars :: Lens' UState RefStore #