--  $Header: /data/cvs-rep/uust/lib/pretty/UU/Pretty/Ext.hs,v 1.1 2002/11/13 16:05:20 uust Exp $
--  $Name:  $ (version name)

module UU.Pretty.Ext ( -- Derived from single and multiple
                       (>^<), (>>^<<), (>#<), (>>#<<), wide_text
                     , vlist, hlist, hlist_sp, list_h1, hlist_h1
                     , (>|<<), (>-<<), (>>|<), (>>-<), pp_es
                       -- Displaying the result
                     , vdisp
                       -- Printing brackets
                     , pp_wrap, pp_quotes, pp_doubleQuotes
                     , pp_parens, pp_brackets, pp_braces
                       -- Printing structures
                     , hv, hv_sp, pp_block, pp_ite
                     , pp_list, pp_slist, pp_parens_list
                     ) where

{- Derived pretty-printing combinators. Version 2.0c
   Authors: S. Doaitse Swierstra and Pablo R. Azero
   Date: July, 1999
 -}

import UU.Pretty.Basic

infixr 3 >#<, >>#<<, >>|<, >|<<
infixr 2 >>-<, >-<<
infixr 1 >^<, >>^<<

-- -------------------------------------------------------------------
-- PP instances for often used simple data types ---------------------

instance PP Int where
  pp :: Int -> PP_Doc
pp = String -> PP_Doc
text (String -> PP_Doc) -> (Int -> String) -> Int -> PP_Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> String
forall a. Show a => a -> String
show

instance PP Float where
  pp :: Float -> PP_Doc
pp = String -> PP_Doc
text (String -> PP_Doc) -> (Float -> String) -> Float -> PP_Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> String
forall a. Show a => a -> String
show

-- -------------------------------------------------------------------
-- Derived from single and multiple ----------------------------------

(>^<), (>#<) :: (PP a, PP b) => a -> b -> PP_Doc
a
a  >^< :: forall a b. (PP a, PP b) => a -> b -> PP_Doc
>^<  b
b  =  PP_Doc -> PP_Doc
join  (a
a  a -> b -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
>//<  b
b)
a
l  >#< :: forall a b. (PP a, PP b) => a -> b -> PP_Doc
>#<  b
r  =  a
l a -> PP_Doc -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
>|< String
" " String -> b -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
>|< b
r

pp_es :: t a -> PP_Doc
pp_es t a
string = if t a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null t a
string then PP_Doc
empty else t a -> PP_Doc
forall a. PP a => a -> PP_Doc
pp t a
string

wide_text :: Int -> String -> PP_Doc
wide_text Int
t String
s | Int
ls Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
t    = String -> PP_Doc
text String
s
              | Bool
otherwise = String -> PP_Doc
text (String -> PP_Doc) -> (String -> String) -> String -> PP_Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (if Int
t Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 then Int -> String -> String
forall a. Int -> [a] -> [a]
take Int
t else Int -> String -> String
forall a. Int -> [a] -> [a]
take Int
0) (String -> PP_Doc) -> String -> PP_Doc
forall a b. (a -> b) -> a -> b
$ (String
s String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
spaces)
  where ls :: Int
ls     = String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length String
s
        spaces :: String
spaces = Char -> String
forall a. a -> [a]
repeat Char
' '

hlist, vlist, hlist_sp :: PP a => [a] -> PP_Doc
vlist :: forall a. PP a => [a] -> PP_Doc
vlist    = (a -> PP_Doc -> PP_Doc) -> PP_Doc -> [a] -> PP_Doc
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr  a -> PP_Doc -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
(>-<) PP_Doc
empty
hlist :: forall a. PP a => [a] -> PP_Doc
hlist    = (a -> PP_Doc -> PP_Doc) -> PP_Doc -> [a] -> PP_Doc
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr  a -> PP_Doc -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
(>|<) PP_Doc
empty
hlist_sp :: forall a. PP a => [a] -> PP_Doc
hlist_sp = (a -> PP_Doc -> PP_Doc) -> PP_Doc -> [a] -> PP_Doc
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr  a -> PP_Doc -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
(>#<) PP_Doc
empty

list_h1 :: [PP_Doc] -> [PP_Doc]
list_h1 :: [PP_Doc] -> [PP_Doc]
list_h1   = (PP_Doc -> PP_Doc) -> [PP_Doc] -> [PP_Doc]
forall a b. (a -> b) -> [a] -> [b]
map PP_Doc -> PP_Doc
element_h1

hlist_h1 :: [PP_Doc] -> PP_Doc
hlist_h1  = (PP_Doc -> PP_Doc -> PP_Doc) -> [PP_Doc] -> PP_Doc
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 PP_Doc -> PP_Doc -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
(>|<) ([PP_Doc] -> PP_Doc)
-> ([PP_Doc] -> [PP_Doc]) -> [PP_Doc] -> PP_Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [PP_Doc] -> [PP_Doc]
list_h1

(>>^<<), (>>#<<) :: PP_Exp -> PP_Exp -> PP_Exp
PP_Exp
a >>^<< :: PP_Exp -> PP_Exp -> PP_Exp
>>^<< PP_Exp
b  =  PP_Exp -> PP_Exp
ejoin (PP_Exp
a PP_Exp -> PP_Exp -> PP_Exp
>>//<< PP_Exp
b)
PP_Exp
l >>#<< :: PP_Exp -> PP_Exp -> PP_Exp
>>#<< PP_Exp
r  =  PP_Exp
l PP_Exp -> PP_Exp -> PP_Exp
>>|<< (String
" " String -> PP_Exp -> PP_Exp
forall a. PP a => a -> PP_Exp -> PP_Exp
>|<< PP_Exp
r)

(>|<<), (>-<<) :: PP a => a -> PP_Exp -> PP_Exp
a
l >|<< :: forall a. PP a => a -> PP_Exp -> PP_Exp
>|<< PP_Exp
r = a -> PP_Exp
forall a. PP a => a -> PP_Exp
c2e a
l PP_Exp -> PP_Exp -> PP_Exp
>>|<< PP_Exp
r
a
u >-<< :: forall a. PP a => a -> PP_Exp -> PP_Exp
>-<< PP_Exp
l = a -> PP_Exp
forall a. PP a => a -> PP_Exp
c2e a
u PP_Exp -> PP_Exp -> PP_Exp
>>-<< PP_Exp
l

(>>|<), (>>-<) :: PP a => PP_Exp -> a -> PP_Exp
PP_Exp
l >>|< :: forall a. PP a => PP_Exp -> a -> PP_Exp
>>|< a
r = PP_Exp
l PP_Exp -> PP_Exp -> PP_Exp
>>|<< a -> PP_Exp
forall a. PP a => a -> PP_Exp
c2e a
r
PP_Exp
u >>-< :: forall a. PP a => PP_Exp -> a -> PP_Exp
>>-< a
l = PP_Exp
u PP_Exp -> PP_Exp -> PP_Exp
>>-<< a -> PP_Exp
forall a. PP a => a -> PP_Exp
c2e a
l

-- -------------------------------------------------------------------
-- Displaying the result ---------------------------------------------

vdisp :: Int -> [PP_Doc] -> ShowS
vdisp :: Int -> [PP_Doc] -> String -> String
vdisp Int
pw = (PP_Doc -> (String -> String) -> String -> String)
-> (String -> String) -> [PP_Doc] -> String -> String
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\PP_Doc
f String -> String
fs -> PP_Doc -> Int -> String -> String
disp PP_Doc
f Int
pw (String -> String) -> (String -> String) -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String
"\n"String -> String -> String
forall a. [a] -> [a] -> [a]
++) (String -> String) -> (String -> String) -> String -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
fs) String -> String
forall a. a -> a
id

-- -------------------------------------------------------------------
-- Printing brackets -------------------------------------------------

pp_wrap :: PP a =>  a -> a -> PP_Doc -> PP_Doc
pp_wrap :: forall a. PP a => a -> a -> PP_Doc -> PP_Doc
pp_wrap a
op a
cl PP_Doc
p = a
op a -> PP_Doc -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
>|< (PP_Doc
p PP_Doc -> a -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
>|< a
cl)

pp_quotes :: PP_Doc -> PP_Doc
pp_quotes       = Char -> Char -> PP_Doc -> PP_Doc
forall a. PP a => a -> a -> PP_Doc -> PP_Doc
pp_wrap Char
'`' Char
'\''
pp_doubleQuotes :: PP_Doc -> PP_Doc
pp_doubleQuotes = Char -> Char -> PP_Doc -> PP_Doc
forall a. PP a => a -> a -> PP_Doc -> PP_Doc
pp_wrap Char
'"' Char
'"'
pp_parens :: PP_Doc -> PP_Doc
pp_parens       = Char -> Char -> PP_Doc -> PP_Doc
forall a. PP a => a -> a -> PP_Doc -> PP_Doc
pp_wrap Char
'(' Char
')'
pp_brackets :: PP_Doc -> PP_Doc
pp_brackets     = Char -> Char -> PP_Doc -> PP_Doc
forall a. PP a => a -> a -> PP_Doc -> PP_Doc
pp_wrap Char
'[' Char
']'
pp_braces :: PP_Doc -> PP_Doc
pp_braces       = Char -> Char -> PP_Doc -> PP_Doc
forall a. PP a => a -> a -> PP_Doc -> PP_Doc
pp_wrap Char
'{' Char
'}'

-- -------------------------------------------------------------------
-- Printing structures

-- hv: display a list of elements either horizontally or vertically,
-- 2 possible layouts: horizonal or vertical

hv :: PP a => [a] -> PP_Doc
hv :: forall a. PP a => [a] -> PP_Doc
hv = PP_Doc -> PP_Doc
join (PP_Doc -> PP_Doc) -> ([a] -> PP_Doc) -> [a] -> PP_Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (PP_Doc -> PP_Doc -> PP_Doc) -> PP_Doc -> [PP_Doc] -> PP_Doc
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr PP_Doc -> PP_Doc -> PP_Doc
forall {a}. PP a => a -> a -> PP_Doc
onehv (PP_Doc
empty PP_Doc -> PP_Doc -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
>//< PP_Doc
empty) ([PP_Doc] -> PP_Doc) -> ([a] -> [PP_Doc]) -> [a] -> PP_Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> PP_Doc) -> [a] -> [PP_Doc]
forall a b. (a -> b) -> [a] -> [b]
map a -> PP_Doc
forall a. PP a => a -> PP_Doc
pp
  where onehv :: a -> a -> PP_Doc
onehv a
p a
ps =      PP_Exp -> PP_Exp
eelement_h1 PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>|<< PP_Exp
fpar
                   PP_Exp -> PP_Exp -> PP_Exp
>>//<< PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>-<< PP_Exp
spar
                   PP_Exp -> [a] -> PP_Doc
forall a. PP a => PP_Exp -> [a] -> PP_Doc
>>$<   [a
p, a
ps]

-- hv_sp: same as hv but inserts spaces between the elements
-- 2 possible layouts: horizonal or vertical

hv_sp :: PP a => [a] -> PP_Doc
hv_sp :: forall a. PP a => [a] -> PP_Doc
hv_sp [a]
l | [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [a]
l    = PP_Doc
empty
        | Bool
otherwise = [PP_Doc] -> PP_Doc
forall a. PP a => [a] -> PP_Doc
lhv_sp ([PP_Doc] -> PP_Doc) -> ([a] -> [PP_Doc]) -> [a] -> PP_Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> PP_Doc) -> [a] -> [PP_Doc]
forall a b. (a -> b) -> [a] -> [b]
map a -> PP_Doc
forall a. PP a => a -> PP_Doc
pp ([a] -> PP_Doc) -> [a] -> PP_Doc
forall a b. (a -> b) -> a -> b
$ [a]
l

lhv_sp :: [a] -> PP_Doc
lhv_sp fs :: [a]
fs@(a
f:[a]
fss) = PP_Exp
hs PP_Exp -> PP_Exp -> PP_Exp
>>^<< PP_Exp
vs PP_Exp -> [a] -> PP_Doc
forall a. PP a => PP_Exp -> [a] -> PP_Doc
>>$< [a]
fs
  where (PP_Exp
hs, PP_Exp
vs)  = (a -> (PP_Exp, PP_Exp) -> (PP_Exp, PP_Exp))
-> (PP_Exp, PP_Exp) -> [a] -> (PP_Exp, PP_Exp)
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> (PP_Exp, PP_Exp) -> (PP_Exp, PP_Exp)
forall {p}. p -> (PP_Exp, PP_Exp) -> (PP_Exp, PP_Exp)
paralg (PP_Exp
par, PP_Exp
par) [a]
fss
        paralg :: p -> (PP_Exp, PP_Exp) -> (PP_Exp, PP_Exp)
paralg    = \p
_ (PP_Exp
nhs,PP_Exp
nvs) -> (PP_Exp -> PP_Exp
eelement_h1 PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>#<< PP_Exp
nhs, PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>-<< PP_Exp
nvs)

-- pp_block: printing of block structures with open, close and separator
--           keywords
-- 2 possible layouts: horizonal or vertical

--pp_block :: String -> String -> String -> [PP_Doc] -> PP_Doc
pp_block :: t a -> t a -> t a -> [PP_Doc] -> PP_Doc
pp_block t a
okw t a
ckw t a
sep [PP_Doc]
fs
  | [PP_Doc] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [PP_Doc]
fs   = [PP_Doc] -> PP_Doc
forall a. PP a => [a] -> PP_Doc
hv [PP_Doc
open, PP_Doc
close]
  | Bool
otherwise = PP_Doc -> PP_Doc
join
      (      PP_Exp -> PP_Exp
eelement_h1  PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>|<< PP_Exp
fpar
      PP_Exp -> PP_Exp -> PP_Exp
>>//<<              PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>-<< PP_Exp
spar
      PP_Exp -> [PP_Doc] -> PP_Doc
forall a. PP a => PP_Exp -> [a] -> PP_Doc
>>$< [PP_Doc
open PP_Doc -> PP_Doc -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
>|< (Int -> PP_Doc -> PP_Doc
forall a. PP a => Int -> a -> PP_Doc
indent (Int
startcolumnInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
lk) (PP_Doc -> PP_Doc) -> ([PP_Doc] -> PP_Doc) -> [PP_Doc] -> PP_Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [PP_Doc] -> PP_Doc
forall a. [a] -> a
head ([PP_Doc] -> PP_Doc) -> [PP_Doc] -> PP_Doc
forall a b. (a -> b) -> a -> b
$ [PP_Doc]
fs), PP_Doc
hvopts]
      )
  where lk :: Int
lk           =  t a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length t a
okw
        lsep :: Int
lsep         =  t a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length t a
sep
        startcolumn :: Int
startcolumn  =  (Int
lk Int -> Int -> Int
forall a. Ord a => a -> a -> a
`max` Int
lsep)
        hvopts :: PP_Doc
hvopts       =  (PP_Doc -> PP_Doc -> PP_Doc) -> PP_Doc -> [PP_Doc] -> PP_Doc
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr PP_Doc -> PP_Doc -> PP_Doc
hvoptalg PP_Doc
dclose ([PP_Doc] -> [PP_Doc]
forall a. [a] -> [a]
tail [PP_Doc]
fs)
        hvoptalg :: PP_Doc -> PP_Doc -> PP_Doc
hvoptalg PP_Doc
p PP_Doc
ps
          = (       PP_Exp
par  PP_Exp -> PP_Exp -> PP_Exp
>>|<<  PP_Exp -> PP_Exp
eelement_h1 PP_Exp
par                   PP_Exp -> PP_Exp -> PP_Exp
>>|<<  PP_Exp
fpar
             PP_Exp -> PP_Exp -> PP_Exp
>>//<< PP_Exp
par  PP_Exp -> PP_Exp -> PP_Exp
>>|<<  Int -> PP_Exp -> PP_Exp
eindent (Int
startcolumn Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
lsep) PP_Exp
par  PP_Exp -> PP_Exp -> PP_Exp
>>-<<  PP_Exp
spar
            ) PP_Exp -> [PP_Doc] -> PP_Doc
forall a. PP a => PP_Exp -> [a] -> PP_Doc
>>$< [t a -> PP_Doc
forall {t :: * -> *} {a}. (Foldable t, PP (t a)) => t a -> PP_Doc
pp_es t a
sep, PP_Doc
p, PP_Doc
ps]
        dclose :: PP_Doc
dclose       =  Int -> PP_Exp -> PP_Exp
eindent (Int
startcolumnInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
lk) PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>//<< PP_Exp
par PP_Exp -> [PP_Doc] -> PP_Doc
forall a. PP a => PP_Exp -> [a] -> PP_Doc
>>$< [PP_Doc
close]
        open :: PP_Doc
open         =  t a -> PP_Doc
forall {t :: * -> *} {a}. (Foldable t, PP (t a)) => t a -> PP_Doc
pp_es t a
okw
        close :: PP_Doc
close        =  t a -> PP_Doc
forall {t :: * -> *} {a}. (Foldable t, PP (t a)) => t a -> PP_Doc
pp_es t a
ckw

-- pp_ite: printing an if-then-else-fi statement
-- three possible layouts: horizonal, vertical or mixed

--pp_ite :: (PP a, PP b, PP c, PP d)
--       => a -> b -> c -> d -> PP_Doc -> PP_Doc -> PP_Doc -> PP_Doc
pp_ite :: a -> a -> a -> a -> b -> b -> b -> PP_Doc
pp_ite a
kw_if a
kw_then a
kw_else a
kw_fi b
c b
t b
e
  = (     PP_Exp -> PP_Exp
eelement_h1 ( PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>|<< PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>|<< PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>|<< PP_Exp
par )
    PP_Exp -> PP_Exp -> PP_Exp
>>^<< (     (     ( PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>|<< PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>^<< PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>-<< PP_Exp
par )
                PP_Exp -> [PP_Exp] -> PP_Exp
>>$<< [PP_Exp
par, PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>-<< PP_Exp
par]
                )
          PP_Exp -> PP_Exp -> PP_Exp
>>-<< PP_Exp
par
          )
    )  PP_Exp -> [PP_Doc] -> PP_Doc
forall a. PP a => PP_Exp -> [a] -> PP_Doc
>>$< [ a
kw_if   a -> b -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
>|< b
c
            , a
kw_then a -> b -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
>|< b
t
            , a
kw_else a -> b -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
>|< b
e
            , a -> PP_Doc
forall a. PP a => a -> PP_Doc
pp a
kw_fi
            ]

-- pp_slist: printing a list of elements in a "mini page", needs open, close and
--          separator keywords and a "mini page" width
-- one possible layout: depends on the page width given, when it reaches the end
-- of the page it continues on the next line
-- restrictions: only simple elements allowed (no pp_slists or flexible layouts
--               in the list [PP_Doc])

pp_slist :: Int -> String -> String -> String -> [PP_Doc] -> PP_Doc
pp_slist :: Int -> String -> String -> String -> [PP_Doc] -> PP_Doc
pp_slist Int
pw String
ol String
cl String
sep [PP_Doc]
fl
  | [PP_Doc] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [PP_Doc]
fl    =   [PP_Doc] -> PP_Doc
forall a. PP a => [a] -> PP_Doc
hv [PP_Doc
open, PP_Doc
close]
  | Bool
otherwise  =   PP_Exp -> PP_Exp
eelement_h1 (PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>|<< PP_Exp
par) PP_Exp -> PP_Exp -> PP_Exp
>>^<< (PP_Exp
par PP_Exp -> PP_Exp -> PP_Exp
>>-<< PP_Exp
par)
               PP_Exp -> [PP_Doc] -> PP_Doc
forall a. PP a => PP_Exp -> [a] -> PP_Doc
>>$< [PP_Doc
nes, PP_Doc
close]
  where nes :: PP_Doc
nes    =   Int -> [PP_Doc] -> PP_Doc
forall a. PP a => Int -> [a] -> PP_Doc
fillblock Int
pw (PP_Doc
openPP_Doc -> [PP_Doc] -> [PP_Doc]
forall a. a -> [a] -> [a]
: PP_Doc
nePP_Doc -> [PP_Doc] -> [PP_Doc]
forall a. a -> [a] -> [a]
: (PP_Doc -> PP_Doc) -> [PP_Doc] -> [PP_Doc]
forall a b. (a -> b) -> [a] -> [b]
map (String -> PP_Doc
forall {t :: * -> *} {a}. (Foldable t, PP (t a)) => t a -> PP_Doc
pp_es String
sep PP_Doc -> PP_Doc -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
>|<) ([PP_Doc] -> [PP_Doc]
forall a. [a] -> [a]
tail [PP_Doc]
fl))
        ne :: PP_Doc
ne     =   (Int -> Char -> String
forall a. Int -> a -> [a]
replicate (if Int
ws Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0 then Int
0 else Int
ws Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Char
' ')
               String -> PP_Doc -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
>|< ([PP_Doc] -> PP_Doc
forall a. [a] -> a
head [PP_Doc]
fl)
        ws :: Int
ws     =   String -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length String
sep
        open :: PP_Doc
open   = String -> PP_Doc
forall {t :: * -> *} {a}. (Foldable t, PP (t a)) => t a -> PP_Doc
pp_es String
ol
        close :: PP_Doc
close  = String -> PP_Doc
forall {t :: * -> *} {a}. (Foldable t, PP (t a)) => t a -> PP_Doc
pp_es String
cl

-- pp_list: printing a list of elements in a "mini page", needs open, close and
--          separator keywords and a "mini page" width
-- one possible layout: depends on the page width given, when it reaches the end
-- of the page it continues on the next line

pp_list :: Int -> String -> String -> String -> [PP_Doc] -> PP_Doc
pp_list :: Int -> String -> String -> String -> [PP_Doc] -> PP_Doc
pp_list Int
pw String
ol String
cl String
_   []     = String -> PP_Doc
forall {t :: * -> *} {a}. (Foldable t, PP (t a)) => t a -> PP_Doc
pp_es (String
ol String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
cl)
pp_list Int
pw String
ol String
cl String
sep (PP_Doc
f:[PP_Doc]
fs)
  = Int -> [PP_Doc] -> PP_Doc
forall a. PP a => Int -> [a] -> PP_Doc
fillblock Int
pw (String -> PP_Doc
forall a. PP a => a -> PP_Doc
pp String
olPP_Doc -> [PP_Doc] -> [PP_Doc]
forall a. a -> [a] -> [a]
: (PP_Doc -> PP_Doc
forall a. PP a => a -> PP_Doc
pp PP_Doc
f)PP_Doc -> [PP_Doc] -> [PP_Doc]
forall a. a -> [a] -> [a]
: ((PP_Doc -> PP_Doc) -> [PP_Doc] -> [PP_Doc]
forall a b. (a -> b) -> [a] -> [b]
map (String -> PP_Doc
forall {t :: * -> *} {a}. (Foldable t, PP (t a)) => t a -> PP_Doc
pp_es String
sep PP_Doc -> PP_Doc -> PP_Doc
forall a b. (PP a, PP b) => a -> b -> PP_Doc
>|<) [PP_Doc]
fs) [PP_Doc] -> [PP_Doc] -> [PP_Doc]
forall a. [a] -> [a] -> [a]
++ [ String -> PP_Doc
forall a. PP a => a -> PP_Doc
pp String
cl ])

-- pp_parens_list: idem pp_list, with parenthesis and comma separator

pp_parens_list :: Int -> [PP_Doc] -> PP_Doc
pp_parens_list :: Int -> [PP_Doc] -> PP_Doc
pp_parens_list Int
mpw = Int -> String -> String -> String -> [PP_Doc] -> PP_Doc
pp_list Int
mpw String
"(" String
")" String
", "