{-# LANGUAGE RecordWildCards #-}

-- SPDX-FileCopyrightText: Copyright (c) 2025 Objectionary.com
-- SPDX-License-Identifier: MIT

module Encoding (toASCII, withEncoding, Encoding (..), ToASCII) where

import CST

data Encoding = ASCII | UNICODE
  deriving (Encoding -> Encoding -> Bool
(Encoding -> Encoding -> Bool)
-> (Encoding -> Encoding -> Bool) -> Eq Encoding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Encoding -> Encoding -> Bool
== :: Encoding -> Encoding -> Bool
$c/= :: Encoding -> Encoding -> Bool
/= :: Encoding -> Encoding -> Bool
Eq, Int -> Encoding -> ShowS
[Encoding] -> ShowS
Encoding -> String
(Int -> Encoding -> ShowS)
-> (Encoding -> String) -> ([Encoding] -> ShowS) -> Show Encoding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Encoding -> ShowS
showsPrec :: Int -> Encoding -> ShowS
$cshow :: Encoding -> String
show :: Encoding -> String
$cshowList :: [Encoding] -> ShowS
showList :: [Encoding] -> ShowS
Show)

withEncoding :: (ToASCII a) => Encoding -> a -> a
withEncoding :: forall a. ToASCII a => Encoding -> a -> a
withEncoding Encoding
UNICODE a
node = a
node
withEncoding Encoding
ASCII a
node = a -> a
forall a. ToASCII a => a -> a
toASCII a
node

class ToASCII a where
  toASCII :: a -> a

instance ToASCII EXPRESSION where
  toASCII :: EXPRESSION -> EXPRESSION
toASCII EX_GLOBAL{} = GLOBAL -> EXPRESSION
EX_GLOBAL GLOBAL
Q
  toASCII EX_XI{} = XI -> EXPRESSION
EX_XI XI
DOLLAR
  toASCII EX_ATTR{ATTRIBUTE
attr :: ATTRIBUTE
$sel:attr:EX_GLOBAL :: EXPRESSION -> ATTRIBUTE
..} = ATTRIBUTE -> EXPRESSION
EX_ATTR (ATTRIBUTE -> ATTRIBUTE
forall a. ToASCII a => a -> a
toASCII ATTRIBUTE
attr)
  toASCII EX_TERMINATION{} = TERMINATION -> EXPRESSION
EX_TERMINATION TERMINATION
T
  toASCII EX_FORMATION{BINDING
TAB
EOL
RSB
LSB
lsb :: LSB
eol :: EOL
tab :: TAB
binding :: BINDING
eol' :: EOL
tab' :: TAB
rsb :: RSB
$sel:lsb:EX_GLOBAL :: EXPRESSION -> LSB
$sel:eol:EX_GLOBAL :: EXPRESSION -> EOL
$sel:tab:EX_GLOBAL :: EXPRESSION -> TAB
$sel:binding:EX_GLOBAL :: EXPRESSION -> BINDING
$sel:eol':EX_GLOBAL :: EXPRESSION -> EOL
$sel:tab':EX_GLOBAL :: EXPRESSION -> TAB
$sel:rsb:EX_GLOBAL :: EXPRESSION -> RSB
..} = LSB -> EOL -> TAB -> BINDING -> EOL -> TAB -> RSB -> EXPRESSION
EX_FORMATION LSB
LSB' EOL
eol TAB
tab (BINDING -> BINDING
forall a. ToASCII a => a -> a
toASCII BINDING
binding) EOL
eol' TAB
tab' RSB
RSB'
  toASCII EX_DISPATCH{ATTRIBUTE
EXPRESSION
SPACE
$sel:attr:EX_GLOBAL :: EXPRESSION -> ATTRIBUTE
expr :: EXPRESSION
space :: SPACE
attr :: ATTRIBUTE
$sel:expr:EX_GLOBAL :: EXPRESSION -> EXPRESSION
$sel:space:EX_GLOBAL :: EXPRESSION -> SPACE
..} = EXPRESSION -> SPACE -> ATTRIBUTE -> EXPRESSION
EX_DISPATCH (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr) SPACE
space (ATTRIBUTE -> ATTRIBUTE
forall a. ToASCII a => a -> a
toASCII ATTRIBUTE
attr)
  toASCII EX_APPLICATION{Int
EXPRESSION
APP_ARGUMENT
TAB
EOL
SPACE
$sel:eol:EX_GLOBAL :: EXPRESSION -> EOL
$sel:tab:EX_GLOBAL :: EXPRESSION -> TAB
$sel:eol':EX_GLOBAL :: EXPRESSION -> EOL
$sel:tab':EX_GLOBAL :: EXPRESSION -> TAB
$sel:expr:EX_GLOBAL :: EXPRESSION -> EXPRESSION
$sel:space:EX_GLOBAL :: EXPRESSION -> SPACE
expr :: EXPRESSION
space :: SPACE
eol :: EOL
tab :: TAB
argument :: APP_ARGUMENT
eol' :: EOL
tab' :: TAB
indent :: Int
$sel:argument:EX_GLOBAL :: EXPRESSION -> APP_ARGUMENT
$sel:indent:EX_GLOBAL :: EXPRESSION -> Int
..} = EXPRESSION
-> SPACE
-> EOL
-> TAB
-> APP_ARGUMENT
-> EOL
-> TAB
-> Int
-> EXPRESSION
EX_APPLICATION (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr) SPACE
space EOL
eol TAB
tab (APP_ARGUMENT -> APP_ARGUMENT
forall a. ToASCII a => a -> a
toASCII APP_ARGUMENT
argument) EOL
eol' TAB
tab' Int
indent
  toASCII EX_NONFINITE{[Argument]
NonFinite
TAB
GLOBAL
$sel:tab:EX_GLOBAL :: EXPRESSION -> TAB
global :: GLOBAL
nonfinite :: NonFinite
tab :: TAB
rhos :: [Argument]
$sel:global:EX_GLOBAL :: EXPRESSION -> GLOBAL
$sel:rhos:EX_GLOBAL :: EXPRESSION -> [Argument]
$sel:nonfinite:EX_GLOBAL :: EXPRESSION -> NonFinite
..} = GLOBAL -> NonFinite -> TAB -> [Argument] -> EXPRESSION
EX_NONFINITE GLOBAL
Q NonFinite
nonfinite TAB
tab [Argument]
rhos
  toASCII EX_META{$sel:meta:EX_GLOBAL :: EXPRESSION -> META
meta = META{$sel:hd:META :: META -> META_HEAD
hd = META_HEAD
N, Text
EXCLAMATION
excl :: EXCLAMATION
rest :: Text
$sel:excl:META :: META -> EXCLAMATION
$sel:rest:META :: META -> Text
..}} = META -> EXPRESSION
EX_META (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
EXCL META_HEAD
N' Text
rest)
  toASCII EX_META{$sel:meta:EX_GLOBAL :: EXPRESSION -> META
meta = META{$sel:hd:META :: META -> META_HEAD
hd = META_HEAD
K, Text
EXCLAMATION
$sel:excl:META :: META -> EXCLAMATION
$sel:rest:META :: META -> Text
excl :: EXCLAMATION
rest :: Text
..}} = META -> EXPRESSION
EX_META (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
EXCL META_HEAD
K' Text
rest)
  toASCII EX_META{META
$sel:meta:EX_GLOBAL :: EXPRESSION -> META
meta :: META
..} = META -> EXPRESSION
EX_META (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
EXCL META_HEAD
E' (META -> Text
rest META
meta))
  toASCII EX_PHI_MEET{Int
Maybe String
EXPRESSION
$sel:expr:EX_GLOBAL :: EXPRESSION -> EXPRESSION
prefix :: Maybe String
idx :: Int
expr :: EXPRESSION
$sel:prefix:EX_GLOBAL :: EXPRESSION -> Maybe String
$sel:idx:EX_GLOBAL :: EXPRESSION -> Int
..} = Maybe String -> Int -> EXPRESSION -> EXPRESSION
EX_PHI_MEET Maybe String
prefix Int
idx (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr)
  toASCII EX_PHI_AGAIN{Int
Maybe String
EXPRESSION
$sel:expr:EX_GLOBAL :: EXPRESSION -> EXPRESSION
$sel:prefix:EX_GLOBAL :: EXPRESSION -> Maybe String
$sel:idx:EX_GLOBAL :: EXPRESSION -> Int
prefix :: Maybe String
idx :: Int
expr :: EXPRESSION
..} = Maybe String -> Int -> EXPRESSION -> EXPRESSION
EX_PHI_AGAIN Maybe String
prefix Int
idx (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr)
  toASCII EX_SINGLE{EXPRESSION
PAIR
SPACE
$sel:space:EX_GLOBAL :: EXPRESSION -> SPACE
pair :: PAIR
space :: SPACE
formation :: EXPRESSION
$sel:pair:EX_GLOBAL :: EXPRESSION -> PAIR
$sel:formation:EX_GLOBAL :: EXPRESSION -> EXPRESSION
..} = PAIR -> SPACE -> EXPRESSION -> EXPRESSION
EX_SINGLE (PAIR -> PAIR
forall a. ToASCII a => a -> a
toASCII PAIR
pair) SPACE
space (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
formation)
  toASCII EXPRESSION
