Safe Haskell	Safe
Language	Haskell2010

Zinza

Contents

Compilation to Haskell module
Input class
- Generic deriving
Templates
Types
Values
Errors
Location
Variables

Description

SPDX-Identifier-Id: GPL-2.0-or-later AND BSD-3-Clause

Zinza - a small jinja-syntax-inspired typed-template compiler.

Zinza typechecks and compiles a template. We can compile either to Haskell function, or to verbatim Haskell module (planned).

Zinza is very minimalistic. Features are added when needed.

Example usage

Given a template

{% for license in licenses %}
licenseName {{license.con}} = {{license.name}}
{% endfor %}

and data definitions like:

newtype Licenses = Licenses { licenses :: [License] }
  deriving (Generic)

data License = License
    { licenseCon  :: String
    , licenseName :: String
    }
  deriving (Generic)

We can (generically) derive Zinza instances for Licenses and License

instance Zinza Licenses where
    toType  = genericToType  id
    toValue = genericToValue id

instance Zinza License where
    toType  = genericToTypeSFP
    toValue = genericToValueSFP

Then the example of run-time usage is

example :: IO String
example = do
    -- this might fail, type errors!
    run <- parseAndCompileTemplateIO "fixtures/licenses.zinza"
    -- this shouldn't fail (run-time errors are due bugs in zinza)
    run $ Licenses
        [ License "Foo" (show "foo-1.0")
        , License "Bar" (show "bar-1.2")
        ]

The result of running an example is:

licenseName Foo = "foo-1.0"
licenseName Bar = "bar-1.2"

Module generation

Zinza also supports standalone module generation.

parseAndCompileModuleIO (simpleConfig "DemoLicenses" ["Licenses"] :: ModuleConfig Licenses) "fixtures/licenses.zinza" >>= putStr

prints a Haskell module source code:

module DemoLicenses (render) where
import Prelude (String, fst, snd, ($))
import Control.Monad (forM_)
import Licenses
type Writer a = (String, a)
tell :: String -> Writer (); tell x = (x, ())
execWriter :: Writer a -> String; execWriter = fst
render :: Licenses -> String
render (z_root) = execWriter $ do
  forM_ (licenses $ z_root) $ z_var0_license -> do
    tell "licenseName "
    tell (licenseCon $ z_var0_license)
    tell " = "
    tell (licenseName $ z_var0_license)
    tell "n"

which is not dependent on Zinza. You are free to use more efficient writer as well.

Expressions

{{ expression }}

Expression syntax has only two structures

negated: !foo
field access foo.bar

Control structures

The for and if statements are supported:

{% for value in values %}
...
{% endfor %}

{% if boolExpression %}
...
{% elif anotherBoolExpression %}
...
{% else %}
...
{% endif %}

If a control structure tag starts at the first column, the possible trailing new line feed is stripped. This way full-line control tags don't introduce new lines in the output.

Comments

