napkin-api
Safe HaskellNone
LanguageGHC2024

Napkin.Run.Effects

Synopsis

Documentation

module Napkin.Run.Effects.Languages.FatalError

getCurrentTime :: forall (effs :: EffectRow). Member (Time :: (Type -> Type) -> Type -> Type) effs => Sem effs UTCTime #

getAnnotations :: forall {k} (b :: k) (r :: EffectRow). Member (AnnotateRead b :: (Type -> Type) -> Type -> Type) r => Ref Table -> Sem r TableAnnotations #

getTargetAnnotations :: forall {k} (b :: k) (effs :: EffectRow). Members '[AnnotateRead b :: (Type -> Type) -> Type -> Type, Reader TargetName] effs => Sem effs TableAnnotations #

annotateColumn :: forall {k} (b :: k) (effs :: EffectRow). Member (AnnotateWrite b :: (Type -> Type) -> Type -> Type) effs => Ref Table -> Ref SExp -> Text -> Sem effs () #

annotateColumns :: forall {k} (b :: k) (r :: EffectRow). Member (AnnotateWrite b :: (Type -> Type) -> Type -> Type) r => Ref Table -> ColumnsAnnotations -> Sem r () #

annotateTable :: forall {k} (b :: k) (r :: EffectRow). Member (AnnotateWrite b :: (Type -> Type) -> Type -> Type) r => Ref Table -> Text -> Sem r () #

annotateTargetColumn :: forall {k} (b :: k) (effs :: EffectRow). Members '[AnnotateWrite b :: (Type -> Type) -> Type -> Type, Reader TargetName] effs => Ref SExp -> Text -> Sem effs () #

annotateTargetColumns :: forall {k} (b :: k) (effs :: EffectRow). Members '[AnnotateWrite b :: (Type -> Type) -> Type -> Type, Reader TargetName] effs => ColumnsAnnotations -> Sem effs () #

annotateTargetTable :: forall {k} (b :: k) (effs :: EffectRow). Members '[AnnotateWrite b :: (Type -> Type) -> Type -> Type, Reader TargetName] effs => Text -> Sem effs () #

pattern FailureWithMessage :: Text -> AssertionStatus #

assert :: forall (r :: EffectRow). Member (Assertion :: (Type -> Type) -> Type -> Type) r => Text -> AssertionStatus -> Sem r () #

assert' :: forall (r :: EffectRow). Member (Assertion :: (Type -> Type) -> Type -> Type) r => AssertionGroup -> AssertionSeverity -> Text -> AssertionStatus -> Sem r () #

Assertions are run-time checks based on actual results that may be returned by various operations. Dry runs may ignore these failures, but they're respected in real operations.

assertEquals :: forall a (r :: EffectRow). (Eq a, Member (Assertion :: (Type -> Type) -> Type -> Type) r) => Text -> a -> a -> Sem r () #

