Sigil

isEffectNameIn :: Set String -> String -> Boolean

isEffectName :: String -> Boolean

defaultEffectNames :: Set String

assignVarColors :: Array String -> Map String String

Assign colors to type variables. Earlier variables get earlier palette slots.

renderTypeSynonymInto :: String -> { body :: RenderType, name :: String, typeParams :: Array String } -> Effect Unit

Render a type synonym into a container element.

renderTypeSynonym :: { body :: RenderType, name :: String, typeParams :: Array String } -> String

Render a type synonym to an HTML string. Shows header (type + name + type params), then = body.

renderSignetInto :: String -> { ast :: RenderType } -> Effect Unit

Render a signet into a container element.

renderSignet :: { ast :: RenderType } -> String

Render a signet (dots with rotated identifier labels) to HTML. Same dot layout as the siglet, but each dot has a 45-degree rotated label beneath it showing the type identifier name.

renderSignatureInto :: String -> { ast :: RenderType, className :: Maybe String, name :: String, typeParams :: Array String } -> Effect Unit

Render a full-size signature into a container element.

renderSignature :: { ast :: RenderType, className :: Maybe String, name :: String, typeParams :: Array String } -> String

Render a full-size type signature to an HTML string. Uses Swiss typographic layout: preamble (∀ left, constraints right), declaration (name ::), body (indented with left rule).

renderSigletInto :: String -> { ast :: RenderType } -> Effect Unit

Render a siglet into a container element.

renderSiglet :: { ast :: RenderType } -> String

Render a siglet (miniature signature) to HTML. Constrained type variables get pill style; unconstrained get colored text.

renderForeignImportInto :: String -> { ast :: RenderType, name :: String } -> Effect Unit

Render a foreign import into a container element.

renderForeignImport :: { ast :: RenderType, name :: String } -> String

Render a foreign import to an HTML string. Shows header (foreign import + name), then :: body with preamble.

renderDataDeclInto :: String -> { constructors :: Array { args :: Array RenderType, name :: String }, keyword :: Maybe String, name :: String, typeParams :: Array String } -> Effect Unit

Render a data declaration into a container element.

renderDataDecl :: { constructors :: Array { args :: Array RenderType, name :: String }, keyword :: Maybe String, name :: String, typeParams :: Array String } -> String

Render a data/newtype declaration to an HTML string. Shows header (keyword + name + type params), then constructor branches in a rail layout, or an opaque indicator if no constructors.

renderClassDeclInto :: String -> { methods :: Array { ast :: Maybe RenderType, name :: String }, name :: String, superclasses :: Array SuperclassInfo, typeParams :: Array String } -> Effect Unit

Render a class declaration into a container element.

renderClassDecl :: { methods :: Array { ast :: Maybe RenderType, name :: String }, name :: String, superclasses :: Array SuperclassInfo, typeParams :: Array String } -> String

Render a type class definition to an HTML string. Shows header (class + name + type params), superclass row, own methods, and inherited methods grouped by superclass.

renderBodyInto :: String -> { ast :: RenderType } -> Effect Unit

Render a sigil body (no header) into a container element.

renderBody :: { ast :: RenderType } -> String

Render the sigil body only (no name header, no ::) to HTML. Used for inline rendering in value cells when there's enough space. Still shows preamble (quantifier + constraints) if present.

peelSignature :: RenderType -> PeeledSig

Peel outermost forall quantifiers and constraints from the AST. Nested foralls/constraints (rank-N, inside parens) are left intact.

escapeHtml :: String -> String

Escape HTML special characters.

parseToRenderType :: String -> Maybe RenderType

Parse a type signature string to RenderType. Sanitizes loader artifacts (e.g. trailing comma before row variable) before parsing.

extractCtorRenderTypes :: String -> Array RenderType

Extract constructor argument types as RenderType values. Constructor sigs look like "a -> b -> MyType a b" — returns [TVar "a", TVar "b"].

extractCtorArgs :: String -> Array String

Extract constructor argument types from a constructor signature string. Constructor sigs look like "a -> b -> MyType a b" — returns ["a", "b"] as text.

elideConstraint :: Constraint -> Constraint

elideAST :: RenderType -> RenderType

Prepare AST for siglet rendering. Preserves record/row structure (with elided field types) so the siglet renderer can show { ○ ○ ○ } notation. Forall, constraints, and parens are kept. Normalizes Record (row) application to TRecord.

type SvgPrimitive = { attrs :: Array { key :: String, value :: String }, children :: Array LayoutNode, tag :: String, textContent :: Maybe String }

toSvgPrimitive :: LayoutNode -> SvgPrimitive

fontFamily :: String

renderSignatureIntoSvg :: String -> { ast :: RenderType, className :: Maybe String, name :: String, sig :: String, typeParams :: Array String } -> Effect Unit

