{-# LANGUAGE CPP, OverloadedStrings #-}
{-# OPTIONS_HADDOCK hide #-}
{- |
   Module      : Data.GraphViz.Attributes.Arrows
   Description : Arrow types
   Copyright   : (c) Ivan Lazar Miljenovic
   License     : 3-Clause BSD-style
   Maintainer  : Ivan.Miljenovic@gmail.com



 -}
module Data.GraphViz.Attributes.Arrows where

import Data.GraphViz.Internal.Util (bool)
import Data.GraphViz.Parsing
import Data.GraphViz.Printing

import Data.Maybe (isJust)

#if !MIN_VERSION_base (4,13,0)
import Data.Monoid ((<>))
#endif

-- -----------------------------------------------------------------------------

-- | /Dot/ has a basic grammar of arrow shapes which allows usage of
--   up to 1,544,761 different shapes from 9 different basic
--   'ArrowShape's.  Note that whilst an explicit list is used in the
--   definition of 'ArrowType', there must be at least one tuple and a
--   maximum of 4 (since that is what is required by Dot).  For more
--   information, see: <http://graphviz.org/doc/info/arrows.html>
--
--   The 19 basic arrows shown on the overall attributes page have
--   been defined below as a convenience.  Parsing of the 5
--   backward-compatible special cases is also supported.
newtype ArrowType = AType [(ArrowModifier, ArrowShape)]
    deriving (ArrowType -> ArrowType -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArrowType -> ArrowType -> Bool
$c/= :: ArrowType -> ArrowType -> Bool
== :: ArrowType -> ArrowType -> Bool
$c== :: ArrowType -> ArrowType -> Bool
Eq, Eq ArrowType
ArrowType -> ArrowType -> Bool
ArrowType -> ArrowType -> Ordering
ArrowType -> ArrowType -> ArrowType
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
min :: ArrowType -> ArrowType -> ArrowType
$cmin :: ArrowType -> ArrowType -> ArrowType
max :: ArrowType -> ArrowType -> ArrowType
$cmax :: ArrowType -> ArrowType -> ArrowType
>= :: ArrowType -> ArrowType -> Bool
$c>= :: ArrowType -> ArrowType -> Bool
> :: ArrowType -> ArrowType -> Bool
$c> :: ArrowType -> ArrowType -> Bool
<= :: ArrowType -> ArrowType -> Bool
$c<= :: ArrowType -> ArrowType -> Bool
< :: ArrowType -> ArrowType -> Bool
$c< :: ArrowType -> ArrowType -> Bool
compare :: ArrowType -> ArrowType -> Ordering
$ccompare :: ArrowType -> ArrowType -> Ordering
Ord, Int -> ArrowType -> ShowS
[ArrowType] -> ShowS
ArrowType -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ArrowType] -> ShowS
$cshowList :: [ArrowType] -> ShowS
show :: ArrowType -> String
$cshow :: ArrowType -> String
showsPrec :: Int -> ArrowType -> ShowS
$cshowsPrec :: Int -> ArrowType -> ShowS
Show, ReadPrec [ArrowType]
ReadPrec ArrowType
Int -> ReadS ArrowType
ReadS [ArrowType]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ArrowType]
$creadListPrec :: ReadPrec [ArrowType]
readPrec :: ReadPrec ArrowType
$creadPrec :: ReadPrec ArrowType
readList :: ReadS [ArrowType]
$creadList :: ReadS [ArrowType]
readsPrec :: Int -> ReadS ArrowType
$creadsPrec :: Int -> ReadS ArrowType
Read)

-- Used for default
normal :: ArrowType
normal :: ArrowType
normal = [(ArrowModifier, ArrowShape)] -> ArrowType
AType [(ArrowModifier
noMods, ArrowShape
Normal)]

-- Used for backward-compatible parsing
eDiamond, openArr, halfOpen, emptyArr, invEmpty :: ArrowType

eDiamond :: ArrowType
eDiamond = [(ArrowModifier, ArrowShape)] -> ArrowType
AType [(ArrowModifier
openMod, ArrowShape
Diamond)]
openArr :: ArrowType
openArr = [(ArrowModifier, ArrowShape)] -> ArrowType
AType [(ArrowModifier
noMods, ArrowShape
Vee)]
halfOpen :: ArrowType
halfOpen = [(ArrowModifier, ArrowShape)] -> ArrowType
AType [(ArrowFill -> ArrowSide -> ArrowModifier
ArrMod ArrowFill
FilledArrow ArrowSide
LeftSide, ArrowShape
Vee)]
emptyArr :: ArrowType
emptyArr = [(ArrowModifier, ArrowShape)] -> ArrowType
AType [(ArrowModifier
openMod, ArrowShape
Normal)]
invEmpty :: ArrowType
invEmpty = [(ArrowModifier, ArrowShape)] -> ArrowType
AType [ (ArrowModifier
noMods, ArrowShape
Inv)
                 , (ArrowModifier
openMod, ArrowShape
Normal)]

