{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# OPTIONS_GHC -Wno-partial-fields -Wno-name-shadowing #-}

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

import AST
import Bytes (NonFinite, btsIsUtf8, btsSize, btsToNonFinite, btsToNum, btsToStr)
import Data.Maybe (isJust)
import qualified Data.Text as T
import qualified Yaml as Y

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

data BYTES
  = BT_EMPTY
  | BT_ONE String
  | BT_MANY [String]
  | BT_META META
  | BT_PIPED BYTES
  | BT_CUT [String] Int [String]
  deriving (BYTES -> BYTES -> Bool
(BYTES -> BYTES -> Bool) -> (BYTES -> BYTES -> Bool) -> Eq BYTES
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BYTES -> BYTES -> Bool
== :: BYTES -> BYTES -> Bool
$c/= :: BYTES -> BYTES -> Bool
/= :: BYTES -> BYTES -> Bool
Eq, Int -> BYTES -> ShowS
[BYTES] -> ShowS
BYTES -> String
(Int -> BYTES -> ShowS)
-> (BYTES -> String) -> ([BYTES] -> ShowS) -> Show BYTES
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BYTES -> ShowS
showsPrec :: Int -> BYTES -> ShowS
$cshow :: BYTES -> String
show :: BYTES -> String
$cshowList :: [BYTES] -> ShowS
showList :: [BYTES] -> ShowS
Show)

data META_HEAD
  = E
  | E'
  | N
  | N'
  | K
  | K'
  | A
  | TAU
  | TAU'
  | I
  | I'
  | B
  | B'
  | D
  | D'
  | D''
  | F
  | F'
  | F''
  | S
  | S'
  | S''
  deriving (META_HEAD -> META_HEAD -> Bool
(META_HEAD -> META_HEAD -> Bool)
-> (META_HEAD -> META_HEAD -> Bool) -> Eq META_HEAD
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: META_HEAD -> META_HEAD -> Bool
== :: META_HEAD -> META_HEAD -> Bool
$c/= :: META_HEAD -> META_HEAD -> Bool
/= :: META_HEAD -> META_HEAD -> Bool
Eq, Int -> META_HEAD -> ShowS
[META_HEAD] -> ShowS
META_HEAD -> String
(Int -> META_HEAD -> ShowS)
-> (META_HEAD -> String)
-> ([META_HEAD] -> ShowS)
-> Show META_HEAD
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> META_HEAD -> ShowS
showsPrec :: Int -> META_HEAD -> ShowS
$cshow :: META_HEAD -> String
show :: META_HEAD -> String
$cshowList :: [META_HEAD] -> ShowS
showList :: [META_HEAD] -> ShowS
Show)

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

data META = META {META -> EXCLAMATION
excl :: EXCLAMATION, META -> META_HEAD
hd :: META_HEAD, META -> Text
rest :: T.Text}
  deriving (META -> META -> Bool
(META -> META -> Bool) -> (META -> META -> Bool) -> Eq META
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: META -> META -> Bool
== :: META -> META -> Bool
$c/= :: META -> META -> Bool
/= :: META -> META -> Bool
Eq, Int -> META -> ShowS
[META] -> ShowS
META -> String
(Int -> META -> ShowS)
-> (META -> String) -> ([META] -> ShowS) -> Show META
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> META -> ShowS
showsPrec :: Int -> META -> ShowS
$cshow :: META -> String
show :: META -> String
$cshowList :: [META] -> ShowS
showList :: [META] -> ShowS
Show)

data TAB
  = TAB {TAB -> Int
indent :: Int}
  | TAB'
  | NO_TAB
  deriving (TAB -> TAB -> Bool
(TAB -> TAB -> Bool) -> (TAB -> TAB -> Bool) -> Eq TAB
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TAB -> TAB -> Bool
== :: TAB -> TAB -> Bool
$c/= :: TAB -> TAB -> Bool
/= :: TAB -> TAB -> Bool
Eq, Int -> TAB -> ShowS
[TAB] -> ShowS
TAB -> String
(Int -> TAB -> ShowS)
-> (TAB -> String) -> ([TAB] -> ShowS) -> Show TAB
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TAB -> ShowS
showsPrec :: Int -> TAB -> ShowS
$cshow :: TAB -> String
show :: TAB -> String
$cshowList :: [TAB] -> ShowS
showList :: [TAB] -> ShowS
Show)

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

data ALPHA
  = AL_IDX {ALPHA -> ALPHA'
sym :: ALPHA', ALPHA -> Int
idx :: Int}
  | AL_META {sym :: ALPHA', ALPHA -> META
meta :: META}
  deriving (ALPHA -> ALPHA -> Bool
(ALPHA -> ALPHA -> Bool) -> (ALPHA -> ALPHA -> Bool) -> Eq ALPHA
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ALPHA -> ALPHA -> Bool
== :: ALPHA -> ALPHA -> Bool
$c/= :: ALPHA -> ALPHA -> Bool
/= :: ALPHA -> ALPHA -> Bool
Eq, Int -> ALPHA -> ShowS
[ALPHA] -> ShowS
ALPHA -> String
(Int -> ALPHA -> ShowS)
-> (ALPHA -> String) -> ([ALPHA] -> ShowS) -> Show ALPHA
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ALPHA -> ShowS
showsPrec :: Int -> ALPHA -> ShowS
$cshow :: ALPHA -> String
show :: ALPHA -> String
$cshowList :: [ALPHA] -> ShowS
showList :: [ALPHA] -> ShowS
Show)

data PAIR
  = PA_TAU {PAIR -> ATTRIBUTE
attr :: ATTRIBUTE, PAIR -> ARROW
arrow :: ARROW, PAIR -> EXPRESSION
expr :: EXPRESSION}
  | PA_ALPHA {PAIR -> ALPHA
alpha :: ALPHA, arrow :: ARROW, expr :: EXPRESSION}
  | PA_FORMATION {attr :: ATTRIBUTE, PAIR -> [ATTRIBUTE]
voids :: [ATTRIBUTE], arrow :: ARROW, expr :: EXPRESSION}
  | PA_VOID {attr :: ATTRIBUTE, arrow :: ARROW, PAIR -> VOID
void :: VOID}
  | PA_LAMBDA {PAIR -> Text
func :: T.Text}
  | PA_LAMBDA' {func :: T.Text}
  | PA_META_LAMBDA {PAIR -> META
meta :: META}
  | PA_META_LAMBDA' {meta :: META}
  | PA_DELTA {PAIR -> BYTES
bytes :: BYTES}
  | PA_DELTA' {bytes :: BYTES}
  | PA_META_DELTA {meta :: META}
  | PA_META_DELTA' {meta :: META}
  | PA_FOLDED {PAIR -> Int
count :: Int}
  deriving (PAIR -> PAIR -> Bool
(PAIR -> PAIR -> Bool) -> (PAIR -> PAIR -> Bool) -> Eq PAIR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PAIR -> PAIR -> Bool
== :: PAIR -> PAIR -> Bool
$c/= :: PAIR -> PAIR -> Bool
/= :: PAIR -> PAIR -> Bool
Eq, Int -> PAIR -> ShowS
[PAIR] -> ShowS
PAIR -> String
(Int -> PAIR -> ShowS)
-> (PAIR -> String) -> ([PAIR] -> ShowS) -> Show PAIR
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PAIR -> ShowS
showsPrec :: Int -> PAIR -> ShowS
$cshow :: PAIR -> String
show :: PAIR -> String
$cshowList :: [PAIR] -> ShowS
showList :: [PAIR] -> ShowS
Show)

newtype APP_BINDING = APP_BINDING {APP_BINDING -> PAIR
pair :: PAIR}
  deriving (APP_BINDING -> APP_BINDING -> Bool
(APP_BINDING -> APP_BINDING -> Bool)
-> (APP_BINDING -> APP_BINDING -> Bool) -> Eq APP_BINDING
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: APP_BINDING -> APP_BINDING -> Bool
== :: APP_BINDING -> APP_BINDING -> Bool
$c/= :: APP_BINDING -> APP_BINDING -> Bool
/= :: APP_BINDING -> APP_BINDING -> Bool
Eq, Int -> APP_BINDING -> ShowS
[APP_BINDING] -> ShowS
APP_BINDING -> String
(Int -> APP_BINDING -> ShowS)
-> (APP_BINDING -> String)
-> ([APP_BINDING] -> ShowS)
-> Show APP_BINDING
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> APP_BINDING -> ShowS
showsPrec :: Int -> APP_BINDING -> ShowS
$cshow :: APP_BINDING -> String
show :: APP_BINDING -> String
$cshowList :: [APP_BINDING] -> ShowS
showList :: [APP_BINDING] -> ShowS
Show)

data BINDING
  = BI_PAIR {BINDING -> PAIR
pair :: PAIR, BINDING -> BINDINGS
bindings :: BINDINGS, BINDING -> TAB
tab :: TAB}
  | BI_EMPTY {tab :: TAB}
  | BI_META {BINDING -> META
meta :: META, bindings :: BINDINGS, tab :: TAB}
  deriving (BINDING -> BINDING -> Bool
(BINDING -> BINDING -> Bool)
-> (BINDING -> BINDING -> Bool) -> Eq BINDING
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BINDING -> BINDING -> Bool
== :: BINDING -> BINDING -> Bool
$c/= :: BINDING -> BINDING -> Bool
/= :: BINDING -> BINDING -> Bool
Eq, Int -> BINDING -> ShowS
[BINDING] -> ShowS
BINDING -> String
(Int -> BINDING -> ShowS)
-> (BINDING -> String) -> ([BINDING] -> ShowS) -> Show BINDING
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BINDING -> ShowS
showsPrec :: Int -> BINDING -> ShowS
$cshow :: BINDING -> String
show :: BINDING -> String
$cshowList :: [BINDING] -> ShowS
showList :: [BINDING] -> ShowS
Show)

data BINDINGS
  = BDS_PAIR {BINDINGS -> EOL
eol :: EOL, BINDINGS -> TAB
tab :: TAB, BINDINGS -> PAIR
pair :: PAIR, BINDINGS -> BINDINGS
bindings :: BINDINGS}
  | BDS_EMPTY {tab :: TAB}
  | BDS_META {eol :: EOL, tab :: TAB, BINDINGS -> META
meta :: META, bindings :: BINDINGS}
  deriving (BINDINGS -> BINDINGS -> Bool
(BINDINGS -> BINDINGS -> Bool)
-> (BINDINGS -> BINDINGS -> Bool) -> Eq BINDINGS
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BINDINGS -> BINDINGS -> Bool
== :: BINDINGS -> BINDINGS -> Bool
$c/= :: BINDINGS -> BINDINGS -> Bool
/= :: BINDINGS -> BINDINGS -> Bool
Eq, Int -> BINDINGS -> ShowS
[BINDINGS] -> ShowS
BINDINGS -> String
(Int -> BINDINGS -> ShowS)
-> (BINDINGS -> String) -> ([BINDINGS] -> ShowS) -> Show BINDINGS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BINDINGS -> ShowS
showsPrec :: Int -> BINDINGS -> ShowS
$cshow :: BINDINGS -> String
show :: BINDINGS -> String
$cshowList :: [BINDINGS] -> ShowS
showList :: [BINDINGS] -> ShowS
Show)

data APP_ARG = APP_ARG {APP_ARG -> EXPRESSION
expr :: EXPRESSION, APP_ARG -> APP_ARGS
args :: APP_ARGS}
  deriving (APP_ARG -> APP_ARG -> Bool
(APP_ARG -> APP_ARG -> Bool)
-> (APP_ARG -> APP_ARG -> Bool) -> Eq APP_ARG
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: APP_ARG -> APP_ARG -> Bool
== :: APP_ARG -> APP_ARG -> Bool
$c/= :: APP_ARG -> APP_ARG -> Bool
/= :: APP_ARG -> APP_ARG -> Bool
Eq, Int -> APP_ARG -> ShowS
[APP_ARG] -> ShowS
APP_ARG -> String
(Int -> APP_ARG -> ShowS)
-> (APP_ARG -> String) -> ([APP_ARG] -> ShowS) -> Show APP_ARG
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> APP_ARG -> ShowS
showsPrec :: Int -> APP_ARG -> ShowS
$cshow :: APP_ARG -> String
show :: APP_ARG -> String
$cshowList :: [APP_ARG] -> ShowS
showList :: [APP_ARG] -> ShowS
Show)

data APP_ARGS
  = AAS_EXPR {APP_ARGS -> EOL
eol :: EOL, APP_ARGS -> TAB
tab :: TAB, APP_ARGS -> EXPRESSION
expr :: EXPRESSION, APP_ARGS -> APP_ARGS
args :: APP_ARGS}
  | AAS_EMPTY
  deriving (APP_ARGS -> APP_ARGS -> Bool
(APP_ARGS -> APP_ARGS -> Bool)
-> (APP_ARGS -> APP_ARGS -> Bool) -> Eq APP_ARGS
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: APP_ARGS -> APP_ARGS -> Bool
== :: APP_ARGS -> APP_ARGS -> Bool
$c/= :: APP_ARGS -> APP_ARGS -> Bool
/= :: APP_ARGS -> APP_ARGS -> Bool
Eq, Int -> APP_ARGS -> ShowS
[APP_ARGS] -> ShowS
APP_ARGS -> String
(Int -> APP_ARGS -> ShowS)
-> (APP_ARGS -> String) -> ([APP_ARGS] -> ShowS) -> Show APP_ARGS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> APP_ARGS -> ShowS
showsPrec :: Int -> APP_ARGS -> ShowS
$cshow :: APP_ARGS -> String
show :: APP_ARGS -> String
$cshowList :: [APP_ARGS] -> ShowS
showList :: [APP_ARGS] -> ShowS
Show)

data APP_ARGUMENT
  = AA_TAU APP_BINDING
  | AA_TAUS BINDING
  | AA_EXPRS APP_ARG
  deriving (APP_ARGUMENT -> APP_ARGUMENT -> Bool
(APP_ARGUMENT -> APP_ARGUMENT -> Bool)
-> (APP_ARGUMENT -> APP_ARGUMENT -> Bool) -> Eq APP_ARGUMENT
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: APP_ARGUMENT -> APP_ARGUMENT -> Bool
== :: APP_ARGUMENT -> APP_ARGUMENT -> Bool
$c/= :: APP_ARGUMENT -> APP_ARGUMENT -> Bool
/= :: APP_ARGUMENT -> APP_ARGUMENT -> Bool
Eq, Int -> APP_ARGUMENT -> ShowS
[APP_ARGUMENT] -> ShowS
APP_ARGUMENT -> String
(Int -> APP_ARGUMENT -> ShowS)
-> (APP_ARGUMENT -> String)
-> ([APP_ARGUMENT] -> ShowS)
-> Show APP_ARGUMENT
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> APP_ARGUMENT -> ShowS
showsPrec :: Int -> APP_ARGUMENT -> ShowS
$cshow :: APP_ARGUMENT -> String
show :: APP_ARGUMENT -> String
$cshowList :: [APP_ARGUMENT] -> ShowS
showList :: [APP_ARGUMENT] -> ShowS
Show)

data EXPRESSION
  = EX_GLOBAL {EXPRESSION -> GLOBAL
global :: GLOBAL}
  | EX_XI {EXPRESSION -> XI
xi :: XI}
  | EX_ATTR {EXPRESSION -> ATTRIBUTE
attr :: ATTRIBUTE}
  | EX_TERMINATION {EXPRESSION -> TERMINATION
termination :: TERMINATION}
  | EX_FORMATION {EXPRESSION -> LSB
lsb :: LSB, EXPRESSION -> EOL
eol :: EOL, EXPRESSION -> TAB
tab :: TAB, EXPRESSION -> BINDING
binding :: BINDING, EXPRESSION -> EOL
eol' :: EOL, EXPRESSION -> TAB
tab' :: TAB, EXPRESSION -> RSB
rsb :: RSB}
  | EX_DISPATCH {EXPRESSION -> EXPRESSION
expr :: EXPRESSION, EXPRESSION -> SPACE
space :: SPACE, attr :: ATTRIBUTE}
  | EX_APPLICATION {expr :: EXPRESSION, space :: SPACE, eol :: EOL, tab :: TAB, EXPRESSION -> APP_ARGUMENT
argument :: APP_ARGUMENT, eol' :: EOL, tab' :: TAB, EXPRESSION -> Int
indent :: Int}
  | EX_STRING {EXPRESSION -> String
str :: String, tab :: TAB, EXPRESSION -> [Argument]
rhos :: [Argument]}
  | EX_NUMBER {EXPRESSION -> Double
num :: Double, tab :: TAB, rhos :: [Argument]}
  | EX_NONFINITE {global :: GLOBAL, EXPRESSION -> NonFinite
nonfinite :: NonFinite, tab :: TAB, rhos :: [Argument]}
  | EX_META {EXPRESSION -> META
meta :: META}
  | EX_PHI_MEET {EXPRESSION -> Maybe String
prefix :: Maybe String, EXPRESSION -> Int
idx :: Int, expr :: EXPRESSION}
  | EX_PHI_AGAIN {prefix :: Maybe String, idx :: Int, expr :: EXPRESSION}
  | EX_BYTES {EXPRESSION -> BYTES
bytes :: BYTES}
  | EX_SINGLE {EXPRESSION -> PAIR
pair :: PAIR, space :: SPACE, EXPRESSION -> EXPRESSION
formation :: EXPRESSION}
  deriving (EXPRESSION -> EXPRESSION -> Bool
(EXPRESSION -> EXPRESSION -> Bool)
-> (EXPRESSION -> EXPRESSION -> Bool) -> Eq EXPRESSION
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EXPRESSION -> EXPRESSION -> Bool
== :: EXPRESSION -> EXPRESSION -> Bool
$c/= :: EXPRESSION -> EXPRESSION -> Bool
/= :: EXPRESSION -> EXPRESSION -> Bool
Eq, Int -> EXPRESSION -> ShowS
[EXPRESSION] -> ShowS
EXPRESSION -> String
(Int -> EXPRESSION -> ShowS)
-> (EXPRESSION -> String)
-> ([EXPRESSION] -> ShowS)
-> Show EXPRESSION
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EXPRESSION -> ShowS
showsPrec :: Int -> EXPRESSION -> ShowS
$cshow :: EXPRESSION -> String
show :: EXPRESSION -> String
$cshowList :: [EXPRESSION] -> ShowS
showList :: [EXPRESSION] -> ShowS
Show)

data ATTRIBUTE
  = AT_LABEL {ATTRIBUTE -> Text
label :: T.Text}
  | AT_RHO {ATTRIBUTE -> RHO
rho :: RHO}
  | AT_PHI {ATTRIBUTE -> PHI
phi :: PHI}
  | AT_LAMBDA {ATTRIBUTE -> LAMBDA
lambda :: LAMBDA}
  | AT_DELTA {ATTRIBUTE -> DELTA
delta :: DELTA}
  | AT_META {ATTRIBUTE -> META
meta :: META}
  | AT_REST {ATTRIBUTE -> DOTS
dots :: DOTS}
  deriving (ATTRIBUTE -> ATTRIBUTE -> Bool
(ATTRIBUTE -> ATTRIBUTE -> Bool)
-> (ATTRIBUTE -> ATTRIBUTE -> Bool) -> Eq ATTRIBUTE
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ATTRIBUTE -> ATTRIBUTE -> Bool
== :: ATTRIBUTE -> ATTRIBUTE -> Bool
$c/= :: ATTRIBUTE -> ATTRIBUTE -> Bool
/= :: ATTRIBUTE -> ATTRIBUTE -> Bool
Eq, Int -> ATTRIBUTE -> ShowS
[ATTRIBUTE] -> ShowS
ATTRIBUTE -> String
(Int -> ATTRIBUTE -> ShowS)
-> (ATTRIBUTE -> String)
-> ([ATTRIBUTE] -> ShowS)
-> Show ATTRIBUTE
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ATTRIBUTE -> ShowS
showsPrec :: Int -> ATTRIBUTE -> ShowS
$cshow :: ATTRIBUTE -> String
show :: ATTRIBUTE -> String
$cshowList :: [ATTRIBUTE] -> ShowS
showList :: [ATTRIBUTE] -> ShowS
Show)

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

data SET
  = ST_BINDING {SET -> BINDING
binding :: BINDING}
  | ST_ATTRIBUTES {SET -> [ATTRIBUTE]
attrs :: [ATTRIBUTE]}
  deriving (SET -> SET -> Bool
(SET -> SET -> Bool) -> (SET -> SET -> Bool) -> Eq SET
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SET -> SET -> Bool
== :: SET -> SET -> Bool
$c/= :: SET -> SET -> Bool
/= :: SET -> SET -> Bool
Eq, Int -> SET -> ShowS
[SET] -> ShowS
SET -> String
(Int -> SET -> ShowS)
-> (SET -> String) -> ([SET] -> ShowS) -> Show SET
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SET -> ShowS
showsPrec :: Int -> SET -> ShowS
$cshow :: SET -> String
show :: SET -> String
$cshowList :: [SET] -> ShowS
showList :: [SET] -> ShowS
Show)

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

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

data NUMBER
  = IDX_META {NUMBER -> META
meta :: META}
  | LENGTH {NUMBER -> BINDING
binding :: BINDING}
  | DOMAIN {binding :: BINDING}
  | LITERAL {NUMBER -> Int
num :: Int}
  deriving (NUMBER -> NUMBER -> Bool
(NUMBER -> NUMBER -> Bool)
-> (NUMBER -> NUMBER -> Bool) -> Eq NUMBER
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NUMBER -> NUMBER -> Bool
== :: NUMBER -> NUMBER -> Bool
$c/= :: NUMBER -> NUMBER -> Bool
/= :: NUMBER -> NUMBER -> Bool
Eq, Int -> NUMBER -> ShowS
[NUMBER] -> ShowS
NUMBER -> String
(Int -> NUMBER -> ShowS)
-> (NUMBER -> String) -> ([NUMBER] -> ShowS) -> Show NUMBER
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NUMBER -> ShowS
showsPrec :: Int -> NUMBER -> ShowS
$cshow :: NUMBER -> String
show :: NUMBER -> String
$cshowList :: [NUMBER] -> ShowS
showList :: [NUMBER] -> ShowS
Show)

data COMPARABLE
  = CMP_ATTR {COMPARABLE -> ATTRIBUTE
attr :: ATTRIBUTE}
  | CMP_EXPR {COMPARABLE -> EXPRESSION
expr :: EXPRESSION}
  | CMP_NUM {COMPARABLE -> NUMBER
num :: NUMBER}
  deriving (COMPARABLE -> COMPARABLE -> Bool
(COMPARABLE -> COMPARABLE -> Bool)
-> (COMPARABLE -> COMPARABLE -> Bool) -> Eq COMPARABLE
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: COMPARABLE -> COMPARABLE -> Bool
== :: COMPARABLE -> COMPARABLE -> Bool
$c/= :: COMPARABLE -> COMPARABLE -> Bool
/= :: COMPARABLE -> COMPARABLE -> Bool
Eq, Int -> COMPARABLE -> ShowS
[COMPARABLE] -> ShowS
COMPARABLE -> String
(Int -> COMPARABLE -> ShowS)
-> (COMPARABLE -> String)
-> ([COMPARABLE] -> ShowS)
-> Show COMPARABLE
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> COMPARABLE -> ShowS
showsPrec :: Int -> COMPARABLE -> ShowS
$cshow :: COMPARABLE -> String
show :: COMPARABLE -> String
$cshowList :: [COMPARABLE] -> ShowS
showList :: [COMPARABLE] -> ShowS
Show)

data CONDITION
  = CO_EMPTY
  | CO_BELONGS {CONDITION -> ATTRIBUTE
attr :: ATTRIBUTE, CONDITION -> BELONGING
belongs :: BELONGING, CONDITION -> SET
set :: SET}
  | CO_LOGIC {CONDITION -> [CONDITION]
conditions :: [CONDITION], CONDITION -> LOGIC_OPERATOR
operator :: LOGIC_OPERATOR}
  | CO_NF {CONDITION -> EXPRESSION
expr :: EXPRESSION}
  | CO_ABSOLUTE {expr :: EXPRESSION, belongs :: BELONGING}
  | CO_NOT {CONDITION -> CONDITION
condition :: CONDITION}
  | CO_COMPARE {CONDITION -> COMPARABLE
left :: COMPARABLE, CONDITION -> EQUAL
equal :: EQUAL, CONDITION -> COMPARABLE
right :: COMPARABLE}
  | CO_MATCHES {CONDITION -> String
regex :: String, expr :: EXPRESSION}
  | CO_PART_OF {expr :: EXPRESSION, CONDITION -> BINDING
binding :: BINDING}
  | CO_DISJOINT {CONDITION -> [ATTRIBUTE]
attrs :: [ATTRIBUTE], CONDITION -> [BINDING]
groups :: [BINDING]}
  | CO_SUBSET {attrs :: [ATTRIBUTE], belongs :: BELONGING, groups :: [BINDING]}
  | CO_FORMATION {expr :: EXPRESSION}
  deriving (CONDITION -> CONDITION -> Bool
(CONDITION -> CONDITION -> Bool)
-> (CONDITION -> CONDITION -> Bool) -> Eq CONDITION
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CONDITION -> CONDITION -> Bool
== :: CONDITION -> CONDITION -> Bool
$c/= :: CONDITION -> CONDITION -> Bool
/= :: CONDITION -> CONDITION -> Bool
Eq, Int -> CONDITION -> ShowS
[CONDITION] -> ShowS
CONDITION -> String
(Int -> CONDITION -> ShowS)
-> (CONDITION -> String)
-> ([CONDITION] -> ShowS)
-> Show CONDITION
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CONDITION -> ShowS
showsPrec :: Int -> CONDITION -> ShowS
$cshow :: CONDITION -> String
show :: CONDITION -> String
$cshowList :: [CONDITION] -> ShowS
showList :: [CONDITION] -> ShowS
Show)

data EXTRA_ARG
  = ARG_EXPR {EXTRA_ARG -> EXPRESSION
expr :: EXPRESSION}
  | ARG_ATTR {EXTRA_ARG -> ATTRIBUTE
attr :: ATTRIBUTE}
  | ARG_BINDING {EXTRA_ARG -> BINDING
binding :: BINDING}
  | ARG_BYTES {EXTRA_ARG -> BYTES
bytes :: BYTES}
  deriving (EXTRA_ARG -> EXTRA_ARG -> Bool
(EXTRA_ARG -> EXTRA_ARG -> Bool)
-> (EXTRA_ARG -> EXTRA_ARG -> Bool) -> Eq EXTRA_ARG
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EXTRA_ARG -> EXTRA_ARG -> Bool
== :: EXTRA_ARG -> EXTRA_ARG -> Bool
$c/= :: EXTRA_ARG -> EXTRA_ARG -> Bool
/= :: EXTRA_ARG -> EXTRA_ARG -> Bool
Eq, Int -> EXTRA_ARG -> ShowS
[EXTRA_ARG] -> ShowS
EXTRA_ARG -> String
(Int -> EXTRA_ARG -> ShowS)
-> (EXTRA_ARG -> String)
-> ([EXTRA_ARG] -> ShowS)
-> Show EXTRA_ARG
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EXTRA_ARG -> ShowS
showsPrec :: Int -> EXTRA_ARG -> ShowS
$cshow :: EXTRA_ARG -> String
show :: EXTRA_ARG -> String
$cshowList :: [EXTRA_ARG] -> ShowS
showList :: [EXTRA_ARG] -> ShowS
Show)

data EXTRA = EXTRA {EXTRA -> EXTRA_ARG
meta :: EXTRA_ARG, EXTRA -> String
func :: String, EXTRA -> [EXTRA_ARG]
args :: [EXTRA_ARG]}
  deriving (EXTRA -> EXTRA -> Bool
(EXTRA -> EXTRA -> Bool) -> (EXTRA -> EXTRA -> Bool) -> Eq EXTRA
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EXTRA -> EXTRA -> Bool
== :: EXTRA -> EXTRA -> Bool
$c/= :: EXTRA -> EXTRA -> Bool
/= :: EXTRA -> EXTRA -> Bool
Eq, Int -> EXTRA -> ShowS
[EXTRA] -> ShowS
EXTRA -> String
(Int -> EXTRA -> ShowS)
-> (EXTRA -> String) -> ([EXTRA] -> ShowS) -> Show EXTRA
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EXTRA -> ShowS
showsPrec :: Int -> EXTRA -> ShowS
$cshow :: EXTRA -> String
show :: EXTRA -> String
$cshowList :: [EXTRA] -> ShowS
showList :: [EXTRA] -> ShowS
Show)

expressionToCST :: Expression -> EXPRESSION
expressionToCST :: Expression -> EXPRESSION
expressionToCST = Expression -> EXPRESSION
forall a b. ToCST a b => a -> b
toCST'

expressionToCSTFrom :: Int -> Expression -> EXPRESSION
expressionToCSTFrom :: Int -> Expression -> EXPRESSION
expressionToCSTFrom Int
tabs Expression
expr = Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Expression
expr (Int
tabs, EOL
EOL)

sweetNumber :: Bytes -> Bool
sweetNumber :: Bytes -> Bool
sweetNumber (BtMeta Text
_) = Bool
False
sweetNumber (BtAny Slot
_) = Bool
False
sweetNumber Bytes
bts
  | Bytes -> Int
btsSize Bytes
bts Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
8 = Bool
False
sweetNumber Bytes
bts = case Bytes -> Double
btsToNum Bytes
bts of
  Double
dbl | Double -> Bool
forall a. RealFloat a => a -> Bool
isNaN Double
dbl Bool -> Bool -> Bool
|| Double -> Bool
forall a. RealFloat a => a -> Bool
isInfinite Double
dbl -> Maybe NonFinite -> Bool
forall a. Maybe a -> Bool
isJust (Bytes -> Maybe NonFinite
btsToNonFinite Bytes
bts)
  Double
_ -> Bool
True

sweetString :: Bytes -> Bool
sweetString :: Bytes -> Bool
sweetString (BtMeta Text
_) = Bool
False
sweetString (BtAny Slot
_) = Bool
False
sweetString Bytes
bts = Bytes -> Bool
btsIsUtf8 Bytes
bts

sweetCollapsible :: Expression -> Bool
sweetCollapsible :: Expression -> Bool
sweetCollapsible (DataNumber Bytes
bts) = Bytes -> Bool
sweetNumber Bytes
bts
sweetCollapsible (DataString Bytes
bts) = Bytes -> Bool
sweetString Bytes
bts
sweetCollapsible Expression
_ = Bool
True

attributeToCST :: Attribute -> ATTRIBUTE
attributeToCST :: Attribute -> ATTRIBUTE
attributeToCST = Attribute -> ATTRIBUTE
forall a b. ToCST a b => a -> b
toCST'

bindingsToCST :: [Binding] -> BINDING
bindingsToCST :: [Binding] -> BINDING
bindingsToCST = [Binding] -> BINDING
forall a b. ToCST a b => a -> b
toCST'

conditionToCST :: Y.Condition -> CONDITION
conditionToCST :: Condition -> CONDITION
conditionToCST = Condition -> CONDITION
forall a b. ToCST a b => a -> b
toCST'

comparableToCST :: Y.Comparable -> COMPARABLE
comparableToCST :: Comparable -> COMPARABLE
comparableToCST = Comparable -> COMPARABLE
forall a b. ToCST a b => a -> b
toCST'

numberToCST :: Y.Number -> NUMBER
numberToCST :: Number -> NUMBER
numberToCST = Number -> NUMBER
forall a b. ToCST a b => a -> b
toCST'

extraToCST :: Y.Extra -> EXTRA
extraToCST :: Extra -> EXTRA
extraToCST = Extra -> EXTRA
forall a b. ToCST a b => a -> b
toCST'

toCST' :: ToCST a b => a -> b
toCST' :: forall a b. ToCST a b => a -> b
toCST' = (a -> (Int, EOL) -> b
forall a b. ToCST a b => a -> (Int, EOL) -> b
`toCST` (Int
0, EOL
EOL))

