{-# LANGUAGE InstanceSigs #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# OPTIONS_GHC -Wno-name-shadowing #-}

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

module Sugar (toSalty, withSugarType, withoutRho, revealXi, SugarType (..), ToSalty) where

import AST
import Bytes (nonFiniteBts, numToBts, strToBts, unescapeStr)
import CST

withSugarType :: (ToSalty a) => SugarType -> a -> a
withSugarType :: forall a. ToSalty a => SugarType -> a -> a
withSugarType SugarType
SWEET a
node = a
node
withSugarType SugarType
SALTY a
node = a -> a
forall a. ToSalty a => a -> a
toSalty a
node

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

withoutRho :: SugarType -> EXPRESSION -> EXPRESSION
withoutRho :: SugarType -> EXPRESSION -> EXPRESSION
withoutRho SugarType
sugar = EXPRESSION -> EXPRESSION
goExpr
  where
    goExpr :: EXPRESSION -> EXPRESSION
    goExpr :: EXPRESSION -> EXPRESSION
goExpr 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
..} = case BINDING -> BINDING
goBinding BINDING
binding of
      empty :: BINDING
empty@BI_EMPTY{} -> LSB -> EOL -> TAB -> BINDING -> EOL -> TAB -> RSB -> EXPRESSION
EX_FORMATION LSB
lsb EOL
NO_EOL TAB
NO_TAB BINDING
empty EOL
NO_EOL TAB
NO_TAB RSB
rsb
      binding' :: BINDING
binding'@BI_PAIR{$sel:pair:BI_PAIR :: BINDING -> PAIR
pair = PAIR
pair', $sel:bindings:BI_PAIR :: BINDING -> BINDINGS
bindings = BDS_EMPTY{}}
        | SugarType
sugar SugarType -> SugarType -> Bool
forall a. Eq a => a -> a -> Bool
== SugarType
SWEET Bool -> Bool -> Bool
&& PAIR -> Bool
sugared PAIR
pair' -> PAIR -> SPACE -> EXPRESSION -> EXPRESSION
EX_SINGLE PAIR
pair' SPACE
NO_SPACE (LSB -> EOL -> TAB -> BINDING -> EOL -> TAB -> RSB -> EXPRESSION
EX_FORMATION LSB
lsb EOL
eol TAB
tab BINDING
binding' EOL
eol' TAB
tab' RSB
rsb)
      BINDING
binding' -> LSB -> EOL -> TAB -> BINDING -> EOL -> TAB -> RSB -> EXPRESSION
EX_FORMATION LSB
lsb EOL
eol TAB
tab BINDING
binding' EOL
eol' TAB
tab' RSB
rsb
    goExpr EX_DISPATCH{ATTRIBUTE
EXPRESSION
SPACE
expr :: EXPRESSION
space :: SPACE
attr :: ATTRIBUTE
$sel:attr:EX_GLOBAL :: EXPRESSION -> ATTRIBUTE
$sel:expr:EX_GLOBAL :: EXPRESSION -> EXPRESSION
$sel:space:EX_GLOBAL :: EXPRESSION -> SPACE
..} = EXPRESSION -> SPACE -> ATTRIBUTE -> EXPRESSION
EX_DISPATCH (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
expr) SPACE
space ATTRIBUTE
attr
    goExpr 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
..} = case APP_ARGUMENT -> Maybe APP_ARGUMENT
goArgument APP_ARGUMENT
argument of
      Maybe APP_ARGUMENT
Nothing -> EXPRESSION -> EXPRESSION
goExpr EXPRESSION
expr
      Just APP_ARGUMENT
argument' -> EXPRESSION
-> SPACE
-> EOL
-> TAB
-> APP_ARGUMENT
-> EOL
-> TAB
-> Int
-> EXPRESSION
EX_APPLICATION (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
expr) SPACE
space EOL
eol TAB
tab APP_ARGUMENT
argument' EOL
eol' TAB
tab' Int
indent
    goExpr 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
goExpr EXPRESSION
expr)
    goExpr 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
goExpr EXPRESSION
expr)
    goExpr 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 -> Bool
isRho PAIR
pair = EXPRESSION -> EXPRESSION
goExpr EXPRESSION
formation
      | Bool
otherwise = PAIR -> SPACE -> EXPRESSION -> EXPRESSION
EX_SINGLE (PAIR -> PAIR
goPair PAIR
pair) SPACE
space (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
formation)
    goExpr EX_NUMBER{Double
[Argument]
TAB
$sel:tab:EX_GLOBAL :: EXPRESSION -> TAB
num :: Double
tab :: TAB
rhos :: [Argument]
$sel:rhos:EX_GLOBAL :: EXPRESSION -> [Argument]
$sel:num:EX_GLOBAL :: EXPRESSION -> Double
..} = Double -> TAB -> [Argument] -> EXPRESSION
EX_NUMBER Double
num TAB
tab ((Argument -> Bool) -> [Argument] -> [Argument]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> (Argument -> Bool) -> Argument -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Argument -> Bool
isRhoArgument) [Argument]
rhos)
    goExpr EX_STRING{String
[Argument]
TAB
$sel:tab:EX_GLOBAL :: EXPRESSION -> TAB
$sel:rhos:EX_GLOBAL :: EXPRESSION -> [Argument]
str :: String
tab :: TAB
rhos :: [Argument]
$sel:str:EX_GLOBAL :: EXPRESSION -> String
..} = String -> TAB -> [Argument] -> EXPRESSION
EX_STRING String
str TAB
tab ((Argument -> Bool) -> [Argument] -> [Argument]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> (Argument -> Bool) -> Argument -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Argument -> Bool
isRhoArgument) [Argument]
rhos)
    goExpr EX_NONFINITE{[Argument]
NonFinite
TAB
GLOBAL
$sel:tab:EX_GLOBAL :: EXPRESSION -> TAB
$sel:rhos:EX_GLOBAL :: EXPRESSION -> [Argument]
global :: GLOBAL
nonfinite :: NonFinite
tab :: TAB
rhos :: [Argument]
$sel:global:EX_GLOBAL :: EXPRESSION -> GLOBAL
$sel:nonfinite:EX_GLOBAL :: EXPRESSION -> NonFinite
..} = GLOBAL -> NonFinite -> TAB -> [Argument] -> EXPRESSION
EX_NONFINITE GLOBAL
global NonFinite
nonfinite TAB
tab ((Argument -> Bool) -> [Argument] -> [Argument]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> (Argument -> Bool) -> Argument -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Argument -> Bool
isRhoArgument) [Argument]
rhos)
    goExpr EXPRESSION
expr = EXPRESSION
expr
    goBinding :: BINDING -> BINDING
    goBinding :: BINDING -> BINDING
goBinding empty :: BINDING
empty@BI_EMPTY{} = BINDING
empty
    goBinding BI_META{BINDINGS
TAB
META
$sel:bindings:BI_PAIR :: BINDING -> BINDINGS
meta :: META
bindings :: BINDINGS
tab :: TAB
$sel:tab:BI_PAIR :: BINDING -> TAB
$sel:meta:BI_PAIR :: BINDING -> META
..} = META -> BINDINGS -> TAB -> BINDING
BI_META META
meta (BINDINGS -> BINDINGS
goBindings BINDINGS
bindings) TAB
tab
    goBinding BI_PAIR{BINDINGS
PAIR
TAB
$sel:pair:BI_PAIR :: BINDING -> PAIR
$sel:bindings:BI_PAIR :: BINDING -> BINDINGS
$sel:tab:BI_PAIR :: BINDING -> TAB
pair :: PAIR
bindings :: BINDINGS
tab :: TAB
..}
      | PAIR -> Bool
isRho PAIR
pair = TAB -> BINDINGS -> BINDING
promote TAB
tab (BINDINGS -> BINDINGS
goBindings BINDINGS
bindings)
      | Bool