instance PrintDot ArrowType where
  unqtDot :: ArrowType -> DotCode
unqtDot (AType [(ArrowModifier, ArrowShape)]
mas) = forall (m :: * -> *). Functor m => m [Doc] -> m Doc
hcat forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM forall {a} {a}. (PrintDot a, PrintDot a) => (a, a) -> DotCode
appMod [(ArrowModifier, ArrowShape)]
mas
    where
      appMod :: (a, a) -> DotCode
appMod (a
m, a
a) = forall a. PrintDot a => a -> DotCode
unqtDot a
m forall a. Semigroup a => a -> a -> a
<> forall a. PrintDot a => a -> DotCode
unqtDot a
a

instance ParseDot ArrowType where
  parseUnqt :: Parse ArrowType
parseUnqt = Parse ArrowType
specialArrowParse
              forall s a. Parser s a -> Parser s a -> Parser s a
`onFail`
              ([(ArrowModifier, ArrowShape)] -> ArrowType
AType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (p :: * -> *) a. PolyParse p => p a -> p [a]
many1 (forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (,) forall a. ParseDot a => Parse a
parseUnqt forall a. ParseDot a => Parse a
parseUnqt))

specialArrowParse :: Parse ArrowType
specialArrowParse :: Parse ArrowType
specialArrowParse = forall a. [(String, a)] -> Parse a
stringValue [ (String
"ediamond", ArrowType
eDiamond)
                                , (String
"open", ArrowType
openArr)
                                , (String
"halfopen", ArrowType
halfOpen)
                                , (String
"empty", ArrowType
emptyArr)
                                , (String
"invempty", ArrowType
invEmpty)
                                ]

data ArrowShape = Box
                | Crow
                | Diamond
                | DotArrow
                | Inv
                | NoArrow
                | Normal
                | Tee
                | Vee
                deriving (ArrowShape -> ArrowShape -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArrowShape -> ArrowShape -> Bool
$c/= :: ArrowShape -> ArrowShape -> Bool
== :: ArrowShape -> ArrowShape -> Bool
$c== :: ArrowShape -> ArrowShape -> Bool
Eq, Eq ArrowShape
ArrowShape -> ArrowShape -> Bool
ArrowShape -> ArrowShape -> Ordering
ArrowShape -> ArrowShape -> ArrowShape
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
min :: ArrowShape -> ArrowShape -> ArrowShape
$cmin :: ArrowShape -> ArrowShape -> ArrowShape
max :: ArrowShape -> ArrowShape -> ArrowShape
$cmax :: ArrowShape -> ArrowShape -> ArrowShape
>= :: ArrowShape -> ArrowShape -> Bool
$c>= :: ArrowShape -> ArrowShape -> Bool
> :: ArrowShape -> ArrowShape -> Bool
$c> :: ArrowShape -> ArrowShape -> Bool
<= :: ArrowShape -> ArrowShape -> Bool
$c<= :: ArrowShape -> ArrowShape -> Bool
< :: ArrowShape -> ArrowShape -> Bool
$c< :: ArrowShape -> ArrowShape -> Bool
compare :: ArrowShape -> ArrowShape -> Ordering
$ccompare :: ArrowShape -> ArrowShape -> Ordering
Ord, ArrowShape
forall a. a -> a -> Bounded a
maxBound :: ArrowShape
$cmaxBound :: ArrowShape
minBound :: ArrowShape
$cminBound :: ArrowShape
Bounded, Int -> ArrowShape
ArrowShape -> Int
ArrowShape -> [ArrowShape]
ArrowShape -> ArrowShape
ArrowShape -> ArrowShape -> [ArrowShape]
ArrowShape -> ArrowShape -> ArrowShape -> [ArrowShape]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: ArrowShape -> ArrowShape -> ArrowShape -> [ArrowShape]
$cenumFromThenTo :: ArrowShape -> ArrowShape -> ArrowShape -> [ArrowShape]
enumFromTo :: ArrowShape -> ArrowShape -> [ArrowShape]
$cenumFromTo :: ArrowShape -> ArrowShape -> [ArrowShape]
enumFromThen :: ArrowShape -> ArrowShape -> [ArrowShape]
$cenumFromThen :: ArrowShape -> ArrowShape -> [ArrowShape]
enumFrom :: ArrowShape -> [ArrowShape]
$cenumFrom :: ArrowShape -> [ArrowShape]
fromEnum :: ArrowShape -> Int
$cfromEnum :: ArrowShape -> Int
toEnum :: Int -> ArrowShape
$ctoEnum :: Int -> ArrowShape
pred :: ArrowShape -> ArrowShape
$cpred :: ArrowShape -> ArrowShape
succ :: ArrowShape -> ArrowShape
$csucc :: ArrowShape -> ArrowShape
Enum, Int -> ArrowShape -> ShowS
[ArrowShape] -> ShowS
ArrowShape -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ArrowShape] -> ShowS
$cshowList :: [ArrowShape] -> ShowS
show :: ArrowShape -> String
$cshow :: ArrowShape -> String
showsPrec :: Int -> ArrowShape -> ShowS
$cshowsPrec :: Int -> ArrowShape -> ShowS
Show, ReadPrec [ArrowShape]
ReadPrec ArrowShape
Int -> ReadS ArrowShape
ReadS [ArrowShape]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ArrowShape]
$creadListPrec :: ReadPrec [ArrowShape]
readPrec :: ReadPrec ArrowShape
$creadPrec :: ReadPrec ArrowShape
readList :: ReadS [ArrowShape]
$creadList :: ReadS [ArrowShape]
readsPrec :: Int -> ReadS ArrowShape
$creadsPrec :: Int -> ReadS ArrowShape
Read)