metaTail :: T.Text -> T.Text
metaTail :: Text -> Text
metaTail = Int -> Text -> Text
T.drop Int
1

anyMeta :: META_HEAD -> META
anyMeta :: META_HEAD -> META
anyMeta META_HEAD
hd' = EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
NO_EXCL META_HEAD
hd' Text
T.empty

exMetaHead :: T.Text -> META_HEAD
exMetaHead :: Text -> META_HEAD
exMetaHead Text
mt
  | Text -> Text -> Bool
T.isPrefixOf Text
"n" Text
mt = META_HEAD
N
  | Text -> Text -> Bool
T.isPrefixOf Text
"k" Text
mt = META_HEAD
K
  | Bool
otherwise = META_HEAD
E

class ToCST a b where
  toCST :: a -> (Int, EOL) -> b

instance ToCST Expression EXPRESSION where
  toCST :: Expression -> (Int, EOL) -> EXPRESSION
toCST Expression
ExRoot (Int, EOL)
_ = GLOBAL -> EXPRESSION
EX_GLOBAL GLOBAL
Φ
  toCST Expression
ExXi (Int, EOL)
_ = XI -> EXPRESSION
EX_XI XI
XI
  toCST (ExMeta Text
mt) (Int, EOL)
_ = META -> EXPRESSION
EX_META (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
NO_EXCL (Text -> META_HEAD
exMetaHead Text
mt) (Text -> Text
metaTail Text
mt))
  toCST (ExAny (Slot Text
kind Int
_)) (Int, EOL)
_ = META -> EXPRESSION
EX_META (META_HEAD -> META
anyMeta (Text -> META_HEAD
exMetaHead Text
kind))
  toCST Expression
