Parameters for knitting. If possible, create this via, e.g.,

myConfig = (defaultKnitConfig $ Just "myCacheDir") { pandocWriterConfig = myConfig }

so that your code will still compile if parameters are added to this structure.

NB: the type parameters of this configuration specify the cache types:

• sc :: Type -> Constraint, where c a is the constraint to be satisfied for serializable a.
• ct :: Type, is the value type held in the in-memory cache.
• k :: Type, is the key type of the cache.

The serializeDict field holds functions for encoding (forall a. c a=> a -> ct) and decoding (forall a. c a => ct -> Either SerializationError a).

The persistCache field holds an interpreter for the persistence layer of the cache. See AtomicCache for examples of persistence layers.

If you want to use a different serializer ("binary" or "store") and/or a different type to hold cached values in-memory, you can set these fields accordingly.

Sensible defaults for a knit configuration.

Create HTML Text from pandoc fragments. In use, you may need a type-application to specify m. This allows use of any underlying monad to handle the Pandoc effects. NB: Resulting document is *Lazy* Text, as produced by the Blaze render function.

Create multiple HTML docs (as Text) from the named sets of pandoc fragments. In use, you may need a type-application to specify m. This allows use of any underlying monad to handle the Pandoc effects. NB: Resulting documents are *Lazy* Text, as produced by the Blaze render function.

lift an action in a base monad into a Polysemy monad. This is just a renaming of embed for convenience.

Constraint alias for the effects we need (and run) when calling knitHtml or knitHtmls. Anything inside a call to Knit can use any of these effects. Any other effects added to this stack will need to be run before knitHtml(s)

Constraint alias for the effects we need to use the cache.

Constraint alias for the effects we need to use the default cache with Text keys.

Constraint alias for the effects we need to knit one document.

Constraint alias for the effects we need to knit multiple documents.

Constraints required to knit a document using effects from a base monad m.

Throw an error with a specific message. This will emerge as a PandocSomeError in order to avoid complicating the error type. NB: The Member constraint is satisfied by KnitEffectStack m.

Throw on Nothing with given message. This will emerge as a PandocSomeError in order to avoid complicating the error type.

Throw on Left with message. This will emerge as a PandocSomeError in order to avoid complicating the error type.

Map an error type, @e, into a PandocError so it will be handled in this stack

Add a Pandoc MarkDown fragment with default options

Add Strict Text Html to current Pandoc

Add Lazy Text Html to current Pandoc

Add Blaze Html

Add Lucid Html

Add LaTeX

Add hvega (via html). Requires html since vega-lite renders using javascript.

Convert given Pandoc to Blaze Html.

Convert current Pandoc document (from the ToPandoc effect) into a Blaze Html document. Incudes support for template and template variables and changes to the default writer options.

options for the mindoc template

Write each lazy text from a list of DocWithInfo to disk. File names come from the PandocInfo Directory is a function arguments. File extension is "html"

Write the Lazy Text in a DocWithInfo to disk, Name comes from the PandocInfo Directory is an argument to the function File extension is "html" Create the parent directory or directories, if necessary.

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

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

A proof that the effect e is available somewhere inside of the effect stack r.

Type-alias for use with the Docs effect.

Type to hold info about each document that will be required for rendering and output

Pandoc writer, add any read format to current doc

ADT to allow inputs to request support, if necessary or possible, in the output format. E.g., Latex output in Html needs MathJax. But Latex needs to nothing to output in Latex. Vega-lite needs some script headers to output in Html and can't be output in other formats. For now, we support all the things we can in any output format so this just results in a runtime test.

Supported formats for writing current Pandoc

Supported formats for adding to current Pandoc

Add the Pandoc stored in the writer-style ToPandoc effect to the named docs collection with the given name.

Data type to hold one document with info of type i and doc of type a.

Constraint helper for LogEntry type with prefixes

List of Logger effects for a prefixed log of type LogEntry

Severity/importance of message.

log everything.

log all but Debug messages.

log everything above Diagnostic.

log debug messages with level lower than or equal to the given Int.

Add one log-entry of the LogEntry type.

Add a prefix for the block of code.

Run the Logger and PrefixLog effects in IO: filtered via the severity of the message and formatted using "prettyprinter".

Get an unused id with prefix as specified. Useful for figures, etc.

type-alias for default Serializer

type-alias for default in-memory storage type.

Perform a sequence of effectful actions concurrently.

Since: polysemy-1.2.2.0