instance PrintDot ArrowShape where
  unqtDot :: ArrowShape -> DotCode
unqtDot ArrowShape
Box      = forall (m :: * -> *). Applicative m => Text -> m Doc
text Text
"box"
  unqtDot ArrowShape
Crow     = forall (m :: * -> *). Applicative m => Text -> m Doc
text Text
"crow"
  unqtDot ArrowShape
Diamond  = forall (m :: * -> *). Applicative m => Text -> m Doc
text Text
"diamond"
  unqtDot ArrowShape
DotArrow = forall (m :: * -> *). Applicative m => Text -> m Doc
text Text
"dot"
  unqtDot ArrowShape
Inv      = forall (m :: * -> *). Applicative m => Text -> m Doc
text Text
"inv"
  unqtDot ArrowShape
NoArrow  = forall (m :: * -> *). Applicative m => Text -> m Doc
text Text
"none"
  unqtDot ArrowShape
Normal   = forall (m :: * -> *). Applicative m => Text -> m Doc
text Text
"normal"
  unqtDot ArrowShape
Tee      = forall (m :: * -> *). Applicative m => Text -> m Doc
text Text
"tee"
  unqtDot ArrowShape
Vee      = forall (m :: * -> *). Applicative m => Text -> m Doc
text Text
"vee"

instance ParseDot ArrowShape where
  parseUnqt :: Parse ArrowShape
parseUnqt = forall a. [(String, a)] -> Parse a
stringValue [ (String
"box", ArrowShape
Box)
                          , (String
"crow", ArrowShape
Crow)
                          , (String
"diamond", ArrowShape
Diamond)
                          , (String
"dot", ArrowShape
DotArrow)
                          , (String
"inv", ArrowShape
Inv)
                          , (String
"none", ArrowShape
NoArrow)
                          , (String
"normal", ArrowShape
Normal)
                          , (String
"tee", ArrowShape
Tee)
                          , (String
"vee", ArrowShape
Vee)
                          ]