expr = EXPRESSION
expr

instance ToASCII APP_BINDING where
  toASCII :: APP_BINDING -> APP_BINDING
toASCII APP_BINDING{PAIR
pair :: PAIR
$sel:pair:APP_BINDING :: APP_BINDING -> PAIR
..} = PAIR -> APP_BINDING
APP_BINDING (PAIR -> PAIR
forall a. ToASCII a => a -> a
toASCII PAIR
pair)

instance ToASCII BINDING where
  toASCII :: BINDING -> BINDING
toASCII BI_PAIR{BINDINGS
PAIR
TAB
pair :: PAIR
bindings :: BINDINGS
tab :: TAB
$sel:pair:BI_PAIR :: BINDING -> PAIR
$sel:bindings:BI_PAIR :: BINDING -> BINDINGS
$sel:tab:BI_PAIR :: BINDING -> TAB
..} = PAIR -> BINDINGS -> TAB -> BINDING
BI_PAIR (PAIR -> PAIR
forall a. ToASCII a => a -> a
toASCII PAIR
pair) (BINDINGS -> BINDINGS
forall a. ToASCII a => a -> a
toASCII BINDINGS
bindings) TAB
tab
  toASCII BI_META{$sel:meta:BI_PAIR :: BINDING -> META
meta = META{Text
EXCLAMATION
META_HEAD
$sel:hd:META :: META -> META_HEAD
$sel:excl:META :: META -> EXCLAMATION
$sel:rest:META :: META -> Text
excl :: EXCLAMATION
hd :: META_HEAD
rest :: Text
..}, BINDINGS
TAB
$sel:bindings:BI_PAIR :: BINDING -> BINDINGS
$sel:tab:BI_PAIR :: BINDING -> TAB
bindings :: BINDINGS
tab :: TAB
..} = META -> BINDINGS -> TAB -> BINDING
BI_META (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
EXCL META_HEAD
B' Text
rest) (BINDINGS -> BINDINGS
forall a. ToASCII a => a -> a
toASCII BINDINGS
bindings) TAB
tab
  toASCII BINDING