otherwise = PAIR -> BINDINGS -> TAB -> BINDING
BI_PAIR (PAIR -> PAIR
goPair PAIR
pair) (BINDINGS -> BINDINGS
goBindings BINDINGS
bindings) TAB
tab
    goBindings :: BINDINGS -> BINDINGS
    goBindings :: BINDINGS -> BINDINGS
goBindings empty :: BINDINGS
empty@BDS_EMPTY{} = BINDINGS
empty
    goBindings BDS_META{BINDINGS
TAB
META
EOL
eol :: EOL
tab :: TAB
meta :: META
bindings :: BINDINGS
$sel:eol:BDS_PAIR :: BINDINGS -> EOL
$sel:tab:BDS_PAIR :: BINDINGS -> TAB
$sel:bindings:BDS_PAIR :: BINDINGS -> BINDINGS
$sel:meta:BDS_PAIR :: BINDINGS -> META
..} = EOL -> TAB -> META -> BINDINGS -> BINDINGS
BDS_META EOL
eol TAB
tab META
meta (BINDINGS -> BINDINGS
goBindings BINDINGS
bindings)
    goBindings BDS_PAIR{BINDINGS
PAIR
TAB
EOL
$sel:eol:BDS_PAIR :: BINDINGS -> EOL
$sel:tab:BDS_PAIR :: BINDINGS -> TAB
$sel:bindings:BDS_PAIR :: BINDINGS -> BINDINGS
eol :: EOL
tab :: TAB
pair :: PAIR
bindings :: BINDINGS
$sel:pair:BDS_PAIR :: BINDINGS -> PAIR
..}
      | PAIR -> Bool
isRho PAIR
pair = BINDINGS -> BINDINGS
goBindings BINDINGS
bindings
      | Bool
otherwise = EOL -> TAB -> PAIR -> BINDINGS -> BINDINGS
BDS_PAIR EOL
eol TAB
tab (PAIR -> PAIR
goPair PAIR
pair) (BINDINGS -> BINDINGS
goBindings BINDINGS
bindings)
    promote :: TAB -> BINDINGS -> BINDING
    promote :: TAB -> BINDINGS -> BINDING
promote TAB
tab (BDS_EMPTY TAB
_) = TAB -> BINDING
BI_EMPTY TAB
tab
    promote TAB
tab (BDS_PAIR EOL
_ TAB
_ PAIR
pair BINDINGS
bindings) = PAIR -> BINDINGS -> TAB -> BINDING
BI_PAIR PAIR
pair BINDINGS
bindings TAB
tab
    promote TAB
tab (BDS_META EOL
_ TAB
_ META
meta BINDINGS
bindings) = META -> BINDINGS -> TAB -> BINDING
BI_META META
meta BINDINGS
bindings TAB
tab
    goArgument :: APP_ARGUMENT -> Maybe APP_ARGUMENT
    goArgument :: APP_ARGUMENT -> Maybe APP_ARGUMENT
goArgument (AA_TAU (APP_BINDING PAIR
pair))
      | PAIR -> Bool
isRho PAIR
pair = Maybe APP_ARGUMENT
forall a. Maybe a
Nothing
      | Bool
otherwise = APP_ARGUMENT -> Maybe APP_ARGUMENT
forall a. a -> Maybe a
Just (APP_BINDING -> APP_ARGUMENT
AA_TAU (PAIR -> APP_BINDING
APP_BINDING (PAIR -> PAIR
goPair PAIR
pair)))
    goArgument (AA_TAUS BINDING
binding) = case BINDING -> BINDING
goArgBinding BINDING
binding of
      BI_EMPTY{} -> Maybe APP_ARGUMENT
forall a. Maybe a
Nothing
      BINDING
binding'
        | SugarType
sugar SugarType -> SugarType -> Bool
forall a. Eq a => a -> a -> Bool
== SugarType
SWEET, Just APP_ARG
args <- BINDING -> Maybe APP_ARG
positional BINDING
binding' -> APP_ARGUMENT -> Maybe APP_ARGUMENT
forall a. a -> Maybe a
Just (APP_ARG -> APP_ARGUMENT
AA_EXPRS APP_ARG
args)
        | Bool
otherwise -> APP_ARGUMENT -> Maybe APP_ARGUMENT
forall a. a -> Maybe a
Just (BINDING -> APP_ARGUMENT
AA_TAUS BINDING
binding')
    goArgument (AA_EXPRS APP_ARG
args) = APP_ARGUMENT -> Maybe APP_ARGUMENT
forall a. a -> Maybe a
Just (APP_ARG -> APP_ARGUMENT
AA_EXPRS (APP_ARG -> APP_ARG
goAppArg APP_ARG
args))
    positional :: BINDING -> Maybe APP_ARG
    positional :: BINDING -> Maybe APP_ARG
positional (BI_PAIR (PA_ALPHA (AL_IDX ALPHA'
_ Int
0) ARROW
_ EXPRESSION
first) BINDINGS
rest TAB
_) = EXPRESSION -> APP_ARGS -> APP_ARG
APP_ARG EXPRESSION
first (APP_ARGS -> APP_ARG) -> Maybe APP_ARGS -> Maybe APP_ARG
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> BINDINGS -> Maybe APP_ARGS
following Int
1 BINDINGS
rest
      where
        following :: Int -> BINDINGS -> Maybe APP_ARGS
        following :: Int -> BINDINGS -> Maybe APP_ARGS
following Int
_ BDS_EMPTY{} = APP_ARGS -> Maybe APP_ARGS
forall a. a -> Maybe a
Just APP_ARGS
AAS_EMPTY
        following Int
next (BDS_PAIR EOL
eol' TAB
tab' (PA_ALPHA (AL_IDX ALPHA'
_ Int
index) ARROW
_ EXPRESSION
arg) BINDINGS
more)
          | Int
index Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
next = EOL -> TAB -> EXPRESSION -> APP_ARGS -> APP_ARGS
AAS_EXPR EOL
eol' TAB
tab' EXPRESSION
arg (APP_ARGS -> APP_ARGS) -> Maybe APP_ARGS -> Maybe APP_ARGS
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> BINDINGS -> Maybe APP_ARGS
following (Int
next Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) BINDINGS
more
        following Int
_ BINDINGS
_ = Maybe APP_ARGS
forall a. Maybe a
Nothing
    positional BINDING
_ = Maybe APP_ARG
forall a. Maybe a
Nothing
    goArgBinding :: BINDING -> BINDING
    goArgBinding :: BINDING -> BINDING
goArgBinding empty :: BINDING
empty@BI_EMPTY{} = BINDING
empty
    goArgBinding BI_META{BINDINGS
TAB
META
$sel:bindings:BI_PAIR :: BINDING -> BINDINGS
$sel:tab:BI_PAIR :: BINDING -> TAB
$sel:meta:BI_PAIR :: BINDING -> META
meta :: META
bindings :: BINDINGS
tab :: TAB
..} = META -> BINDINGS -> TAB -> BINDING
BI_META META
meta (BINDINGS -> BINDINGS
goArgBindings BINDINGS
bindings) TAB
tab
    goArgBinding BI_PAIR{BINDINGS
PAIR
TAB
$sel:pair:BI_PAIR :: BINDING -> PAIR
$sel:bindings:BI_PAIR :: BINDING -> BINDINGS
$sel:tab:BI_PAIR :: BINDING -> TAB
pair :: PAIR
bindings :: BINDINGS
tab :: TAB
..}
      | PAIR -> Bool
isRho PAIR
pair = TAB -> BINDINGS -> BINDING
promote TAB
tab (BINDINGS -> BINDINGS
goArgBindings BINDINGS
bindings)
      | Bool