-- | What modifications to apply to an 'ArrowShape'.
data ArrowModifier = ArrMod { ArrowModifier -> ArrowFill
arrowFill :: ArrowFill
                            , ArrowModifier -> ArrowSide
arrowSide :: ArrowSide
                            }
                   deriving (ArrowModifier -> ArrowModifier -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArrowModifier -> ArrowModifier -> Bool
$c/= :: ArrowModifier -> ArrowModifier -> Bool
== :: ArrowModifier -> ArrowModifier -> Bool
$c== :: ArrowModifier -> ArrowModifier -> Bool
Eq, Eq ArrowModifier
ArrowModifier -> ArrowModifier -> Bool
ArrowModifier -> ArrowModifier -> Ordering
ArrowModifier -> ArrowModifier -> ArrowModifier
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
min :: ArrowModifier -> ArrowModifier -> ArrowModifier
$cmin :: ArrowModifier -> ArrowModifier -> ArrowModifier
max :: ArrowModifier -> ArrowModifier -> ArrowModifier
$cmax :: ArrowModifier -> ArrowModifier -> ArrowModifier
>= :: ArrowModifier -> ArrowModifier -> Bool
$c>= :: ArrowModifier -> ArrowModifier -> Bool
> :: ArrowModifier -> ArrowModifier -> Bool
$c> :: ArrowModifier -> ArrowModifier -> Bool
<= :: ArrowModifier -> ArrowModifier -> Bool
$c<= :: ArrowModifier -> ArrowModifier -> Bool
< :: ArrowModifier -> ArrowModifier -> Bool
$c< :: ArrowModifier -> ArrowModifier -> Bool
compare :: ArrowModifier -> ArrowModifier -> Ordering
$ccompare :: ArrowModifier -> ArrowModifier -> Ordering
Ord, Int -> ArrowModifier -> ShowS
[ArrowModifier] -> ShowS
ArrowModifier -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ArrowModifier] -> ShowS
$cshowList :: [ArrowModifier] -> ShowS
show :: ArrowModifier -> String
$cshow :: ArrowModifier -> String
showsPrec :: Int -> ArrowModifier -> ShowS
$cshowsPrec :: Int -> ArrowModifier -> ShowS
Show, ReadPrec [ArrowModifier]
ReadPrec ArrowModifier
Int -> ReadS ArrowModifier
ReadS [ArrowModifier]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ArrowModifier]
$creadListPrec :: ReadPrec [ArrowModifier]
readPrec :: ReadPrec ArrowModifier
$creadPrec :: ReadPrec ArrowModifier
readList :: ReadS [ArrowModifier]
$creadList :: ReadS [ArrowModifier]
readsPrec :: Int -> ReadS ArrowModifier
$creadsPrec :: Int -> ReadS ArrowModifier
Read)

-- | Apply no modifications to an 'ArrowShape'.
noMods :: ArrowModifier
noMods :: ArrowModifier
noMods = ArrowFill -> ArrowSide -> ArrowModifier
ArrMod ArrowFill
FilledArrow ArrowSide
BothSides

-- | 'OpenArrow' and 'BothSides'
openMod :: ArrowModifier
openMod :: ArrowModifier
openMod = ArrowFill -> ArrowSide -> ArrowModifier
ArrMod ArrowFill
OpenArrow ArrowSide
BothSides

instance PrintDot ArrowModifier where
  unqtDot :: ArrowModifier -> DotCode
unqtDot (ArrMod ArrowFill
f ArrowSide
s) = forall a. PrintDot a => a -> DotCode
unqtDot ArrowFill
f forall a. Semigroup a => a -> a -> a
<> forall a. PrintDot a => a -> DotCode
unqtDot ArrowSide
s

instance ParseDot ArrowModifier where
  parseUnqt :: Parse ArrowModifier
parseUnqt = forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 ArrowFill -> ArrowSide -> ArrowModifier
ArrMod forall a. ParseDot a => Parse a
parseUnqt forall a. ParseDot a => Parse a
parseUnqt