ExTermination (Int, EOL)
_ = TERMINATION -> EXPRESSION
EX_TERMINATION TERMINATION
DEAD
  toCST (ExBytes Bytes
bts) (Int, EOL)
ctx = BYTES -> EXPRESSION
EX_BYTES (Bytes -> (Int, EOL) -> BYTES
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Bytes
bts (Int, EOL)
ctx)
  toCST (ExPhiMeet Maybe String
prefix Int
idx Expression
expr) (Int, EOL)
ctx = Maybe String -> Int -> EXPRESSION -> EXPRESSION
EX_PHI_MEET Maybe String
prefix Int
idx (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Expression
expr (Int, EOL)
ctx)
  toCST (ExPhiAgain Maybe String
prefix Int
idx Expression
expr) (Int, EOL)
ctx = Maybe String -> Int -> EXPRESSION -> EXPRESSION
EX_PHI_AGAIN Maybe String
prefix Int
idx (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Expression
expr (Int, EOL)
ctx)
  toCST (ExFormation []) (Int, EOL)
_ = LSB -> EOL -> TAB -> BINDING -> EOL -> TAB -> RSB -> EXPRESSION
EX_FORMATION LSB
LSB EOL
NO_EOL TAB
NO_TAB (TAB -> BINDING
BI_EMPTY TAB
NO_TAB) EOL
NO_EOL TAB
NO_TAB RSB
RSB
  toCST (ExFormation [Binding]
bds) ctx :: (Int, EOL)
ctx@(Int
tabs, EOL
eol) =
    EXPRESSION -> (PAIR -> EXPRESSION) -> Maybe PAIR -> EXPRESSION