otherwise = PAIR -> BINDINGS -> TAB -> BINDING
BI_PAIR (PAIR -> PAIR
goPair PAIR
pair) (BINDINGS -> BINDINGS
goArgBindings BINDINGS
bindings) TAB
tab
    goArgBindings :: BINDINGS -> BINDINGS
    goArgBindings :: BINDINGS -> BINDINGS
goArgBindings empty :: BINDINGS
empty@BDS_EMPTY{} = BINDINGS
empty
    goArgBindings BDS_META{BINDINGS
TAB
META
EOL
$sel:eol:BDS_PAIR :: BINDINGS -> EOL
$sel:tab:BDS_PAIR :: BINDINGS -> TAB
$sel:bindings:BDS_PAIR :: BINDINGS -> BINDINGS
$sel:meta:BDS_PAIR :: BINDINGS -> META
eol :: EOL
tab :: TAB
meta :: META
bindings :: BINDINGS
..} = EOL -> TAB -> META -> BINDINGS -> BINDINGS
BDS_META EOL
eol TAB
tab META
meta (BINDINGS -> BINDINGS
goArgBindings BINDINGS
bindings)
    goArgBindings BDS_PAIR{BINDINGS
PAIR
TAB
EOL
$sel:eol:BDS_PAIR :: BINDINGS -> EOL
$sel:tab:BDS_PAIR :: BINDINGS -> TAB
$sel:bindings:BDS_PAIR :: BINDINGS -> BINDINGS
$sel:pair:BDS_PAIR :: BINDINGS -> PAIR
eol :: EOL
tab :: TAB
pair :: PAIR
bindings :: BINDINGS
..}
      | PAIR -> Bool
isRho PAIR
pair = BINDINGS -> BINDINGS
goArgBindings BINDINGS
bindings
      | Bool
otherwise = EOL -> TAB -> PAIR -> BINDINGS -> BINDINGS
BDS_PAIR EOL
eol TAB
tab (PAIR -> PAIR
goPair PAIR
pair) (BINDINGS -> BINDINGS
goArgBindings BINDINGS
bindings)
    goAppArg :: APP_ARG -> APP_ARG
    goAppArg :: APP_ARG -> APP_ARG
goAppArg 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
goExpr EXPRESSION
expr) (APP_ARGS -> APP_ARGS
goAppArgs APP_ARGS
args)
    goAppArgs :: APP_ARGS -> APP_ARGS
    goAppArgs :: APP_ARGS -> APP_ARGS
goAppArgs APP_ARGS
AAS_EMPTY = APP_ARGS
AAS_EMPTY
    goAppArgs 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
goExpr EXPRESSION
expr) (APP_ARGS -> APP_ARGS
goAppArgs APP_ARGS
args)
    goPair :: PAIR -> PAIR
    goPair :: PAIR -> PAIR
goPair 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
attr ARROW
arrow (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
expr)
    goPair 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 ARROW
arrow (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
expr)
    goPair 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]
..} = case (ATTRIBUTE -> Bool) -> [ATTRIBUTE] -> [ATTRIBUTE]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> (ATTRIBUTE -> Bool) -> ATTRIBUTE -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ATTRIBUTE -> Bool
rho) [ATTRIBUTE]
voids of
      [] -> ATTRIBUTE -> ARROW -> EXPRESSION -> PAIR
PA_TAU ATTRIBUTE
attr ARROW
arrow (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
expr)
      [ATTRIBUTE]
voids' -> ATTRIBUTE -> [ATTRIBUTE] -> ARROW -> EXPRESSION -> PAIR
PA_FORMATION ATTRIBUTE
attr [ATTRIBUTE]
voids' ARROW
arrow (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
expr)
      where
        rho :: ATTRIBUTE -> Bool
        rho :: ATTRIBUTE -> Bool
rho AT_RHO{} = Bool
True
        rho ATTRIBUTE
_ = Bool
False
    goPair PAIR
pair = PAIR
pair
    sugared :: PAIR -> Bool
    sugared :: PAIR -> Bool
sugared PA_TAU{$sel:attr:PA_TAU :: PAIR -> ATTRIBUTE
attr = AT_DELTA{}} = Bool
False
    sugared PA_TAU{$sel:attr:PA_TAU :: PAIR -> ATTRIBUTE
attr = AT_LAMBDA{}} = Bool
False
    sugared PA_ALPHA{} = Bool
False
    sugared PA_FORMATION{$sel:voids:PA_TAU :: PAIR -> [ATTRIBUTE]
voids = []} = Bool
True
    sugared PA_FORMATION{} = Bool
False
    sugared PAIR
_ = Bool
True
    isRho :: PAIR -> Bool
    isRho :: PAIR -> Bool
isRho PA_VOID{$sel:attr:PA_TAU :: PAIR -> ATTRIBUTE
attr = AT_RHO RHO
_} = Bool
True
    isRho PA_TAU{$sel:attr:PA_TAU :: PAIR -> ATTRIBUTE
attr = AT_RHO RHO
_} = Bool
True
    isRho PA_FORMATION{$sel:attr:PA_TAU :: PAIR -> ATTRIBUTE
attr = AT_RHO RHO
_} = Bool
True
    isRho PAIR
_ = Bool
False
    isRhoArgument :: Argument -> Bool
    isRhoArgument :: Argument -> Bool
isRhoArgument (ArTau Attribute
AtRho Expression
_) = Bool
True
    isRhoArgument Argument
_ = Bool
False

revealXi :: SugarType -> EXPRESSION -> EXPRESSION
revealXi :: SugarType -> EXPRESSION -> EXPRESSION
revealXi SugarType
_ = EXPRESSION -> EXPRESSION
goExpr
  where
    goExpr :: EXPRESSION -> EXPRESSION
    goExpr :: EXPRESSION -> EXPRESSION
goExpr EX_ATTR{ATTRIBUTE
$sel:attr:EX_GLOBAL :: EXPRESSION -> ATTRIBUTE
attr :: ATTRIBUTE
..} = EXPRESSION -> SPACE -> ATTRIBUTE -> EXPRESSION
EX_DISPATCH (XI -> EXPRESSION
EX_XI XI
XI) SPACE
NO_SPACE ATTRIBUTE
attr
    goExpr EX_DISPATCH{ATTRIBUTE
EXPRESSION
SPACE
$sel:attr:EX_GLOBAL :: EXPRESSION -> ATTRIBUTE
$sel:expr:EX_GLOBAL :: EXPRESSION -> EXPRESSION
$sel:space:EX_GLOBAL :: EXPRESSION -> SPACE
expr :: EXPRESSION
space :: SPACE
attr :: ATTRIBUTE
..} = EXPRESSION -> SPACE -> ATTRIBUTE -> EXPRESSION
EX_DISPATCH (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
expr) SPACE
space ATTRIBUTE
attr
    goExpr 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
