Tidy.Codegen.Monad

type CodegenState e = { declarations :: List (Declaration e), exports :: Set CodegenExport, importsFrom :: Map ModuleName (Set (CodegenImport)), importsOpen :: Set ModuleName, importsQualified :: Map ModuleName (Set ModuleName) }

newtype CodegenT :: Type -> (Type -> Type) -> Type -> Typenewtype CodegenT e m a

A Monad transformer which tracks module imports/exports. With this, you can define codegen procedures in a modular way without having to manually calculate imports or do post-traversals.

Constructors

• CodegenT (StateT (CodegenState e) m a)

Instances

• (Functor m) => Functor (CodegenT e m)
• (Monad m) => Apply (CodegenT e m)
• (Monad m) => Applicative (CodegenT e m)
• (Monad m) => Bind (CodegenT e m)
• (Monad m) => Monad (CodegenT e m)
• MonadTrans (CodegenT e)
• (Monad m) => MonadTell (Array (Declaration e)) (CodegenT e m)
• (MonadEffect m) => MonadEffect (CodegenT e m)
• (Monad m, MonadST h m) => MonadST h (CodegenT e m)

type Codegen e = CodegenT e (Free Identity)

data CodegenExport

Constructors

• CodegenExportType Boolean Proper
• CodegenExportTypeOp SymbolName
• CodegenExportClass Proper
• CodegenExportValue Ident
• CodegenExportOp SymbolName
• CodegenExportModule ModuleName

Instances

• Eq CodegenExport
• Ord CodegenExport

data CodegenImport

Constructors

• CodegenImportType Boolean Proper
• CodegenImportTypeOp SymbolName
• CodegenImportClass Proper
• CodegenImportValue Ident
• CodegenImportOp SymbolName

Instances

• Eq CodegenImport
• Ord CodegenImport

data ImportName name

Constructors

• ImportName CodegenImport (QualifiedName name)

Instances

• ToImportFrom (ImportName name) (QualifiedName name)

write :: forall m e. Monad m => Declaration e -> CodegenT e m Unit

Writes a declaration to the module.

writeAndExport :: forall m e. Monad m => Declaration e -> CodegenT e m Unit

Writes a declaration and exports it.

exportValue :: forall e m name. Monad m => ToToken name Ident => name -> CodegenT e m Unit

Exports a value.

exportOp :: forall e m name. Monad m => ToToken name SymbolName => name -> CodegenT e m Unit

Exports an operator.

exportType :: forall e m name. Monad m => ToToken name Proper => name -> CodegenT e m Unit

Exports a type.

exportTypeAll :: forall e m name. Monad m => ToToken name Proper => name -> CodegenT e m Unit

Exports a type with all data members.

exportTypeOp :: forall e m name. Monad m => ToToken name SymbolName => name -> CodegenT e m Unit

Exports a type operator.

exportClass :: forall e m name. Monad m => ToToken name Proper => name -> CodegenT e m Unit

Exports a class.

exportModule :: forall e m name. Monad m => ToToken name ModuleName => name -> CodegenT e m Unit

Exports a module re-export.

exporting :: forall e m a. Monad m => CodegenT e m a -> CodegenT e m a

Exports all declarations written within the provided block.

importFrom :: forall e m mod name imp. Monad m => ToModuleName mod => ToImportFrom name imp => mod -> name -> CodegenT e m imp

Imports from a particular module, yielding a QualifiedName which can be used with the Tidy.Codegen constructors. If the requested import is qualified, an appropriate qualified import will be generated.

example = do
  -- Generates a `import Effect.Class.Console as Console` import
  consoleLog <- importFrom "Effect.Class.Console" (importValue "Console.log")
  -- Generates a `import Data.Map (Map)` import
  mapType <- importFrom "Data.Map" (importType "Map")
  -- Group multiple imports with a record
  dataMap <- import From "Data.Map"
    { type: importType "Map"
    , lookup: importValue "Map.lookup"
    }
  ...

importOpen :: forall e m mod. Monad m => ToModuleName mod => mod -> CodegenT e m Unit

Imports a module with an open import.

example = do
  importOpen "Prelude"
  ...

importValue :: forall name. ToToken name (Qualified Ident) => name -> ImportName Ident

Imports a value. Use with importFrom.

importOp :: forall name. ToToken name (Qualified SymbolName) => name -> ImportName Operator

Imports a value operator, yield. Use with importFrom.

importType :: forall name. ToToken name (Qualified Proper) => name -> ImportName Proper

Imports a type. Use with importFrom.

importTypeAll :: forall name. ToToken name (Qualified Proper) => name -> ImportName Proper

Imports a type. Use with importFrom.

importTypeOp :: forall name. ToToken name (Qualified SymbolName) => name -> ImportName Operator

Imports a type operator. Use with importFrom.

importClass :: forall name. ToToken name (Qualified Proper) => name -> ImportName Proper

Imports a class. Use with importFrom.

importCtor :: forall ty ctor. ToToken ty Proper => ToToken ctor (Qualified Proper) => ty -> ctor -> ImportName Proper

Imports a data constructor for a type. Use with importFrom.

example = do
  just <- importFrom "Data.Maybe" (importCtor "Maybe" "Just")

codegenModule :: forall e name. ToName name ModuleName => name -> Codegen e Unit -> Module e

Extracts a CST Module.

runCodegenT :: forall m e a. CodegenT e m a -> m (Tuple a (CodegenState e))

Extracts codegen state and the produced value.

runCodegenTModule :: forall e m a name. Functor m => ToName name ModuleName => name -> CodegenT e m a -> m (Tuple a (Module e))

Extracts a CST Module and the produced value.

moduleFromCodegenState :: forall e name. ToName name ModuleName => name -> CodegenState e -> Module e

Constructs a CST Module from codegen state.

class ToImportFrom name imp | name -> imp where

Members

• toImportFrom :: forall f. Applicative f => ImportResolver f -> name -> f imp

Instances

• ToImportFrom (ImportName name) (QualifiedName name)
• (RowToList rin rl, ToImportFromRecord rl (Record rin) (Record rout)) => ToImportFrom (Record rin) (Record rout)

class ToImportFromRecord :: RowList Type -> Type -> Type -> Constraintclass ToImportFromRecord (rl :: RowList Type) rin rout | rl rin -> rout where

Members

• toImportFromRecord :: forall f. Applicative f => ImportResolver f -> Proxy rl -> rin -> f (Builder (Record ()) rout)

Instances

• (ToImportFrom val imp, ToImportFromRecord rest (Record rin) (Record rout'), IsSymbol sym, Cons sym val rx rin, Cons sym imp rout' rout, Lacks sym rout') => ToImportFromRecord (Cons sym val rest) (Record rin) (Record rout)
• ToImportFromRecord Nil (Record rin) (Record ())