assertError :: forall (r :: EffectRow). Member (Assertion :: (Type -> Type) -> Type -> Type) r => Text -> Sem ((Error Text :: (Type -> Type) -> Type -> Type) ': r) () -> Sem r () #

assertM :: forall (r :: EffectRow). Member (Assertion :: (Type -> Type) -> Type -> Type) r => Text -> Sem r AssertionStatus -> Sem r () #

assertTrue :: forall (r :: EffectRow). Member (Assertion :: (Type -> Type) -> Type -> Type) r => Text -> Bool -> Sem r () #

assertTrueWith :: forall (r :: EffectRow). Member (Assertion :: (Type -> Type) -> Type -> Type) r => Text -> Bool -> Text -> Sem r () #

assertTrueWithM :: forall (r :: EffectRow). Member (Assertion :: (Type -> Type) -> Type -> Type) r => Text -> Bool -> Sem r Text -> Sem r () #

describe :: forall (r :: EffectRow) a. Members '[Assertion :: (Type -> Type) -> Type -> Type, Log :: (Type -> Type) -> Type -> Type] r => Text -> Sem r a -> Sem r a #

describe' :: forall (r :: EffectRow) a. Members '[Assertion :: (Type -> Type) -> Type -> Type, Log :: (Type -> Type) -> Type -> Type] r => [Text] -> Sem r a -> Sem r a #

failedAssertion :: forall (r :: EffectRow). Member (Assertion :: (Type -> Type) -> Type -> Type) r => Text -> Sem r () #

warnOnly :: forall (r :: EffectRow) a. Member (Assertion :: (Type -> Type) -> Type -> Type) r => Sem r a -> Sem r a #

executeExternalCommand :: forall (effs :: EffectRow). Members '[FatalError :: (Type -> Type) -> Type -> Type, External :: (Type -> Type) -> Type -> Type] effs => ExternalCommand -> Sem effs () #

loadQueryFromFile :: forall (r :: EffectRow). Member (LoadQuery :: (Type -> Type) -> Type -> Type) r => FilePath -> SqlTemplateVariables -> Sem r (Either LoadQueryError Text) #

loadSqlFile :: forall (r :: EffectRow). Members '[SqlParse :: (Type -> Type) -> Type -> Type, LoadQuery :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type] r => FilePath -> SqlTemplateVariables -> Sem r Query #

logAlert :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LText -> Sem effs () #

logAlert' :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LogItem -> LText -> Sem effs () #

logCritical :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LText -> Sem effs () #

logCritical' :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LogItem -> LText -> Sem effs () #

logDebug :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LText -> Sem effs () #

logDebug' :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LogItem -> LText -> Sem effs () #

logEmergency :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LText -> Sem effs () #

logEmergency' :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LogItem -> LText -> Sem effs () #

logError :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LText -> Sem effs () #

logError' :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LogItem -> LText -> Sem effs () #

logInfo :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LText -> Sem effs () #

logInfo' :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LogItem -> LText -> Sem effs () #

logNotice :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LText -> Sem effs () #

logNotice' :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LogItem -> LText -> Sem effs () #

logWarning :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LText -> Sem effs () #

logWarning' :: forall (effs :: EffectRow). Member (Log :: (Type -> Type) -> Type -> Type) effs => LogItem -> LText -> Sem effs () #

recreateMaterializedViewAs :: forall b (r :: EffectRow). Member (RecreateTable b :: (Type -> Type) -> Type -> Type) r => BackendMaterializedViewMeta b -> Ref Table -> Query -> Sem r () #

recreateTableAs :: forall b (r :: EffectRow). Member (RecreateTable b :: (Type -> Type) -> Type -> Type) r => BackendTableMeta b -> Ref Table -> NonEmpty Query -> Sem r () #

recreateTableStatement :: forall b (effs :: EffectRow). Members '[RecreateTable b :: (Type -> Type) -> Type -> Type, Reader TargetName] effs => BackendTableMeta b -> CreateTableDDL -> [InsertStatement] -> Sem effs () #

recreateTargetMaterializedView :: forall b (effs :: EffectRow). Members '[RecreateTable b :: (Type -> Type) -> Type -> Type, Reader TargetName] effs => BackendMaterializedViewMeta b -> Query -> Sem effs () #

recreateTargetTable :: forall b (effs :: EffectRow). Members '[RecreateTable b :: (Type -> Type) -> Type -> Type, Reader TargetName] effs => BackendTableMeta b -> NonEmpty Query -> Sem effs () #

recreateTargetView :: forall b (effs :: EffectRow). Members '[RecreateTable b :: (Type -> Type) -> Type -> Type, Reader TargetName] effs => BackendViewMeta b -> Query -> Sem effs () #

recreateViewAs :: forall b (r :: EffectRow). Member (RecreateTable b :: (Type -> Type) -> Type -> Type) r => BackendViewMeta b -> Ref Table -> Query -> Sem r () #

overrideDialect :: forall (r :: EffectRow) a. Member (Reader SQLDialect) r => SQLDialect -> Sem r a -> Sem r a #

parseSqlExp :: forall (r :: EffectRow). Members '[SqlParse :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type] r => SourceLocation -> Text -> Sem r SExp #

parseSqlQuery :: forall (r :: EffectRow). Members '[SqlParse :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type] r => SourceLocation -> Text -> Sem r Query #

parseStatements :: forall (r :: EffectRow) a. (Members '[SqlParse :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type] r, Stateable a) => TargetName -> SourceLocation -> Text -> Sem r [a] #

checkTableExists :: forall {k} (b :: k) (r :: EffectRow). Member (SqlRead b :: (Type -> Type) -> Type -> Type) r => Ref Table -> Sem r Bool #

getRelationSchema :: forall {k} (b :: k) (r :: EffectRow). Members '[SqlRead b :: (Type -> Type) -> Type -> Type, Input TemporaryTableName :: (Type -> Type) -> Type -> Type] r => Relation -> Sem r [BackendSchemaField b] #

getTableKind :: forall {k} (b :: k) (r :: EffectRow). Member (SqlRead b :: (Type -> Type) -> Type -> Type) r => Ref Table -> Sem r TableKind #

runQuery :: forall {k} (b :: k) (r :: EffectRow). Member (SqlRead b :: (Type -> Type) -> Type -> Type) r => Query -> Sem r [Map Text Value] #

runQuerySingleAnswer :: forall {k} (b :: k) a (r :: EffectRow). (Member (SqlRead b :: (Type -> Type) -> Type -> Type) r, Val a) => Query -> Sem r (Maybe a) #

Run a query and pull out the first column from its first row. Meant for queries that return a single result.

renderQuery :: forall (r :: EffectRow). Member (SqlRender :: (Type -> Type) -> Type -> Type) r => Query -> Sem r SqlText #

renderSExp :: forall (r :: EffectRow). Member (SqlRender :: (Type -> Type) -> Type -> Type) r => SExp -> Sem r SqlText #

addColumn :: forall b (r :: EffectRow). Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r => Ref Table -> Text -> Type -> Sem r () #

copyTable :: forall b (r :: EffectRow). Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r => Ref Table -> Ref Table -> TableWriteStrategy -> Sem r () #

copyTableToTarget :: forall b (r :: EffectRow). Members '[Reader TargetName, SqlWrite b :: (Type -> Type) -> Type -> Type] r => Ref Table -> TableWriteStrategy -> Sem r () #

createMaterializedViewAs :: forall b (r :: EffectRow). (Default (BackendMaterializedViewMeta b), Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r) => Ref Table -> Query -> Sem r () #

createMaterializedViewAsWithMeta :: forall b (r :: EffectRow). Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r => BackendMaterializedViewMeta b -> Ref Table -> Query -> Sem r () #

createTableAs :: forall b (r :: EffectRow). (Default (BackendTableMeta b), Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r) => Ref Table -> Query -> Sem r () #

createTableAsWithMeta :: forall b (r :: EffectRow). Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r => BackendTableMeta b -> Ref Table -> Query -> Sem r () #

createViewAs :: forall b (r :: EffectRow). (Default (BackendViewMeta b), Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r) => Ref Table -> Query -> Sem r () #

createViewAsWithMeta :: forall b (r :: EffectRow). Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r => BackendViewMeta b -> Ref Table -> Query -> Sem r () #

deleteFrom :: forall b (r :: EffectRow). Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r => Ref Table -> SExp -> Sem r () #

dropColumn :: forall b (r :: EffectRow). Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r => Ref Table -> Text -> Sem r () #

dropMaterializedView :: forall b (r :: EffectRow). Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r => Ref Table -> MissingBehavior -> Cascade -> Sem r () #

dropTable :: forall b (r :: EffectRow). Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r => Ref Table -> MissingBehavior -> Cascade -> Sem r () #

dropView :: forall b (r :: EffectRow). Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r => Ref Table -> MissingBehavior -> Cascade -> Sem r () #

insertInto :: forall b (r :: EffectRow). Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r => Ref Table -> InsertColumnsList -> Query -> Sem r () #

renameTable :: forall b (r :: EffectRow). Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r => Ref Table -> Ref Table -> Sem r () #

updateTable :: forall b (r :: EffectRow). Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r => UpdateQuery -> Sem r () #

addDependencies :: forall (r :: EffectRow). Member (Output ExtraDependencies :: (Type -> Type) -> Type -> Type) r => Set (Ref Table) -> Sem r () #

Add the given references to list of dependencies for the underlying region.

Later during interpretation, this will cause the given dependencies to be forcefully considered upstream dependencies within the enclosed region even though they were not seen in the parsed SQL.

addDependency :: forall (r :: EffectRow). Member (Output ExtraDependencies :: (Type -> Type) -> Type -> Type) r => Ref Table -> Sem r () #

Add the given reference to list of dependency for the underlying region.

Later during interpretation, this will cause the given dependency to be forcefully considered upstream dependency within the enclosed region even though they were not seen in the parsed SQL.

applyTransformer :: forall (r :: EffectRow) a. Member (Reader QueryTransformer) r => QueryTransformerUnit -> Sem r a -> Sem r a #

Comprehensively apply the given transformer around the given region.

deleteFromTarget :: forall b (effs :: EffectRow). Members '[SqlWrite b :: (Type -> Type) -> Type -> Type, Reader TargetName] effs => SExp -> Sem effs () #

hideArtifact :: forall a (r :: EffectRow). Member (Reader HiddenArtifacts) r => Ref Table -> Sem r a -> Sem r a #

Add the given artifact to the hide list around the given region.

Later during interpretation, this will cause the given artifact to not be reported to the tablespec within the enclosed region.

hideDependencies :: forall a (r :: EffectRow). Member (Reader HiddenDependencies) r => Set (Ref Table) -> Sem r a -> Sem r a #

Add the given dependencies to the hide list around the given region.

Later during interpretation, this will cause the given dependencies to not be considered upstream dependencies within the enclosed region.

hideDependency :: forall a (r :: EffectRow). Member (Reader HiddenDependencies) r => Ref Table -> Sem r a -> Sem r a #

Add the given dependency to the hide list around the given region.

Later during interpretation, this will cause the given dependency to not be considered upstream dependency within the enclosed region.

insertQueryIntoTarget :: forall b (effs :: EffectRow). Members '[SqlWrite b :: (Type -> Type) -> Type -> Type, Reader TargetName] effs => Query -> Sem effs () #

overrideTarget :: forall a (r :: EffectRow). Member (Reader TargetName) r => Ref Table -> Sem r a -> Sem r a #

renameReferences :: forall (r :: EffectRow) a. Member (Reader QueryTransformer) r => (Ref Table -> Ref Table) -> Sem r a -> Sem r a #

Apply given table name renamer to every single reference occurrence everywhere.

If you want to target only certain tables, make sure the function you provide here does the filtering internally.

updateTarget :: forall b (effs :: EffectRow). Members '[SqlWrite b :: (Type -> Type) -> Type -> Type, Reader TargetName] effs => (Ref Relation -> U ()) -> Sem effs () #

askArg :: forall a (r :: EffectRow). (FromJSON a, Members '[Input MetaArguments :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type, Log :: (Type -> Type) -> Type -> Type] r) => Text -> Sem r a #

askArgMb :: forall a (r :: EffectRow). (FromJSON a, Members '[Input MetaArguments :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type, Log :: (Type -> Type) -> Type -> Type] r) => Text -> Sem r (Maybe a) #

askBoolArg :: forall (r :: EffectRow). Members '[Input MetaArguments :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type, Log :: (Type -> Type) -> Type -> Type] r => Text -> Sem r Bool #

askBoolArgDefault :: forall (r :: EffectRow). Members '[Input MetaArguments :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type, Log :: (Type -> Type) -> Type -> Type] r => Bool -> Text -> Sem r Bool #

askBoolArgMb :: forall (r :: EffectRow). Members '[Input MetaArguments :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type, Log :: (Type -> Type) -> Type -> Type] r => Text -> Sem r (Maybe Bool) #

askNumArg :: forall (r :: EffectRow). Members '[Input MetaArguments :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type, Log :: (Type -> Type) -> Type -> Type] r => Text -> Sem r Scientific #

askNumArgDefault :: forall (r :: EffectRow). Members '[Input MetaArguments :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type, Log :: (Type -> Type) -> Type -> Type] r => Scientific -> Text -> Sem r Scientific #

askNumArgMb :: forall (r :: EffectRow). Members '[Input MetaArguments :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type, Log :: (Type -> Type) -> Type -> Type] r => Text -> Sem r (Maybe Scientific) #

askTextArg :: forall (r :: EffectRow). Members '[Input MetaArguments :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type, Log :: (Type -> Type) -> Type -> Type] r => Text -> Sem r Text #

askTextArgDefault :: forall (r :: EffectRow). Members '[Input MetaArguments :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type, Log :: (Type -> Type) -> Type -> Type] r => Text -> Text -> Sem r Text #

askTextArgMb :: forall (r :: EffectRow). Members '[Input MetaArguments :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type, Log :: (Type -> Type) -> Type -> Type] r => Text -> Sem r (Maybe Text) #

withTypedArg :: forall a b (r :: EffectRow). (FromJSON a, Members '[Input MetaArguments :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type] r, Typeable a) => (a -> Sem r b) -> Sem r b #

parserlessHook :: HookProgram b -> HookProgramWithArgParser b #

parserlessSpec :: SpecProgram b -> SpecProgramWithArgParser b #

parserlessPreprocessor :: SpecPreprocessor b -> SpecPreprocessorWithArgParser b #

announceMetaArguments :: SpecProgramArguments -> b -> (SpecProgramArguments, b) #

noMetaArguments :: b -> (SpecProgramArguments, b) #

optionalArg :: SpecProgramArgumentDescription -> SpecProgramArgumentDefinition #

requiredArg :: SpecProgramArgumentDescription -> SpecProgramArgumentDefinition #

requiredArgDef :: ToJSON a => a -> SpecProgramArgumentDescription -> SpecProgramArgumentDefinition #

newtype RandomToken #

Constructors

RandomToken 

Fields

type Time = Input UTCTime :: k1 -> Type -> Type #

data SQLDialect #

Constructors

NapkinSQL SimpleSQLParserDialect 
PostgreSQL 
SimpleSQLParser SimpleSQLParserDialect 
RawSQL 

Instances

Instances details
FromJSON SQLDialect # 
Instance details

Defined in Napkin.Parse.Base

Methods

parseJSON :: Value -> Parser SQLDialect #

parseJSONList :: Value -> Parser [SQLDialect] #

omittedField :: Maybe SQLDialect #

Show SQLDialect # 
Instance details

Defined in Napkin.Parse.Base

Methods

showsPrec :: Int -> SQLDialect -> ShowS #

show :: SQLDialect -> String #

showList :: [SQLDialect] -> ShowS #

Eq SQLDialect # 
Instance details

Defined in Napkin.Parse.Base

Methods

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

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

data AnnotateRead (b :: k) (m :: k1) a #

Instances

Instances details
ToDumpItem (b :: k) (AnnotateRead b :: (Type -> Type) -> Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Interceptors.LogProgram.Types

Methods

toDumpItem :: forall (r :: EffectRow) x. AnnotateRead b (Sem r) x -> DumpItem b #

GShow (AnnotateRead bk a :: Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Languages.AnnotateRead

Methods

gshowsPrec :: Int -> AnnotateRead bk a a0 -> ShowS #

Show (AnnotateRead bk a b) # 
Instance details

Defined in Napkin.Run.Effects.Languages.AnnotateRead

Methods

showsPrec :: Int -> AnnotateRead bk a b -> ShowS #

show :: AnnotateRead bk a b -> String #

showList :: [AnnotateRead bk a b] -> ShowS #

Eq (AnnotateRead bk a b) # 
Instance details

Defined in Napkin.Run.Effects.Languages.AnnotateRead

Methods

(==) :: AnnotateRead bk a b -> AnnotateRead bk a b -> Bool #

(/=) :: AnnotateRead bk a b -> AnnotateRead bk a b -> Bool #

data TableAnnotations #

Constructors

TableAnnotations 

Fields

Instances

Instances details
Generic TableAnnotations # 
Instance details

Defined in Napkin.Run.Effects.Languages.AnnotateRead

Associated Types

type Rep TableAnnotations 
Instance details

Defined in Napkin.Run.Effects.Languages.AnnotateRead

type Rep TableAnnotations = D1 ('MetaData "TableAnnotations" "Napkin.Run.Effects.Languages.AnnotateRead" "napkin-spec-2.0.0-3eiQvLVwprjIPwzzdqIJoX" 'False) (C1 ('MetaCons "TableAnnotations" 'PrefixI 'True) (S1 ('MetaSel ('Just "tableAnnotation") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Text)) :*: S1 ('MetaSel ('Just "columnsAnnotations") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ColumnsAnnotations)))

Methods

from :: TableAnnotations -> Rep TableAnnotations x #

to :: Rep TableAnnotations x -> TableAnnotations #

type Rep TableAnnotations # 
Instance details

Defined in Napkin.Run.Effects.Languages.AnnotateRead

type Rep TableAnnotations = D1 ('MetaData "TableAnnotations" "Napkin.Run.Effects.Languages.AnnotateRead" "napkin-spec-2.0.0-3eiQvLVwprjIPwzzdqIJoX" 'False) (C1 ('MetaCons "TableAnnotations" 'PrefixI 'True) (S1 ('MetaSel ('Just "tableAnnotation") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Text)) :*: S1 ('MetaSel ('Just "columnsAnnotations") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ColumnsAnnotations)))

data AnnotateWrite (b :: k) (m :: k1) a #

Instances

Instances details
ToDumpItem (b :: k) (AnnotateWrite b :: (Type -> Type) -> Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Interceptors.LogProgram.Types

Methods

toDumpItem :: forall (r :: EffectRow) x. AnnotateWrite b (Sem r) x -> DumpItem b #

GShow (AnnotateWrite bk a :: Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Languages.AnnotateWrite

Methods

gshowsPrec :: Int -> AnnotateWrite bk a a0 -> ShowS #

Show (AnnotateWrite bk a b) # 
Instance details

Defined in Napkin.Run.Effects.Languages.AnnotateWrite

Methods

showsPrec :: Int -> AnnotateWrite bk a b -> ShowS #

show :: AnnotateWrite bk a b -> String #

showList :: [AnnotateWrite bk a b] -> ShowS #

Eq (AnnotateWrite bk a b) # 
Instance details

Defined in Napkin.Run.Effects.Languages.AnnotateWrite

Methods

(==) :: AnnotateWrite bk a b -> AnnotateWrite bk a b -> Bool #

(/=) :: AnnotateWrite bk a b -> AnnotateWrite bk a b -> Bool #

data Assertion (m :: k) a #

Assertion effects so we can skip past them in dry runs, and optionally throw exceptions or just collect them along the way for final reporting, etc..

Instances

Instances details
ToDumpItem (b :: k) (Assertion :: (Type -> Type) -> Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Interceptors.LogProgram.Types

Methods

toDumpItem :: forall (r :: EffectRow) x. Assertion (Sem r) x -> DumpItem b #

GShow (Assertion a :: Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Languages.Assertion

Methods

gshowsPrec :: Int -> Assertion a a0 -> ShowS #

Show (Assertion a b) # 
Instance details

Defined in Napkin.Run.Effects.Languages.Assertion

Methods

showsPrec :: Int -> Assertion a b -> ShowS #

show :: Assertion a b -> String #

showList :: [Assertion a b] -> ShowS #

Eq (Assertion a b) # 
Instance details

Defined in Napkin.Run.Effects.Languages.Assertion

Methods

(==) :: Assertion a b -> Assertion a b -> Bool #

(/=) :: Assertion a b -> Assertion a b -> Bool #

data AssertionStatus #

Constructors

Success 
Failure (Maybe Text) 

Instances

Instances details
ToJSON AssertionStatus # 
Instance details

Defined in Napkin.Run.Effects.Languages.Assertion

Methods

toJSON :: AssertionStatus -> Value #

toEncoding :: AssertionStatus -> Encoding #

toJSONList :: [AssertionStatus] -> Value #

toEncodingList :: [AssertionStatus] -> Encoding #

omitField :: AssertionStatus -> Bool #

Generic AssertionStatus # 
Instance details

Defined in Napkin.Run.Effects.Languages.Assertion

Associated Types

type Rep AssertionStatus 
Instance details

Defined in Napkin.Run.Effects.Languages.Assertion

type Rep AssertionStatus = D1 ('MetaData "AssertionStatus" "Napkin.Run.Effects.Languages.Assertion" "napkin-spec-2.0.0-3eiQvLVwprjIPwzzdqIJoX" 'False) (C1 ('MetaCons "Success" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Failure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Text))))

Methods

from :: AssertionStatus -> Rep AssertionStatus x #

to :: Rep AssertionStatus x -> AssertionStatus #

Show AssertionStatus # 
Instance details

Defined in Napkin.Run.Effects.Languages.Assertion

Methods

showsPrec :: Int -> AssertionStatus -> ShowS #

show :: AssertionStatus -> String #

showList :: [AssertionStatus] -> ShowS #

Eq AssertionStatus # 
Instance details

Defined in Napkin.Run.Effects.Languages.Assertion

Methods

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

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

type Rep AssertionStatus # 
Instance details

Defined in Napkin.Run.Effects.Languages.Assertion

type Rep AssertionStatus = D1 ('MetaData "AssertionStatus" "Napkin.Run.Effects.Languages.Assertion" "napkin-spec-2.0.0-3eiQvLVwprjIPwzzdqIJoX" 'False) (C1 ('MetaCons "Success" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Failure" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Text))))

data External (m :: k) a #

Instances

Instances details
ToDumpItem (b :: k) (External :: (Type -> Type) -> Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Interceptors.LogProgram.Types

Methods

toDumpItem :: forall (r :: EffectRow) x. External (Sem r) x -> DumpItem b #

GEq (External a :: Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Languages.External

Methods

geq :: External a a0 -> External a b -> Maybe (a0 :~: b) #

GShow (External t :: Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Languages.External

Methods

gshowsPrec :: Int -> External t a -> ShowS #

Show (External m a) # 
Instance details

Defined in Napkin.Run.Effects.Languages.External

Methods

showsPrec :: Int -> External m a -> ShowS #

show :: External m a -> String #

showList :: [External m a] -> ShowS #

Eq (External m a) # 
Instance details

Defined in Napkin.Run.Effects.Languages.External

Methods

(==) :: External m a -> External m a -> Bool #

(/=) :: External m a -> External m a -> Bool #

data LoadQuery (m :: k) a #

Effects that deal with local files

Instances

Instances details
CacheableEffect (LoadQuery :: k -> Type -> Type) LoadQueryCacheKey # 
Instance details

Defined in Napkin.Run.Effects.Languages.LoadQuery

Methods

cacheKey :: Proxy LoadQueryCacheKey #

Eq (LoadQuery m a) # 
Instance details

Defined in Napkin.Run.Effects.Languages.LoadQuery

Methods

(==) :: LoadQuery m a -> LoadQuery m a -> Bool #

(/=) :: LoadQuery m a -> LoadQuery m a -> Bool #

Ord (LoadQuery m a) # 
Instance details

Defined in Napkin.Run.Effects.Languages.LoadQuery

Methods

compare :: LoadQuery m a -> LoadQuery m a -> Ordering #

(<) :: LoadQuery m a -> LoadQuery m a -> Bool #

(<=) :: LoadQuery m a -> LoadQuery m a -> Bool #

(>) :: LoadQuery m a -> LoadQuery m a -> Bool #

(>=) :: LoadQuery m a -> LoadQuery m a -> Bool #

max :: LoadQuery m a -> LoadQuery m a -> LoadQuery m a #

min :: LoadQuery m a -> LoadQuery m a -> LoadQuery m a #

newtype LoadQueryError #

Constructors

LoadQueryError Text 

Instances

Instances details
Show LoadQueryError # 
Instance details

Defined in Napkin.Run.Effects.Languages.LoadQuery

Methods

showsPrec :: Int -> LoadQueryError -> ShowS #

show :: LoadQueryError -> String #

showList :: [LoadQueryError] -> ShowS #

Eq LoadQueryError # 
Instance details

Defined in Napkin.Run.Effects.Languages.LoadQuery

Methods

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

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

type Log = Output LogLine :: k -> Type -> Type #

data RecreateTable b (m :: k) a #

Instances

Instances details
(Show (BackendMaterializedViewMeta b), Show (BackendTableMeta b), Show (BackendViewMeta b)) => GShow (RecreateTable b a :: Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Languages.Recreate

Methods

gshowsPrec :: Int -> RecreateTable b a a0 -> ShowS #

(Show (BackendMaterializedViewMeta b), Show (BackendTableMeta b), Show (BackendViewMeta b)) => Show (RecreateTable b a c) # 
Instance details

Defined in Napkin.Run.Effects.Languages.Recreate

Methods

showsPrec :: Int -> RecreateTable b a c -> ShowS #

show :: RecreateTable b a c -> String #

showList :: [RecreateTable b a c] -> ShowS #

data SqlParse (m :: k) a #

Instances

Instances details
GShow (SqlParse a :: Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlParse

Methods

gshowsPrec :: Int -> SqlParse a a0 -> ShowS #

CacheableEffect (SqlParse :: k -> Type -> Type) SqlParseCacheKey # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlParse

Methods

cacheKey :: Proxy SqlParseCacheKey #

Show (SqlParse m a) # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlParse

Methods

showsPrec :: Int -> SqlParse m a -> ShowS #

show :: SqlParse m a -> String #

showList :: [SqlParse m a] -> ShowS #

Eq (SqlParse m a) # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlParse

Methods

(==) :: SqlParse m a -> SqlParse m a -> Bool #

(/=) :: SqlParse m a -> SqlParse m a -> Bool #

Ord (SqlParse m a) # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlParse

Methods

compare :: SqlParse m a -> SqlParse m a -> Ordering #

(<) :: SqlParse m a -> SqlParse m a -> Bool #

(<=) :: SqlParse m a -> SqlParse m a -> Bool #

(>) :: SqlParse m a -> SqlParse m a -> Bool #

(>=) :: SqlParse m a -> SqlParse m a -> Bool #

max :: SqlParse m a -> SqlParse m a -> SqlParse m a #

min :: SqlParse m a -> SqlParse m a -> SqlParse m a #

newtype TargetName #

Constructors

TargetName (Ref Table) 

data SqlRead (b :: k) (m :: k1) a #

Instances

Instances details
(IsRenderable Query b, IsRenderable SExp b, IsRenderable Text b) => ToDumpItem (b :: k) (SqlRead b :: (Type -> Type) -> Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Interceptors.LogProgram.Types

Methods

toDumpItem :: forall (r :: EffectRow) x. SqlRead b (Sem r) x -> DumpItem b #

GShow (SqlRead b m :: Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlRead

Methods

gshowsPrec :: Int -> SqlRead b m a -> ShowS #

Show (SqlRead b m a) # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlRead

Methods

showsPrec :: Int -> SqlRead b m a -> ShowS #

show :: SqlRead b m a -> String #

showList :: [SqlRead b m a] -> ShowS #

Eq (SqlRead b m a) # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlRead

Methods

(==) :: SqlRead b m a -> SqlRead b m a -> Bool #

(/=) :: SqlRead b m a -> SqlRead b m a -> Bool #

data SqlRender (m :: k) a #

Instances

Instances details
GShow (SqlRender a :: Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlRender

Methods

gshowsPrec :: Int -> SqlRender a a0 -> ShowS #

CacheableEffect (SqlRender :: k -> Type -> Type) SqlRenderCacheKey # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlRender

Methods

cacheKey :: Proxy SqlRenderCacheKey #

Show (SqlRender a b) # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlRender

Methods

showsPrec :: Int -> SqlRender a b -> ShowS #

show :: SqlRender a b -> String #

showList :: [SqlRender a b] -> ShowS #

Eq (SqlRender m a) # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlRender

Methods

(==) :: SqlRender m a -> SqlRender m a -> Bool #

(/=) :: SqlRender m a -> SqlRender m a -> Bool #

Ord (SqlRender m a) # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlRender

Methods

compare :: SqlRender m a -> SqlRender m a -> Ordering #

(<) :: SqlRender m a -> SqlRender m a -> Bool #

(<=) :: SqlRender m a -> SqlRender m a -> Bool #

(>) :: SqlRender m a -> SqlRender m a -> Bool #

(>=) :: SqlRender m a -> SqlRender m a -> Bool #

max :: SqlRender m a -> SqlRender m a -> SqlRender m a #

min :: SqlRender m a -> SqlRender m a -> SqlRender m a #

data Cascade #

Constructors

Cascade 
Restrict 

Instances

Instances details
Data Cascade # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlWrite

Methods

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

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

toConstr :: Cascade -> Constr #

dataTypeOf :: Cascade -> DataType #

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

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

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

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

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

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

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

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

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

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

Generic Cascade # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlWrite

Associated Types

type Rep Cascade 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlWrite

type Rep Cascade = D1 ('MetaData "Cascade" "Napkin.Run.Effects.Languages.SqlWrite" "napkin-spec-2.0.0-3eiQvLVwprjIPwzzdqIJoX" 'False) (C1 ('MetaCons "Cascade" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Restrict" 'PrefixI 'False) (U1 :: Type -> Type))

Methods

from :: Cascade -> Rep Cascade x #

to :: Rep Cascade x -> Cascade #

Show Cascade # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlWrite

Methods

showsPrec :: Int -> Cascade -> ShowS #

show :: Cascade -> String #

showList :: [Cascade] -> ShowS #

Eq Cascade # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlWrite

Methods

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

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

ToHashComponent (b :: k) Cascade # 
Instance details

Defined in Napkin.Run.Effects.Interceptors.LogProgram.Types

Methods

toHashComponent :: Cascade -> HashComponent #

type Rep Cascade # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlWrite

type Rep Cascade = D1 ('MetaData "Cascade" "Napkin.Run.Effects.Languages.SqlWrite" "napkin-spec-2.0.0-3eiQvLVwprjIPwzzdqIJoX" 'False) (C1 ('MetaCons "Cascade" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Restrict" 'PrefixI 'False) (U1 :: Type -> Type))

data MissingBehavior #

Constructors

IgnoreMissing 
FailMissing 

Instances

Instances details
Data MissingBehavior # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlWrite

Methods

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

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

toConstr :: MissingBehavior -> Constr #

dataTypeOf :: MissingBehavior -> DataType #

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

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

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

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

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

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

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

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

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

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

Generic MissingBehavior # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlWrite

Associated Types

type Rep MissingBehavior 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlWrite

type Rep MissingBehavior = D1 ('MetaData "MissingBehavior" "Napkin.Run.Effects.Languages.SqlWrite" "napkin-spec-2.0.0-3eiQvLVwprjIPwzzdqIJoX" 'False) (C1 ('MetaCons "IgnoreMissing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FailMissing" 'PrefixI 'False) (U1 :: Type -> Type))

Methods

from :: MissingBehavior -> Rep MissingBehavior x #

to :: Rep MissingBehavior x -> MissingBehavior #

Show MissingBehavior # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlWrite

Methods

showsPrec :: Int -> MissingBehavior -> ShowS #

show :: MissingBehavior -> String #

showList :: [MissingBehavior] -> ShowS #

Eq MissingBehavior # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlWrite

Methods

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

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

ToHashComponent (b :: k) MissingBehavior # 
Instance details

Defined in Napkin.Run.Effects.Interceptors.LogProgram.Types

Methods

toHashComponent :: MissingBehavior -> HashComponent #

type Rep MissingBehavior # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlWrite

type Rep MissingBehavior = D1 ('MetaData "MissingBehavior" "Napkin.Run.Effects.Languages.SqlWrite" "napkin-spec-2.0.0-3eiQvLVwprjIPwzzdqIJoX" 'False) (C1 ('MetaCons "IgnoreMissing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FailMissing" 'PrefixI 'False) (U1 :: Type -> Type))

data SqlWrite b (m :: k) a #

Instances

Instances details
(Default (BackendTableMeta b), Default (BackendViewMeta b), Eq (BackendMaterializedViewMeta b), Eq (BackendTableMeta b), Eq (BackendViewMeta b), Eq (YamlBackendMaterializedViewMeta b), IsRenderable Query b, IsRenderable SExp b, IsRenderable Statement b, IsRenderable Text b, IsRenderable UpdateQuery b, MaybeDefault (YamlBackendMaterializedViewMeta b), Show (BackendMaterializedViewMeta b), Show (BackendTableMeta b), Show (BackendViewMeta b), ToHashComponent b (BackendMaterializedViewMeta b), ToHashComponent b (BackendTableMeta b), ToHashComponent b (BackendViewMeta b), Typeable (BackendMaterializedViewMeta b), Typeable (BackendTableMeta b), Typeable (BackendViewMeta b)) => ToDumpItem (b :: Type) (SqlWrite b :: (Type -> Type) -> Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Interceptors.LogProgram.Types

Methods

toDumpItem :: forall (r :: EffectRow) x. SqlWrite b (Sem r) x -> DumpItem b #

(Show (BackendMaterializedViewMeta bk), Show (BackendTableMeta bk), Show (BackendViewMeta bk)) => GShow (SqlWrite bk a :: Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlWrite

Methods

gshowsPrec :: Int -> SqlWrite bk a a0 -> ShowS #

(Show (BackendMaterializedViewMeta bk), Show (BackendTableMeta bk), Show (BackendViewMeta bk)) => Show (SqlWrite bk a b) # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlWrite

Methods

showsPrec :: Int -> SqlWrite bk a b -> ShowS #

show :: SqlWrite bk a b -> String #

showList :: [SqlWrite bk a b] -> ShowS #

(Eq (BackendMaterializedViewMeta bk), Eq (BackendTableMeta bk), Eq (BackendViewMeta bk)) => Eq (SqlWrite bk a b) # 
Instance details

Defined in Napkin.Run.Effects.Languages.SqlWrite

Methods

(==) :: SqlWrite bk a b -> SqlWrite bk a b -> Bool #

(/=) :: SqlWrite bk a b -> SqlWrite bk a b -> Bool #

newtype ExtraDependencies #

Constructors

ExtraDependencies (Set (Ref Table)) 

Instances

Instances details
Default ExtraDependencies # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

def :: ExtraDependencies #

Monoid ExtraDependencies # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

mempty :: ExtraDependencies #

mappend :: ExtraDependencies -> ExtraDependencies -> ExtraDependencies #

mconcat :: [ExtraDependencies] -> ExtraDependencies #

Semigroup ExtraDependencies # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

(<>) :: ExtraDependencies -> ExtraDependencies -> ExtraDependencies #

sconcat :: NonEmpty ExtraDependencies -> ExtraDependencies #

stimes :: Integral b => b -> ExtraDependencies -> ExtraDependencies #

IsList ExtraDependencies # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Associated Types

type Item ExtraDependencies 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

type Item ExtraDependencies = Item (Set (Ref Table))

Methods

fromList :: [Item ExtraDependencies] -> ExtraDependencies #

fromListN :: Int -> [Item ExtraDependencies] -> ExtraDependencies #

toList :: ExtraDependencies -> [Item ExtraDependencies] #

Show ExtraDependencies # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

showsPrec :: Int -> ExtraDependencies -> ShowS #

show :: ExtraDependencies -> String #

showList :: [ExtraDependencies] -> ShowS #

Eq ExtraDependencies # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

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

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

type Item ExtraDependencies # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

type Item ExtraDependencies = Item (Set (Ref Table))

newtype HiddenArtifacts #

Constructors

HiddenArtifacts (Set (Ref Table)) 

Instances

Instances details
Default HiddenArtifacts # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

def :: HiddenArtifacts #

Monoid HiddenArtifacts # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

mempty :: HiddenArtifacts #

mappend :: HiddenArtifacts -> HiddenArtifacts -> HiddenArtifacts #

mconcat :: [HiddenArtifacts] -> HiddenArtifacts #

Semigroup HiddenArtifacts # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

(<>) :: HiddenArtifacts -> HiddenArtifacts -> HiddenArtifacts #

sconcat :: NonEmpty HiddenArtifacts -> HiddenArtifacts #

stimes :: Integral b => b -> HiddenArtifacts -> HiddenArtifacts #

IsList HiddenArtifacts # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Associated Types

type Item HiddenArtifacts 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

type Item HiddenArtifacts = Item (Set (Ref Table))

Methods

fromList :: [Item HiddenArtifacts] -> HiddenArtifacts #

fromListN :: Int -> [Item HiddenArtifacts] -> HiddenArtifacts #

toList :: HiddenArtifacts -> [Item HiddenArtifacts] #

Show HiddenArtifacts # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

showsPrec :: Int -> HiddenArtifacts -> ShowS #

show :: HiddenArtifacts -> String #

showList :: [HiddenArtifacts] -> ShowS #

Eq HiddenArtifacts # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

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

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

type Item HiddenArtifacts # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

type Item HiddenArtifacts = Item (Set (Ref Table))

newtype HiddenDependencies #

Constructors

HiddenDependencies (Set (Ref Table)) 

Instances

Instances details
Default HiddenDependencies # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

def :: HiddenDependencies #

Monoid HiddenDependencies # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

mempty :: HiddenDependencies #

mappend :: HiddenDependencies -> HiddenDependencies -> HiddenDependencies #

mconcat :: [HiddenDependencies] -> HiddenDependencies #

Semigroup HiddenDependencies # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

(<>) :: HiddenDependencies -> HiddenDependencies -> HiddenDependencies #

sconcat :: NonEmpty HiddenDependencies -> HiddenDependencies #

stimes :: Integral b => b -> HiddenDependencies -> HiddenDependencies #

IsList HiddenDependencies # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Associated Types

type Item HiddenDependencies 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

type Item HiddenDependencies = Item (Set (Ref Table))

Methods

fromList :: [Item HiddenDependencies] -> HiddenDependencies #

fromListN :: Int -> [Item HiddenDependencies] -> HiddenDependencies #

toList :: HiddenDependencies -> [Item HiddenDependencies] #

Show HiddenDependencies # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

showsPrec :: Int -> HiddenDependencies -> ShowS #

show :: HiddenDependencies -> String #

showList :: [HiddenDependencies] -> ShowS #

Eq HiddenDependencies # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

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

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

type Item HiddenDependencies # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

type Item HiddenDependencies = Item (Set (Ref Table))

newtype MetaArguments #

Constructors

MetaArguments 

Fields

Instances

Instances details
Monoid MetaArguments # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

mempty :: MetaArguments #

mappend :: MetaArguments -> MetaArguments -> MetaArguments #

mconcat :: [MetaArguments] -> MetaArguments #

Semigroup MetaArguments # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

(<>) :: MetaArguments -> MetaArguments -> MetaArguments #

sconcat :: NonEmpty MetaArguments -> MetaArguments #

stimes :: Integral b => b -> MetaArguments -> MetaArguments #

IsList MetaArguments # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Associated Types

type Item MetaArguments 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

type Item MetaArguments = Item (Map Text Value)

Methods

fromList :: [Item MetaArguments] -> MetaArguments #

fromListN :: Int -> [Item MetaArguments] -> MetaArguments #

toList :: MetaArguments -> [Item MetaArguments] #

Show MetaArguments # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

showsPrec :: Int -> MetaArguments -> ShowS #

show :: MetaArguments -> String #

showList :: [MetaArguments] -> ShowS #

Eq MetaArguments # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

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

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

type Item MetaArguments # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

type Item MetaArguments = Item (Map Text Value)

newtype TableMemo #

Constructors

TableMemo [Value] 

Instances

Instances details
ToJSON TableMemo # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

toJSON :: TableMemo -> Value #

toEncoding :: TableMemo -> Encoding #

toJSONList :: [TableMemo] -> Value #

toEncodingList :: [TableMemo] -> Encoding #

omitField :: TableMemo -> Bool #

Monoid TableMemo # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

mempty :: TableMemo #

mappend :: TableMemo -> TableMemo -> TableMemo #

mconcat :: [TableMemo] -> TableMemo #

Semigroup TableMemo # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

(<>) :: TableMemo -> TableMemo -> TableMemo #

sconcat :: NonEmpty TableMemo -> TableMemo #

stimes :: Integral b => b -> TableMemo -> TableMemo #

Show TableMemo # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

showsPrec :: Int -> TableMemo -> ShowS #

show :: TableMemo -> String #

showList :: [TableMemo] -> ShowS #

Eq TableMemo # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

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

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

ToDumpItem (b :: k) (Output TableMemo :: (Type -> Type) -> Type -> Type) # 
Instance details

Defined in Napkin.Run.Effects.Interceptors.LogProgram.Types

Methods

toDumpItem :: forall (r :: EffectRow) x. Output TableMemo (Sem r) x -> DumpItem b #

newtype TableMemos #

Constructors

TableMemos (Map SpecTableName TableMemo) 

Instances

Instances details
Monoid TableMemos # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

mempty :: TableMemos #

mappend :: TableMemos -> TableMemos -> TableMemos #

mconcat :: [TableMemos] -> TableMemos #

Semigroup TableMemos # 
Instance details

Defined in Napkin.Run.Effects.Languages.TableSpec

Methods

(<>) :: TableMemos -> TableMemos -> TableMemos #

sconcat :: NonEmpty TableMemos -> TableMemos #

stimes :: Integral b => b -> TableMemos -> TableMemos #

ToDumpItem (b :: k) (Reader TableMemos) # 
Instance details

Defined in Napkin.Run.Effects.Interceptors.LogProgram.Types

Methods

toDumpItem :: forall (r :: EffectRow) x. Reader TableMemos (Sem r) x -> DumpItem b #

type HookProgram b = HookProgram' b () #

Hooks have different capabilities than specs

type HookProgram' b a = Sem (TableHookProgramEffects b) a #

Programs packaged up for use in Specs. Intended for use in providing introspectable CustomCreate actions in specs.

newtype HookProgramWithArgParser b #

Constructors

HookProgramWithArgParser (Object -> Parser (SpecProgramArguments, HookProgram b)) 

type IOGlobalHookProgram b = IOGlobalHookProgram' b () #

type IOGlobalHookProgram' b a = Sem (IOGlobalHookProgramEffects b) a #

type PureGlobalHookProgram b = PureGlobalHookProgram' b () #

type PureGlobalHookProgram' b a = Sem (PureGlobalHookProgramEffects b) a #

class RunBackendEffect b where #

Minimal complete definition

runBackendEffectReal, runBackendEffectFake, interceptBackendEffectDiscoverDependencies, interceptBackendEffectApplyQueryTransformer

Methods

runBackendEffectReal :: forall (m :: Type -> Type) (r :: EffectRow) a. (LocalQueryStats b m, Members '[FatalError :: (Type -> Type) -> Type -> Type, Embed m] r, MonadNapkin b m, SqlIO m) => BackendConn b -> Sem (BackendSpecificEffect b ': r) a -> Sem r a #

runBackendEffectFake :: forall (r :: EffectRow) a. Members '[Reader HiddenDependencies, State IState :: (Type -> Type) -> Type -> Type, FatalError :: (Type -> Type) -> Type -> Type] r => Sem (BackendSpecificEffect b ': r) a -> Sem r a #

interceptBackendEffectDiscoverDependencies :: forall (r :: EffectRow) a. Members '[Input (Transformed HiddenDependencies) :: (Type -> Type) -> Type -> Type, Output Dependencies :: (Type -> Type) -> Type -> Type, BackendSpecificEffect b] r => Sem r a -> Sem r a #

interceptBackendEffectApplyQueryTransformer :: forall (r :: EffectRow) a. Members '[Output ExtraDependencies :: (Type -> Type) -> Type -> Type, Reader QueryTransformer, BackendSpecificEffect b] r => Sem r a -> Sem r a #

backendDependencyValidator :: Proxy b -> [(SpecDependency -> Ref Table) -> SpecsDepsTables -> [WithSpecTable Text]] #

default backendDependencyValidator :: Proxy b -> [(SpecDependency -> Ref Table) -> SpecsDepsTables -> [WithSpecTable Text]] #

type SpecProgram b = SpecProgram' b () #

type SpecProgram' b a = Sem (SpecProgramEffects b) a #

newtype SpecProgramWithArgParser b #

Constructors

SpecProgramWithArgParser (Object -> Parser (SpecProgramArguments, SpecProgram b)) 

newtype SpecPreprocessorWithArgParser b #

Constructors

SpecPreprocessorWithArgParser (Object -> Parser (SpecProgramArguments, SpecPreprocessor b)) 

type family Members (es :: [Effect]) (r :: EffectRow) where ... #

Makes constraints of functions that use multiple effects shorter by translating single list of effects into multiple Member constraints:

foo :: Members '[ Output Int
                , Output Bool
                , State String
                ] r
    => Sem r ()

translates into:

foo :: ( Member (Output Int) r
       , Member (Output Bool) r
       , Member (State String) r
       )
    => Sem r ()

Since: polysemy-0.1.2.0

Equations

Members ('[] :: [Effect]) r = () 
Members (e ': es) r = (Member e r, Members es r) 

data Sem (r :: EffectRow) a #

The Sem monad handles computations of arbitrary extensible effects. A value of type Sem r describes a program with the capabilities of r. For best results, r should always be kept polymorphic, but you can add capabilities via the Member constraint.

The value of the Sem monad is that it allows you to write programs against a set of effects without a predefined meaning, and provide that meaning later. For example, unlike with mtl, you can decide to interpret an Error effect traditionally as an Either, or instead as (a significantly faster) IO Exception. These interpretations (and others that you might add) may be used interchangeably without needing to write any newtypes or Monad instances. The only change needed to swap interpretations is to change a call from runError to errorToIOFinal.

The effect stack r can contain arbitrary other monads inside of it. These monads are lifted into effects via the Embed effect. Monadic values can be lifted into a Sem via embed.

Higher-order actions of another monad can be lifted into higher-order actions of Sem via the Final effect, which is more powerful than Embed, but also less flexible to interpret.

A Sem can be interpreted as a pure value (via run) or as any traditional Monad (via runM or runFinal). Each effect E comes equipped with some interpreters of the form:

runE :: Sem (E ': r) a -> Sem r a

which is responsible for removing the effect E from the effect stack. It is the order in which you call the interpreters that determines the monomorphic representation of the r parameter.

Order of interpreters can be important - it determines behaviour of effects that manipulate state or change control flow. For example, when interpreting this action:

>>> :{
  example :: Members '[State String, Error String] r => Sem r String
  example = do
    put "start"
    let throwing, catching :: Members '[State String, Error String] r => Sem r String
        throwing = do
          modify (++"-throw")
          throw "error"
          get
        catching = do
          modify (++"-catch")
          get
    catch @String throwing (\ _ -> catching)
:}

when handling Error first, state is preserved after error occurs:

>>> :{
  example
    & runError
    & fmap (either id id)
    & evalState ""
    & runM
    & (print =<<)
:}
"start-throw-catch"

while handling State first discards state in such cases:

>>> :{
  example
    & evalState ""
    & runError
    & fmap (either id id)
    & runM
    & (print =<<)
:}
"start-catch"

A good rule of thumb is to handle effects which should have "global" behaviour over other effects later in the chain.

After all of your effects are handled, you'll be left with either a Sem '[] a, a Sem '[ Embed m ] a, or a Sem '[ Final m ] a value, which can be consumed respectively by run, runM, and runFinal.

Examples

As an example of keeping r polymorphic, we can consider the type

Member (State String) r => Sem r ()

to be a program with access to

get :: Sem r String
put :: String -> Sem r ()

methods.

By also adding a

Member (Error Bool) r

constraint on r, we gain access to the

throw :: Bool -> Sem r a
catch :: Sem r a -> (Bool -> Sem r a) -> Sem r a

functions as well.

In this sense, a Member (State s) r constraint is analogous to mtl's MonadState s m and should be thought of as such. However, unlike mtl, a Sem monad may have an arbitrary number of the same effect.

For example, we can write a Sem program which can output either Ints or Bools:

foo :: ( Member (Output Int) r
       , Member (Output Bool) r
       )
    => Sem r ()
foo = do
  output @Int  5
  output True

Notice that we must use -XTypeApplications to specify that we'd like to use the (Output Int) effect.

Since: polysemy-0.1.2.0

Instances

Instances details
Member NonDet r => Alternative (Sem r) # 
Instance details

Defined in Polysemy.Internal

Methods

empty :: Sem r a #

(<|>) :: Sem r a -> Sem r a -> Sem r a #

some :: Sem r a -> Sem r [a] #

many :: Sem r a -> Sem r [a] #

Applicative (Sem f) # 
Instance details

Defined in Polysemy.Internal

Methods

pure :: a -> Sem f a #

(<*>) :: Sem f (a -> b) -> Sem f a -> Sem f b #

liftA2 :: (a -> b -> c) -> Sem f a -> Sem f b -> Sem f c #

(*>) :: Sem f a -> Sem f b -> Sem f b #

(<*) :: Sem f a -> Sem f b -> Sem f a #

Functor (Sem f) # 
Instance details

Defined in Polysemy.Internal

Methods

fmap :: (a -> b) -> Sem f a -> Sem f b #

(<$) :: a -> Sem f b -> Sem f a #

Monad (Sem f) # 
Instance details

Defined in Polysemy.Internal

Methods

(>>=) :: Sem f a -> (a -> Sem f b) -> Sem f b #

(>>) :: Sem f a -> Sem f b -> Sem f b #

return :: a -> Sem f a #

Member NonDet r => MonadPlus (Sem r) #

Since: polysemy-0.2.1.0

Instance details

Defined in Polysemy.Internal

Methods

mzero :: Sem r a #

mplus :: Sem r a -> Sem r a -> Sem r a #

Member (Fail :: (Type -> Type) -> Type -> Type) r => MonadFail (Sem r) #

Since: polysemy-1.1.0.0

Instance details

Defined in Polysemy.Internal

Methods

fail :: String -> Sem r a #

Member Fixpoint r => MonadFix (Sem r) # 
Instance details

Defined in Polysemy.Internal

Methods

mfix :: (a -> Sem r a) -> Sem r a #

Member (Embed IO) r => MonadIO (Sem r) #

This instance will only lift IO actions. If you want to lift into some other MonadIO type, use this instance, and handle it via the embedToMonadIO interpretation.

Instance details

Defined in Polysemy.Internal

Methods

liftIO :: IO a -> Sem r a #

Monoid a => Monoid (Sem f a) #

Since: polysemy-1.6.0.0

Instance details

Defined in Polysemy.Internal

Methods

mempty :: Sem f a #

mappend :: Sem f a -> Sem f a -> Sem f a #

mconcat :: [Sem f a] -> Sem f a #

Semigroup a => Semigroup (Sem f a) #

Since: polysemy-1.6.0.0

Instance details

Defined in Polysemy.Internal

Methods

(<>) :: Sem f a -> Sem f a -> Sem f a #

sconcat :: NonEmpty (Sem f a) -> Sem f a #

stimes :: Integral b => b -> Sem f a -> Sem f a #

class Member (t :: Effect) (r :: EffectRow) #

This class indicates that an effect must be present in the caller's stack. It is the main mechanism by which a program defines its effect dependencies.

Minimal complete definition

membership'

Instances

Instances details
Member t z => Member t (_1 ': z) # 
Instance details

Defined in Polysemy.Internal.Union

Methods

membership' :: ElemOf t (_1 ': z)

Member t (t ': z) # 
Instance details

Defined in Polysemy.Internal.Union

Methods

membership' :: ElemOf t (t ': z)