$sel:argument:EX_GLOBAL :: EXPRESSION -> APP_ARGUMENT
$sel:indent:EX_GLOBAL :: EXPRESSION -> Int
expr :: EXPRESSION
space :: SPACE
eol :: EOL
tab :: TAB
argument :: APP_ARGUMENT
eol' :: EOL
tab' :: TAB
indent :: Int
..} = EXPRESSION
-> SPACE
-> EOL
-> TAB
-> APP_ARGUMENT
-> EOL
-> TAB
-> Int
-> EXPRESSION
EX_APPLICATION (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
expr) SPACE
space EOL
eol TAB
tab (APP_ARGUMENT -> APP_ARGUMENT
goArgument APP_ARGUMENT
argument) EOL
eol' TAB
tab' Int
indent
    goExpr EX_FORMATION{BINDING
TAB
EOL
RSB
LSB
$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 :: LSB
eol :: EOL
tab :: TAB
binding :: BINDING
eol' :: EOL
tab' :: TAB
rsb :: RSB
..} = LSB -> EOL -> TAB -> BINDING -> EOL -> TAB -> RSB -> EXPRESSION
EX_FORMATION LSB
lsb EOL
eol TAB
tab (BINDING -> BINDING
goBinding BINDING
binding) EOL
eol' TAB
tab' RSB
rsb
    goExpr EX_PHI_MEET{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_MEET Maybe String
prefix Int
idx (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
expr)
    goExpr 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
goExpr EXPRESSION
expr)
    goExpr EX_SINGLE{EXPRESSION
PAIR
SPACE
$sel:space:EX_GLOBAL :: EXPRESSION -> SPACE
$sel:pair:EX_GLOBAL :: EXPRESSION -> PAIR
$sel:formation:EX_GLOBAL :: EXPRESSION -> EXPRESSION
pair :: PAIR
space :: SPACE
formation :: EXPRESSION
..} = PAIR -> SPACE -> EXPRESSION -> EXPRESSION
EX_SINGLE (PAIR -> PAIR
goPair PAIR
pair) SPACE
space (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
formation)
    goExpr EXPRESSION
expr = EXPRESSION
expr
    goArgument :: APP_ARGUMENT -> APP_ARGUMENT
    goArgument :: APP_ARGUMENT -> APP_ARGUMENT
goArgument (AA_TAU (APP_BINDING PAIR
pair)) = APP_BINDING -> APP_ARGUMENT
AA_TAU (PAIR -> APP_BINDING
APP_BINDING (PAIR -> PAIR
goPair PAIR
pair))
    goArgument (AA_TAUS BINDING
binding) = BINDING -> APP_ARGUMENT
AA_TAUS (BINDING -> BINDING
goBinding BINDING
binding)
    goArgument (AA_EXPRS APP_ARG
arg) = APP_ARG -> APP_ARGUMENT
AA_EXPRS (APP_ARG -> APP_ARG
goAppArg APP_ARG
arg)
    goAppArg :: APP_ARG -> APP_ARG
    goAppArg :: APP_ARG -> APP_ARG
goAppArg APP_ARG{EXPRESSION
APP_ARGS
$sel:expr:APP_ARG :: APP_ARG -> EXPRESSION
$sel:args:APP_ARG :: APP_ARG -> APP_ARGS
expr :: EXPRESSION
args :: APP_ARGS
..} = EXPRESSION -> APP_ARGS -> APP_ARG
APP_ARG (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
expr) (APP_ARGS -> APP_ARGS
goAppArgs APP_ARGS
args)
    goAppArgs :: APP_ARGS -> APP_ARGS
    goAppArgs :: APP_ARGS -> APP_ARGS
goAppArgs APP_ARGS
AAS_EMPTY = APP_ARGS
AAS_EMPTY
    goAppArgs AAS_EXPR{EXPRESSION
APP_ARGS
TAB
EOL
$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 :: EOL
tab :: TAB
expr :: EXPRESSION
args :: APP_ARGS
..} = EOL -> TAB -> EXPRESSION -> APP_ARGS -> APP_ARGS
AAS_EXPR EOL
eol TAB
tab (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
expr) (APP_ARGS -> APP_ARGS
goAppArgs APP_ARGS
args)
    goBinding :: BINDING -> BINDING
    goBinding :: BINDING -> BINDING
goBinding BI_PAIR{BINDINGS
PAIR
TAB
$sel:pair:BI_PAIR :: BINDING -> PAIR
$sel:bindings:BI_PAIR :: BINDING -> BINDINGS
$sel:tab:BI_PAIR :: BINDING -> TAB
pair :: PAIR
bindings :: BINDINGS
tab :: TAB
..} = PAIR -> BINDINGS -> TAB -> BINDING
BI_PAIR (PAIR -> PAIR
goPair PAIR
pair) (BINDINGS -> BINDINGS
goBindings BINDINGS
bindings) TAB
tab
    goBinding BINDING
binding = BINDING
binding
    goBindings :: BINDINGS -> BINDINGS
    goBindings :: BINDINGS -> BINDINGS
goBindings BDS_PAIR{BINDINGS
PAIR
TAB
EOL
$sel:eol:BDS_PAIR :: BINDINGS -> EOL
$sel:tab:BDS_PAIR :: BINDINGS -> TAB
$sel:bindings:BDS_PAIR :: BINDINGS -> BINDINGS
$sel:pair:BDS_PAIR :: BINDINGS -> PAIR
eol :: EOL
tab :: TAB
pair :: PAIR
bindings :: BINDINGS
..} = EOL -> TAB -> PAIR -> BINDINGS -> BINDINGS
BDS_PAIR EOL
eol TAB
tab (PAIR -> PAIR
goPair PAIR
pair) (BINDINGS -> BINDINGS
goBindings BINDINGS
bindings)
    goBindings BINDINGS
bindings = BINDINGS
bindings
    goPair :: PAIR -> PAIR
    goPair :: PAIR -> PAIR
goPair PA_TAU{ATTRIBUTE
EXPRESSION
ARROW
$sel:attr:PA_TAU :: PAIR -> ATTRIBUTE
$sel:arrow:PA_TAU :: PAIR -> ARROW
$sel:expr:PA_TAU :: PAIR -> EXPRESSION
attr :: ATTRIBUTE
arrow :: ARROW
expr :: EXPRESSION
..} = ATTRIBUTE -> ARROW -> EXPRESSION -> PAIR
PA_TAU ATTRIBUTE
attr ARROW
arrow (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
expr)
    goPair PA_ALPHA{EXPRESSION
ALPHA
ARROW
$sel:arrow:PA_TAU :: PAIR -> ARROW
$sel:expr:PA_TAU :: PAIR -> EXPRESSION
$sel:alpha:PA_TAU :: PAIR -> ALPHA
alpha :: ALPHA
arrow :: ARROW
expr :: EXPRESSION
..} = ALPHA -> ARROW -> EXPRESSION -> PAIR
PA_ALPHA ALPHA
alpha ARROW
arrow (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
expr)
    goPair PA_FORMATION{[ATTRIBUTE]
ATTRIBUTE
EXPRESSION
ARROW
$sel:attr:PA_TAU :: PAIR -> ATTRIBUTE
$sel:arrow:PA_TAU :: PAIR -> ARROW
$sel:expr:PA_TAU :: PAIR -> EXPRESSION
$sel:voids:PA_TAU :: PAIR -> [ATTRIBUTE]
attr :: ATTRIBUTE
voids :: [ATTRIBUTE]
arrow :: ARROW
expr :: EXPRESSION
..} = ATTRIBUTE -> [ATTRIBUTE] -> ARROW -> EXPRESSION -> PAIR
PA_FORMATION ATTRIBUTE
attr [ATTRIBUTE]
voids ARROW
arrow (EXPRESSION -> EXPRESSION
goExpr EXPRESSION
expr)
    goPair PAIR
pair = PAIR
pair

class ToSalty a where
  toSalty :: a -> a

instance ToSalty EXPRESSION where
  toSalty :: EXPRESSION -> EXPRESSION
toSalty EX_ATTR{ATTRIBUTE
$sel:attr:EX_GLOBAL :: EXPRESSION -> ATTRIBUTE
attr :: ATTRIBUTE
..} = EXPRESSION -> SPACE -> ATTRIBUTE -> EXPRESSION
EX_DISPATCH (XI -> EXPRESSION
EX_XI XI
XI) SPACE
NO_SPACE ATTRIBUTE
attr
  toSalty EX_DISPATCH{ATTRIBUTE
EXPRESSION
SPACE
$sel:attr:EX_GLOBAL :: EXPRESSION -> ATTRIBUTE
$sel:expr:EX_GLOBAL :: EXPRESSION -> EXPRESSION
$sel:space:EX_GLOBAL :: EXPRESSION -> SPACE
expr :: EXPRESSION
space :: SPACE
attr :: ATTRIBUTE
..} = EXPRESSION -> SPACE -> ATTRIBUTE -> EXPRESSION
EX_DISPATCH (EXPRESSION -> EXPRESSION
forall a. ToSalty a => a -> a
toSalty EXPRESSION
expr) SPACE
space ATTRIBUTE
attr
  toSalty formation :: EXPRESSION