{# Comments are omitted from the output #}

Synopsis

parseAndCompileTemplate :: (Zinza a, ThrowRuntime m) => FilePath -> String -> Either CompileOrParseError (a -> m String)
parseAndCompileTemplateIO :: (Zinza a, ThrowRuntime m) => FilePath -> IO (a -> m String)
parseAndCompileModule :: Zinza a => ModuleConfig a -> FilePath -> String -> Either CompileOrParseError String
parseAndCompileModuleIO :: Zinza a => ModuleConfig a -> FilePath -> IO String
data ModuleConfig a = ModuleConfig {
- mcHeader :: [String]
- mcRender :: String
}
simpleConfig :: forall a. Typeable a => String -> [String] -> ModuleConfig a
class Zinza a where
- toType :: Proxy a -> Ty
- toTypeList :: Proxy a -> Ty
- toValue :: a -> Value
- toValueList :: [a] -> Value
genericToType :: forall a. (Generic a, GZinzaType (Rep a)) => (String -> String) -> Proxy a -> Ty
genericToValue :: forall a. (Generic a, GZinzaValue (Rep a)) => (String -> String) -> a -> Value
genericToTypeSFP :: forall a. (Generic a, GZinzaType (Rep a), GFieldNames (Rep a)) => Proxy a -> Ty
genericToValueSFP :: forall a. (Generic a, GZinzaValue (Rep a), GFieldNames (Rep a)) => a -> Value
stripFieldPrefix :: forall a. (Generic a, GFieldNames (Rep a)) => Proxy a -> String -> String
class GZinzaType (f :: Type -> Type)
class GZinzaValue (f :: Type -> Type)
class GFieldNames (f :: Type -> Type)
data Node a
- = NRaw String
- | NExpr (LExpr a)
- | NIf (LExpr a) (Nodes a) (Nodes a)
- | NFor Var (LExpr a) (Nodes (Maybe a))
- | NComment
type Nodes a = [Node a]
data Expr a
- = EVar (Located a)
- | EField (LExpr a) (Located Var)
- | ENot (LExpr a)
type LExpr a = Located (Expr a)
data Ty
- = TyBool
- | TyString (Maybe Selector)
- | TyList (Maybe Selector) Ty
- | TyRecord (Map Var (Selector, Ty))
displayTy :: Ty -> String
data Value
- = VBool Bool
- | VString String
- | VList [Value]
- | VRecord (Map Var Value)
newtype ParseError = ParseError String
data CompileError
- = UnboundTopLevelVar Loc Var
- | ARuntimeError RuntimeError
data CompileOrParseError
- = ACompileError CompileError
- | AParseError ParseError
data RuntimeError
- = NotBool Loc Ty
- | NotString Loc Ty
- | NotRecord Loc Ty
- | NotList Loc Ty
- | FieldNotInRecord Loc Var Ty
class AsRuntimeError e where
- asRuntimeError :: RuntimeError -> e
class Monad m => ThrowRuntime m where
- throwRuntime :: RuntimeError -> m a
data Loc = Loc !Int !Int
data Located a = L !Loc a
zeroLoc :: Loc
displayLoc :: Loc -> String
class Traversable t => TraversableWithLoc t where
- traverseWithLoc :: Applicative f => (Loc -> a -> f b) -> t a -> f (t b)
type Var = String
type Selector = String

Documentation

parseAndCompileTemplate Source #

Arguments

:: (Zinza a, ThrowRuntime m)
=> FilePath	name of the template
-> String	contents of the template
-> Either CompileOrParseError (a -> m String)

Parse and compile the template into Haskell function.

parseAndCompileTemplateIO :: (Zinza a, ThrowRuntime m) => FilePath -> IO (a -> m String) Source #

Like parseAndCompileTemplate but reads file and (possibly) throws CompileOrParseError.

Compilation to Haskell module

parseAndCompileModule :: Zinza a => ModuleConfig a -> FilePath -> String -> Either CompileOrParseError String Source #

Parse and compile the template into String representing a Haskell module.

parseAndCompileModuleIO :: Zinza a => ModuleConfig a -> FilePath -> IO String Source #

Like parseAndCompileModule but reads file and (possibly) throws CompileOrParseError.

data ModuleConfig a Source #

Configuration for module rendering

Constructors

ModuleConfig
Fields mcHeader :: [String] module header mcRender :: String name of the function

Instances

Show (ModuleConfig a) Source #
Instance details Defined in Zinza.Module Methods showsPrec :: Int -> ModuleConfig a -> ShowS # show :: ModuleConfig a -> String # showList :: [ModuleConfig a] -> ShowS #

simpleConfig Source #

Arguments

:: Typeable a
=> String	module name
-> [String]	imports
-> ModuleConfig a

Simple configuration to use with parseAndCompileModule or parseAndCompileModuleIO.

Input class

class Zinza a where Source #

Zinza class tells how to convert the type into template parameters, and their types.

Class can be auto-derived for product types.

>>> data R = R { recFoo :: String, recBar :: Char } deriving Generic
>>> instance Zinza R where toType = genericToTypeSFP; toValue = genericToValueSFP
>>> displayTy $ toType (Proxy :: Proxy R)
"{bar: String, foo: String}"

Minimal complete definition

toType, toValue

Methods

toType :: Proxy a -> Ty Source #

toTypeList :: Proxy a -> Ty Source #

toValue :: a -> Value Source #

toValueList :: [a] -> Value Source #

Instances

Zinza Bool Source #
Instance details Defined in Zinza.Class Methods toType :: Proxy Bool -> Ty Source # toTypeList :: Proxy Bool -> Ty Source # toValue :: Bool -> Value Source # toValueList :: [Bool] -> Value Source #
Zinza Char Source #
Instance details Defined in Zinza.Class Methods toType :: Proxy Char -> Ty Source # toTypeList :: Proxy Char -> Ty Source # toValue :: Char -> Value Source # toValueList :: [Char] -> Value Source #
Zinza () Source #
Instance details Defined in Zinza.Class Methods toType :: Proxy () -> Ty Source # toTypeList :: Proxy () -> Ty Source # toValue :: () -> Value Source # toValueList :: [()] -> Value Source #
Zinza Text Source #
Instance details Defined in Zinza.Class Methods toType :: Proxy Text -> Ty Source # toTypeList :: Proxy Text -> Ty Source # toValue :: Text -> Value Source # toValueList :: [Text] -> Value Source #
Zinza Text Source #
Instance details Defined in Zinza.Class Methods toType :: Proxy Text -> Ty Source # toTypeList :: Proxy Text -> Ty Source # toValue :: Text -> Value Source # toValueList :: [Text] -> Value Source #
Zinza a => Zinza [a] Source #
Instance details Defined in Zinza.Class Methods toType :: Proxy [a] -> Ty Source # toTypeList :: Proxy [a] -> Ty Source # toValue :: [a] -> Value Source # toValueList :: [[a]] -> Value Source #
Zinza a => Zinza (NonEmpty a) Source #
Instance details Defined in Zinza.Class Methods toType :: Proxy (NonEmpty a) -> Ty Source # toTypeList :: Proxy (NonEmpty a) -> Ty Source # toValue :: NonEmpty a -> Value Source # toValueList :: [NonEmpty a] -> Value Source #
Zinza a => Zinza (Set a) Source #
Instance details Defined in Zinza.Class Methods toType :: Proxy (Set a) -> Ty Source # toTypeList :: Proxy (Set a) -> Ty Source # toValue :: Set a -> Value Source # toValueList :: [Set a] -> Value Source #
(Zinza a, Zinza b) => Zinza (a, b) Source #
Instance details Defined in Zinza.Class Methods toType :: Proxy (a, b) -> Ty Source # toTypeList :: Proxy (a, b) -> Ty Source # toValue :: (a, b) -> Value Source # toValueList :: [(a, b)] -> Value Source #
(Zinza k, Zinza v) => Zinza (Map k v) Source #	Pairs are encoded as `{key: k, val: v }`
Instance details Defined in Zinza.Class Methods toType :: Proxy (Map k v) -> Ty Source # toTypeList :: Proxy (Map k v) -> Ty Source # toValue :: Map k v -> Value Source # toValueList :: [Map k v] -> Value Source #

Generic deriving

genericToType Source #

Arguments

:: (Generic a, GZinzaType (Rep a))
=> (String -> String)	field renamer
-> Proxy a
-> Ty

Generically derive toType function.

genericToValue Source #

Arguments

:: (Generic a, GZinzaValue (Rep a))
=> (String -> String)	field renamer
-> a
-> Value

Generically derive toValue function.

genericToTypeSFP :: forall a. (Generic a, GZinzaType (Rep a), GFieldNames (Rep a)) => Proxy a -> Ty Source #

genericToType with stripFieldPrefix.

genericToValueSFP :: forall a. (Generic a, GZinzaValue (Rep a), GFieldNames (Rep a)) => a -> Value Source #

genericToValue with stripFieldPrefix.

stripFieldPrefix :: forall a. (Generic a, GFieldNames (Rep a)) => Proxy a -> String -> String Source #

Field renamer which will automatically strip lowercase prefix from field names.

>>> data R = R { recFoo :: Int, recBar :: Char } deriving Generic
>>> stripFieldPrefix (Proxy :: Proxy R) "recFoo"
"foo"

If whole field is lower case, it's left intact

>>> newtype Wrapped = Wrap { unwrap :: String } deriving Generic
>>> stripFieldPrefix (Proxy :: Proxy Wrapped) "unwrap"
"unwrap"

class GZinzaType (f :: Type -> Type) Source #

Minimal complete definition

gtoType

Instances

(i ~ D, GZinzaTypeSum f) => GZinzaType (M1 i c f) Source #
Instance details Defined in Zinza.Generic Methods gtoType :: Proxy (M1 i c f) -> [(String, Ty)]

class GZinzaValue (f :: Type -> Type) Source #

Minimal complete definition

gtoValue

Instances

(i ~ D, GZinzaValueSum f) => GZinzaValue (M1 i c f) Source #
Instance details Defined in Zinza.Generic Methods gtoValue :: M1 i c f () -> [(Var, Value)]

class GFieldNames (f :: Type -> Type) Source #

Minimal complete definition

fieldNames

Instances

(i ~ D, GFieldNamesSum f) => GFieldNames (M1 i c f) Source #
Instance details Defined in Zinza.Generic Methods fieldNames :: Proxy (M1 i c f) -> [String]

Templates

data Node a Source #

Template parts.

We use polymorphic recursion for de Bruijn indices. See materials on bound library.

Constructors

NRaw String	raw text block
NExpr (LExpr a)	expression `expr : String`
NIf (LExpr a) (Nodes a) (Nodes a)	conditional block, `expr : Bool`
NFor Var (LExpr a) (Nodes (Maybe a))	for loop, `expr : List a`
NComment	comments

Instances

Functor Node Source #
Instance details Defined in Zinza.Node Methods fmap :: (a -> b) -> Node a -> Node b # (<$) :: a -> Node b -> Node a #
Foldable Node Source #
Instance details Defined in Zinza.Node Methods fold :: Monoid m => Node m -> m # foldMap :: Monoid m => (a -> m) -> Node a -> m # foldr :: (a -> b -> b) -> b -> Node a -> b # foldr' :: (a -> b -> b) -> b -> Node a -> b # foldl :: (b -> a -> b) -> b -> Node a -> b # foldl' :: (b -> a -> b) -> b -> Node a -> b # foldr1 :: (a -> a -> a) -> Node a -> a # foldl1 :: (a -> a -> a) -> Node a -> a # toList :: Node a -> [a] # null :: Node a -> Bool # length :: Node a -> Int # elem :: Eq a => a -> Node a -> Bool # maximum :: Ord a => Node a -> a # minimum :: Ord a => Node a -> a # sum :: Num a => Node a -> a # product :: Num a => Node a -> a #
Traversable Node Source #
Instance details Defined in Zinza.Node Methods traverse :: Applicative f => (a -> f b) -> Node a -> f (Node b) # sequenceA :: Applicative f => Node (f a) -> f (Node a) # mapM :: Monad m => (a -> m b) -> Node a -> m (Node b) # sequence :: Monad m => Node (m a) -> m (Node a) #
TraversableWithLoc Node Source #
Instance details Defined in Zinza.Node Methods traverseWithLoc :: Applicative f => (Loc -> a -> f b) -> Node a -> f (Node b) Source #
Show a => Show (Node a) Source #
Instance details Defined in Zinza.Node Methods showsPrec :: Int -> Node a -> ShowS # show :: Node a -> String # showList :: [Node a] -> ShowS #

type Nodes a = [Node a] Source #

A list of Nodes.

data Expr a Source #

Expressions in templates.

Note: there are only eliminators; we cannot construct "bigger" expressions.

Constructors

EVar (Located a)	variable
EField (LExpr a) (Located Var)	field accessor
ENot (LExpr a)	negation

Instances

Monad Expr Source #	`Monad` instance gives substitution.
Instance details Defined in Zinza.Expr Methods (>>=) :: Expr a -> (a -> Expr b) -> Expr b # (>>) :: Expr a -> Expr b -> Expr b # return :: a -> Expr a # fail :: String -> Expr a #
Functor Expr Source #
Instance details Defined in Zinza.Expr Methods fmap :: (a -> b) -> Expr a -> Expr b # (<$) :: a -> Expr b -> Expr a #
Applicative Expr Source #
Instance details Defined in Zinza.Expr Methods pure :: a -> Expr a # (<>) :: Expr (a -> b) -> Expr a -> Expr b # liftA2 :: (a -> b -> c) -> Expr a -> Expr b -> Expr c # (>) :: Expr a -> Expr b -> Expr b # (<*) :: Expr a -> Expr b -> Expr a #
Foldable Expr Source #
Instance details Defined in Zinza.Expr Methods fold :: Monoid m => Expr m -> m # foldMap :: Monoid m => (a -> m) -> Expr a -> m # foldr :: (a -> b -> b) -> b -> Expr a -> b # foldr' :: (a -> b -> b) -> b -> Expr a -> b # foldl :: (b -> a -> b) -> b -> Expr a -> b # foldl' :: (b -> a -> b) -> b -> Expr a -> b # foldr1 :: (a -> a -> a) -> Expr a -> a # foldl1 :: (a -> a -> a) -> Expr a -> a # toList :: Expr a -> [a] # null :: Expr a -> Bool # length :: Expr a -> Int # elem :: Eq a => a -> Expr a -> Bool # maximum :: Ord a => Expr a -> a # minimum :: Ord a => Expr a -> a # sum :: Num a => Expr a -> a # product :: Num a => Expr a -> a #
Traversable Expr Source #
Instance details Defined in Zinza.Expr Methods traverse :: Applicative f => (a -> f b) -> Expr a -> f (Expr b) # sequenceA :: Applicative f => Expr (f a) -> f (Expr a) # mapM :: Monad m => (a -> m b) -> Expr a -> m (Expr b) # sequence :: Monad m => Expr (m a) -> m (Expr a) #
TraversableWithLoc Expr Source #
Instance details Defined in Zinza.Expr Methods traverseWithLoc :: Applicative f => (Loc -> a -> f b) -> Expr a -> f (Expr b) Source #
Show a => Show (Expr a) Source #
Instance details Defined in Zinza.Expr Methods showsPrec :: Int -> Expr a -> ShowS # show :: Expr a -> String # showList :: [Expr a] -> ShowS #

type LExpr a = Located (Expr a) Source #

Located expression.

Types

Zinza's type-system is delibarately extremely simple.

data Ty Source #

Zinza types.

The selectors tell how the Haskell value can be converted to primitive value. E.g.

>>> toType (Proxy :: Proxy Char)
TyString (Just "return")

Here, return converts Char to String.

Constructors

TyBool	boolean
TyString (Maybe Selector)	string
TyList (Maybe Selector) Ty	lists
TyRecord (Map Var (Selector, Ty))	records

Instances

Eq Ty Source #
Instance details Defined in Zinza.Type Methods (==) :: Ty -> Ty -> Bool # (/=) :: Ty -> Ty -> Bool #
Ord Ty Source #
Instance details Defined in Zinza.Type Methods compare :: Ty -> Ty -> Ordering # (<) :: Ty -> Ty -> Bool # (<=) :: Ty -> Ty -> Bool # (>) :: Ty -> Ty -> Bool # (>=) :: Ty -> Ty -> Bool # max :: Ty -> Ty -> Ty # min :: Ty -> Ty -> Ty #
Show Ty Source #
Instance details Defined in Zinza.Type Methods showsPrec :: Int -> Ty -> ShowS # show :: Ty -> String # showList :: [Ty] -> ShowS #

displayTy :: Ty -> String Source #

Pretty print Ty.

Values

Values are passed at run-time, when the template is interpreted. When compiled to the Haskell module, Values aren't used.

data Value Source #

Template values.

Constructors

VBool Bool	booleans
VString String	strings
VList [Value]	lists
VRecord (Map Var Value)	records

Instances

Show Value Source #
Instance details Defined in Zinza.Value Methods showsPrec :: Int -> Value -> ShowS # show :: Value -> String # showList :: [Value] -> ShowS #

Errors

newtype ParseError Source #

Constructors

ParseError String

Instances

Show ParseError Source #
Instance details Defined in Zinza.Errors Methods showsPrec :: Int -> ParseError -> ShowS # show :: ParseError -> String # showList :: [ParseError] -> ShowS #
Exception ParseError Source #
Instance details Defined in Zinza.Errors Methods toException :: ParseError -> SomeException # fromException :: SomeException -> Maybe ParseError # displayException :: ParseError -> String #

data CompileError Source #

Constructors

UnboundTopLevelVar Loc Var
ARuntimeError RuntimeError

Instances

Show CompileError Source #
Instance details Defined in Zinza.Errors Methods showsPrec :: Int -> CompileError -> ShowS # show :: CompileError -> String # showList :: [CompileError] -> ShowS #
Exception CompileError Source #
Instance details Defined in Zinza.Errors Methods toException :: CompileError -> SomeException # fromException :: SomeException -> Maybe CompileError # displayException :: CompileError -> String #
AsRuntimeError CompileError Source #
Instance details Defined in Zinza.Errors Methods asRuntimeError :: RuntimeError -> CompileError Source #

data CompileOrParseError Source #

Constructors

ACompileError CompileError
AParseError ParseError

Instances

Show CompileOrParseError Source #
Instance details Defined in Zinza.Errors Methods showsPrec :: Int -> CompileOrParseError -> ShowS # show :: CompileOrParseError -> String # showList :: [CompileOrParseError] -> ShowS #
Exception CompileOrParseError Source #
Instance details Defined in Zinza.Errors Methods toException :: CompileOrParseError -> SomeException # fromException :: SomeException -> Maybe CompileOrParseError # displayException :: CompileOrParseError -> String #

data RuntimeError Source #

Constructors

NotBool Loc Ty
NotString Loc Ty
NotRecord Loc Ty
NotList Loc Ty
FieldNotInRecord Loc Var Ty

Instances

Show RuntimeError Source #
Instance details Defined in Zinza.Errors Methods showsPrec :: Int -> RuntimeError -> ShowS # show :: RuntimeError -> String # showList :: [RuntimeError] -> ShowS #
Exception RuntimeError Source #
Instance details Defined in Zinza.Errors Methods toException :: RuntimeError -> SomeException # fromException :: SomeException -> Maybe RuntimeError # displayException :: RuntimeError -> String #
AsRuntimeError RuntimeError Source #
Instance details Defined in Zinza.Errors Methods asRuntimeError :: RuntimeError -> RuntimeError Source #

class AsRuntimeError e where Source #

Class representing errors containing RuntimeErrors.

Without bugs, compiled template should not throw any RuntimeErrors, as they are prevented statically, i.e. reported already as CompileErrors.

Methods

asRuntimeError :: RuntimeError -> e Source #

Instances

AsRuntimeError RuntimeError Source #
Instance details Defined in Zinza.Errors Methods asRuntimeError :: RuntimeError -> RuntimeError Source #
AsRuntimeError CompileError Source #
Instance details Defined in Zinza.Errors Methods asRuntimeError :: RuntimeError -> CompileError Source #

class Monad m => ThrowRuntime m where Source #

Methods

throwRuntime :: RuntimeError -> m a Source #

Instances

ThrowRuntime IO Source #
Instance details Defined in Zinza.Errors Methods throwRuntime :: RuntimeError -> IO a Source #
AsRuntimeError e => ThrowRuntime (Either e) Source #
Instance details Defined in Zinza.Errors Methods throwRuntime :: RuntimeError -> Either e a Source #

Location

data Loc Source #

Location, line and column.

Constructors

Loc !Int !Int

Instances

Eq Loc Source #
Instance details Defined in Zinza.Pos Methods (==) :: Loc -> Loc -> Bool # (/=) :: Loc -> Loc -> Bool #
Show Loc Source #
Instance details Defined in Zinza.Pos Methods showsPrec :: Int -> Loc -> ShowS # show :: Loc -> String # showList :: [Loc] -> ShowS #

data Located a Source #

Located element.

Constructors

L !Loc a

Instances

Functor Located Source #
Instance details Defined in Zinza.Pos Methods fmap :: (a -> b) -> Located a -> Located b # (<$) :: a -> Located b -> Located a #
Foldable Located Source #
Instance details Defined in Zinza.Pos Methods fold :: Monoid m => Located m -> m # foldMap :: Monoid m => (a -> m) -> Located a -> m # foldr :: (a -> b -> b) -> b -> Located a -> b # foldr' :: (a -> b -> b) -> b -> Located a -> b # foldl :: (b -> a -> b) -> b -> Located a -> b # foldl' :: (b -> a -> b) -> b -> Located a -> b # foldr1 :: (a -> a -> a) -> Located a -> a # foldl1 :: (a -> a -> a) -> Located a -> a # toList :: Located a -> [a] # null :: Located a -> Bool # length :: Located a -> Int # elem :: Eq a => a -> Located a -> Bool # maximum :: Ord a => Located a -> a # minimum :: Ord a => Located a -> a # sum :: Num a => Located a -> a # product :: Num a => Located a -> a #
Traversable Located Source #
Instance details Defined in Zinza.Pos Methods traverse :: Applicative f => (a -> f b) -> Located a -> f (Located b) # sequenceA :: Applicative f => Located (f a) -> f (Located a) # mapM :: Monad m => (a -> m b) -> Located a -> m (Located b) # sequence :: Monad m => Located (m a) -> m (Located a) #
Eq a => Eq (Located a) Source #
Instance details Defined in Zinza.Pos Methods (==) :: Located a -> Located a -> Bool # (/=) :: Located a -> Located a -> Bool #
Show a => Show (Located a) Source #
Instance details Defined in Zinza.Pos Methods showsPrec :: Int -> Located a -> ShowS # show :: Located a -> String # showList :: [Located a] -> ShowS #

zeroLoc :: Loc Source #

Unknown location.

displayLoc :: Loc -> String Source #

Pretty-print location.

class Traversable t => TraversableWithLoc t where Source #

Some containers have location for each element.

Methods

traverseWithLoc :: Applicative f => (Loc -> a -> f b) -> t a -> f (t b) Source #

Instances

TraversableWithLoc Expr Source #
Instance details Defined in Zinza.Expr Methods traverseWithLoc :: Applicative f => (Loc -> a -> f b) -> Expr a -> f (Expr b) Source #
TraversableWithLoc Node Source #
Instance details Defined in Zinza.Node Methods traverseWithLoc :: Applicative f => (Loc -> a -> f b) -> Node a -> f (Node b) Source #

Variables

type Var = String Source #

Variable name, possibly a fieldname in the record.

type Selector = String Source #

Haskell selector.