{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE RecordWildCards #-}

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

module Lining (toSingleLine, LineFormat (..), withLineFormat, ToSingleLine) where

import CST

withLineFormat :: (ToSingleLine a) => LineFormat -> a -> a
withLineFormat :: forall a. ToSingleLine a => LineFormat -> a -> a
withLineFormat LineFormat
MULTILINE a
node = a
node
withLineFormat LineFormat
SINGLELINE a
node = a -> a
forall a. ToSingleLine a => a -> a
toSingleLine a
node

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

class ToSingleLine a where
  toSingleLine :: a -> a

instance ToSingleLine EXPRESSION where
  toSingleLine :: EXPRESSION -> EXPRESSION
toSingleLine EX_FORMATION{LSB
lsb :: LSB
$sel:lsb:EX_GLOBAL :: EXPRESSION -> LSB
lsb, $sel:binding:EX_GLOBAL :: EXPRESSION -> BINDING
binding = bd :: BINDING
bd@BI_EMPTY{}, RSB
rsb :: RSB
$sel:rsb:EX_GLOBAL :: EXPRESSION -> RSB
rsb} = LSB -> EOL -> TAB -> BINDING -> EOL -> TAB -> RSB -> EXPRESSION
EX_FORMATION LSB
lsb EOL
NO_EOL TAB
NO_TAB BINDING
bd EOL
NO_EOL TAB
NO_TAB RSB
rsb
  toSingleLine EX_FORMATION{BINDING
TAB
EOL
RSB
LSB
$sel:lsb:EX_GLOBAL :: EXPRESSION -> LSB
$sel:binding:EX_GLOBAL :: EXPRESSION -> BINDING
$sel:rsb:EX_GLOBAL :: EXPRESSION -> RSB
lsb :: LSB
eol :: EOL
tab :: TAB
binding :: BINDING
eol' :: EOL
tab' :: TAB
rsb :: RSB
$sel:eol:EX_GLOBAL :: EXPRESSION -> EOL
$sel:tab:EX_GLOBAL :: EXPRESSION -> TAB
$sel:eol':EX_GLOBAL :: EXPRESSION -> EOL
$sel:tab':EX_GLOBAL :: EXPRESSION -> TAB
..} = LSB -> EOL -> TAB -> BINDING -> EOL -> TAB -> RSB -> EXPRESSION
EX_FORMATION LSB
lsb EOL
NO_EOL TAB
TAB' (BINDING -> BINDING
forall a. ToSingleLine a => a -> a
toSingleLine BINDING
binding) EOL
NO_EOL TAB
TAB' RSB
rsb
  toSingleLine 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
forall a. ToSingleLine a => a -> a
toSingleLine EXPRESSION
expr) SPACE
space ATTRIBUTE
attr
  toSingleLine EX_APPLICATION{Int
EXPRESSION
APP_ARGUMENT
TAB
EOL
SPACE
$sel:eol:EX_GLOBAL :: EXPRESSION -> EOL
$sel:tab:EX_GLOBAL :: EXPRESSION -> TAB
$sel:eol':EX_GLOBAL :: EXPRESSION -> EOL
$sel:tab':EX_GLOBAL :: EXPRESSION -> TAB
$sel:expr:EX_GLOBAL :: EXPRESSION -> EXPRESSION
$sel:space:EX_GLOBAL :: EXPRESSION -> SPACE
expr :: EXPRESSION
space :: SPACE
eol :: EOL
tab :: TAB
argument :: APP_ARGUMENT
eol' :: EOL
tab' :: TAB
indent :: Int
$sel:argument:EX_GLOBAL :: EXPRESSION -> APP_ARGUMENT
$sel:indent:EX_GLOBAL :: EXPRESSION -> Int
..} = EXPRESSION
-> SPACE
-> EOL
-> TAB
-> APP_ARGUMENT
-> EOL
-> TAB
-> Int
-> EXPRESSION
EX_APPLICATION (EXPRESSION -> EXPRESSION
forall a. ToSingleLine a => a -> a
toSingleLine EXPRESSION
expr) SPACE
space EOL
NO_EOL TAB
TAB' (APP_ARGUMENT -> APP_ARGUMENT
forall a. ToSingleLine a => a -> a
toSingleLine APP_ARGUMENT
argument) EOL
NO_EOL TAB
TAB' Int
indent
  toSingleLine EX_PHI_MEET{Int
Maybe String
EXPRESSION
$sel:expr:EX_GLOBAL :: EXPRESSION -> EXPRESSION
prefix :: Maybe String
idx :: Int
expr :: EXPRESSION
$sel:prefix:EX_GLOBAL :: EXPRESSION -> Maybe String
$sel:idx:EX_GLOBAL :: EXPRESSION -> Int
..} = Maybe String -> Int -> EXPRESSION -> EXPRESSION
EX_PHI_MEET Maybe String
prefix Int
idx (EXPRESSION -> EXPRESSION
forall a. ToSingleLine a => a -> a
toSingleLine EXPRESSION
expr)
  toSingleLine 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. ToSingleLine a => a -> a
