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.

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.

lift an action in a base monad into a Polysemy monad

Constraints required to build a document while also using effects from a base monad m.

Add a table given a Colonnade representation producing text

Add a Blaze-Colonnade Html Table

Add a Blaze-Colonnade Cell Table

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

The Semantic monad handles computations of arbitrary extensible effects. A value of type Semantic 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 Semantic 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 tradtionally as an Either, or instead significantly faster as an IO Exception. These interpretations (and others that you might add) may be used interchangably without needing to write any newtypes or Monad instances. The only change needed to swap interpretations is to change a call from runError to runErrorInIO.

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

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

runE :: Semantic (E ': r) a -> Semantic 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.

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

Examples

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

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

to be a program with access to

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

methods.

By also adding a

Member (Error Bool) r

constraint on r, we gain access to the

throw :: Bool -> Semantic r a
catch :: Semantic r a -> (Bool -> Semantic r a) -> Semantic 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 Semantic monad may have an arbitrary number of the same effect.

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

foo :: ( Member (Output Int) r
       , Member (Output Bool) r
       )
    => Semantic 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.

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

An effect which allows a regular Monad m into the Semantic ecosystem. Monadic actions in m can be lifted into Semantic via sendM.

For example, you can use this effect to lift IO actions directly into Semantic:

sendM (putStrLn "hello") :: Member (Lift IO) r => Semantic r ()

That being said, you lose out on a significant amount of the benefits of Semantic by using sendM directly in application code; doing so will tie your application code directly to the underlying monad, and prevent you from interpreting it differently. For best results, only use Lift in your effect interpreters.

Consider using trace and runTraceIO as a substitute for using putStrLn directly.

Type-alias for use with the Docs effect.

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

Constraint helper for LogEntry type with prefixes

Severity of message. Based on monad-logger.

LogSeverity list used in order to output everything.

LogSeverity list used to output all but Diagnostic. Diagnostic messages are sometimes useful for debugging but can get noisy depending on how you use it.

Add one log-entry of the LogEntry type.

Add a prefix for the block of code.

Run the Logger and PrefixLog effects using the preferred handler and filter output in any Polysemy monad with IO in the union.