formation@EX_FORMATION{$sel:binding:EX_GLOBAL :: EXPRESSION -> BINDING
binding = BI_EMPTY{}} = EXPRESSION
formation
  toSalty EX_FORMATION{BINDING
TAB
EOL
RSB
LSB
$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 :: LSB
eol :: EOL
tab :: TAB
binding :: BINDING
eol' :: EOL
tab' :: TAB
rsb :: RSB
..} = LSB -> EOL -> TAB -> BINDING -> EOL -> TAB -> RSB -> EXPRESSION
EX_FORMATION LSB
lsb EOL
eol TAB
tab (BINDING -> BINDING
forall a. ToSalty a => a -> a
toSalty BINDING
binding) EOL
eol' TAB
tab' RSB
rsb
  toSalty EX_APPLICATION{$sel:argument:EX_GLOBAL :: EXPRESSION -> APP_ARGUMENT
argument = AA_TAU APP_BINDING
tau, Int
EXPRESSION
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
$sel:indent:EX_GLOBAL :: EXPRESSION -> Int
expr :: EXPRESSION
space :: SPACE
eol :: EOL
tab :: TAB
eol' :: EOL
tab' :: TAB
indent :: Int
..} = EXPRESSION
-> SPACE
-> EOL
-> TAB
-> APP_ARGUMENT
-> EOL
-> TAB
-> Int
-> EXPRESSION
EX_APPLICATION (EXPRESSION -> EXPRESSION
forall a. ToSalty a => a -> a
toSalty EXPRESSION
expr) SPACE
space EOL
EOL (Int -> TAB
TAB Int
indent) (APP_BINDING -> APP_ARGUMENT
AA_TAU (APP_BINDING -> APP_BINDING
forall a. ToSalty a => a -> a
toSalty APP_BINDING
tau)) EOL
EOL (Int -> TAB
TAB (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)) Int
indent
  toSalty EX_APPLICATION{$sel:argument:EX_GLOBAL :: EXPRESSION -> APP_ARGUMENT
argument = AA_TAUS BINDING
taus, Int
EXPRESSION
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
$sel:indent:EX_GLOBAL :: EXPRESSION -> Int
expr :: EXPRESSION
space :: SPACE
eol :: EOL
tab :: TAB
eol' :: EOL
tab' :: TAB
indent :: Int
..} =
    (EXPRESSION -> PAIR -> EXPRESSION)
-> EXPRESSION -> [PAIR] -> EXPRESSION
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl
      EXPRESSION -> PAIR -> EXPRESSION
toApplication
      EXPRESSION
expr
      (BINDING -> [PAIR]
tauToPairs BINDING
taus)
    where
      toApplication :: EXPRESSION -> PAIR -> EXPRESSION
      toApplication :: EXPRESSION -> PAIR -> EXPRESSION
toApplication EXPRESSION
exp PAIR
pair =
        EXPRESSION
-> SPACE
-> EOL
-> TAB
-> APP_ARGUMENT
-> EOL
-> TAB
-> Int
-> EXPRESSION
EX_APPLICATION (EXPRESSION -> EXPRESSION
forall a. ToSalty a => a -> a
toSalty EXPRESSION
exp) SPACE
space EOL
EOL (Int -> TAB
TAB Int
indent) (APP_BINDING -> APP_ARGUMENT
AA_TAU (PAIR -> APP_BINDING
APP_BINDING (PAIR -> PAIR
forall a. ToSalty a => a -> a
toSalty PAIR
pair))) EOL
EOL (Int -> TAB
TAB (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)) Int
indent
      tauToPairs :: BINDING -> [PAIR]
      tauToPairs :: BINDING -> [PAIR]
tauToPairs BI_PAIR{BINDINGS
PAIR
TAB
$sel:pair:BI_PAIR :: BINDING -> PAIR
$sel:bindings:BI_PAIR :: BINDING -> BINDINGS
$sel:tab:BI_PAIR :: BINDING -> TAB
pair :: PAIR
bindings :: BINDINGS
tab :: TAB
..} = PAIR
pair PAIR -> [PAIR] -> [PAIR]
forall a. a -> [a] -> [a]
: BINDINGS -> [PAIR]
tausToPairs BINDINGS
bindings
      tauToPairs BI_EMPTY{} = []
      tauToPairs (BI_META META
mt BINDINGS
_ TAB
_) = String -> [PAIR]
forall a. HasCallStack => String -> a
error (String -> [PAIR]) -> String -> [PAIR]
forall a b. (a -> b) -> a -> b
$ String
"BI_META " String -> ShowS
forall a. [a] -> [a] -> [a]
++ META -> String
forall a. Show a => a -> String
show META
mt String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" unexpected in tauToPairs"
      tausToPairs :: BINDINGS -> [PAIR]
      tausToPairs :: BINDINGS -> [PAIR]
tausToPairs BDS_EMPTY{} = []
      tausToPairs BDS_PAIR{BINDINGS
PAIR
TAB
EOL
$sel:eol:BDS_PAIR :: BINDINGS -> EOL
$sel:tab:BDS_PAIR :: BINDINGS -> TAB
$sel:bindings:BDS_PAIR :: BINDINGS -> BINDINGS
$sel:pair:BDS_PAIR :: BINDINGS -> PAIR
eol :: EOL
tab :: TAB
pair :: PAIR
bindings :: BINDINGS
..} = PAIR
pair PAIR -> [PAIR] -> [PAIR]
forall a. a -> [a] -> [a]
: BINDINGS -> [PAIR]
tausToPairs BINDINGS
bindings
      tausToPairs (BDS_META EOL
_ TAB
_ META
mt BINDINGS
_) = String -> [PAIR]
forall a. HasCallStack => String -> a
error (String -> [PAIR]) -> String -> [PAIR]
forall a b. (a -> b) -> a -> b
$ String
"BDS_META " String -> ShowS
forall a. [a] -> [a] -> [a]
++ META -> String
forall a. Show a => a -> String
show META
mt String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" unexpected in tausToPairs"
  toSalty EX_APPLICATION{$sel:argument:EX_GLOBAL :: EXPRESSION -> APP_ARGUMENT
argument = AA_EXPRS APP_ARG
args, Int
EXPRESSION
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
$sel:indent:EX_GLOBAL :: EXPRESSION -> Int
expr :: EXPRESSION
space :: SPACE
eol :: EOL
tab :: TAB
eol' :: EOL
tab' :: TAB
indent :: Int
..} = EXPRESSION -> EXPRESSION
forall a. ToSalty a => a -> a
toSalty (EXPRESSION
-> SPACE
-> EOL
-> TAB
-> APP_ARGUMENT
-> EOL
-> TAB
-> Int
-> EXPRESSION
EX_APPLICATION EXPRESSION
expr SPACE
space EOL
EOL (Int -> TAB
TAB Int
indent) (BINDING -> APP_ARGUMENT
AA_TAUS (APP_ARG -> TAB -> BINDING
argToBinding APP_ARG
args TAB
tab)) EOL
EOL (Int -> TAB
TAB (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)) Int
indent)
    where
      argToBinding :: APP_ARG -> TAB -> BINDING
      argToBinding :: APP_ARG -> TAB -> BINDING