bd = BINDING
bd

instance ToASCII BINDINGS where
  toASCII :: BINDINGS -> BINDINGS
toASCII BDS_PAIR{BINDINGS
PAIR
TAB
EOL
eol :: EOL
tab :: TAB
pair :: PAIR
bindings :: BINDINGS
$sel:eol:BDS_PAIR :: BINDINGS -> EOL
$sel:tab:BDS_PAIR :: BINDINGS -> TAB
$sel:pair:BDS_PAIR :: BINDINGS -> PAIR
$sel:bindings:BDS_PAIR :: BINDINGS -> BINDINGS
..} = EOL -> TAB -> PAIR -> BINDINGS -> BINDINGS
BDS_PAIR EOL
eol TAB
tab (PAIR -> PAIR
forall a. ToASCII a => a -> a
toASCII PAIR
pair) (BINDINGS -> BINDINGS
forall a. ToASCII a => a -> a
toASCII BINDINGS
bindings)
  toASCII BDS_META{BINDINGS
TAB
META
EOL
$sel:eol:BDS_PAIR :: BINDINGS -> EOL
$sel:tab:BDS_PAIR :: BINDINGS -> TAB
$sel:bindings:BDS_PAIR :: BINDINGS -> BINDINGS
eol :: EOL
tab :: TAB
meta :: META
bindings :: BINDINGS
$sel:meta:BDS_PAIR :: BINDINGS -> META
..} = EOL -> TAB -> META -> BINDINGS -> BINDINGS
BDS_META EOL
eol TAB
tab (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
EXCL META_HEAD
B' (META -> Text
rest META
meta)) (BINDINGS -> BINDINGS
forall a. ToASCII a => a -> a
toASCII BINDINGS
bindings)
  toASCII BINDINGS