toSingleLine EXPRESSION
expr)
  toSingleLine EX_SINGLE{EXPRESSION
PAIR
SPACE
$sel:space:EX_GLOBAL :: EXPRESSION -> SPACE
pair :: PAIR
space :: SPACE
formation :: EXPRESSION
$sel:pair:EX_GLOBAL :: EXPRESSION -> PAIR
$sel:formation:EX_GLOBAL :: EXPRESSION -> EXPRESSION
..} = PAIR -> SPACE -> EXPRESSION -> EXPRESSION
EX_SINGLE (PAIR -> PAIR
forall a. ToSingleLine a => a -> a
toSingleLine PAIR
pair) SPACE
space (EXPRESSION -> EXPRESSION
forall a. ToSingleLine a => a -> a
toSingleLine EXPRESSION
formation)
  toSingleLine EXPRESSION
expr = EXPRESSION
expr

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

instance ToSingleLine BINDING where
  toSingleLine :: BINDING -> BINDING
toSingleLine BI_PAIR{BINDINGS
PAIR
TAB
pair :: PAIR
bindings :: BINDINGS
tab :: TAB
$sel:pair:BI_PAIR :: BINDING -> PAIR
$sel:bindings:BI_PAIR :: BINDING -> BINDINGS
$sel:tab:BI_PAIR :: BINDING -> TAB
..} = PAIR -> BINDINGS -> TAB -> BINDING
BI_PAIR (PAIR -> PAIR
forall a. ToSingleLine a => a -> a
toSingleLine PAIR
pair) (BINDINGS -> BINDINGS
forall a. ToSingleLine a => a -> a
toSingleLine BINDINGS
bindings) TAB
TAB'
  toSingleLine BI_META{BINDINGS
TAB
META
$sel:bindings:BI_PAIR :: BINDING -> BINDINGS
$sel:tab:BI_PAIR :: BINDING -> TAB
meta :: META
bindings :: BINDINGS
tab :: TAB
$sel:meta:BI_PAIR :: BINDING -> META
..} = META -> BINDINGS -> TAB -> BINDING
BI_META META
meta (BINDINGS -> BINDINGS
forall a. ToSingleLine a => a -> a
toSingleLine BINDINGS
bindings) TAB
TAB'
  toSingleLine BINDING
bd = BINDING
bd

instance ToSingleLine BINDINGS where
  toSingleLine :: BINDINGS -> BINDINGS
toSingleLine BDS_PAIR{BINDINGS
PAIR
TAB
EOL
eol :: EOL
tab :: TAB
pair :: PAIR
bindings :: BINDINGS
$sel:eol:BDS_PAIR :: BINDINGS -> EOL
$sel:tab:BDS_PAIR :: BINDINGS -> TAB
$sel:pair:BDS_PAIR :: BINDINGS -> PAIR
$sel:bindings:BDS_PAIR :: BINDINGS -> BINDINGS
..} = EOL -> TAB -> PAIR -> BINDINGS -> BINDINGS
BDS_PAIR EOL
NO_EOL TAB
TAB' (PAIR -> PAIR
forall a. ToSingleLine a => a -> a
toSingleLine PAIR
pair) (BINDINGS -> BINDINGS
forall a. ToSingleLine a => a -> a
toSingleLine BINDINGS
bindings)
  toSingleLine BDS_META{BINDINGS
TAB
META
EOL
$sel:eol:BDS_PAIR :: BINDINGS -> EOL
$sel:tab:BDS_PAIR :: BINDINGS -> TAB
$sel:bindings:BDS_PAIR :: BINDINGS -> BINDINGS
eol :: EOL
tab :: TAB
meta :: META
bindings :: BINDINGS
$sel:meta:BDS_PAIR :: BINDINGS -> META
..} = EOL -> TAB -> META -> BINDINGS -> BINDINGS
BDS_META EOL
NO_EOL TAB
TAB' META
meta (BINDINGS -> BINDINGS
forall a. ToSingleLine a => a -> a
toSingleLine BINDINGS
bindings)
  toSingleLine BINDINGS
bds = BINDINGS
bds

instance ToSingleLine PAIR where
  toSingleLine :: PAIR -> PAIR
toSingleLine 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
forall a. ToSingleLine a => a -> a
toSingleLine EXPRESSION
expr)
  toSingleLine 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
forall a. ToSingleLine a => a -> a
toSingleLine EXPRESSION
expr)
  toSingleLine PA_FORMATION{[ATTRIBUTE]
ATTRIBUTE
EXPRESSION
ARROW
$sel:attr:PA_TAU :: PAIR -> ATTRIBUTE
$sel:arrow:PA_TAU :: PAIR -> ARROW
$sel:expr:PA_TAU :: PAIR -> EXPRESSION
attr :: ATTRIBUTE
voids :: [ATTRIBUTE]
arrow :: ARROW
expr :: EXPRESSION
$sel:voids:PA_TAU :: PAIR -> [ATTRIBUTE]
..} = ATTRIBUTE -> [ATTRIBUTE] -> ARROW -> EXPRESSION -> PAIR
PA_FORMATION ATTRIBUTE
attr [ATTRIBUTE]
voids ARROW
arrow (EXPRESSION -> EXPRESSION
forall a. ToSingleLine a => a -> a
toSingleLine EXPRESSION
expr)
  toSingleLine PAIR
pair = PAIR
pair

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

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

instance ToSingleLine APP_ARGS where
  toSingleLine :: APP_ARGS -> APP_ARGS
toSingleLine 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
NO_EOL TAB
TAB' (EXPRESSION -> EXPRESSION
forall a. ToSingleLine a => a -> a
toSingleLine EXPRESSION
expr) (APP_ARGS -> APP_ARGS
forall a. ToSingleLine a => a -> a
toSingleLine APP_ARGS
args)
  toSingleLine APP_ARGS
args = APP_ARGS
args

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

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

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

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

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

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