Render a signature into a DOM element selected by CSS selector.

renderClassDeclIntoSvg :: String -> { methods :: Array { ast :: Maybe RenderType, name :: String }, name :: String, superclasses :: Array SuperclassInfo, typeParams :: Array String } -> Effect Unit

Render a class definition into a DOM element selected by CSS selector.

renderAdtIntoSvg :: String -> { constructors :: Array { args :: Array RenderType, name :: String }, keyword :: Maybe String, name :: String, typeParams :: Array String } -> Effect Unit

Render an ADT into a DOM element selected by CSS selector.

emitNode :: LayoutNode -> Effect Element

Emit a single LayoutNode to a DOM element.

emit :: LayoutNode -> Dimensions -> Effect Element

Emit a layout tree as a detached SVG element with the given dimensions.

layoutADT :: { constructors :: Array { args :: Array RenderType, name :: String }, keyword :: Maybe String, name :: String, typeParams :: Array String } -> { dimensions :: Dimensions, layout :: LayoutNode }

Lay out a data type with constructor branches.

layoutClassDef :: { methods :: Array { ast :: Maybe RenderType, name :: String }, name :: String, superclasses :: Array SuperclassInfo, typeParams :: Array String } -> { dimensions :: Dimensions, layout :: LayoutNode }

Lay out a type class definition.

layoutSiglet :: { ast :: RenderType, maxHeight :: Number, maxWidth :: Number } -> Maybe { layout :: LayoutNode, scaledHeight :: Number, scaledWidth :: Number }

Lay out a siglet (elided miniature type signature). TCon names render as small circles; TVar pills keep colors. Layout mirrors the full-size sigil: constraint pile above, body middle, forall row below. Returns Nothing if the type can't fit.

layoutSignature :: { ast :: RenderType, className :: Maybe String, name :: String, sig :: String, typeParams :: Array String } -> { dimensions :: Dimensions, layout :: LayoutNode }

Lay out a value/type-synonym signature.

layoutSparkline :: { ast :: RenderType, maxHeight :: Number, maxScale :: Maybe Number, maxWidth :: Number } -> Maybe { layout :: LayoutNode, scaledHeight :: Number, scaledWidth :: Number }

Lay out a sparkline miniature.

type RenderContext = { charWidth :: Number, fontSize :: Number, lineHeight :: Number, padding :: { x :: Number, y :: Number }, sigletMode :: Boolean, varColors :: Map String String }

Rendering context threaded through layout functions.

measure :: RenderContext -> RenderType -> Dimensions

Measure a RenderType node's dimensions.

defaultRenderContext :: RenderContext

type RenderResult = { nodes :: Array LayoutNode, width :: Number }

Internal result from node-level layout: positioned nodes + consumed width.

data LayoutNode

A positioned SVG primitive. The entire layout pipeline produces these; only Emit touches the DOM.

Constructors

• LText { fontSize :: Number, style :: String, text :: String, x :: Number, y :: Number }
• LRect { height :: Number, rx :: Number, style :: String, width :: Number, x :: Number, y :: Number }
• LLine { stroke :: String, strokeDasharray :: String, strokeLinecap :: String, strokeWidth :: Number, x1 :: Number, x2 :: Number, y1 :: Number, y2 :: Number }
• LCircle { cx :: Number, cy :: Number, fill :: String, r :: Number, stroke :: String, strokeWidth :: Number }
• LGroup { children :: Array LayoutNode, transform :: String }

type Dimensions = { height :: Number, width :: Number }

renderTypeToText :: RenderType -> String

Render a RenderType back to plain text.

fieldVars :: Array RowField -> Maybe String -> Set String

Collect type variables from record/row fields.

collectTypeVars :: RenderType -> Set String

Collect all type variable names from a RenderType.

collectForallVars :: RenderType -> Array String

Collect all forall-quantified variable names (including nested foralls).

collectArrowParams :: RenderType -> Array RenderType

Collect all params of an arrow chain (including return type at end).

type SuperclassInfo = { methods :: Array { ast :: Maybe RenderType, name :: String }, name :: String }

Superclass info for class definition rendering. Contains the class name and its required methods with optional parsed types.

type RowField = { label :: String, value :: RenderType }

data RenderType

Constructors

• TVar String
• TCon String
• TApp RenderType (Array RenderType)
• TArrow RenderType RenderType
• TConstrained (Array Constraint) RenderType
• TForall (Array String) RenderType
• TRecord (Array RowField) (Maybe String)
• TRow (Array RowField) (Maybe String)
• TParens RenderType
• TKinded RenderType RenderType
• TString String
• TWildcard
• TOperator RenderType String RenderType

type Constraint = { args :: Array RenderType, className :: String }