bds = BINDINGS
bds

instance ToASCII APP_ARGUMENT where
  toASCII :: APP_ARGUMENT -> APP_ARGUMENT
toASCII (AA_TAU APP_BINDING
tau) = APP_BINDING -> APP_ARGUMENT
AA_TAU (APP_BINDING -> APP_BINDING
forall a. ToASCII a => a -> a
toASCII APP_BINDING
tau)
  toASCII (AA_TAUS BINDING
taus) = BINDING -> APP_ARGUMENT
AA_TAUS (BINDING -> BINDING
forall a. ToASCII a => a -> a
toASCII BINDING
taus)
  toASCII (AA_EXPRS APP_ARG
args) = APP_ARG -> APP_ARGUMENT
AA_EXPRS (APP_ARG -> APP_ARG
forall a. ToASCII a => a -> a
toASCII APP_ARG
args)

instance ToASCII APP_ARG where
  toASCII :: APP_ARG -> APP_ARG
toASCII APP_ARG{EXPRESSION
APP_ARGS
expr :: EXPRESSION
args :: APP_ARGS
$sel:expr:APP_ARG :: APP_ARG -> EXPRESSION
$sel:args:APP_ARG :: APP_ARG -> APP_ARGS
..} = EXPRESSION -> APP_ARGS -> APP_ARG
APP_ARG (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr) (APP_ARGS -> APP_ARGS
forall a. ToASCII a => a -> a
toASCII APP_ARGS
args)

instance ToASCII APP_ARGS where
  toASCII :: APP_ARGS -> APP_ARGS
toASCII AAS_EXPR{EXPRESSION
APP_ARGS
TAB
EOL
eol :: EOL
tab :: TAB
expr :: EXPRESSION
args :: APP_ARGS
$sel:eol:AAS_EXPR :: APP_ARGS -> EOL
$sel:tab:AAS_EXPR :: APP_ARGS -> TAB
$sel:expr:AAS_EXPR :: APP_ARGS -> EXPRESSION
$sel:args:AAS_EXPR :: APP_ARGS -> APP_ARGS
..} = EOL -> TAB -> EXPRESSION -> APP_ARGS -> APP_ARGS
AAS_EXPR EOL
eol TAB
tab (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr) (APP_ARGS -> APP_ARGS
forall a. ToASCII a => a -> a
toASCII APP_ARGS
args)
  toASCII APP_ARGS
args = APP_ARGS
args

instance ToASCII PAIR where
  toASCII :: PAIR -> PAIR
