{-# LANGUAGE DeriveAnyClass    #-}
{-# LANGUAGE DeriveFunctor     #-}
{-# LANGUAGE DeriveGeneric     #-}
{-# LANGUAGE OverloadedStrings #-}

module A ( E (..), T (..), (~>), TB (..), C (..)
         , L (..), N (..), BBin (..), BTer (..)
         , BUn (..), DfnVar (..)
         , D (..), Program (..)
         , Mode (..)
         , mapExpr
         , getS, flushD
         ) where

import           Control.DeepSeq    (NFData)
import qualified Data.ByteString    as BS
import qualified Data.IntMap        as IM
import           Data.List          (foldl')
import           Data.Maybe         (isJust)
import qualified Data.Text          as T
import           Data.Text.Encoding (decodeUtf8)
import qualified Data.Vector        as V
import           GHC.Generics       (Generic)
import           Nm
import           Nm.Map             (NmMap)
import qualified Nm.Map             as Nm
import           Prettyprinter      (Doc, Pretty (..), braces, brackets, concatWith, encloseSep, flatAlt, group, hardline, indent, parens, pipe, punctuate, tupled, (<+>))
import           Regex.Rure         (RurePtr)

infixr 6 <#>
infixr 6 <##>

(<#>), (<##>) :: Doc a -> Doc a -> Doc a
<#> :: forall a. Doc a -> Doc a -> Doc a
(<#>) Doc a
x Doc a
y = Doc a
x Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> Doc a
forall ann. Doc ann
hardline Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> Doc a
y
<##> :: forall a. Doc a -> Doc a -> Doc a
(<##>) Doc a
x Doc a
y = Doc a
x Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> Doc a
forall ann. Doc ann
hardline Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> Doc a
forall ann. Doc ann
hardline Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> Doc a
y

data TB = TyI | TyFloat | TyStr
        | TyStream | TyVec | TyOption
        | TyR | TyBool | TyUnit
        deriving (TB -> TB -> Bool
(TB -> TB -> Bool) -> (TB -> TB -> Bool) -> Eq TB
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TB -> TB -> Bool
== :: TB -> TB -> Bool
$c/= :: TB -> TB -> Bool
/= :: TB -> TB -> Bool
Eq, Eq TB
Eq TB =>
(TB -> TB -> Ordering)
-> (TB -> TB -> Bool)
-> (TB -> TB -> Bool)
-> (TB -> TB -> Bool)
-> (TB -> TB -> Bool)
-> (TB -> TB -> TB)
-> (TB -> TB -> TB)
-> Ord TB
TB -> TB -> Bool
TB -> TB -> Ordering
TB -> TB -> TB
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TB -> TB -> Ordering
compare :: TB -> TB -> Ordering
$c< :: TB -> TB -> Bool
< :: TB -> TB -> Bool
$c<= :: TB -> TB -> Bool
<= :: TB -> TB -> Bool
$c> :: TB -> TB -> Bool
> :: TB -> TB -> Bool
$c>= :: TB -> TB -> Bool
>= :: TB -> TB -> Bool
$cmax :: TB -> TB -> TB
max :: TB -> TB -> TB
$cmin :: TB -> TB -> TB
min :: TB -> TB -> TB
Ord)

tupledByFunky :: Doc ann -> [Doc ann] -> Doc ann
tupledByFunky :: forall ann. Doc ann -> [Doc ann] -> Doc ann
tupledByFunky Doc ann
sep = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
group (Doc ann -> Doc ann)
-> ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc ann -> Doc ann -> Doc ann -> [Doc ann] -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann -> [Doc ann] -> Doc ann
encloseSep (Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
flatAlt Doc ann
"⟨ " Doc ann
"⟨") (Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
flatAlt Doc ann
" ⟩" Doc ann
"⟩") Doc ann
sep

tupledBy :: Doc ann -> [Doc ann] -> Doc ann
tupledBy :: forall ann. Doc ann -> [Doc ann] -> Doc ann
tupledBy Doc ann
sep = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
group (Doc ann -> Doc ann)
-> ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc ann -> Doc ann -> Doc ann -> [Doc ann] -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann -> [Doc ann] -> Doc ann
encloseSep (Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
flatAlt Doc ann
"( " Doc ann
"(") (Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
flatAlt Doc ann
" )" Doc ann
")") Doc ann
sep

j'Tup :: Pretty a => [a] -> Doc ann
j'Tup :: forall a ann. Pretty a => [a] -> Doc ann
j'Tup = Doc ann -> [Doc ann] -> Doc ann
forall ann. Doc ann -> [Doc ann] -> Doc ann
tupledBy Doc ann
" . " ([Doc ann] -> Doc ann) -> ([a] -> [Doc ann]) -> [a] -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Doc ann) -> [a] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Doc ann
forall ann. a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty

jrec :: [Doc ann] -> Doc ann
jrec = Doc ann -> Doc ann -> Doc ann -> [Doc ann] -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann -> [Doc ann] -> Doc ann
encloseSep (Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
flatAlt Doc ann
"#{ " Doc ann
"#{") (Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
flatAlt (Doc ann
forall ann. Doc ann
hardline Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
"}") Doc ann
"}") (Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
flatAlt Doc ann
" ; " Doc ann
"; ")

infixr 0 ~>

(~>) :: T -> T -> T
~> :: T -> T -> T
(~>) = T -> T -> T
TyArr

infixr 0 :$

data T = TyB { T -> TB
tyBuiltin :: TB }
       | (:$) { T -> T
tyApp0, T -> T
tyApp1 :: T }
       | TyArr { T -> T
tyArr0, T -> T
tyArr1 :: T }
       | TyVar { T -> Nm ()
tyVar :: Nm () }
       | TyTup { T -> [T]
tyTups :: [T] }
       | TyRec { T -> NmMap T
tyres :: NmMap T }
       | Rho { T -> Nm ()
tyRho :: Nm (), T -> IntMap T
tyArms :: IM.IntMap T }
       | Ρ { T -> Nm ()
tyΡ :: Nm (), T -> NmMap T
tyρs :: NmMap T }
       deriving T -> T -> Bool
(T -> T -> Bool) -> (T -> T -> Bool) -> Eq T
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: T -> T -> Bool
== :: T -> T -> Bool
$c/= :: T -> T -> Bool
/= :: T -> T -> Bool
Eq

instance Pretty TB where
    pretty :: forall ann. TB -> Doc ann
pretty TB
TyI = Doc ann
"Integer"; pretty TB
TyStr = Doc ann
"Str"; pretty TB
TyFloat = Doc ann
"Float"
    pretty TB
TyStream = Doc ann
"Stream"; pretty TB
TyVec = Doc ann
"List"; pretty TB
TyOption = Doc ann
"Optional"
    pretty TB
TyBool = Doc ann
"Bool"; pretty TB
TyUnit = Doc ann
"𝟙"; pretty TB
TyR = Doc ann
"Regex"

instance Show TB where show :: TB -> String
show=Doc Any -> String
forall a. Show a => a -> String
show(Doc Any -> String) -> (TB -> Doc Any) -> TB -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
.TB -> Doc Any
forall a ann. Pretty a => a -> Doc ann
forall ann. TB -> Doc ann
pretty

instance Pretty T where
    pretty :: forall ann. T -> Doc ann
pretty (TyB TB
b)        = TB -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. TB -> Doc ann
pretty TB
b
    pretty (T
ty:$T
ty')      = T -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. T -> Doc ann
pretty T
ty Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> T -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. T -> Doc ann
pretty T
ty'
    pretty (TyVar Nm ()
n)      = Nm () -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Nm () -> Doc ann
pretty Nm ()
n
    pretty (TyArr T
ty T
ty') = T -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. T -> Doc ann
pretty T
ty Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
"⟶" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> T -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. T -> Doc ann
pretty T
ty'
    pretty (TyTup [T]
tys)    = [T] -> Doc ann
forall a ann. Pretty a => [a] -> Doc ann
j'Tup [T]
tys
    pretty (TyRec NmMap T
rs)     = [Doc ann] -> Doc ann
forall {ann}. [Doc ann] -> Doc ann
jrec ((\(Nm ()
n,T
t) -> Nm () -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Nm () -> Doc ann
pretty Nm ()
n Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
":" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> T -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. T -> Doc ann
pretty T
t)((Nm (), T) -> Doc ann) -> [(Nm (), T)] -> [Doc ann]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>NmMap T -> [(Nm (), T)]
forall a. NmMap a -> [(Nm (), a)]
Nm.toList NmMap T
rs)
    pretty (Rho Nm ()
n IntMap T
fs)     = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (Nm () -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Nm () -> Doc ann
pretty Nm ()
n Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
forall ann. Doc ann
pipe Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> [(Int, T)] -> Doc ann
forall a ann. Pretty a => [(a, T)] -> Doc ann
prettyFields (IntMap T -> [(Int, T)]
forall a. IntMap a -> [(Int, a)]
IM.toList IntMap T
fs))
    pretty (Ρ Nm ()
n NmMap T
fs)       = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (Nm () -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Nm () -> Doc ann
pretty Nm ()
n Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
forall ann. Doc ann
pipe Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> [(Nm (), T)] -> Doc ann
forall a ann. Pretty a => [(a, T)] -> Doc ann
prettyFields (NmMap T -> [(Nm (), T)]
forall a. NmMap a -> [(Nm (), a)]
Nm.toList NmMap T
fs))

parensp :: Bool -> Doc ann -> Doc ann
parensp Bool
True=Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens; parensp Bool
False=Doc ann -> Doc ann
forall a. a -> a
id

prettyFields :: Pretty a => [(a, T)] -> Doc ann
prettyFields :: forall a ann. Pretty a => [(a, T)] -> Doc ann
prettyFields = [Doc ann] -> Doc ann
forall a. Monoid a => [a] -> a
mconcat ([Doc ann] -> Doc ann)
-> ([(a, T)] -> [Doc ann]) -> [(a, T)] -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
"," ([Doc ann] -> [Doc ann])
-> ([(a, T)] -> [Doc ann]) -> [(a, T)] -> [Doc ann]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a, T) -> Doc ann) -> [(a, T)] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a, T) -> Doc ann
forall {a} {a} {ann}. (Pretty a, Pretty a) => (a, a) -> Doc ann
g where g :: (a, a) -> Doc ann
g (a
i, a
t) = a -> Doc ann
forall ann. a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty a
i Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
":" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> a -> Doc ann
forall ann. a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty a
t

instance Show T where show :: T -> String
show=Doc Any -> String
forall a. Show a => a -> String
show(Doc Any -> String) -> (T -> Doc Any) -> T -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
.T -> Doc Any
forall a ann. Pretty a => a -> Doc ann
forall ann. T -> Doc ann
pretty

data BUn = Tally -- length of string field
         | Const
         | Not -- ^ Boolean
         | At !Int | Select !Int | SelR !(Nm ())
         | IParse | FParse | Parse
         | Floor | Ceiling
         | Some
         | Dedup | CatMaybes
         | Negate
         | TallyList -- length of vector
         | Head | Tail | Init | Last
         deriving (BUn -> BUn -> Bool
(BUn -> BUn -> Bool) -> (BUn -> BUn -> Bool) -> Eq BUn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BUn -> BUn -> Bool
== :: BUn -> BUn -> Bool
$c/= :: BUn -> BUn -> Bool
/= :: BUn -> BUn -> Bool
Eq)

instance Pretty BUn where
    pretty :: forall ann. BUn -> Doc ann
pretty BUn
Tally      = Doc ann
"#"
    pretty BUn
Const      = Doc ann
"[:"
    pretty BUn
Not        = Doc ann
"!"
    pretty (At Int
i)     = Doc ann
"." Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int
i
    pretty (Select Int
i) = Doc ann
"->" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int
i
    pretty (SelR Nm ()
r)   = Doc ann
"->" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Nm () -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Nm () -> Doc ann
pretty Nm ()
r
    pretty BUn
IParse     = Doc ann
":i"
    pretty BUn
FParse     = Doc ann
":f"
    pretty BUn
Floor      = Doc ann
"floor"
    pretty BUn
Ceiling    = Doc ann
"ceil"
    pretty BUn
Parse      = Doc ann
":"
    pretty BUn
Some       = Doc ann
"Some"
    pretty BUn
Dedup      = Doc ann
"~."
    pretty BUn
CatMaybes  = Doc ann
".?"
    pretty BUn
Negate     = Doc ann
"-."
    pretty BUn
TallyList  = Doc ann
"#*"
    pretty BUn
Head       = Doc ann
"head#"
    pretty BUn
Tail       = Doc ann
"tail#"
    pretty BUn
Init       = Doc ann
"init#"
    pretty BUn
Last       = Doc ann
"last#"

data BTer = ZipW
          | Fold | Scan | ScanList
          | Substr | Sub1 | Subs
          | Option
          | Captures | AllCaptures | Ixes
          | Bookend
          deriving (BTer -> BTer -> Bool
(BTer -> BTer -> Bool) -> (BTer -> BTer -> Bool) -> Eq BTer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BTer -> BTer -> Bool
== :: BTer -> BTer -> Bool
$c/= :: BTer -> BTer -> Bool
/= :: BTer -> BTer -> Bool
Eq)

instance Pretty BTer where
    pretty :: forall ann. BTer -> Doc ann
pretty BTer
ZipW        = Doc ann
","
    pretty BTer
Fold        = Doc ann
"|"
    pretty BTer
Scan        = Doc ann
"^"
    pretty BTer
ScanList    = Doc ann
"^*"
    pretty BTer
Substr      = Doc ann
"substr"
    pretty BTer
Option      = Doc ann
"option"
    pretty BTer
Captures    = Doc ann
"~*"
    pretty BTer
AllCaptures = Doc ann
"captures"
    pretty BTer
Sub1        = Doc ann
"sub1"
    pretty BTer
Subs        = Doc ann
"subs"
    pretty BTer
Bookend     = Doc ann
",,"
    pretty BTer
Ixes        = Doc ann
"ices"

-- builtin
data BBin = Plus | Times | Div
          | Minus | Exp
          | Eq | Neq | Geq | Gt | Lt | Leq
          | Map
          | Matches -- ^ @'string' ~ /pat/@
          | NotMatches | MMatch
          | And | Or
          | Min | Max
          | Split | Splitc
          | Prior | DedupOn | MapMaybe
          | Filter | Fold1
          | Match | Sprintf
          | Report
          | Take | Drop
          | Rein | Nier
          deriving (BBin -> BBin -> Bool
(BBin -> BBin -> Bool) -> (BBin -> BBin -> Bool) -> Eq BBin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BBin -> BBin -> Bool
== :: BBin -> BBin -> Bool
$c/= :: BBin -> BBin -> Bool
/= :: BBin -> BBin -> Bool
Eq)

instance Pretty BBin where
    pretty :: forall ann. BBin -> Doc ann
pretty BBin
Plus = Doc ann
"+"; pretty BBin
Times = Doc ann
"*"; pretty BBin
Div = Doc ann
"%"; pretty BBin
Minus = Doc ann
"-"
    pretty BBin
Eq = Doc ann
"="; pretty BBin
Gt = Doc ann
">"; pretty BBin
Lt = Doc ann
"<"; pretty BBin
Geq = Doc ann
">="
    pretty BBin
Leq = Doc ann
"<="; pretty BBin
Neq = Doc ann
"!="; pretty BBin
Map = Doc ann
"¨"; pretty BBin
Matches = Doc ann
"~"
    pretty BBin
MMatch = Doc ann
"~?"; pretty BBin
NotMatches = Doc ann
"!~"; pretty BBin
And = Doc ann
"&"; pretty BBin
Or = Doc ann
"||"
    pretty BBin
Max = Doc ann
"max"; pretty BBin
Min = Doc ann
"min"; pretty BBin
Prior = Doc ann
"\\."; pretty BBin
Filter = Doc ann
"#."
    pretty BBin
Split = Doc ann
"split"; pretty BBin
Splitc = Doc ann
"splitc"; pretty BBin
Sprintf = Doc ann
"sprintf"
    pretty BBin
Match = Doc ann
"match"; pretty BBin
MapMaybe = Doc ann
":?"; pretty BBin
Fold1 = Doc ann
"|>"
    pretty BBin
Exp = Doc ann
"**"; pretty BBin
DedupOn = Doc ann
"~.*"; pretty BBin
Report = Doc ann
"$>"
    pretty BBin
Take = Doc ann
"take#"; pretty BBin
Drop = Doc ann
"drop#"; pretty BBin
Rein = Doc ann
"reintercalate"
    pretty BBin
Nier = Doc ann
"@@"

data DfnVar = X | Y deriving (DfnVar -> DfnVar -> Bool
(DfnVar -> DfnVar -> Bool)
-> (DfnVar -> DfnVar -> Bool) -> Eq DfnVar
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DfnVar -> DfnVar -> Bool
== :: DfnVar -> DfnVar -> Bool
$c/= :: DfnVar -> DfnVar -> Bool
/= :: DfnVar -> DfnVar -> Bool
Eq)

instance Pretty DfnVar where pretty :: forall ann. DfnVar -> Doc ann
pretty DfnVar
X=Doc ann
"x"; pretty DfnVar
Y=Doc ann
"y"

-- 0-ary
data N = Ix | Nf | None | Fp | MZ deriving (N -> N -> Bool
(N -> N -> Bool) -> (N -> N -> Bool) -> Eq N
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: N -> N -> Bool
== :: N -> N -> Bool
$c/= :: N -> N -> Bool
/= :: N -> N -> Bool
Eq)

data L = ILit !Integer | FLit !Double | BLit !Bool | StrLit BS.ByteString deriving ((forall x. L -> Rep L x) -> (forall x. Rep L x -> L) -> Generic L
forall x. Rep L x -> L
forall x. L -> Rep L x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. L -> Rep L x
from :: forall x. L -> Rep L x
$cto :: forall x. Rep L x -> L
to :: forall x. Rep L x -> L
Generic, L -> ()
(L -> ()) -> NFData L
forall a. (a -> ()) -> NFData a
$crnf :: L -> ()
rnf :: L -> ()
NFData, L -> L -> Bool
(L -> L -> Bool) -> (L -> L -> Bool) -> Eq L
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: L -> L -> Bool
== :: L -> L -> Bool
$c/= :: L -> L -> Bool
/= :: L -> L -> Bool
Eq)

class PS a where ps :: Int -> a -> Doc ann

-- expression
data E a = Column { forall a. E a -> a
eLoc :: a, forall a. E a -> Int
col :: Int }
         | IParseCol { eLoc :: a, col :: Int } | FParseCol { eLoc :: a, col :: Int } | ParseCol { eLoc :: a, col :: Int }
         | Field { eLoc :: a, forall a. E a -> Int
eField :: Int } | LastField { eLoc :: a } | FieldList { eLoc :: a }
         | AllField { eLoc :: a } -- ^ Think @$0@ in awk.
         | AllColumn { eLoc :: a } -- ^ Think @$0@ in awk.
         | IParseAllCol { eLoc :: a } -- ^ @$0@, parsed as an integer
         | FParseAllCol { eLoc :: a } -- ^ @$0@, parsed as a float
         | ParseAllCol { eLoc :: a }
         | EApp { eLoc :: a, forall a. E a -> E a
eApp0, forall a. E a -> E a
eApp1 :: E a }
         | Guarded { eLoc :: a, forall a. E a -> E a
eP, forall a. E a -> E a
eGuarded :: E a }
         | Implicit { eLoc :: a, forall a. E a -> E a
eImplicit :: E a }
         | Let { eLoc :: a, forall a. E a -> (Nm a, E a)
eBind :: (Nm a, E a), forall a. E a -> E a
eE :: E a }
         | Var { eLoc :: a, forall a. E a -> Nm a
eVar :: !(Nm a) }
         | F { forall a. E a -> Nm a
hole :: !(Nm a) }
         | Lit { eLoc :: a, forall a. E a -> L
lit :: !L }
         | RegexLit { eLoc :: a, forall a. E a -> ByteString
eRr :: BS.ByteString }
         | Lam { eLoc :: a, forall a. E a -> Nm a
eBound :: Nm a, forall a. E a -> E a
lamE :: E a }
         | Dfn { eLoc :: a, forall a. E a -> E a
eDfn :: E a }
         | BB { eLoc :: a, forall a. E a -> BBin
eBin :: BBin } | TB { eLoc :: a, forall a. E a -> BTer
eTer :: BTer } | UB { eLoc :: a, forall a. E a -> BUn
eUn :: BUn }
         | NB { eLoc :: a, forall a. E a -> N
eNil :: N }
         | Tup { eLoc :: a, forall a. E a -> [E a]
esTup :: [E a] }
         | Rec { eLoc :: a, forall a. E a -> [(Nm a, E a)]
esR :: [(Nm a, E a)] }
         | ResVar { eLoc :: a, forall a. E a -> DfnVar
dfnVar :: DfnVar }
         | RC RurePtr -- compiled regex after normalization
         | Arr { eLoc :: a, forall a. E a -> Vector (E a)
elems :: !(V.Vector (E a)) }
         | Anchor { eLoc :: a, forall a. E a -> [E a]
eAnchored :: [E a] }
         | Paren { eLoc :: a, forall a. E a -> E a
eExpr :: E a }
         | OptionVal { eLoc :: a, forall a. E a -> Maybe (E a)
eMaybe :: Maybe (E a) }
         | Cond { eLoc :: a, forall a. E a -> E a
eIf, forall a. E a -> E a
eThen, forall a. E a -> E a
eElse :: E a }
         | RwB { eLoc :: a, eBin :: BBin } | RwT { eLoc :: a, eTer :: BTer }
         deriving ((forall a b. (a -> b) -> E a -> E b)
-> (forall a b. a -> E b -> E a) -> Functor E
forall a b. a -> E b -> E a
forall a b. (a -> b) -> E a -> E b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> E a -> E b
fmap :: forall a b. (a -> b) -> E a -> E b
$c<$ :: forall a b. a -> E b -> E a
<$ :: forall a b. a -> E b -> E a
Functor)

instance Pretty N where
    pretty :: forall ann. N -> Doc ann
pretty N
Ix=Doc ann
"⍳"; pretty N
Nf=Doc ann
"nf"; pretty N
None=Doc ann
"None"; pretty N
Fp=Doc ann
"fp"; pretty N
MZ=Doc ann
"⍬"

instance Pretty L where
    pretty :: forall ann. L -> Doc ann
pretty (ILit Integer
i)     = Integer -> Doc ann
forall ann. Integer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Integer
i
    pretty (FLit Double
d)     = Double -> Doc ann
forall ann. Double -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Double
d
    pretty (BLit Bool
True)  = Doc ann
"#t"
    pretty (BLit Bool
False) = Doc ann
"#f"
    pretty (StrLit ByteString
str) = Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty (ByteString -> Text
decodeUtf8 ByteString
str)

mPrec :: BBin -> Maybe Int
mPrec :: BBin -> Maybe Int
mPrec BBin
Prior      = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mPrec BBin
DedupOn    = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mPrec BBin
MapMaybe   = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mPrec BBin
Map        = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mPrec BBin
Filter     = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mPrec BBin
Fold1      = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mPrec BBin
Exp        = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
8
mPrec BBin
Plus       = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
6
mPrec BBin
Minus      = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
6
mPrec BBin
Times      = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
7
mPrec BBin
Div        = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
7
mPrec BBin
Eq         = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4
mPrec BBin
Neq        = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4
mPrec BBin
Geq        = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4
mPrec BBin
Gt         = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4
mPrec BBin
Lt         = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4
mPrec BBin
Leq        = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4
mPrec BBin
Matches    = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mPrec BBin
NotMatches = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mPrec BBin
MMatch     = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5
mPrec BBin
Report     = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4
mPrec BBin
And        = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
3
mPrec BBin
Or         = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2
mPrec BBin
_          = Maybe Int
forall a. Maybe a
Nothing

instance PS (E a) where
    ps :: forall ann. Int -> E a -> Doc ann
ps Int
_ (Column a
_ Int
i)    = Doc ann
"$" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int
i
    ps Int
_ AllColumn{}     = Doc ann
"$0"
    ps Int
_ IParseAllCol{}  = Doc ann
"$0:i"
    ps Int
_ FParseAllCol{}  = Doc ann
"$0:f"
    ps Int
_ ParseAllCol{}   = Doc ann
"$0:"
    ps Int
_ (IParseCol a
_ Int
i) = Doc ann
"$" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int
i Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
":i"
    ps Int
_ (FParseCol a
_ Int
i) = Doc ann
"$" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int
i Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
":f"
    ps Int
_ (ParseCol a
_ Int
i)  = Doc ann
"$" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int
i Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
":"
    ps Int
_ AllField{}      = Doc ann
"`0"
    ps Int
_ (Field a
_ Int
i)     = Doc ann
"`" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int
i
    ps Int
_ LastField{}     = Doc ann
"`*"
    ps Int
_ FieldList{}     = Doc ann
"`$"
    ps Int
d (EApp a
_ (EApp a
_ (BB a
_ BBin
op) E a
e0) E a
e1) | Just Int
d' <- BBin -> Maybe Int
mPrec BBin
op = Bool -> Doc ann -> Doc ann
forall {ann}. Bool -> Doc ann -> Doc ann
parensp (Int
dInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
d') (Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps (Int
d'Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) E a
e0 Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> BBin -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. BBin -> Doc ann
pretty BBin
op Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps (Int
d'Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) E a
e1)
    ps Int
_ (EApp a
_ (BB a
_ BBin
op) E a
e) | Maybe Int -> Bool
forall a. Maybe a -> Bool
isJust (BBin -> Maybe Int
mPrec BBin
op) = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
e Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> BBin -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. BBin -> Doc ann
pretty BBin
op)
    ps Int
d (EApp a
_ (UB a
_ (At Int
i)) E a
e)     = Bool -> Doc ann -> Doc ann
forall {ann}. Bool -> Doc ann -> Doc ann
parensp (Int
dInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
0) (Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
1 E a
e) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"." Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int
i
    ps Int
d (EApp a
_ (UB a
_ (Select Int
i)) E a
e) = Bool -> Doc ann -> Doc ann
forall {ann}. Bool -> Doc ann -> Doc ann
parensp (Int
dInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
0) (Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
1 E a
e) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"->" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int
i
    ps Int
d (EApp a
_ (UB a
_ (SelR Nm ()
n)) E a
e)   = Bool -> Doc ann -> Doc ann
forall {ann}. Bool -> Doc ann -> Doc ann
parensp (Int
dInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
0) (Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
1 E a
e) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"->" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Nm () -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Nm () -> Doc ann
pretty Nm ()
n
    ps Int
_ (EApp a
_ (UB a
_ BUn
IParse) E a
e')    = E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
e' Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
":i"
    ps Int
_ (EApp a
_ (UB a
_ BUn
FParse) E a
e')    = E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
e' Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
":f"
    ps Int
_ (EApp a
_ (UB a
_ BUn
Parse) E a
e')     = E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
e' Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
":"
    ps Int
d (EApp a
_ (EApp a
_ (EApp a
_ (TB a
_ BTer
Bookend) E a
e) E a
e') E a
e'')  = Bool -> Doc ann -> Doc ann
forall {ann}. Bool -> Doc ann -> Doc ann
parensp (Int
dInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
3) (Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
4 E a
e Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
",," Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
4 E a
e' Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
5 E a
e'')
    ps Int
d (EApp a
_ (EApp a
_ (EApp a
_ (TB a
_ BTer
Fold) E a
e) E a
e') E a
e'')     = Bool -> Doc ann -> Doc ann
forall {ann}. Bool -> Doc ann -> Doc ann
parensp (Int
dInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
5) (Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
6 E a
e Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"|" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
6 E a
e' Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
7 E a
e'')
    ps Int
d (EApp a
_ (EApp a
_ (EApp a
_ (TB a
_ BTer
Scan) E a
e) E a
e') E a
e'')     = Bool -> Doc ann -> Doc ann
forall {ann}. Bool -> Doc ann -> Doc ann
parensp (Int
dInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
5) (Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
6 E a
e Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"^" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
6 E a
e' Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
7 E a
e'')
    ps Int
d (EApp a
_ (EApp a
_ (EApp a
_ (TB a
_ BTer
ScanList) E a
e) E a
e') E a
e'') = Bool -> Doc ann -> Doc ann
forall {ann}. Bool -> Doc ann -> Doc ann
parensp (Int
dInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
5) (Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
6 E a
e Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"^" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
6 E a
e' Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
7 E a
e'')
    ps Int
d (EApp a
_ (EApp a
_ (EApp a
_ (TB a
_ BTer
ZipW) E a
op) E a
e') E a
e'')    = Bool -> Doc ann -> Doc ann
forall {ann}. Bool -> Doc ann -> Doc ann
parensp (Int
dInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
5) (Doc ann
"," Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
6 E a
op Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
7 E a
e' Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
8 E a
e'')
    ps Int
d (EApp a
_ (EApp a
_ (EApp a
_ (TB a
_ BTer
Captures) E a
e) E a
e') E a
e'') = Bool -> Doc ann -> Doc ann
forall {ann}. Bool -> Doc ann -> Doc ann
parensp (Int
dInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
6) (Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
7 E a
e Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
"~*" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
7 E a
e' Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
8 E a
e'')
    ps Int
d (EApp a
_ E a
e0 E a
e1) = Bool -> Doc ann -> Doc ann
forall {ann}. Bool -> Doc ann -> Doc ann
parensp (Int
dInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
10) (Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
10 E a
e0 Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
11 E a
e1)
    ps Int
d (OptionVal a
_ (Just E a
e)) = Bool -> Doc ann -> Doc ann
forall {ann}. Bool -> Doc ann -> Doc ann
parensp (Int
dInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
10) (Doc ann
"Some" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
11 E a
e)
    ps Int
_ (OptionVal a
_ Maybe (E a)
Nothing) = Doc ann
"None"
    ps Int
_ (BB a
_ BBin
op)         = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (BBin -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. BBin -> Doc ann
pretty BBin
op)
    ps Int
_ (Lit a
_ L
l)         = L -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. L -> Doc ann
pretty L
l
    ps Int
_ (Var a
_ Nm a
n)         = Nm a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Nm a -> Doc ann
pretty Nm a
n
    ps Int
_ (F Nm a
n)             = Nm a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Nm a -> Doc ann
pretty Nm a
n
    ps Int
_ (RegexLit a
_ ByteString
rr)   = Doc ann
"/" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty (ByteString -> Text
decodeUtf8 ByteString
rr) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"/"
    ps Int
_ (UB a
_ BUn
u)          = BUn -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. BUn -> Doc ann
pretty BUn
u
    ps Int
_ (ResVar a
_ DfnVar
x)      = DfnVar -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. DfnVar -> Doc ann
pretty DfnVar
x
    ps Int
_ (Dfn a
_ E a
e)         = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
brackets (E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
e)
    ps Int
_ (NB a
_ N
n)          = N -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. N -> Doc ann
pretty N
n
    ps Int
_ RC{}              = Doc ann
"(compiled regex)"
    ps Int
_ (Guarded a
_ E a
p E a
e)   = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
p) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
e)
    ps Int
_ (Implicit a
_ E a
e)    = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
braces (Doc ann
"|" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
e)
    ps Int
_ (Paren a
_ E a
e)       = Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
e)
    ps Int
_ (RwB a
_ BBin
MapMaybe)  = Doc ann
"mapMaybe"
    ps Int
_ (RwB a
_ BBin
DedupOn)   = Doc ann
"dedupOn"
    ps Int
_ (RwB a
_ BBin
Filter)    = Doc ann
"filter"
    ps Int
_ (RwT a
_ BTer
Fold)      = Doc ann
"fold"
    ps Int
_ (RwT a
_ BTer
Scan)      = Doc ann
"scan"
    ps Int
_ (RwB a
_ BBin
Fold1)     = Doc ann
"fold1"
    ps Int
_ (Cond a
_ E a
e0 E a
e1 E a
e2) = Doc ann
"?" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
e0 Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
";" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
e1 Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
";" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
e2
    ps Int
_ (Tup a
_ [E a]
es)        = [E a] -> Doc ann
forall a ann. Pretty a => [a] -> Doc ann
j'Tup [E a]
es
    ps Int
_ (Rec a
_ [(Nm a, E a)]
es)        = [Doc ann] -> Doc ann
forall {ann}. [Doc ann] -> Doc ann
jrec ((\(Nm a
n,E a
e) -> Nm a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Nm a -> Doc ann
pretty Nm a
n Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
".=" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
e)((Nm a, E a) -> Doc ann) -> [(Nm a, E a)] -> [Doc ann]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>[(Nm a, E a)]
es)
    ps Int
_ (Arr a
_ Vector (E a)
es)        = Doc ann -> [Doc ann] -> Doc ann
forall ann. Doc ann -> [Doc ann] -> Doc ann
tupledByFunky Doc ann
"," (Vector (Doc ann) -> [Doc ann]
forall a. Vector a -> [a]
V.toList (Vector (Doc ann) -> [Doc ann]) -> Vector (Doc ann) -> [Doc ann]
forall a b. (a -> b) -> a -> b
$ E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty (E a -> Doc ann) -> Vector (E a) -> Vector (Doc ann)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Vector (E a)
es)
    ps Int
_ (Anchor a
_ [E a]
es)     = Doc ann
"&" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann -> [Doc ann] -> Doc ann
forall ann. Doc ann -> [Doc ann] -> Doc ann
tupledBy Doc ann
"." (E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty (E a -> Doc ann) -> [E a] -> [Doc ann]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [E a]
es)
    ps Int
_ (Let a
_ (Nm a
n, E a
b) E a
e)  = Doc ann
"let" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
"val" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Nm a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Nm a -> Doc ann
pretty Nm a
n Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
":=" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
b Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
"in" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
e Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
"end"
    ps Int
d (Lam a
_ Nm a
n E a
e)       = Bool -> Doc ann -> Doc ann
forall {ann}. Bool -> Doc ann -> Doc ann
parensp (Int
dInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
1) (Doc ann
"λ" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Nm a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Nm a -> Doc ann
pretty Nm a
n Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"." Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
2 E a
e)
    ps Int
_ (TB a
_ BTer
g)          = BTer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. BTer -> Doc ann
pretty BTer
g

instance Pretty (E a) where pretty :: forall ann. E a -> Doc ann
pretty=Int -> E a -> Doc ann
forall ann. Int -> E a -> Doc ann
forall a ann. PS a => Int -> a -> Doc ann
ps Int
0

instance Show (E a) where show :: E a -> String
show=Doc Any -> String
forall a. Show a => a -> String
show(Doc Any -> String) -> (E a -> Doc Any) -> E a -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
.E a -> Doc Any
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty

-- for tests
instance Eq (E a) where
    == :: E a -> E a -> Bool
(==) (Column a
_ Int
i) (Column a
_ Int
j)              = Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
j
    (==) (IParseCol a
_ Int
i) (IParseCol a
_ Int
j)        = Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
j
    (==) (FParseCol a
_ Int
i) (FParseCol a
_ Int
j)        = Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
j
    (==) (Field a
_ Int
i) (Field a
_ Int
j)                = Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
j
    (==) LastField{} LastField{}                = Bool
True
    (==) FieldList{} FieldList{}                = Bool
True
    (==) AllColumn{} AllColumn{}                = Bool
True
    (==) AllField{} AllField{}                  = Bool
True
    (==) (EApp a
_ E a
e0 E a
e1) (EApp a
_ E a
e0' E a
e1')        = E a
e0 E a -> E a -> Bool
forall a. Eq a => a -> a -> Bool
== E a
e0' Bool -> Bool -> Bool
&& E a
e1 E a -> E a -> Bool
forall a. Eq a => a -> a -> Bool
== E a
e1'
    (==) (Guarded a
_ E a
p E a
e) (Guarded a
_ E a
p' E a
e')      = E a
p E a -> E a -> Bool
forall a. Eq a => a -> a -> Bool
== E a
p' Bool -> Bool -> Bool
&& E a
e E a -> E a -> Bool
forall a. Eq a => a -> a -> Bool
== E a
e'
    (==) (Implicit a
_ E a
e) (Implicit a
_ E a
e')         = E a
e E a -> E a -> Bool
forall a. Eq a => a -> a -> Bool
== E a
e'
    (==) (Let a
_ (Nm a
n, E a
eϵ) E a
e) (Let a
_ (Nm a
n', E a
eϵ') E a
e') = Nm a -> Nm a -> Bool
forall a. Nm a -> Nm a -> Bool
eqName Nm a
n Nm a
n' Bool -> Bool -> Bool
&& E a
e E a -> E a -> Bool
forall a. Eq a => a -> a -> Bool
== E a
e' Bool -> Bool -> Bool
&& E a
eϵ E a -> E a -> Bool
forall a. Eq a => a -> a -> Bool
== E a
eϵ'
    (==) (Var a
_ Nm a
n) (Var a
_ Nm a
n')                   = Nm a -> Nm a -> Bool
forall a. Nm a -> Nm a -> Bool
eqName Nm a
n Nm a
n'
    (==) (Lam a
_ Nm a
n E a
e) (Lam a
_ Nm a
n' E a
e')              = Nm a -> Nm a -> Bool
forall a. Nm a -> Nm a -> Bool
eqName Nm a
n Nm a
n' Bool -> Bool -> Bool
&& E a
e E a -> E a -> Bool
forall a. Eq a => a -> a -> Bool
== E a
e'
    (==) (Lit a
_ L
l) (Lit a
_ L
l')                   = L
l L -> L -> Bool
forall a. Eq a => a -> a -> Bool
== L
l'
    (==) (RegexLit a
_ ByteString
rr) (RegexLit a
_ ByteString
rr')       = ByteString
rr ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
rr'
    (==) (BB a
_ BBin
b) (BB a
_ BBin
b')                     = BBin
b BBin -> BBin -> Bool
forall a. Eq a => a -> a -> Bool
== BBin
b'
    (==) (TB a
_ BTer
b) (TB a
_ BTer
b')                     = BTer
b BTer -> BTer -> Bool
forall a. Eq a => a -> a -> Bool
== BTer
b'
    (==) (UB a
_ BUn
unOp) (UB a
_ BUn
unOp')               = BUn
unOp BUn -> BUn -> Bool
forall a. Eq a => a -> a -> Bool
== BUn
unOp'
    (==) (NB a
_ N
x) (NB a
_ N
y)                      = N
x N -> N -> Bool
forall a. Eq a => a -> a -> Bool
== N
y
    (==) (Tup a
_ [E a]
es) (Tup a
_ [E a]
es')                 = [E a]
es [E a] -> [E a] -> Bool
forall a. Eq a => a -> a -> Bool
== [E a]
es'
    (==) (Rec a
_ [(Nm a, E a)]
es) (Rec a
_ [(Nm a, E a)]
es')                 = [(Nm a, E a)]
es [(Nm a, E a)] -> [(Nm a, E a)] -> Bool
forall a. Eq a => a -> a -> Bool
== [(Nm a, E a)]
es'
    (==) (ResVar a
_ DfnVar
x) (ResVar a
_ DfnVar
y)              = DfnVar
x DfnVar -> DfnVar -> Bool
forall a. Eq a => a -> a -> Bool
== DfnVar
y
    (==) (Dfn a
_ E a
f) (Dfn a
_ E a
g)                    = E a
f E a -> E a -> Bool
forall a. Eq a => a -> a -> Bool
== E a
g -- we're testing for lexical equivalence
    (==) RC{} E a
_                                 = String -> Bool
forall a. HasCallStack => String -> a
error String
"Cannot compare compiled regex!"
    (==) E a
_ RC{}                                 = String -> Bool
forall a. HasCallStack => String -> a
error String
"Cannot compare compiled regex!"
    (==) (Paren a
_ E a
e) E a
e'                         = E a
e E a -> E a -> Bool
forall a. Eq a => a -> a -> Bool
== E a
e'
    (==) E a
e (Paren a
_ E a
e')                         = E a
e E a -> E a -> Bool
forall a. Eq a => a -> a -> Bool
== E a
e'
    (==) (RwB a
_ BBin
b) (RwB a
_ BBin
b')                   = BBin
b BBin -> BBin -> Bool
forall a. Eq a => a -> a -> Bool
== BBin
b'
    (==) (RwT a
_ BTer
b) (RwT a
_ BTer
b')                   = BTer
b BTer -> BTer -> Bool
forall a. Eq a => a -> a -> Bool
== BTer
b'
    (==) E a
_ E a
_                                    = Bool
False

data C = IsNum | IsEq | IsOrd
       | IsParse | IsPrintf
       | IsSemigroup | IsMonoid
       | Functor -- ^ For map (@"@)
       | Foldable | Witherable
       deriving (C -> C -> Bool
(C -> C -> Bool) -> (C -> C -> Bool) -> Eq C
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: C -> C -> Bool
== :: C -> C -> Bool
$c/= :: C -> C -> Bool
/= :: C -> C -> Bool
Eq, Eq C
Eq C =>
(C -> C -> Ordering)
-> (C -> C -> Bool)
-> (C -> C -> Bool)
-> (C -> C -> Bool)
-> (C -> C -> Bool)
-> (C -> C -> C)
-> (C -> C -> C)
-> Ord C
C -> C -> Bool
C -> C -> Ordering
C -> C -> C
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: C -> C -> Ordering
compare :: C -> C -> Ordering
$c< :: C -> C -> Bool
< :: C -> C -> Bool
$c<= :: C -> C -> Bool
<= :: C -> C -> Bool
$c> :: C -> C -> Bool
> :: C -> C -> Bool
$c>= :: C -> C -> Bool
>= :: C -> C -> Bool
$cmax :: C -> C -> C
max :: C -> C -> C
$cmin :: C -> C -> C
min :: C -> C -> C
Ord)

instance Pretty C where
    pretty :: forall ann. C -> Doc ann
pretty C
IsNum = Doc ann
"Num"; pretty C
IsEq = Doc ann
"Eq"; pretty C
IsOrd = Doc ann
"Ord"
    pretty C
IsParse = Doc ann
"Parseable"; pretty C
IsSemigroup = Doc ann
"Semigroup"
    pretty C
Functor = Doc ann
"Functor"; pretty C
Foldable = Doc ann
"Foldable"
    pretty C
IsPrintf = Doc ann
"Printf"; pretty C
Witherable = Doc ann
"Witherable"
    pretty C
IsMonoid = Doc ann
"Monoid"

instance Show C where show :: C -> String
show=Doc Any -> String
forall a. Show a => a -> String
show(Doc Any -> String) -> (C -> Doc Any) -> C -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
.C -> Doc Any
forall a ann. Pretty a => a -> Doc ann
forall ann. C -> Doc ann
pretty

-- decl
data D a = SetFS T.Text | SetRS T.Text
         | FunDecl (Nm a) [Nm a] (E a)
         | FlushDecl
         | SetAsv | SetUsv | SetCsv
         | SetOFS T.Text | SetORS T.Text
         deriving ((forall a b. (a -> b) -> D a -> D b)
-> (forall a b. a -> D b -> D a) -> Functor D
forall a b. a -> D b -> D a
forall a b. (a -> b) -> D a -> D b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> D a -> D b
fmap :: forall a b. (a -> b) -> D a -> D b
$c<$ :: forall a b. a -> D b -> D a
<$ :: forall a b. a -> D b -> D a
Functor)

instance Pretty (D a) where
    pretty :: forall ann. D a -> Doc ann
pretty (SetFS Text
bs)       = Doc ann
":set fs :=" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
"/" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
bs Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"/;"
    pretty (SetRS Text
rs)       = Doc ann
":set rs :=" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
"/" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
rs Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"/;"
    pretty (FunDecl Nm a
n [Nm a]
ns E a
e) = Doc ann
"fn" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Nm a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Nm a -> Doc ann
pretty Nm a
n Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> [Doc ann] -> Doc ann
forall {ann}. [Doc ann] -> Doc ann
tupled (Nm a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Nm a -> Doc ann
pretty (Nm a -> Doc ann) -> [Nm a] -> [Doc ann]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Nm a]
ns) Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
":=" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<#> Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
indent Int
2 (E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
e Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
";")
    pretty D a
FlushDecl        = Doc ann
":flush;"
    pretty D a
SetAsv           = Doc ann
":set asv;"
    pretty D a
SetUsv           = Doc ann
":set usv;"
    pretty D a
SetCsv           = Doc ann
":set csv;"
    pretty (SetOFS Text
sep)     = Doc ann
":set ofs :=" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
"'" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
sep Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"';"
    pretty (SetORS Text
sep)     = Doc ann
":set ors :=" Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<+> Doc ann
"'" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
pretty Text
sep Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"';"

data Program a = Program { forall a. Program a -> [D a]
decls :: [D a], forall a. Program a -> E a
expr :: E a } deriving ((forall a b. (a -> b) -> Program a -> Program b)
-> (forall a b. a -> Program b -> Program a) -> Functor Program
forall a b. a -> Program b -> Program a
forall a b. (a -> b) -> Program a -> Program b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Program a -> Program b
fmap :: forall a b. (a -> b) -> Program a -> Program b
$c<$ :: forall a b. a -> Program b -> Program a
<$ :: forall a b. a -> Program b -> Program a
Functor)

instance Pretty (Program a) where
    pretty :: forall ann. Program a -> Doc ann
pretty (Program [D a]
ds E a
e) = (Doc ann -> Doc ann -> Doc ann) -> [Doc ann] -> Doc ann
forall (t :: * -> *) ann.
Foldable t =>
(Doc ann -> Doc ann -> Doc ann) -> t (Doc ann) -> Doc ann
concatWith Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
(<##>) (D a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. D a -> Doc ann
pretty (D a -> Doc ann) -> [D a] -> [Doc ann]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [D a]
ds) Doc ann -> Doc ann -> Doc ann
forall a. Doc a -> Doc a -> Doc a
<##> E a -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. E a -> Doc ann
pretty E a
e

instance Show (Program a) where show :: Program a -> String
show=Doc Any -> String
forall a. Show a => a -> String
show(Doc Any -> String)
-> (Program a -> Doc Any) -> Program a -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Program a -> Doc Any
forall a ann. Pretty a => a -> Doc ann
forall ann. Program a -> Doc ann
pretty

flushD :: Program a -> Bool
flushD :: forall a. Program a -> Bool
flushD (Program [D a]
ds E a
_) = (D a -> Bool) -> [D a] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any D a -> Bool
forall {a}. D a -> Bool
p [D a]
ds where p :: D a -> Bool
p D a
FlushDecl = Bool
True; p D a
_ = Bool
False

data Mode = CSV | AWK (Maybe T.Text) (Maybe T.Text) -- field, record

getS :: Program a -> Mode
getS :: forall a. Program a -> Mode
getS (Program [D a]
ds E a
_) = (Mode -> D a -> Mode) -> Mode -> [D a] -> Mode
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' Mode -> D a -> Mode
forall {a}. Mode -> D a -> Mode
go (Maybe Text -> Maybe Text -> Mode
AWK Maybe Text
forall a. Maybe a
Nothing Maybe Text
forall a. Maybe a
Nothing) [D a]
ds where
    go :: Mode -> D a -> Mode
go (AWK Maybe Text
_ Maybe Text
rs) (SetFS Text
bs) = Maybe Text -> Maybe Text -> Mode
AWK (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
bs) Maybe Text
rs
    go Mode
_ D a
SetAsv              = Maybe Text -> Maybe Text -> Mode
AWK (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"\\x1f") (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"\\x1e")
    go Mode
_ D a
SetUsv              = Maybe Text -> Maybe Text -> Mode
AWK (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"␞") (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"␟")
    go Mode
_ D a
SetCsv              = Mode
CSV
    go (AWK Maybe Text
fs Maybe Text
_) (SetRS Text
bs) = Maybe Text -> Maybe Text -> Mode
AWK Maybe Text
fs (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
bs)
    go Mode
next D a
_                = Mode
next

mapExpr :: (E a -> E a) -> Program a -> Program a
mapExpr :: forall a. (E a -> E a) -> Program a -> Program a
mapExpr E a -> E a
f (Program [D a]
ds E a
e) = [D a] -> E a -> Program a
forall a. [D a] -> E a -> Program a
Program [D a]
ds (E a -> E a
f E a
e)