Documentation

module Napkin.Run.Effects.Languages.FatalError

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

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

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

data SQLDialect #

data AssertionStatus #

data Assertion (m :: k) a #

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

data External (m :: k) a #

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

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

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

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

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

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

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

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

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

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

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

newtype RandomToken #

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

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

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

data Sem (r :: EffectRow) a #

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

>>> :{
  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)
:}

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

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

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

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

Member (Error Bool) r

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

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

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

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

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

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

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

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

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

logEmergency :: 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 () #

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 => LogItem -> LText -> Sem effs () #

logWarning' :: 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 => LogItem -> LText -> Sem effs () #

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

logAlert' :: 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 => LogItem -> LText -> Sem effs () #

pattern FailureWithMessage :: Text -> AssertionStatus #

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

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

assertEquals :: forall a (r :: EffectRow). (Eq a, Member (Assertion :: (Type -> Type) -> Type -> Type) r) => Text -> a -> a -> 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 () #

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 #

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

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

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

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

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

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] #

data SqlRender (m :: k) a #

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

data SqlParse (m :: k) a #

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

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

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

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

data LoadQuery (m :: k) a #

newtype LoadQueryError #

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 #

optionalArg :: SpecProgramArgumentDescription -> SpecProgramArgumentDefinition #

requiredArg :: SpecProgramArgumentDescription -> SpecProgramArgumentDefinition #

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

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

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

data SqlWrite b (m :: k) a #

data MissingBehavior #

data Cascade #

createTableAsWithMeta :: forall b (r :: EffectRow). Member (SqlWrite b :: (Type -> Type) -> Type -> Type) r => BackendTableMeta b -> 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 () #

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

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

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

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

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

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

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

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

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

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

newtype TableMemos #

newtype TableMemo #

newtype MetaArguments #

newtype TargetName #

newtype HiddenArtifacts #

newtype HiddenDependencies #

newtype ExtraDependencies #

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

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

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

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

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

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

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

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

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

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

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

data TableAnnotations #

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

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

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

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

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

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

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

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

data RecreateTable b (m :: k) a #

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

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

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

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

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

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

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

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 #

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 #

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) #

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 #

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 #

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) #

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 #

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 #

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) #

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) #

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

class RunBackendEffect b where #

newtype SpecProgramWithArgParser b #

newtype HookProgramWithArgParser b #

type SpecProgram b = SpecProgram' b () #

type PureGlobalHookProgram b = PureGlobalHookProgram' b () #

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

type IOGlobalHookProgram b = IOGlobalHookProgram' b () #

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

type HookProgram b = HookProgram' b () #

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

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

parserlessHook :: HookProgram b -> HookProgramWithArgParser b #

parserlessSpec :: SpecProgram b -> SpecProgramWithArgParser b #

newtype SpecPreprocessorWithArgParser b #

parserlessPreprocessor :: SpecPreprocessor b -> SpecPreprocessorWithArgParser b #