toASCII PA_TAU{ATTRIBUTE
EXPRESSION
ARROW
attr :: ATTRIBUTE
arrow :: ARROW
expr :: EXPRESSION
$sel:attr:PA_TAU :: PAIR -> ATTRIBUTE
$sel:arrow:PA_TAU :: PAIR -> ARROW
$sel:expr:PA_TAU :: PAIR -> EXPRESSION
..} = ATTRIBUTE -> ARROW -> EXPRESSION -> PAIR
PA_TAU (ATTRIBUTE -> ATTRIBUTE
forall a. ToASCII a => a -> a
toASCII ATTRIBUTE
attr) ARROW
ARROW' (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr)
  toASCII PA_ALPHA{EXPRESSION
ALPHA
ARROW
$sel:arrow:PA_TAU :: PAIR -> ARROW
$sel:expr:PA_TAU :: PAIR -> EXPRESSION
alpha :: ALPHA
arrow :: ARROW
expr :: EXPRESSION
$sel:alpha:PA_TAU :: PAIR -> ALPHA
..} = ALPHA -> ARROW -> EXPRESSION -> PAIR
PA_ALPHA (ALPHA -> ALPHA
forall a. ToASCII a => a -> a
toASCII ALPHA
alpha) ARROW
ARROW' (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr)
  toASCII PA_FORMATION{[ATTRIBUTE]
ATTRIBUTE
EXPRESSION
ARROW
$sel:attr:PA_TAU :: PAIR -> ATTRIBUTE
$sel:arrow:PA_TAU :: PAIR -> ARROW
$sel:expr:PA_TAU :: PAIR -> EXPRESSION
attr :: ATTRIBUTE
voids :: [ATTRIBUTE]
arrow :: ARROW
expr :: EXPRESSION
$sel:voids:PA_TAU :: PAIR -> [ATTRIBUTE]
..} = ATTRIBUTE -> [ATTRIBUTE] -> ARROW -> EXPRESSION -> PAIR
PA_FORMATION (ATTRIBUTE -> ATTRIBUTE
forall a. ToASCII a => a -> a
toASCII ATTRIBUTE
attr) ((ATTRIBUTE -> ATTRIBUTE) -> [ATTRIBUTE] -> [ATTRIBUTE]
forall a b. (a -> b) -> [a] -> [b]
map ATTRIBUTE -> ATTRIBUTE
forall a. ToASCII a => a -> a
toASCII [ATTRIBUTE]
voids) ARROW
ARROW' (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr)
  toASCII PA_VOID{ATTRIBUTE
VOID
ARROW
$sel:attr:PA_TAU :: PAIR -> ATTRIBUTE
$sel:arrow:PA_TAU :: PAIR -> ARROW
attr :: ATTRIBUTE
arrow :: ARROW
void :: VOID
$sel:void:PA_TAU :: PAIR -> VOID
..} = ATTRIBUTE -> ARROW -> VOID -> PAIR
PA_VOID (ATTRIBUTE -> ATTRIBUTE
forall a. ToASCII a => a -> a
toASCII ATTRIBUTE
attr) ARROW
ARROW' VOID
QUESTION
  toASCII PA_LAMBDA{Text
func :: Text
$sel:func:PA_TAU :: PAIR -> Text
..} = Text -> PAIR
PA_LAMBDA' Text
func
  toASCII PA_DELTA{BYTES
bytes :: BYTES
$sel:bytes:PA_TAU :: PAIR -> BYTES
..} = BYTES -> PAIR
PA_DELTA' (BYTES -> BYTES
forall a. ToASCII a => a -> a
toASCII BYTES
bytes)
  toASCII PA_META_LAMBDA{$sel:meta:PA_TAU :: PAIR -> META
meta = META{$sel:hd:META :: META -> META_HEAD
hd = META_HEAD
S, Text
EXCLAMATION
$sel:excl:META :: META -> EXCLAMATION
$sel:rest:META :: META -> Text
excl :: EXCLAMATION
rest :: Text
..}} = META -> PAIR
PA_META_LAMBDA' (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
EXCL META_HEAD
S' Text
rest)
  toASCII PA_META_LAMBDA{$sel:meta:PA_TAU :: PAIR -> META
meta = META{Text
EXCLAMATION
META_HEAD
$sel:hd:META :: META -> META_HEAD
$sel:excl:META :: META -> EXCLAMATION
$sel:rest:META :: META -> Text
excl :: EXCLAMATION
hd :: META_HEAD
rest :: Text
..}} = META -> PAIR
PA_META_LAMBDA' (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
EXCL META_HEAD
F' Text
rest)
  toASCII PA_META_DELTA{META
$sel:meta:PA_TAU :: PAIR -> META
meta :: META
..} = META -> PAIR
PA_META_DELTA' (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
EXCL META_HEAD
D'' (META -> Text
rest META
meta))
  toASCII PAIR
pair = PAIR
pair

instance ToASCII BYTES where
  toASCII :: BYTES -> BYTES
toASCII (BT_META META
meta) = META -> BYTES
BT_META (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
EXCL META_HEAD
D'' (META -> Text
rest META
meta))
  toASCII BYTES
bts = BYTES
bts

instance ToASCII ALPHA where
  toASCII :: ALPHA -> ALPHA
toASCII AL_IDX{Int
ALPHA'
sym :: ALPHA'
idx :: Int
$sel:sym:AL_IDX :: ALPHA -> ALPHA'
$sel:idx:AL_IDX :: ALPHA -> Int
..} = ALPHA' -> Int -> ALPHA
AL_IDX ALPHA'
ALPHA' Int
idx
  toASCII AL_META{ALPHA'
META
$sel:sym:AL_IDX :: ALPHA -> ALPHA'
sym :: ALPHA'
meta :: META
$sel:meta:AL_IDX :: ALPHA -> META
..} = ALPHA' -> META -> ALPHA
AL_META ALPHA'
ALPHA' (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
EXCL META_HEAD
I' (META -> Text
rest META
meta))