forall b a. b -> (a -> b) -> Maybe a -> b
maybe EXPRESSION
full (\PAIR
sole -> PAIR -> SPACE -> EXPRESSION -> EXPRESSION
EX_SINGLE PAIR
sole SPACE
NO_SPACE EXPRESSION
full) ([Binding] -> Maybe PAIR
single [Binding]
bds)
    where
      full :: EXPRESSION
      full :: EXPRESSION
full =
        let next :: Int
next = Int
tabs Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
            bds' :: BINDING
bds' = [Binding] -> (Int, EOL) -> BINDING
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST [Binding]
bds (Int
next, EOL
eol) :: BINDING
         in LSB -> EOL -> TAB -> BINDING -> EOL -> TAB -> RSB -> EXPRESSION
EX_FORMATION
              LSB
LSB
              EOL
EOL
              (Int -> TAB
TAB Int
next)
              BINDING
bds'
              EOL
EOL
              (Int -> TAB
TAB Int
tabs)
              RSB
RSB
      single :: [Binding] -> Maybe PAIR
      single :: [Binding] -> Maybe PAIR
single [BiTau Attribute
AtDelta Expression
_] = Maybe PAIR
forall a. Maybe a
Nothing
      single [BiTau Attribute
AtLambda Expression
_] = Maybe PAIR
forall a. Maybe a
Nothing
      single [bd :: Binding
bd@(BiTau Attribute
_ ExFormation{})] | PAIR -> Bool
inlined (Binding -> (Int, EOL) -> PAIR
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Binding
bd (Int, EOL)
ctx) = Maybe PAIR
forall a. Maybe a
Nothing
      single [BiTau Attribute
attr Expression
expr] = PAIR -> Maybe PAIR
forall a. a -> Maybe a
Just (ATTRIBUTE -> ARROW -> EXPRESSION -> PAIR
PA_TAU (Attribute -> (Int, EOL) -> ATTRIBUTE
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Attribute
attr (Int, EOL)
ctx) ARROW
ARROW (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Expression
expr (Int, EOL)
ctx))
      single [BiVoid Attribute
AtRho] = Maybe PAIR
forall a. Maybe a
Nothing
      single [bd :: Binding
bd@(BiVoid Attribute
_)] = PAIR -> Maybe PAIR
forall a. a -> Maybe a
Just (Binding -> (Int, EOL) -> PAIR
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Binding
bd (Int, EOL)
ctx)
      single [bd :: Binding
bd@(BiDelta Bytes
_)] = PAIR -> Maybe PAIR
forall a. a -> Maybe a
Just (Binding -> (Int, EOL) -> PAIR
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Binding
bd (Int, EOL)
ctx)
      single [bd :: Binding
bd@(BiLambda Function
_)] = PAIR -> Maybe PAIR
forall a. a -> Maybe a
Just (Binding -> (Int, EOL) -> PAIR
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Binding
bd (Int, EOL)
ctx)
      single [Binding]