argToBinding APP_ARG{EXPRESSION
APP_ARGS
$sel:expr:APP_ARG :: APP_ARG -> EXPRESSION
$sel:args:APP_ARG :: APP_ARG -> APP_ARGS
expr :: EXPRESSION
args :: APP_ARGS
..} =
        PAIR -> BINDINGS -> TAB -> BINDING
BI_PAIR
          (ALPHA -> ARROW -> EXPRESSION -> PAIR
PA_ALPHA (ALPHA' -> Int -> ALPHA
AL_IDX ALPHA'
ALPHA Int
0) ARROW
ARROW EXPRESSION
expr)
          (APP_ARGS -> Int -> TAB -> BINDINGS
argsToBindings APP_ARGS
args Int
1 TAB
tab)
      argsToBindings :: APP_ARGS -> Int -> TAB -> BINDINGS
      argsToBindings :: APP_ARGS -> Int -> TAB -> BINDINGS
argsToBindings APP_ARGS
AAS_EMPTY Int
_ TAB
tab = TAB -> BINDINGS
BDS_EMPTY TAB
tab
      argsToBindings AAS_EXPR{EXPRESSION
APP_ARGS
TAB
EOL
$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 :: EOL
tab :: TAB
expr :: EXPRESSION
args :: APP_ARGS
..} Int
idx TAB
tb = EOL -> TAB -> PAIR -> BINDINGS -> BINDINGS
BDS_PAIR EOL
eol TAB
tb (ALPHA -> ARROW -> EXPRESSION -> PAIR
PA_ALPHA (ALPHA' -> Int -> ALPHA
AL_IDX ALPHA'
ALPHA Int
idx) ARROW
ARROW EXPRESSION
expr) (APP_ARGS -> Int -> TAB -> BINDINGS
argsToBindings APP_ARGS
args (Int
idx Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) TAB
tb)
  toSalty EX_NUMBER{Double
$sel:num:EX_GLOBAL :: EXPRESSION -> Double
num :: Double
num, $sel:tab:EX_GLOBAL :: EXPRESSION -> TAB
tab = tab :: TAB
tab@TAB{Int
indent :: Int
$sel:indent:TAB :: TAB -> Int
..}, [Argument]
$sel:rhos:EX_GLOBAL :: EXPRESSION -> [Argument]
rhos :: [Argument]
rhos} =
    EXPRESSION
-> EXPRESSION -> EXPRESSION -> TAB -> [Argument] -> EXPRESSION
saltifyPrimitive
      (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST (Text -> Expression
BaseObject Text
"number") (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1, EOL
EOL))
      (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST (Text -> Expression
BaseObject Text
"bytes") (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2, EOL
EOL))
      (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST ([Binding] -> Expression
ExFormation [Bytes -> Binding
BiDelta (Double -> Bytes
numToBts Double
num)]) (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2, EOL
EOL))
      TAB
tab
      [Argument]
rhos
  toSalty EX_NONFINITE{NonFinite
$sel:nonfinite:EX_GLOBAL :: EXPRESSION -> NonFinite
nonfinite :: NonFinite
nonfinite, $sel:tab:EX_GLOBAL :: EXPRESSION -> TAB
tab = tab :: TAB
tab@TAB{Int
$sel:indent:TAB :: TAB -> Int
indent :: Int
..}, [Argument]
$sel:rhos:EX_GLOBAL :: EXPRESSION -> [Argument]
rhos :: [Argument]
rhos} =
    EXPRESSION
-> EXPRESSION -> EXPRESSION -> TAB -> [Argument] -> EXPRESSION
saltifyPrimitive
      (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST (Text -> Expression
BaseObject Text
"number") (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1, EOL
EOL))
      (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST (Text -> Expression
BaseObject Text
"bytes") (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2, EOL
EOL))
      (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST ([Binding] -> Expression
ExFormation [Bytes -> Binding
BiDelta (NonFinite -> Bytes
nonFiniteBts NonFinite
nonfinite)]) (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2, EOL
EOL))
      TAB
tab
      [Argument]
rhos
  toSalty EX_STRING{String
$sel:str:EX_GLOBAL :: EXPRESSION -> String
str :: String
str, $sel:tab:EX_GLOBAL :: EXPRESSION -> TAB
tab = tab :: TAB
tab@TAB{Int
$sel:indent:TAB :: TAB -> Int
indent :: Int
..}, [Argument]
$sel:rhos:EX_GLOBAL :: EXPRESSION -> [Argument]
rhos :: [Argument]
rhos} =
    EXPRESSION
-> EXPRESSION -> EXPRESSION -> TAB -> [Argument] -> EXPRESSION
saltifyPrimitive
      (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST (Text -> Expression
BaseObject Text
"string") (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1, EOL
EOL))
      (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST (Text -> Expression
BaseObject Text
"bytes") (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2, EOL
EOL))
      (Expression -> (Int, EOL) -> EXPRESSION
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST ([Binding] -> Expression
ExFormation [Bytes -> Binding
BiDelta (String -> Bytes
strToBts (ShowS
unescapeStr String
str))]) (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2, EOL
EOL))
      TAB
tab
      [Argument]
rhos
  toSalty EX_PHI_MEET{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_MEET Maybe String
prefix Int
idx (EXPRESSION -> EXPRESSION
forall a. ToSalty a => a -> a
toSalty EXPRESSION
expr)
  toSalty 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. ToSalty a => a -> a
toSalty EXPRESSION
expr)
  toSalty EX_SINGLE{EXPRESSION
PAIR
SPACE
$sel:space:EX_GLOBAL :: EXPRESSION -> SPACE
$sel:pair:EX_GLOBAL :: EXPRESSION -> PAIR
$sel:formation:EX_GLOBAL :: EXPRESSION -> EXPRESSION
pair :: PAIR
space :: SPACE
formation :: EXPRESSION
..} = EXPRESSION -> EXPRESSION
forall a. ToSalty a => a -> a
toSalty EXPRESSION
formation
  toSalty EXPRESSION
expr = EXPRESSION
expr

saltifyPrimitive :: EXPRESSION -> EXPRESSION -> EXPRESSION -> TAB -> [Argument] -> EXPRESSION
saltifyPrimitive :: EXPRESSION
-> EXPRESSION -> EXPRESSION -> TAB -> [Argument] -> EXPRESSION
saltifyPrimitive EXPRESSION
base EXPRESSION
bytes EXPRESSION
data' tb :: TAB
tb@TAB{Int
$sel:indent:TAB :: TAB -> Int
indent :: Int
..} [Argument]
rhos =
  let next :: TAB