instance ToASCII ATTRIBUTE where
  toASCII :: ATTRIBUTE -> ATTRIBUTE
toASCII AT_PHI{} = PHI -> ATTRIBUTE
AT_PHI PHI
AT
  toASCII AT_RHO{} = RHO -> ATTRIBUTE
AT_RHO RHO
CARET
  toASCII AT_META{META
meta :: META
$sel:meta:AT_LABEL :: ATTRIBUTE -> META
..} = META -> ATTRIBUTE
AT_META (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
EXCL META_HEAD
A (META -> Text
rest META
meta))
  toASCII ATTRIBUTE
attr = ATTRIBUTE
attr

instance ToASCII SET where
  toASCII :: SET -> SET
toASCII ST_BINDING{BINDING
binding :: BINDING
$sel:binding:ST_BINDING :: SET -> BINDING
..} = BINDING -> SET
ST_BINDING (BINDING -> BINDING
forall a. ToASCII a => a -> a
toASCII BINDING
binding)
  toASCII ST_ATTRIBUTES{[ATTRIBUTE]
attrs :: [ATTRIBUTE]
$sel:attrs:ST_BINDING :: SET -> [ATTRIBUTE]
..} = [ATTRIBUTE] -> SET
ST_ATTRIBUTES ((ATTRIBUTE -> ATTRIBUTE) -> [ATTRIBUTE] -> [ATTRIBUTE]
forall a b. (a -> b) -> [a] -> [b]
map ATTRIBUTE -> ATTRIBUTE
forall a. ToASCII a => a -> a
toASCII [ATTRIBUTE]
attrs)

instance ToASCII NUMBER where
  toASCII :: NUMBER -> NUMBER
toASCII IDX_META{META
meta :: META
$sel:meta:IDX_META :: NUMBER -> META
..} = META -> NUMBER
IDX_META (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
EXCL META_HEAD
I' (META -> Text
rest META
meta))
  toASCII LENGTH{BINDING
binding :: BINDING
$sel:binding:IDX_META :: NUMBER -> BINDING
..} = BINDING -> NUMBER
LENGTH (BINDING -> BINDING
forall a. ToASCII a => a -> a
toASCII BINDING
binding)
  toASCII DOMAIN{BINDING
$sel:binding:IDX_META :: NUMBER -> BINDING
binding :: BINDING
..} = BINDING -> NUMBER
DOMAIN (BINDING -> BINDING
forall a. ToASCII a => a -> a
toASCII BINDING
binding)
  toASCII literal :: NUMBER
literal@LITERAL{} = NUMBER
literal

instance ToASCII COMPARABLE where
  toASCII :: COMPARABLE -> COMPARABLE
toASCII CMP_ATTR{ATTRIBUTE
attr :: ATTRIBUTE
$sel:attr:CMP_ATTR :: COMPARABLE -> ATTRIBUTE
..} = ATTRIBUTE -> COMPARABLE
CMP_ATTR (ATTRIBUTE -> ATTRIBUTE
forall a. ToASCII a => a -> a
toASCII ATTRIBUTE
attr)
  toASCII CMP_EXPR{EXPRESSION
expr :: EXPRESSION
$sel:expr:CMP_ATTR :: COMPARABLE -> EXPRESSION
..} = EXPRESSION -> COMPARABLE
CMP_EXPR (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr)
  toASCII CMP_NUM{NUMBER
num :: NUMBER
$sel:num:CMP_ATTR :: COMPARABLE -> NUMBER
..} = NUMBER -> COMPARABLE
CMP_NUM (NUMBER -> NUMBER
forall a. ToASCII a => a -> a
toASCII NUMBER
num)

instance ToASCII CONDITION where
  toASCII :: CONDITION -> CONDITION