_ = Maybe PAIR
forall a. Maybe a
Nothing
      inlined :: PAIR -> Bool
      inlined :: PAIR -> Bool
inlined PA_FORMATION{$sel:voids:PA_TAU :: PAIR -> [ATTRIBUTE]
voids = ATTRIBUTE
_ : [ATTRIBUTE]
_} = Bool
True
      inlined PAIR
_ = Bool
False
  toCST (DataString Bytes
bts) (Int
tabs, EOL
_) | Bytes -> Bool
sweetString Bytes
bts = String -> TAB -> [Argument] -> EXPRESSION
EX_STRING (Bytes -> String
btsToStr Bytes
bts) (Int -> TAB
TAB Int
tabs) []
  toCST (DataNumber Bytes
bts) (Int
tabs, EOL
_) | Just NonFinite
nonfinite <- Bytes -> Maybe NonFinite
btsToNonFinite Bytes
bts = GLOBAL -> NonFinite -> TAB -> [Argument] -> EXPRESSION
EX_NONFINITE GLOBAL
Φ NonFinite
nonfinite (Int -> TAB
TAB Int
tabs) []
  toCST (DataNumber Bytes
bts) (Int
tabs, EOL
_) | Bytes -> Bool
sweetNumber Bytes
bts = Double -> TAB -> [Argument] -> EXPRESSION
EX_NUMBER (Bytes -> Double
btsToNum Bytes
bts) (Int -> TAB
TAB Int
tabs) []
  toCST (ExDispatch Expression
ExXi Attribute
attr) (Int, EOL)
ctx = ATTRIBUTE -> EXPRESSION
EX_ATTR (Attribute -> (Int, EOL) -> ATTRIBUTE
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Attribute
attr (Int, EOL)
ctx)
  toCST (ExDispatch Expression
expr Attribute
attr) (Int, EOL)
ctx = EXPRESSION -> SPACE -> ATTRIBUTE -> EXPRESSION
EX_DISPATCH (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Expression
expr (Int, EOL)
ctx) SPACE
NO_SPACE (Attribute -> (Int, EOL) -> ATTRIBUTE
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Attribute
attr (Int, EOL)
ctx)
  toCST app :: Expression
app@(ExApplication Expression
_ Argument
_) ctx :: (Int, EOL)
ctx@(Int
tabs, EOL
eol) =
    let (Expression
ex, [Argument]
ts, [Expression]
exs) = Expression -> (Expression, [Argument], [Expression])
complexApplication Expression
app
        ex' :: EXPRESSION
ex' = Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Expression
ex (Int, EOL)
ctx :: EXPRESSION
        next :: Int
next = Int
tabs Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
        ([Argument]
ts', [Argument]
rs) = Expression -> [Argument] -> ([Argument], [Argument])
withoutRhosInPrimitives Expression
ex [Argument]
ts
        obj :: Expression
obj = Expression -> Argument -> Expression
ExApplication Expression
ex ([Argument] -> Argument
forall a. [a] -> a
head' [Argument]
ts')
     in if [Argument] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Argument]
ts' Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 Bool -> Bool -> Bool
&& Expression -> Bool
dataPrimitive Expression
obj Bool -> Bool -> Bool
&& Expression -> Bool
sweetCollapsible Expression
obj
          then Expression -> Int -> [Argument] -> EXPRESSION
applicationToPrimitive Expression
obj Int
tabs [Argument]
rs
          else
            if [Argument] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Argument]
ts' Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 Bool -> Bool -> Bool
&& [Expression] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Expression]
exs Bool -> Bool -> Bool
&& Expression -> Bool
dataPrimitive Expression
obj Bool -> Bool -> Bool
&& Expression -> Bool
sweetCollapsible Expression
obj
              then
                EXPRESSION
-> SPACE
-> EOL
-> TAB
-> APP_ARGUMENT
-> EOL
-> TAB
-> Int
-> EXPRESSION
EX_APPLICATION
                  (Expression -> Int -> [Argument] -> EXPRESSION
applicationToPrimitive Expression
obj Int
tabs [Argument]
rs)
                  SPACE
NO_SPACE
                  EOL
eol
                  (Int -> TAB
TAB Int
next)
                  (BINDING -> APP_ARGUMENT
AA_TAUS ([Argument] -> (Int, EOL) -> BINDING
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST (Int -> [Argument] -> [Argument]
forall a. Int -> [a] -> [a]
drop Int
1 [Argument]
ts') (Int
next, EOL
eol) :: BINDING))
                  EOL
eol
                  (Int -> TAB
TAB Int
tabs)
                  Int
next
              else
                if [Expression] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Expression]
exs
                  then
                    EXPRESSION
-> SPACE
-> EOL
-> TAB
-> APP_ARGUMENT
-> EOL
-> TAB
-> Int
-> EXPRESSION
EX_APPLICATION
                      EXPRESSION
ex'
                      SPACE
NO_SPACE
                      EOL
eol
                      (Int -> TAB
TAB Int
next)
                      (BINDING -> APP_ARGUMENT
AA_TAUS ([Argument] -> (Int, EOL) -> BINDING
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST [Argument]
ts (Int
next, EOL
eol) :: BINDING))
                      EOL
eol
                      (Int -> TAB
TAB Int
tabs)
                      Int
next
                  else
                    EXPRESSION
-> SPACE
-> EOL
-> TAB
-> APP_ARGUMENT
-> EOL
-> TAB
-> Int
-> EXPRESSION
EX_APPLICATION
                      EXPRESSION
ex'
                      SPACE
NO_SPACE
                      EOL
eol
                      (Int -> TAB
TAB Int
next)
                      (APP_ARG -> APP_ARGUMENT
AA_EXPRS ([Expression] -> (Int, EOL) -> APP_ARG
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST [Expression]
exs (Int
next, EOL
eol)))
                      EOL
eol
                      (Int -> TAB
TAB Int
tabs)
                      Int
next
    where
      primitives :: [T.Text]
      primitives :: [Text]
primitives = [Text
"number", Text
"string"]
      dataPrimitive :: Expression -> Bool
      dataPrimitive :: Expression -> Bool
dataPrimitive Expression
obj' = case Expression -> Maybe (Text, Bytes)
matchDataObject Expression
obj' of
        Just (Text
label, Bytes
_) -> Text
label Text -> [Text] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
primitives
        Maybe (Text, Bytes)
Nothing -> Bool
False
      withoutRhosInPrimitives :: Expression -> [Argument] -> ([Argument], [Argument])
      withoutRhosInPrimitives :: Expression -> [Argument] -> ([Argument], [Argument])
withoutRhosInPrimitives (BaseObject Text
label) (Argument
datum : [Argument]
rest)
        | Text
label Text -> [Text] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
primitives = let ([Argument]
rhos, [Argument]
more) = (Argument -> Bool) -> [Argument] -> ([Argument], [Argument])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span Argument -> Bool
rho [Argument]
rest in (Argument
datum Argument -> [Argument] -> [Argument]
forall a. a -> [a] -> [a]
: [Argument]
more, [Argument]
rhos)
      withoutRhosInPrimitives Expression
_ [Argument]
bds = ([Argument]
bds, [])
      rho :: Argument -> Bool
      rho :: Argument -> Bool
rho (ArTau Attribute
AtRho Expression
_) = Bool
True
      rho Argument
_ = Bool
False
      applicationToPrimitive :: Expression -> Int -> [Argument] -> EXPRESSION
      applicationToPrimitive :: Expression -> Int -> [Argument] -> EXPRESSION
applicationToPrimitive (DataNumber Bytes
bts) Int
tabs [Argument]
rhos = case Bytes -> Maybe NonFinite
btsToNonFinite Bytes
bts of
        Just NonFinite
nonfinite -> GLOBAL -> NonFinite -> TAB -> [Argument] -> EXPRESSION
EX_NONFINITE GLOBAL
Φ NonFinite
nonfinite (Int -> TAB
TAB Int
tabs) [Argument]
rhos
        Maybe NonFinite
Nothing -> Double -> TAB -> [Argument] -> EXPRESSION
EX_NUMBER (Bytes -> Double
btsToNum Bytes
bts) (Int -> TAB
TAB Int
tabs) [Argument]
rhos
      applicationToPrimitive (DataString Bytes
bts) Int
tabs [Argument]
rhos = String -> TAB -> [Argument] -> EXPRESSION
EX_STRING (Bytes -> String
btsToStr Bytes
bts) (Int -> TAB
TAB Int
tabs) [Argument]
rhos
      applicationToPrimitive Expression
_ Int
_ [Argument]
_ = String -> EXPRESSION
forall a. HasCallStack => String -> a
error String
"applicationToPrimitive expects DataNumber or DataString"
      complexApplication :: Expression -> (Expression, [Argument], [Expression])
      complexApplication :: Expression -> (Expression, [Argument], [Expression])