data ArrowFill = OpenArrow
               | FilledArrow
               deriving (ArrowFill -> ArrowFill -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArrowFill -> ArrowFill -> Bool
$c/= :: ArrowFill -> ArrowFill -> Bool
== :: ArrowFill -> ArrowFill -> Bool
$c== :: ArrowFill -> ArrowFill -> Bool
Eq, Eq ArrowFill
ArrowFill -> ArrowFill -> Bool
ArrowFill -> ArrowFill -> Ordering
ArrowFill -> ArrowFill -> ArrowFill
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
min :: ArrowFill -> ArrowFill -> ArrowFill
$cmin :: ArrowFill -> ArrowFill -> ArrowFill
max :: ArrowFill -> ArrowFill -> ArrowFill
$cmax :: ArrowFill -> ArrowFill -> ArrowFill
>= :: ArrowFill -> ArrowFill -> Bool
$c>= :: ArrowFill -> ArrowFill -> Bool
> :: ArrowFill -> ArrowFill -> Bool
$c> :: ArrowFill -> ArrowFill -> Bool
<= :: ArrowFill -> ArrowFill -> Bool
$c<= :: ArrowFill -> ArrowFill -> Bool
< :: ArrowFill -> ArrowFill -> Bool
$c< :: ArrowFill -> ArrowFill -> Bool
compare :: ArrowFill -> ArrowFill -> Ordering
$ccompare :: ArrowFill -> ArrowFill -> Ordering
Ord, ArrowFill
forall a. a -> a -> Bounded a
maxBound :: ArrowFill
$cmaxBound :: ArrowFill
minBound :: ArrowFill
$cminBound :: ArrowFill
Bounded, Int -> ArrowFill
ArrowFill -> Int
ArrowFill -> [ArrowFill]
ArrowFill -> ArrowFill
ArrowFill -> ArrowFill -> [ArrowFill]
ArrowFill -> ArrowFill -> ArrowFill -> [ArrowFill]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: ArrowFill -> ArrowFill -> ArrowFill -> [ArrowFill]
$cenumFromThenTo :: ArrowFill -> ArrowFill -> ArrowFill -> [ArrowFill]
enumFromTo :: ArrowFill -> ArrowFill -> [ArrowFill]
$cenumFromTo :: ArrowFill -> ArrowFill -> [ArrowFill]
enumFromThen :: ArrowFill -> ArrowFill -> [ArrowFill]
$cenumFromThen :: ArrowFill -> ArrowFill -> [ArrowFill]
enumFrom :: ArrowFill -> [ArrowFill]
$cenumFrom :: ArrowFill -> [ArrowFill]
fromEnum :: ArrowFill -> Int
$cfromEnum :: ArrowFill -> Int
toEnum :: Int -> ArrowFill
$ctoEnum :: Int -> ArrowFill
pred :: ArrowFill -> ArrowFill
$cpred :: ArrowFill -> ArrowFill
succ :: ArrowFill -> ArrowFill
$csucc :: ArrowFill -> ArrowFill
Enum, Int -> ArrowFill -> ShowS
[ArrowFill] -> ShowS
ArrowFill -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ArrowFill] -> ShowS
$cshowList :: [ArrowFill] -> ShowS
show :: ArrowFill -> String
$cshow :: ArrowFill -> String
showsPrec :: Int -> ArrowFill -> ShowS
$cshowsPrec :: Int -> ArrowFill -> ShowS
Show, ReadPrec [ArrowFill]
ReadPrec ArrowFill
Int -> ReadS ArrowFill
ReadS [ArrowFill]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ArrowFill]
$creadListPrec :: ReadPrec [ArrowFill]
readPrec :: ReadPrec ArrowFill
$creadPrec :: ReadPrec ArrowFill
readList :: ReadS [ArrowFill]
$creadList :: ReadS [ArrowFill]
readsPrec :: Int -> ReadS ArrowFill
$creadsPrec :: Int -> ReadS ArrowFill
Read)

instance PrintDot ArrowFill where
  unqtDot :: ArrowFill -> DotCode
unqtDot ArrowFill
OpenArrow   = forall (m :: * -> *). Applicative m => Char -> m Doc
char Char
'o'
  unqtDot ArrowFill
FilledArrow = forall (m :: * -> *). Applicative m => m Doc
empty

instance ParseDot ArrowFill where
  parseUnqt :: Parse ArrowFill
parseUnqt = forall a. a -> a -> Bool -> a
bool ArrowFill
FilledArrow ArrowFill
OpenArrow forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Maybe a -> Bool
isJust forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (Char -> Parse Char
character Char
'o')

  -- Not used individually
  parse :: Parse ArrowFill
parse = forall a. ParseDot a => Parse a
parseUnqt