toASCII CO_BELONGS{SET
BELONGING
ATTRIBUTE
attr :: ATTRIBUTE
belongs :: BELONGING
set :: SET
$sel:attr:CO_EMPTY :: CONDITION -> ATTRIBUTE
$sel:belongs:CO_EMPTY :: CONDITION -> BELONGING
$sel:set:CO_EMPTY :: CONDITION -> SET
..} = ATTRIBUTE -> BELONGING -> SET -> CONDITION
CO_BELONGS (ATTRIBUTE -> ATTRIBUTE
forall a. ToASCII a => a -> a
toASCII ATTRIBUTE
attr) BELONGING
belongs (SET -> SET
forall a. ToASCII a => a -> a
toASCII SET
set)
  toASCII CO_LOGIC{[CONDITION]
LOGIC_OPERATOR
conditions :: [CONDITION]
operator :: LOGIC_OPERATOR
$sel:conditions:CO_EMPTY :: CONDITION -> [CONDITION]
$sel:operator:CO_EMPTY :: CONDITION -> LOGIC_OPERATOR
..} = [CONDITION] -> LOGIC_OPERATOR -> CONDITION
CO_LOGIC ((CONDITION -> CONDITION) -> [CONDITION] -> [CONDITION]
forall a b. (a -> b) -> [a] -> [b]
map CONDITION -> CONDITION
forall a. ToASCII a => a -> a
toASCII [CONDITION]
conditions) LOGIC_OPERATOR
operator
  toASCII CO_NF{EXPRESSION
expr :: EXPRESSION
$sel:expr:CO_EMPTY :: CONDITION -> EXPRESSION
..} = EXPRESSION -> CONDITION
CO_NF (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr)
  toASCII CO_ABSOLUTE{BELONGING
EXPRESSION
$sel:belongs:CO_EMPTY :: CONDITION -> BELONGING
$sel:expr:CO_EMPTY :: CONDITION -> EXPRESSION
expr :: EXPRESSION
belongs :: BELONGING
..} = EXPRESSION -> BELONGING -> CONDITION
CO_ABSOLUTE (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr) BELONGING
belongs
  toASCII CO_NOT{CONDITION
condition :: CONDITION
$sel:condition:CO_EMPTY :: CONDITION -> CONDITION
..} = CONDITION -> CONDITION
CO_NOT (CONDITION -> CONDITION
forall a. ToASCII a => a -> a
toASCII CONDITION
condition)
  toASCII CO_COMPARE{COMPARABLE
EQUAL
left :: COMPARABLE
equal :: EQUAL
right :: COMPARABLE
$sel:left:CO_EMPTY :: CONDITION -> COMPARABLE
$sel:equal:CO_EMPTY :: CONDITION -> EQUAL
$sel:right:CO_EMPTY :: CONDITION -> COMPARABLE
..} = COMPARABLE -> EQUAL -> COMPARABLE -> CONDITION
CO_COMPARE (COMPARABLE -> COMPARABLE
forall a. ToASCII a => a -> a
toASCII COMPARABLE
left) EQUAL
equal (COMPARABLE -> COMPARABLE
forall a. ToASCII a => a -> a
toASCII COMPARABLE
right)
  toASCII CO_MATCHES{String
EXPRESSION
$sel:expr:CO_EMPTY :: CONDITION -> EXPRESSION
regex :: String
expr :: EXPRESSION
$sel:regex:CO_EMPTY :: CONDITION -> String
..} = String -> EXPRESSION -> CONDITION
CO_MATCHES String
regex (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr)
  toASCII CO_PART_OF{EXPRESSION
BINDING
$sel:expr:CO_EMPTY :: CONDITION -> EXPRESSION
expr :: EXPRESSION
binding :: BINDING
$sel:binding:CO_EMPTY :: CONDITION -> BINDING
..} = EXPRESSION -> BINDING -> CONDITION
CO_PART_OF (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr) (BINDING -> BINDING
forall a. ToASCII a => a -> a
toASCII BINDING
binding)
  toASCII CO_DISJOINT{[ATTRIBUTE]
[BINDING]
attrs :: [ATTRIBUTE]
groups :: [BINDING]
$sel:attrs:CO_EMPTY :: CONDITION -> [ATTRIBUTE]
$sel:groups:CO_EMPTY :: CONDITION -> [BINDING]
..} = [ATTRIBUTE] -> [BINDING] -> CONDITION
CO_DISJOINT ((ATTRIBUTE -> ATTRIBUTE) -> [ATTRIBUTE] -> [ATTRIBUTE]
forall a b. (a -> b) -> [a] -> [b]
map ATTRIBUTE -> ATTRIBUTE
forall a. ToASCII a => a -> a
toASCII [ATTRIBUTE]
attrs) ((BINDING -> BINDING) -> [BINDING] -> [BINDING]
forall a b. (a -> b) -> [a] -> [b]
map BINDING -> BINDING
forall a. ToASCII a => a -> a
toASCII [BINDING]
groups)
  toASCII CO_SUBSET{[ATTRIBUTE]
[BINDING]
BELONGING
$sel:belongs:CO_EMPTY :: CONDITION -> BELONGING
$sel:attrs:CO_EMPTY :: CONDITION -> [ATTRIBUTE]
$sel:groups:CO_EMPTY :: CONDITION -> [BINDING]
attrs :: [ATTRIBUTE]
belongs :: BELONGING
groups :: [BINDING]
..} = [ATTRIBUTE] -> BELONGING -> [BINDING] -> CONDITION
CO_SUBSET ((ATTRIBUTE -> ATTRIBUTE) -> [ATTRIBUTE] -> [ATTRIBUTE]
forall a b. (a -> b) -> [a] -> [b]
map ATTRIBUTE -> ATTRIBUTE
forall a. ToASCII a => a -> a
toASCII [ATTRIBUTE]
attrs) BELONGING
belongs ((BINDING -> BINDING) -> [BINDING] -> [BINDING]
forall a b. (a -> b) -> [a] -> [b]
map BINDING -> BINDING
forall a. ToASCII a => a -> a
toASCII [BINDING]
groups)
  toASCII CO_FORMATION{EXPRESSION
$sel:expr:CO_EMPTY :: CONDITION -> EXPRESSION
expr :: EXPRESSION
..} = EXPRESSION -> CONDITION
CO_FORMATION (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr)
  toASCII CONDITION