complexApplication Expression
expr =
        let (Expression
expr', [Argument]
taus', [Expression]
exprs') = Expression -> (Expression, [Argument], [Expression])
complexApplication' Expression
expr
         in (Expression
expr', [Argument] -> [Argument]
forall a. [a] -> [a]
reverse [Argument]
taus', [Expression] -> [Expression]
forall a. [a] -> [a]
reverse [Expression]
exprs')
        where
          complexApplication' :: Expression -> (Expression, [Argument], [Expression])
          complexApplication' :: Expression -> (Expression, [Argument], [Expression])
complexApplication' (ExApplication (ExApplication Expression
expr Argument
tau) Argument
tau') =
            let (Expression
before, [Argument]
taus, [Expression]
exprs) = Expression -> (Expression, [Argument], [Expression])
complexApplication' (Expression -> Argument -> Expression
ExApplication Expression
expr Argument
tau)
                taus' :: [Argument]
taus' = Argument
tau' Argument -> [Argument] -> [Argument]
forall a. a -> [a] -> [a]
: [Argument]
taus
             in if [Expression] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Expression]
exprs
                  then (Expression
before, [Argument]
taus', [])
                  else case Argument
tau' of
                    ArAlpha (Alpha Int
idx) Expression
expr' ->
                      if Int
idx Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== [Expression] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Expression]
exprs
                        then (Expression
before, [Argument]
taus', Expression
expr' Expression -> [Expression] -> [Expression]
forall a. a -> [a] -> [a]
: [Expression]
exprs)
                        else (Expression
before, [Argument]
taus', [])
                    Argument
_ -> (Expression
before, [Argument]
taus', [])
          complexApplication' (ExApplication Expression
expr (ArAlpha (Alpha Int
0) Expression
expr')) = (Expression
expr, [Alpha -> Expression -> Argument
ArAlpha (Int -> Alpha
Alpha Int
0) Expression
expr'], [Expression
expr'])
          complexApplication' (ExApplication Expression
expr Argument
tau) = (Expression
expr, [Argument
tau], [])
          complexApplication' Expression
expr = (Expression
expr, [], [])
      head' :: [a] -> a
      head' :: forall a. [a] -> a
head' [] = String -> a
forall a. HasCallStack => String -> a
error String
"Should never be called"
      head' (a
x : [a]
_) = a
x

instance ToCST [Expression] APP_ARG where
  toCST :: [Expression] -> (Int, EOL) -> APP_ARG
toCST (Expression
expr : [Expression]
exprs) (Int, EOL)
ctx = EXPRESSION -> APP_ARGS -> APP_ARG
APP_ARG (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Expression
expr (Int, EOL)
ctx) ([Expression] -> (Int, EOL) -> APP_ARGS
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST [Expression]
exprs (Int, EOL)
ctx)
  toCST [] (Int, EOL)
_ = String -> APP_ARG
forall a. HasCallStack => String -> a
error String
"toCST APP_ARG requires non-empty expression list"

instance ToCST [Expression] APP_ARGS where
  toCST :: [Expression] -> (Int, EOL) -> APP_ARGS
toCST [] (Int, EOL)
_ = APP_ARGS
AAS_EMPTY
  toCST (Expression
expr : [Expression]
exprs) ctx :: (Int, EOL)
ctx@(Int
tabs, EOL
eol) = EOL -> TAB -> EXPRESSION -> APP_ARGS -> APP_ARGS
AAS_EXPR EOL
eol (Int -> TAB
TAB Int
tabs) (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Expression
expr (Int, EOL)
ctx) ([Expression] -> (Int, EOL) -> APP_ARGS
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST [Expression]
exprs (Int, EOL)
ctx)

instance ToCST [Binding] BINDING where
  toCST :: [Binding] -> (Int, EOL) -> BINDING
toCST [] (Int
tabs, EOL
_) = TAB -> BINDING
BI_EMPTY (Int -> TAB
TAB Int
tabs)
  toCST (BiMeta Text
mt : [Binding]
bds) ctx :: (Int, EOL)
ctx@(Int
tabs, EOL
_) = META -> BINDINGS -> TAB -> BINDING
BI_META (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
NO_EXCL META_HEAD
B (Text -> Text
metaTail Text
mt)) ([Binding] -> (Int, EOL) -> BINDINGS
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST [Binding]
bds (Int, EOL)
ctx) (Int -> TAB
TAB Int
tabs)
  toCST (BiAny Slot
_ : [Binding]
bds) ctx :: (Int, EOL)
ctx@(Int
tabs, EOL
_) = META -> BINDINGS -> TAB -> BINDING
BI_META (META_HEAD -> META
anyMeta META_HEAD
B) ([Binding] -> (Int, EOL) -> BINDINGS
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST [Binding]
bds (Int, EOL)
ctx) (Int -> TAB
TAB Int
tabs)
  toCST (Binding
bd : [Binding]
bds) ctx :: (Int, EOL)
ctx@(Int
tabs, EOL
_) = PAIR -> BINDINGS -> TAB -> BINDING
BI_PAIR (Binding -> (Int, EOL) -> PAIR
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Binding
bd (Int, EOL)
ctx) ([Binding] -> (Int, EOL) -> BINDINGS
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST [Binding]
bds (Int, EOL)
ctx) (Int -> TAB
TAB Int
tabs)

instance ToCST [Binding] BINDINGS where
  toCST :: [Binding] -> (Int, EOL) -> BINDINGS
toCST [] (Int
tabs, EOL
_) = TAB -> BINDINGS
BDS_EMPTY (Int -> TAB
TAB Int
tabs)
  toCST (BiMeta Text
mt : [Binding]
bds) ctx :: (Int, EOL)
ctx@(Int
tabs, EOL
eol) = EOL -> TAB -> META -> BINDINGS -> BINDINGS
BDS_META EOL
eol (Int -> TAB
TAB Int
tabs) (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
NO_EXCL META_HEAD
B (Text -> Text
metaTail Text
mt)) ([Binding] -> (Int, EOL) -> BINDINGS
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST [Binding]
bds (Int, EOL)
ctx)
  toCST (BiAny Slot
_ : [Binding]
bds) ctx :: (Int, EOL)
ctx@(Int
tabs, EOL
eol) = EOL -> TAB -> META -> BINDINGS -> BINDINGS
BDS_META EOL
eol (Int -> TAB
TAB Int
tabs) (META_HEAD -> META
anyMeta META_HEAD
B) ([Binding] -> (Int, EOL) -> BINDINGS
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST [Binding]
bds (Int, EOL)
ctx)
  toCST (Binding
bd : [Binding]
bds) ctx :: (Int, EOL)
ctx@(Int
tabs, EOL
eol) = EOL -> TAB -> PAIR -> BINDINGS -> BINDINGS
BDS_PAIR EOL
eol (Int -> TAB
TAB Int
tabs) (Binding -> (Int, EOL) -> PAIR
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Binding
bd (Int, EOL)
ctx) ([Binding] -> (Int, EOL) -> BINDINGS
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST [Binding]
bds (Int, EOL)
ctx)

instance ToCST Binding PAIR where
  toCST :: Binding -> (Int, EOL) -> PAIR
toCST (BiTau Attribute
attr exp :: Expression
exp@(ExFormation [Binding]
bds)) (Int, EOL)
ctx =
    let ([Binding]
head', [Binding]
rest) = (Binding -> Bool) -> [Binding] -> ([Binding], [Binding])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span Binding -> Bool
positionless [Binding]
bds
        voids' :: [Attribute]
voids' = [Attribute
void | BiVoid Attribute
void <- [Binding]
head']
        others :: [Binding]
others = (Binding -> Bool) -> [Binding] -> [Binding]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> (Binding -> Bool) -> Binding -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Binding -> Bool
isVoid) [Binding]
head'
        attr' :: ATTRIBUTE
attr' = Attribute -> (Int, EOL) -> ATTRIBUTE
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Attribute
attr (Int, EOL)
ctx
     in if [Attribute] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Attribute]
voids'
          then ATTRIBUTE -> ARROW -> EXPRESSION -> PAIR
PA_TAU ATTRIBUTE
attr' ARROW
ARROW (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Expression
exp (Int, EOL)
ctx)
          else
            ATTRIBUTE -> [ATTRIBUTE] -> ARROW -> EXPRESSION -> PAIR
PA_FORMATION
              ATTRIBUTE