next = Int -> TAB
TAB (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
   in EXPRESSION -> EXPRESSION
forall a. ToSalty a => a -> a
toSalty
        ( EXPRESSION
-> SPACE
-> EOL
-> TAB
-> APP_ARGUMENT
-> EOL
-> TAB
-> Int
-> EXPRESSION
EX_APPLICATION
            EXPRESSION
base
            SPACE
NO_SPACE
            EOL
EOL
            TAB
next
            ( BINDING -> APP_ARGUMENT
AA_TAUS
                ( PAIR -> BINDINGS -> TAB -> BINDING
BI_PAIR
                    ( ATTRIBUTE -> ARROW -> EXPRESSION -> PAIR
PA_TAU
                        (PHI -> ATTRIBUTE
AT_PHI PHI
PHI)
                        ARROW
ARROW
                        ( EXPRESSION
-> SPACE
-> EOL
-> TAB
-> APP_ARGUMENT
-> EOL
-> TAB
-> Int
-> EXPRESSION
EX_APPLICATION
                            EXPRESSION
bytes
                            SPACE
NO_SPACE
                            EOL
EOL
                            (Int -> TAB
TAB (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2))
                            ( BINDING -> APP_ARGUMENT
AA_TAUS
                                ( PAIR -> BINDINGS -> TAB -> BINDING
BI_PAIR
                                    (ATTRIBUTE -> ARROW -> EXPRESSION -> PAIR
PA_TAU (PHI -> ATTRIBUTE
AT_PHI PHI
PHI) ARROW
ARROW EXPRESSION
data')
                                    (TAB -> BINDINGS
BDS_EMPTY (Int -> TAB
TAB (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)))
                                    (Int -> TAB
TAB (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2))
                                )
                            )
                            EOL
EOL
                            TAB
next
                            (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)
                        )
                    )
                    ([Argument] -> (Int, EOL) -> BINDINGS
forall a b. ToCST a b => a -> (Int, EOL) -> b
toCST [Argument]
rhos (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1, EOL
EOL))
                    TAB
next
                )
            )
            EOL
EOL
            TAB
tb
            (Int
indent Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
        )
saltifyPrimitive EXPRESSION
_ EXPRESSION
_ EXPRESSION
_ TAB
TAB' [Argument]
_ = String -> EXPRESSION
forall a. HasCallStack => String -> a
error String
"saltifyPrimitive requires TAB with indent, got TAB'"
saltifyPrimitive EXPRESSION
_ EXPRESSION
_ EXPRESSION
_ TAB
NO_TAB [Argument]
_ = String -> EXPRESSION
forall a. HasCallStack => String -> a
error String
"saltifyPrimitive requires TAB with indent, got NO_TAB"

instance ToSalty BINDING where
  toSalty :: BINDING -> BINDING
toSalty BI_PAIR{BINDINGS
PAIR
TAB
$sel:pair:BI_PAIR :: BINDING -> PAIR
$sel:bindings:BI_PAIR :: BINDING -> BINDINGS
$sel:tab:BI_PAIR :: BINDING -> TAB
pair :: PAIR
bindings :: BINDINGS
tab :: TAB
..} = PAIR -> BINDINGS -> TAB -> BINDING
BI_PAIR (PAIR -> PAIR
forall a. ToSalty a => a -> a
toSalty PAIR
pair) (BINDINGS -> BINDINGS
forall a. ToSalty a => a -> a
toSalty BINDINGS
bindings) TAB
tab
  toSalty BINDING
bd = BINDING
bd

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

instance ToSalty BINDINGS where
  toSalty :: BINDINGS -> BINDINGS
toSalty BDS_PAIR{BINDINGS
PAIR
TAB
EOL
$sel:eol:BDS_PAIR :: BINDINGS -> EOL
$sel:tab:BDS_PAIR :: BINDINGS -> TAB
$sel:bindings:BDS_PAIR :: BINDINGS -> BINDINGS
$sel:pair:BDS_PAIR :: BINDINGS -> PAIR
eol :: EOL
tab :: TAB
pair :: PAIR
bindings :: BINDINGS
..} = EOL -> TAB -> PAIR -> BINDINGS -> BINDINGS
BDS_PAIR EOL
eol TAB
tab (PAIR -> PAIR
forall a. ToSalty a => a -> a
toSalty PAIR
pair) (BINDINGS -> BINDINGS
forall a. ToSalty a => a -> a
toSalty BINDINGS
bindings)
  toSalty BINDINGS
bds = BINDINGS
bds

instance ToSalty PAIR where
  toSalty :: PAIR -> PAIR
toSalty PA_TAU{ATTRIBUTE
EXPRESSION
ARROW
$sel:attr:PA_TAU :: PAIR -> ATTRIBUTE
$sel:arrow:PA_TAU :: PAIR -> ARROW
$sel:expr:PA_TAU :: PAIR -> EXPRESSION
attr :: ATTRIBUTE
arrow :: ARROW
expr :: EXPRESSION
..} = ATTRIBUTE -> ARROW -> EXPRESSION -> PAIR
PA_TAU ATTRIBUTE
attr ARROW
arrow (EXPRESSION -> EXPRESSION
forall a. ToSalty a => a -> a
toSalty EXPRESSION
expr)
  toSalty PA_ALPHA{EXPRESSION
ALPHA
ARROW
$sel:arrow:PA_TAU :: PAIR -> ARROW
$sel:expr:PA_TAU :: PAIR -> EXPRESSION
$sel:alpha:PA_TAU :: PAIR -> ALPHA
alpha :: ALPHA
arrow :: ARROW
expr :: EXPRESSION
..} = ALPHA -> ARROW -> EXPRESSION -> PAIR
PA_ALPHA ALPHA
alpha ARROW
arrow (EXPRESSION -> EXPRESSION
forall a. ToSalty a => a -> a
toSalty EXPRESSION
expr)
  toSalty PA_FORMATION{[ATTRIBUTE]
$sel:voids:PA_TAU :: PAIR -> [ATTRIBUTE]
voids :: [ATTRIBUTE]
voids, ATTRIBUTE
$sel:attr:PA_TAU :: PAIR -> ATTRIBUTE
attr :: ATTRIBUTE
attr, ARROW
$sel:arrow:PA_TAU :: PAIR -> ARROW
arrow :: ARROW
arrow, $sel:expr:PA_TAU :: PAIR -> EXPRESSION
expr = EX_SINGLE{EXPRESSION
$sel:formation:EX_GLOBAL :: EXPRESSION -> EXPRESSION
formation :: EXPRESSION
formation}} = PAIR -> PAIR
forall a. ToSalty a => a -> a
toSalty (ATTRIBUTE -> [ATTRIBUTE] -> ARROW -> EXPRESSION -> PAIR
PA_FORMATION ATTRIBUTE
attr [ATTRIBUTE]
voids ARROW
arrow EXPRESSION
formation)
  toSalty PA_FORMATION{[ATTRIBUTE]
$sel:voids:PA_TAU :: PAIR -> [ATTRIBUTE]
voids :: [ATTRIBUTE]
voids, ATTRIBUTE
$sel:attr:PA_TAU :: PAIR -> ATTRIBUTE
attr :: ATTRIBUTE
attr, ARROW
$sel:arrow:PA_TAU :: PAIR -> ARROW
arrow :: ARROW
arrow, $sel:expr:PA_TAU :: PAIR -> EXPRESSION
expr = EX_FORMATION{BINDING
TAB
EOL
RSB
LSB
$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 :: LSB
eol :: EOL
tab :: TAB
binding :: BINDING
eol' :: EOL
tab' :: TAB
rsb :: RSB
..}} =
    ATTRIBUTE -> ARROW -> EXPRESSION -> PAIR
PA_TAU ATTRIBUTE
attr ARROW
arrow (EXPRESSION -> EXPRESSION
forall a. ToSalty a => a -> a
toSalty (LSB -> EOL -> TAB -> BINDING -> EOL -> TAB -> RSB -> EXPRESSION
EX_FORMATION LSB
lsb EOL
eol TAB
tab ([ATTRIBUTE] -> BINDING -> BINDING
joinToBinding [ATTRIBUTE]
voids BINDING
binding) EOL
eol' TAB
tab' RSB
rsb))
    where
      joinToBinding :: [ATTRIBUTE] -> BINDING -> BINDING
      joinToBinding :: [ATTRIBUTE] -> BINDING -> BINDING
joinToBinding [] BINDING
bd = BINDING
bd
      joinToBinding (ATTRIBUTE
attr : [ATTRIBUTE]
rest) BINDING
bd = PAIR -> BINDINGS -> TAB -> BINDING
BI_PAIR (ATTRIBUTE -> ARROW -> VOID -> PAIR
PA_VOID ATTRIBUTE
attr ARROW
arrow VOID
EMPTY) ([ATTRIBUTE] -> BINDING -> BINDINGS
joinToBindings [ATTRIBUTE]
rest BINDING
bd) TAB
tab
      joinToBindings :: [ATTRIBUTE] -> BINDING -> BINDINGS
      joinToBindings :: [ATTRIBUTE] -> BINDING -> BINDINGS
joinToBindings [] BI_EMPTY{TAB
$sel:tab:BI_PAIR :: BINDING -> TAB
tab :: TAB
..} = TAB -> BINDINGS
BDS_EMPTY TAB
tab
      joinToBindings [] BI_PAIR{BINDINGS
PAIR
TAB
$sel:pair:BI_PAIR :: BINDING -> PAIR
$sel:bindings:BI_PAIR :: BINDING -> BINDINGS
$sel:tab:BI_PAIR :: BINDING -> TAB
pair :: PAIR
bindings :: BINDINGS
tab :: TAB
..} = EOL -> TAB -> PAIR -> BINDINGS -> BINDINGS
BDS_PAIR EOL
eol TAB
tab PAIR
pair BINDINGS
bindings
      joinToBindings [] BI_META{BINDINGS
TAB
META
$sel:bindings:BI_PAIR :: BINDING -> BINDINGS
$sel:tab:BI_PAIR :: BINDING -> TAB
$sel:meta:BI_PAIR :: BINDING -> META
meta :: META
bindings :: BINDINGS
tab :: TAB
..} = EOL -> TAB -> META -> BINDINGS -> BINDINGS
BDS_META EOL
eol TAB
tab META
meta BINDINGS
bindings
      joinToBindings (ATTRIBUTE
attr : [ATTRIBUTE]
rest) BINDING
bd = EOL -> TAB -> PAIR -> BINDINGS -> BINDINGS
BDS_PAIR EOL
eol TAB
tab (ATTRIBUTE -> ARROW -> VOID -> PAIR
PA_VOID ATTRIBUTE
attr ARROW
arrow VOID
EMPTY) ([ATTRIBUTE] -> BINDING -> BINDINGS
joinToBindings [ATTRIBUTE]
rest BINDING
bd)
  toSalty PAIR
pair = PAIR
pair

instance ToSalty SET where
  toSalty :: SET -> SET
toSalty ST_BINDING{BINDING
binding :: BINDING
$sel:binding:ST_BINDING :: SET -> BINDING
..} = BINDING -> SET
ST_BINDING (BINDING -> BINDING
forall a. ToSalty a => a -> a
toSalty BINDING
binding)
  toSalty SET
st = SET
st

instance ToSalty NUMBER where
  toSalty :: NUMBER -> NUMBER
toSalty LENGTH{BINDING
binding :: BINDING
$sel:binding:IDX_META :: NUMBER -> BINDING
..} = BINDING -> NUMBER
LENGTH (BINDING -> BINDING
forall a. ToSalty a => a -> a
toSalty BINDING
binding)
  toSalty DOMAIN{BINDING
$sel:binding:IDX_META :: NUMBER -> BINDING
binding :: BINDING
..} = BINDING -> NUMBER
DOMAIN (BINDING -> BINDING
forall a. ToSalty a => a -> a
toSalty BINDING
binding)
  toSalty NUMBER
num = NUMBER
num

instance ToSalty COMPARABLE where
  toSalty :: COMPARABLE -> COMPARABLE
toSalty comp :: COMPARABLE
comp@CMP_ATTR{} = COMPARABLE
comp
  toSalty CMP_EXPR{EXPRESSION
expr :: EXPRESSION
$sel:expr:CMP_ATTR :: COMPARABLE -> EXPRESSION
..} = EXPRESSION -> COMPARABLE
CMP_EXPR (EXPRESSION -> EXPRESSION
forall a. ToSalty a => a -> a
toSalty EXPRESSION
expr)
  toSalty CMP_NUM{NUMBER
num :: NUMBER
$sel:num:CMP_ATTR :: COMPARABLE -> NUMBER
..} = NUMBER -> COMPARABLE
CMP_NUM (NUMBER -> NUMBER
forall a. ToSalty a => a -> a
toSalty NUMBER
num)

instance ToSalty CONDITION where
  toSalty :: CONDITION -> CONDITION
toSalty 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
attr BELONGING
belongs (SET -> SET
forall a. ToSalty a => a -> a
toSalty SET
set)
  toSalty 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. ToSalty a => a -> a
toSalty [CONDITION]
conditions) LOGIC_OPERATOR
operator
  toSalty CO_NF{EXPRESSION
expr :: EXPRESSION
$sel:expr:CO_EMPTY :: CONDITION -> EXPRESSION
..} = EXPRESSION -> CONDITION
CO_NF (EXPRESSION -> EXPRESSION
forall a. ToSalty a => a -> a
toSalty EXPRESSION
expr)
  toSalty 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. ToSalty a => a -> a
toSalty EXPRESSION
expr) BELONGING
belongs
  toSalty CO_NOT{CONDITION
condition :: CONDITION
$sel:condition:CO_EMPTY :: CONDITION -> CONDITION
..} = CONDITION -> CONDITION
CO_NOT (CONDITION -> CONDITION
forall a. ToSalty a => a -> a
toSalty CONDITION
condition)
  toSalty 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. ToSalty a => a -> a
toSalty COMPARABLE
left) EQUAL
equal (COMPARABLE -> COMPARABLE
forall a. ToSalty a => a -> a
toSalty COMPARABLE
right)
  toSalty 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. ToSalty a => a -> a