CO_EMPTY = CONDITION
CO_EMPTY

instance ToASCII EXTRA_ARG where
  toASCII :: EXTRA_ARG -> EXTRA_ARG
toASCII ARG_ATTR{ATTRIBUTE
attr :: ATTRIBUTE
$sel:attr:ARG_EXPR :: EXTRA_ARG -> ATTRIBUTE
..} = ATTRIBUTE -> EXTRA_ARG
ARG_ATTR (ATTRIBUTE -> ATTRIBUTE
forall a. ToASCII a => a -> a
toASCII ATTRIBUTE
attr)
  toASCII ARG_EXPR{EXPRESSION
expr :: EXPRESSION
$sel:expr:ARG_EXPR :: EXTRA_ARG -> EXPRESSION
..} = EXPRESSION -> EXTRA_ARG
ARG_EXPR (EXPRESSION -> EXPRESSION
forall a. ToASCII a => a -> a
toASCII EXPRESSION
expr)
  toASCII ARG_BINDING{BINDING
binding :: BINDING
$sel:binding:ARG_EXPR :: EXTRA_ARG -> BINDING
..} = BINDING -> EXTRA_ARG
ARG_BINDING (BINDING -> BINDING
forall a. ToASCII a => a -> a
toASCII BINDING
binding)
  toASCII ARG_BYTES{BYTES
bytes :: BYTES
$sel:bytes:ARG_EXPR :: EXTRA_ARG -> BYTES
..} = BYTES -> EXTRA_ARG
ARG_BYTES (BYTES -> BYTES
forall a. ToASCII a => a -> a
toASCII BYTES
bytes)

instance ToASCII EXTRA where
  toASCII :: EXTRA -> EXTRA
toASCII EXTRA{String
[EXTRA_ARG]
EXTRA_ARG
meta :: EXTRA_ARG
func :: String
args :: [EXTRA_ARG]
$sel:meta:EXTRA :: EXTRA -> EXTRA_ARG
$sel:func:EXTRA :: EXTRA -> String
$sel:args:EXTRA :: EXTRA -> [EXTRA_ARG]
..} = EXTRA_ARG -> String -> [EXTRA_ARG] -> EXTRA
EXTRA (EXTRA_ARG -> EXTRA_ARG
forall a. ToASCII a => a -> a
toASCII EXTRA_ARG
meta) String
func ((EXTRA_ARG -> EXTRA_ARG) -> [EXTRA_ARG] -> [EXTRA_ARG]
forall a b. (a -> b) -> [a] -> [b]
map EXTRA_ARG -> EXTRA_ARG
forall a. ToASCII a => a -> a
toASCII [EXTRA_ARG]
args)