attr'
              ((Attribute -> ATTRIBUTE) -> [Attribute] -> [ATTRIBUTE]
forall a b. (a -> b) -> [a] -> [b]
map (Attribute -> (Int, EOL) -> ATTRIBUTE
forall a b. ToCST a b => a -> (Int, EOL) -> b
`toCST` (Int, EOL)
ctx) [Attribute]
voids')
              ARROW
ARROW
              (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST ([Binding] -> Expression
ExFormation ([Binding]
others [Binding] -> [Binding] -> [Binding]
forall a. [a] -> [a] -> [a]
++ [Binding]
rest)) (Int, EOL)
ctx)
    where
      positionless :: Binding -> Bool
      positionless :: Binding -> Bool
positionless (BiVoid (AtLabel Text
_)) = Bool
True
      positionless (BiVoid Attribute
AtPhi) = Bool
True
      positionless (BiVoid Attribute
AtRho) = Bool
True
      positionless BiLambda{} = Bool
True
      positionless BiDelta{} = Bool
True
      positionless Binding
_ = Bool
False
      isVoid :: Binding -> Bool
      isVoid :: Binding -> Bool
isVoid BiVoid{} = Bool
True
      isVoid Binding
_ = Bool
False
  toCST (BiTau Attribute
attr Expression
exp) (Int, EOL)
ctx = ATTRIBUTE -> ARROW -> EXPRESSION -> PAIR
PA_TAU (Attribute -> (Int, EOL) -> ATTRIBUTE
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Attribute
attr (Int, EOL)
ctx) ARROW
ARROW (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Expression
exp (Int, EOL)
ctx)
  toCST (BiVoid Attribute
attr) (Int, EOL)
ctx = ATTRIBUTE -> ARROW -> VOID -> PAIR
PA_VOID (Attribute -> (Int, EOL) -> ATTRIBUTE
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Attribute
attr (Int, EOL)
ctx) ARROW
ARROW VOID
EMPTY
  toCST (BiDelta Bytes
bts) (Int, EOL)
ctx = BYTES -> PAIR
PA_DELTA (Bytes -> (Int, EOL) -> BYTES
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Bytes
bts (Int, EOL)
ctx)
  toCST (BiLambda (Function Text
name)) (Int, EOL)
_ = Text -> PAIR
PA_LAMBDA Text
name
  toCST (BiLambda (FnMeta Text
mt)) (Int, EOL)
_ = META -> PAIR
PA_META_LAMBDA (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
NO_EXCL META_HEAD
F (Text -> Text
metaTail Text
mt))
  toCST (BiLambda (FnAny Slot
_)) (Int, EOL)
_ = META -> PAIR
PA_META_LAMBDA (META_HEAD -> META
anyMeta META_HEAD
F)
  toCST (BiLambda (FnSymbol Int
idx)) (Int, EOL)
_ = META -> PAIR
PA_META_LAMBDA (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
NO_EXCL META_HEAD
S (String -> Text
T.pack (Int -> String
forall a. Show a => a -> String
show Int
idx)))
  toCST (BiLambda (FnFresh Slot
_)) (Int, EOL)
_ = META -> PAIR
PA_META_LAMBDA (META_HEAD -> META
anyMeta META_HEAD
S)
  toCST (BiMeta Text
mt) (Int, EOL)
_ = String -> PAIR
forall a. HasCallStack => String -> a
error (String -> PAIR) -> String -> PAIR
forall a b. (a -> b) -> a -> b
$ String
"BiMeta binding " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Text -> String
T.unpack Text
mt String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" cannot be converted to PAIR"
  toCST (BiAny Slot
_) (Int, EOL)
_ = String -> PAIR
forall a. HasCallStack => String -> a
error String
"An anonymous meta binding cannot be converted to PAIR"

instance ToCST Argument PAIR where
  toCST :: Argument -> (Int, EOL) -> PAIR
toCST (ArTau Attribute
attr Expression
exp) (Int, EOL)
ctx = ATTRIBUTE -> ARROW -> EXPRESSION -> PAIR
PA_TAU (Attribute -> (Int, EOL) -> ATTRIBUTE
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Attribute
attr (Int, EOL)
ctx) ARROW
ARROW (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Expression
exp (Int, EOL)
ctx)
  toCST (ArAlpha Alpha
alpha Expression
exp) (Int, EOL)
ctx = ALPHA -> ARROW -> EXPRESSION -> PAIR
PA_ALPHA (Alpha -> (Int, EOL) -> ALPHA
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Alpha
alpha (Int, EOL)
ctx) ARROW
ARROW (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Expression
exp (Int, EOL)
ctx)

instance ToCST [Argument] BINDING where
  toCST :: [Argument] -> (Int, EOL) -> BINDING
toCST [] (Int
tabs, EOL
_) = TAB -> BINDING
BI_EMPTY (Int -> TAB
TAB Int
tabs)
  toCST (Argument
arg : [Argument]
args) ctx :: (Int, EOL)
ctx@(Int
tabs, EOL
_) = PAIR -> BINDINGS -> TAB -> BINDING
BI_PAIR (Argument -> (Int, EOL) -> PAIR
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Argument
arg (Int, EOL)
ctx) ([Argument] -> (Int, EOL) -> BINDINGS
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST [Argument]
args (Int, EOL)
ctx) (Int -> TAB
TAB Int
tabs)

instance ToCST [Argument] BINDINGS where
  toCST :: [Argument] -> (Int, EOL) -> BINDINGS
toCST [] (Int
tabs, EOL
_) = TAB -> BINDINGS
BDS_EMPTY (Int -> TAB
TAB Int
tabs)
  toCST (Argument
arg : [Argument]
args) ctx :: (Int, EOL)
ctx@(Int
tabs, EOL
eol) = EOL -> TAB -> PAIR -> BINDINGS -> BINDINGS
BDS_PAIR EOL
eol (Int -> TAB
TAB Int
tabs) (Argument -> (Int, EOL) -> PAIR
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Argument
arg (Int, EOL)
ctx) ([Argument] -> (Int, EOL) -> BINDINGS
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST [Argument]
args (Int, EOL)
ctx)

instance ToCST Binding APP_BINDING where
  toCST :: Binding -> (Int, EOL) -> APP_BINDING
toCST bd :: Binding
bd@(BiTau Attribute
_ Expression
_) (Int, EOL)
ctx = PAIR -> APP_BINDING
APP_BINDING (Binding -> (Int, EOL) -> PAIR
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST Binding
bd (Int, EOL)
ctx :: PAIR)
  toCST Binding
bd (Int, EOL)
_ = String -> APP_BINDING
forall a. HasCallStack => String -> a
error (String -> APP_BINDING) -> String -> APP_BINDING
forall a b. (a -> b) -> a -> b
$ String
"Only BiTau binding can be converted to APP_BINDING, got: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Binding -> String
forall a. Show a => a -> String
show Binding
bd

instance ToCST Bytes BYTES where
  toCST :: Bytes -> (Int, EOL) -> BYTES
toCST Bytes
BtEmpty (Int, EOL)
_ = BYTES
BT_EMPTY
  toCST (BtOne String
byte) (Int, EOL)
_ = String -> BYTES
BT_ONE String
byte
  toCST (BtMany [String]
bts) (Int, EOL)
_ = [String] -> BYTES
BT_MANY [String]
bts
  toCST (BtMeta Text
mt) (Int, EOL)
_ = META -> BYTES
BT_META (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
NO_EXCL META_HEAD
D (Text -> Text
metaTail Text
mt))
  toCST (BtAny Slot
_) (Int, EOL)
_ = META -> BYTES
BT_META (META_HEAD -> META
anyMeta META_HEAD
D)

instance ToCST Attribute ATTRIBUTE where
  toCST :: Attribute -> (Int, EOL) -> ATTRIBUTE
toCST (AtLabel Text
label) (Int, EOL)
_ = Text -> ATTRIBUTE
AT_LABEL Text
label
  toCST Attribute
AtPhi (Int, EOL)
_ = PHI -> ATTRIBUTE
AT_PHI PHI
PHI
  toCST Attribute
AtRho (Int, EOL)
_ = RHO -> ATTRIBUTE
AT_RHO RHO
RHO
  toCST Attribute
AtDelta (Int, EOL)
_ = DELTA -> ATTRIBUTE
AT_DELTA DELTA
DELTA
  toCST Attribute
AtLambda (Int, EOL)
_ = LAMBDA -> ATTRIBUTE
AT_LAMBDA LAMBDA
LAMBDA
  toCST (AtMeta Text
mt) (Int, EOL)
_ = META -> ATTRIBUTE
AT_META (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
NO_EXCL META_HEAD
TAU (Text -> Text
metaTail Text
mt))
  toCST (AtAny Slot
_) (Int, EOL)
_ = META -> ATTRIBUTE
AT_META (META_HEAD -> META
anyMeta META_HEAD
TAU)

instance ToCST Alpha ALPHA where
  toCST :: Alpha -> (Int, EOL) -> ALPHA
toCST (Alpha Int
idx) (Int, EOL)
_ = ALPHA' -> Int -> ALPHA
AL_IDX ALPHA'
ALPHA Int
idx
  toCST (AlMeta Text
mt) (Int, EOL)
_ = ALPHA' -> META -> ALPHA
AL_META ALPHA'
ALPHA (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
NO_EXCL META_HEAD
I (Text -> Text
metaTail Text
mt))
  toCST (AlAny Slot
_) (Int, EOL)
_ = ALPHA' -> META -> ALPHA
AL_META ALPHA'
ALPHA (META_HEAD -> META
anyMeta META_HEAD
I)

instance ToCST Y.Condition CONDITION where
  toCST :: Condition -> (Int, EOL) -> CONDITION
toCST (Y.Not (Y.In [Attribute
attr] [Binding
binding])) (Int, EOL)
_ = ATTRIBUTE -> BELONGING -> SET -> CONDITION
CO_BELONGS (Attribute -> ATTRIBUTE
attributeToCST Attribute
attr) BELONGING
NOT_IN (BINDING -> SET
ST_BINDING ([Binding] -> BINDING
bindingsToCST [Binding
binding]))
  toCST (Y.Not (Y.In [Attribute]
attrs [Binding]
groups)) (Int, EOL)
_ = [ATTRIBUTE] -> BELONGING -> [BINDING] -> CONDITION
CO_SUBSET ((Attribute -> ATTRIBUTE) -> [Attribute] -> [ATTRIBUTE]
forall a b. (a -> b) -> [a] -> [b]
map Attribute -> ATTRIBUTE
attributeToCST [Attribute]
attrs) BELONGING
NOT_IN ((Binding -> BINDING) -> [Binding] -> [BINDING]
forall a b. (a -> b) -> [a] -> [b]
map (\Binding
bd -> [Binding] -> BINDING
bindingsToCST [Binding
bd]) [Binding]
groups)
  toCST (Y.Not (Y.Eq Comparable
left Comparable
right)) (Int, EOL)
_ = COMPARABLE -> EQUAL -> COMPARABLE -> CONDITION
CO_COMPARE (Comparable -> COMPARABLE
comparableToCST Comparable
left) EQUAL
NOT_EQUAL (Comparable -> COMPARABLE
comparableToCST Comparable
right)
  toCST (Y.Not (Y.Gt Comparable
left Comparable
right)) (Int, EOL)
_ = COMPARABLE -> EQUAL -> COMPARABLE -> CONDITION
CO_COMPARE (Comparable -> COMPARABLE
comparableToCST Comparable
left) EQUAL
NOT_GREATER (Comparable -> COMPARABLE
comparableToCST Comparable
right)
  toCST (Y.Not (Y.Absolute Expression
expr)) (Int, EOL)
_ = EXPRESSION -> BELONGING -> CONDITION
CO_ABSOLUTE (Expression -> EXPRESSION
expressionToCST Expression
expr) BELONGING
NOT_IN
  toCST (Y.Absolute Expression
expr) (Int, EOL)
_ = EXPRESSION -> BELONGING -> CONDITION
CO_ABSOLUTE (Expression -> EXPRESSION
expressionToCST Expression
expr) BELONGING
IN
  toCST (Y.Disjoint [Attribute]
attrs [Binding]
groups) (Int, EOL)
_ = [ATTRIBUTE] -> [BINDING] -> CONDITION
CO_DISJOINT ((Attribute -> ATTRIBUTE) -> [Attribute] -> [ATTRIBUTE]
forall a b. (a -> b) -> [a] -> [b]
map Attribute -> ATTRIBUTE
attributeToCST [Attribute]
attrs) ((Binding -> BINDING) -> [Binding] -> [BINDING]
forall a b. (a -> b) -> [a] -> [b]
map (\Binding
bd -> [Binding] -> BINDING
bindingsToCST [Binding
bd]) [Binding]
groups)
  toCST (Y.In [Attribute
attr] [Binding
binding]) (Int, EOL)
_ = ATTRIBUTE -> BELONGING -> SET -> CONDITION
CO_BELONGS (Attribute -> ATTRIBUTE
attributeToCST Attribute
attr) BELONGING
IN (BINDING -> SET
ST_BINDING ([Binding] -> BINDING
bindingsToCST [Binding
binding]))
  toCST (Y.In [Attribute]
attrs [Binding]
groups) (Int, EOL)
_ = [ATTRIBUTE] -> BELONGING -> [BINDING] -> CONDITION
CO_SUBSET ((Attribute -> ATTRIBUTE) -> [Attribute] -> [ATTRIBUTE]
forall a b. (a -> b) -> [a] -> [b]
map Attribute -> ATTRIBUTE
attributeToCST [Attribute]
attrs) BELONGING
IN ((Binding -> BINDING) -> [Binding] -> [BINDING]
forall a b. (a -> b) -> [a] -> [b]
map (\Binding
bd -> [Binding] -> BINDING
bindingsToCST [Binding
bd]) [Binding]
groups)
  toCST (Y.And [Condition]
conds) (Int, EOL)
_ = case [Condition]
conds of
    [] -> CONDITION
CO_EMPTY
    [Condition]
_ -> [CONDITION] -> LOGIC_OPERATOR -> CONDITION
CO_LOGIC ((Condition -> CONDITION) -> [Condition] -> [CONDITION]
forall a b. (a -> b) -> [a] -> [b]
map Condition -> CONDITION
forall a b. ToCST a b => a -> b
toCST' [Condition]
conds) LOGIC_OPERATOR
AND
  toCST (Y.Or [Condition]
conds) (Int, EOL)
_ = case [Condition]
conds of
    [] -> CONDITION
CO_EMPTY
    [Condition]
_ -> [CONDITION] -> LOGIC_OPERATOR -> CONDITION
CO_LOGIC ((Condition -> CONDITION) -> [Condition] -> [CONDITION]
forall a b. (a -> b) -> [a] -> [b]
map Condition -> CONDITION
forall a b. ToCST a b => a -> b
toCST' [Condition]
conds) LOGIC_OPERATOR
OR
  toCST (Y.NF Expression
expr) (Int, EOL)
_ = EXPRESSION -> CONDITION
CO_NF (Expression -> EXPRESSION
expressionToCST Expression
expr)
  toCST (Y.Not Condition
cond) (Int, EOL)
_ = CONDITION -> CONDITION
CO_NOT (Condition -> CONDITION
conditionToCST Condition
cond)
  toCST (Y.Eq Comparable
left Comparable
right) (Int, EOL)
_ = COMPARABLE -> EQUAL -> COMPARABLE -> CONDITION
CO_COMPARE (Comparable -> COMPARABLE
comparableToCST Comparable
left) EQUAL
EQUAL (Comparable -> COMPARABLE
comparableToCST Comparable
right)
  toCST (Y.Gt Comparable
left Comparable
right) (Int, EOL)
_ = COMPARABLE -> EQUAL -> COMPARABLE -> CONDITION
CO_COMPARE (Comparable -> COMPARABLE
comparableToCST Comparable
left) EQUAL
GREATER (Comparable -> COMPARABLE
comparableToCST Comparable
right)
  toCST (Y.Matches String
regex Expression
expr) (Int, EOL)
_ = String -> EXPRESSION -> CONDITION
CO_MATCHES String
regex (Expression -> EXPRESSION
expressionToCST Expression
expr)
  toCST (Y.PartOf Expression
expr Binding
binding) (Int, EOL)
_ = EXPRESSION -> BINDING -> CONDITION
CO_PART_OF (Expression -> EXPRESSION
expressionToCST Expression
expr) ([Binding] -> BINDING
bindingsToCST [Binding
binding])
  toCST (Y.IsFormation Expression
expr) (Int, EOL)
_ = EXPRESSION -> CONDITION
CO_FORMATION (Expression -> EXPRESSION
expressionToCST Expression
expr)

instance ToCST Y.Comparable COMPARABLE where
  toCST :: Comparable -> (Int, EOL) -> COMPARABLE
toCST (Y.CmpAttr Attribute
attr) (Int, EOL)
_ = ATTRIBUTE -> COMPARABLE
CMP_ATTR (Attribute -> ATTRIBUTE
attributeToCST Attribute
attr)
  toCST (Y.CmpExpr Expression
expr) (Int, EOL)
_ = EXPRESSION -> COMPARABLE
CMP_EXPR (Expression -> EXPRESSION
expressionToCST Expression
expr)
  toCST (Y.CmpNum Number
num) (Int, EOL)
_ = NUMBER -> COMPARABLE
CMP_NUM (Number -> NUMBER
numberToCST Number
num)

instance ToCST Y.Number NUMBER where
  toCST :: Number -> (Int, EOL) -> NUMBER
toCST (Y.MetaIndex Text
mt) (Int, EOL)
_ = META -> NUMBER
IDX_META (EXCLAMATION -> META_HEAD -> Text -> META
META EXCLAMATION
NO_EXCL META_HEAD
I (Text -> Text
metaTail Text
mt))
  toCST (Y.AnyIndex Slot
_) (Int, EOL)
_ = META -> NUMBER
IDX_META (META_HEAD -> META
anyMeta META_HEAD
I)
  toCST (Y.Length Binding
binding) (Int, EOL)
_ = BINDING -> NUMBER
LENGTH ([Binding] -> BINDING
bindingsToCST [Binding
binding])
  toCST (Y.Domain Binding
binding) (Int, EOL)
_ = BINDING -> NUMBER
DOMAIN ([Binding] -> BINDING
bindingsToCST [Binding
binding])
  toCST (Y.Literal Int
num) (Int, EOL)
_ = Int -> NUMBER
LITERAL Int
num

instance ToCST Y.ExtraArgument EXTRA_ARG where
  toCST :: ExtraArgument -> (Int, EOL) -> EXTRA_ARG
toCST (Y.ArgAttribute Attribute
attr) (Int, EOL)
_ = ATTRIBUTE -> EXTRA_ARG
ARG_ATTR (Attribute -> ATTRIBUTE
attributeToCST Attribute
attr)
  toCST (Y.ArgExpression Expression
expr) (Int, EOL)
_ = EXPRESSION -> EXTRA_ARG
ARG_EXPR (Expression -> EXPRESSION
expressionToCST Expression
expr)
  toCST (Y.ArgBinding Binding
binding) (Int, EOL)
_ = BINDING -> EXTRA_ARG
ARG_BINDING ([Binding] -> BINDING
bindingsToCST [Binding
binding])
  toCST (Y.ArgBytes Bytes
bytes) (Int, EOL)
_ = BYTES -> EXTRA_ARG
ARG_BYTES (Bytes -> BYTES
forall a b. ToCST a b => a -> b
toCST' Bytes
bytes)

instance ToCST Y.Extra EXTRA where
  toCST :: Extra -> (Int, EOL) -> EXTRA
toCST Y.Extra{String
[ExtraArgument]
ExtraArgument
meta :: ExtraArgument
function :: String
args :: [ExtraArgument]
$sel:meta:Extra :: Extra -> ExtraArgument
$sel:function:Extra :: Extra -> String
$sel:args:Extra :: Extra -> [ExtraArgument]
..} (Int, EOL)
_ = EXTRA_ARG -> String -> [EXTRA_ARG] -> EXTRA
EXTRA (ExtraArgument -> EXTRA_ARG
forall a b. ToCST a b => a -> b
toCST' ExtraArgument
meta) String
function ((ExtraArgument -> EXTRA_ARG) -> [ExtraArgument] -> [EXTRA_ARG]
forall a b. (a -> b) -> [a] -> [b]
map ExtraArgument -> EXTRA_ARG
forall a b. ToCST a b => a -> b
toCST' [ExtraArgument]
args)