toSalty EXPRESSION
expr)
  toSalty 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. ToSalty a => a -> a
toSalty EXPRESSION
expr) (BINDING -> BINDING
forall a. ToSalty a => a -> a
toSalty BINDING
binding)
  toSalty 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]
attrs ((BINDING -> BINDING) -> [BINDING] -> [BINDING]
forall a b. (a -> b) -> [a] -> [b]
map BINDING -> BINDING
forall a. ToSalty a => a -> a
toSalty [BINDING]
groups)
  toSalty 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]
attrs BELONGING
belongs ((BINDING -> BINDING) -> [BINDING] -> [BINDING]
forall a b. (a -> b) -> [a] -> [b]
map BINDING -> BINDING
forall a. ToSalty a => a -> a
toSalty [BINDING]
groups)
  toSalty CO_FORMATION{EXPRESSION
$sel:expr:CO_EMPTY :: CONDITION -> EXPRESSION
expr :: EXPRESSION
..} = EXPRESSION -> CONDITION
CO_FORMATION (EXPRESSION -> EXPRESSION
forall a. ToSalty a => a -> a
toSalty EXPRESSION
expr)
  toSalty CONDITION
CO_EMPTY = CONDITION
CO_EMPTY

instance ToSalty EXTRA_ARG where
  toSalty :: EXTRA_ARG -> EXTRA_ARG
toSalty ARG_EXPR{EXPRESSION
expr :: EXPRESSION
$sel:expr:ARG_EXPR :: EXTRA_ARG -> EXPRESSION
..} = EXPRESSION -> EXTRA_ARG
ARG_EXPR (EXPRESSION -> EXPRESSION
forall a. ToSalty a => a -> a
toSalty EXPRESSION
expr)
  toSalty ARG_BINDING{BINDING
binding :: BINDING
$sel:binding:ARG_EXPR :: EXTRA_ARG -> BINDING
..} = BINDING -> EXTRA_ARG
ARG_BINDING (BINDING -> BINDING
forall a. ToSalty a => a -> a
toSalty BINDING
binding)
  toSalty at :: EXTRA_ARG
at@ARG_ATTR{} = EXTRA_ARG
at
  toSalty bts :: EXTRA_ARG
bts@ARG_BYTES{} = EXTRA_ARG
bts

instance ToSalty EXTRA where
  toSalty :: EXTRA -> EXTRA
toSalty 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. ToSalty a => a -> a
toSalty 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. ToSalty a => a -> a
toSalty [EXTRA_ARG]
args)