-- | Represents which side (when looking towards the node the arrow is
--   pointing to) is drawn.
data ArrowSide = LeftSide
               | RightSide
               | BothSides
               deriving (ArrowSide -> ArrowSide -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ArrowSide -> ArrowSide -> Bool
$c/= :: ArrowSide -> ArrowSide -> Bool
== :: ArrowSide -> ArrowSide -> Bool
$c== :: ArrowSide -> ArrowSide -> Bool
Eq, Eq ArrowSide
ArrowSide -> ArrowSide -> Bool
ArrowSide -> ArrowSide -> Ordering
ArrowSide -> ArrowSide -> ArrowSide
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
min :: ArrowSide -> ArrowSide -> ArrowSide
$cmin :: ArrowSide -> ArrowSide -> ArrowSide
max :: ArrowSide -> ArrowSide -> ArrowSide
$cmax :: ArrowSide -> ArrowSide -> ArrowSide
>= :: ArrowSide -> ArrowSide -> Bool
$c>= :: ArrowSide -> ArrowSide -> Bool
> :: ArrowSide -> ArrowSide -> Bool
$c> :: ArrowSide -> ArrowSide -> Bool
<= :: ArrowSide -> ArrowSide -> Bool
$c<= :: ArrowSide -> ArrowSide -> Bool
< :: ArrowSide -> ArrowSide -> Bool
$c< :: ArrowSide -> ArrowSide -> Bool
compare :: ArrowSide -> ArrowSide -> Ordering
$ccompare :: ArrowSide -> ArrowSide -> Ordering
Ord, ArrowSide
forall a. a -> a -> Bounded a
maxBound :: ArrowSide
$cmaxBound :: ArrowSide
minBound :: ArrowSide
$cminBound :: ArrowSide
Bounded, Int -> ArrowSide
ArrowSide -> Int
ArrowSide -> [ArrowSide]
ArrowSide -> ArrowSide
ArrowSide -> ArrowSide -> [ArrowSide]
ArrowSide -> ArrowSide -> ArrowSide -> [ArrowSide]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: ArrowSide -> ArrowSide -> ArrowSide -> [ArrowSide]
$cenumFromThenTo :: ArrowSide -> ArrowSide -> ArrowSide -> [ArrowSide]
enumFromTo :: ArrowSide -> ArrowSide -> [ArrowSide]
$cenumFromTo :: ArrowSide -> ArrowSide -> [ArrowSide]
enumFromThen :: ArrowSide -> ArrowSide -> [ArrowSide]
$cenumFromThen :: ArrowSide -> ArrowSide -> [ArrowSide]
enumFrom :: ArrowSide -> [ArrowSide]
$cenumFrom :: ArrowSide -> [ArrowSide]
fromEnum :: ArrowSide -> Int
$cfromEnum :: ArrowSide -> Int
toEnum :: Int -> ArrowSide
$ctoEnum :: Int -> ArrowSide
pred :: ArrowSide -> ArrowSide
$cpred :: ArrowSide -> ArrowSide
succ :: ArrowSide -> ArrowSide
$csucc :: ArrowSide -> ArrowSide
Enum, Int -> ArrowSide -> ShowS
[ArrowSide] -> ShowS
ArrowSide -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ArrowSide] -> ShowS
$cshowList :: [ArrowSide] -> ShowS
show :: ArrowSide -> String
$cshow :: ArrowSide -> String
showsPrec :: Int -> ArrowSide -> ShowS
$cshowsPrec :: Int -> ArrowSide -> ShowS
Show, ReadPrec [ArrowSide]
ReadPrec ArrowSide
Int -> ReadS ArrowSide
ReadS [ArrowSide]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ArrowSide]
$creadListPrec :: ReadPrec [ArrowSide]
readPrec :: ReadPrec ArrowSide
$creadPrec :: ReadPrec ArrowSide
readList :: ReadS [ArrowSide]
$creadList :: ReadS [ArrowSide]
readsPrec :: Int -> ReadS ArrowSide
$creadsPrec :: Int -> ReadS ArrowSide
Read)

instance PrintDot ArrowSide where
  unqtDot :: ArrowSide -> DotCode
unqtDot ArrowSide
LeftSide  = forall (m :: * -> *). Applicative m => Char -> m Doc
char Char
'l'
  unqtDot ArrowSide
RightSide = forall (m :: * -> *). Applicative m => Char -> m Doc
char Char
'r'
  unqtDot ArrowSide
BothSides = forall (m :: * -> *). Applicative m => m Doc
empty

instance ParseDot ArrowSide where
  parseUnqt :: Parse ArrowSide
parseUnqt = Maybe Char -> ArrowSide
getSideType forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
optional (forall (p :: * -> *) a. PolyParse p => [p a] -> p a
oneOf forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map Char -> Parse Char
character [Char
'l', Char
'r'])
    where
      getSideType :: Maybe Char -> ArrowSide
getSideType = forall b a. b -> (a -> b) -> Maybe a -> b
maybe ArrowSide
BothSides
                          (forall a. a -> a -> Bool -> a
bool ArrowSide
RightSide ArrowSide
LeftSide forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => a -> a -> Bool
(==) Char
'l')

  -- Not used individually
  parse :: Parse ArrowSide
parse = forall a. ParseDot a => Parse a
parseUnqt