{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# OPTIONS_GHC -Wwarn=orphans #-}

-- | This module provides basic types

module Modelling.Types (
  Change (..),
  Letters (..),
  Name (..),
  NameMapping (..),
  fromNameMapping,
  showLetters,
  showName,
  toNameMapping,
  ) where

import qualified Data.Bimap                       as BM

import Modelling.Auxiliary.Common       (skipSpaces)

import Autolib.Hash                     (Hashable)
import Autolib.Reader                   (Reader (atomic_readerPrec))
import Autolib.ToDoc                    (ToDoc (toDocPrec), text)
import Data.Bimap                       (Bimap)
import Data.Char                        (isAlpha, isAlphaNum)
import Data.Data                        (Data)
import Data.GraphViz                    (GraphvizCommand (..))
import Data.Maybe                       (maybeToList)
import Data.String                      (IsString (fromString))
import GHC.Generics                     (Generic)
import Text.ParserCombinators.Parsec (
  Parser,
  char,
  many1,
  optionMaybe,
  satisfy,
  endBy,
  )

newtype Name = Name { Name -> String
unName :: String }
  deriving (Name -> Name -> Bool
(Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
/= :: Name -> Name -> Bool
Eq, (forall x. Name -> Rep Name x)
-> (forall x. Rep Name x -> Name) -> Generic Name
forall x. Rep Name x -> Name
forall x. Name -> Rep Name x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Name -> Rep Name x
from :: forall x. Name -> Rep Name x
$cto :: forall x. Rep Name x -> Name
to :: forall x. Rep Name x -> Name
Generic, Eq Name
Eq Name => (Int -> Name -> Int) -> (Name -> Int) -> Hashable Name
Int -> Name -> Int
Name -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Name -> Int
hashWithSalt :: Int -> Name -> Int
$chash :: Name -> Int
hash :: Name -> Int
Hashable, Eq Name
Eq Name =>
(Name -> Name -> Ordering)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Name)
-> (Name -> Name -> Name)
-> Ord Name
Name -> Name -> Bool
Name -> Name -> Ordering
Name -> Name -> Name
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 :: Name -> Name -> Ordering
compare :: Name -> Name -> Ordering
$c< :: Name -> Name -> Bool
< :: Name -> Name -> Bool
$c<= :: Name -> Name -> Bool
<= :: Name -> Name -> Bool
$c> :: Name -> Name -> Bool
> :: Name -> Name -> Bool
$c>= :: Name -> Name -> Bool
>= :: Name -> Name -> Bool
$cmax :: Name -> Name -> Name
max :: Name -> Name -> Name
$cmin :: Name -> Name -> Name
min :: Name -> Name -> Name
Ord, ReadPrec [Name]
ReadPrec Name
Int -> ReadS Name
ReadS [Name]
(Int -> ReadS Name)
-> ReadS [Name] -> ReadPrec Name -> ReadPrec [Name] -> Read Name
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Name
readsPrec :: Int -> ReadS Name
$creadList :: ReadS [Name]
readList :: ReadS [Name]
$creadPrec :: ReadPrec Name
readPrec :: ReadPrec Name
$creadListPrec :: ReadPrec [Name]
readListPrec :: ReadPrec [Name]
Read, Int -> Name -> String -> String
[Name] -> String -> String
Name -> String
(Int -> Name -> String -> String)
-> (Name -> String) -> ([Name] -> String -> String) -> Show Name
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Name -> String -> String
showsPrec :: Int -> Name -> String -> String
$cshow :: Name -> String
show :: Name -> String
$cshowList :: [Name] -> String -> String
showList :: [Name] -> String -> String
Show)

instance IsString Name where
  fromString :: String -> Name
fromString = String -> Name
Name

showName :: Name -> String
showName :: Name -> String
showName = Name -> String
unName

parseNamePrec :: Int -> Parser Name
parseNamePrec :: Int -> Parser Name
parseNamePrec Int
_ = do
  Parser ()
skipSpaces
  (String -> Name) -> (String -> String) -> String -> Name
forall a b. (a -> b) -> (String -> a) -> String -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> Name
Name ((String -> String) -> String -> Name)
-> (String -> String -> String) -> String -> String -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String -> String
forall a. [a] -> [a] -> [a]
(++)
    (String -> String -> Name)
-> ParsecT String () Identity String
-> ParsecT String () Identity (String -> Name)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Char
-> ParsecT String () Identity String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many1 ((Char -> Bool) -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
satisfy Char -> Bool
isAlphaNum)
    ParsecT String () Identity (String -> Name)
-> ParsecT String () Identity String -> Parser Name
forall a b.
ParsecT String () Identity (a -> b)
-> ParsecT String () Identity a -> ParsecT String () Identity b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (Maybe Char -> String
forall a. Maybe a -> [a]
maybeToList (Maybe Char -> String)
-> ParsecT String () Identity (Maybe Char)
-> ParsecT String () Identity String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Char
-> ParsecT String () Identity (Maybe Char)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe (Char -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'.'))
    Parser Name -> Parser () -> Parser Name
forall a b.
ParsecT String () Identity a
-> ParsecT String () Identity b -> ParsecT String () Identity a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parser ()
skipSpaces

instance Reader Name where
  atomic_readerPrec :: Int -> Parser Name
atomic_readerPrec = Int -> Parser Name
parseNamePrec

instance ToDoc Name where
  toDocPrec :: Int -> Name -> Doc
toDocPrec Int
_ = String -> Doc
text (String -> Doc) -> (Name -> String) -> Name -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> String
showName

newtype Letters = Letters { Letters -> String
lettersList :: String }
  deriving (Letters -> Letters -> Bool
(Letters -> Letters -> Bool)
-> (Letters -> Letters -> Bool) -> Eq Letters
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Letters -> Letters -> Bool
== :: Letters -> Letters -> Bool
$c/= :: Letters -> Letters -> Bool
/= :: Letters -> Letters -> Bool
Eq, (forall x. Letters -> Rep Letters x)
-> (forall x. Rep Letters x -> Letters) -> Generic Letters
forall x. Rep Letters x -> Letters
forall x. Letters -> Rep Letters x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Letters -> Rep Letters x
from :: forall x. Letters -> Rep Letters x
$cto :: forall x. Rep Letters x -> Letters
to :: forall x. Rep Letters x -> Letters
Generic, Eq Letters
Eq Letters =>
(Letters -> Letters -> Ordering)
-> (Letters -> Letters -> Bool)
-> (Letters -> Letters -> Bool)
-> (Letters -> Letters -> Bool)
-> (Letters -> Letters -> Bool)
-> (Letters -> Letters -> Letters)
-> (Letters -> Letters -> Letters)
-> Ord Letters
Letters -> Letters -> Bool
Letters -> Letters -> Ordering
Letters -> Letters -> Letters
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 :: Letters -> Letters -> Ordering
compare :: Letters -> Letters -> Ordering
$c< :: Letters -> Letters -> Bool
< :: Letters -> Letters -> Bool
$c<= :: Letters -> Letters -> Bool
<= :: Letters -> Letters -> Bool
$c> :: Letters -> Letters -> Bool
> :: Letters -> Letters -> Bool
$c>= :: Letters -> Letters -> Bool
>= :: Letters -> Letters -> Bool
$cmax :: Letters -> Letters -> Letters
max :: Letters -> Letters -> Letters
$cmin :: Letters -> Letters -> Letters
min :: Letters -> Letters -> Letters
Ord, ReadPrec [Letters]
ReadPrec Letters
Int -> ReadS Letters
ReadS [Letters]
(Int -> ReadS Letters)
-> ReadS [Letters]
-> ReadPrec Letters
-> ReadPrec [Letters]
-> Read Letters
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Letters
readsPrec :: Int -> ReadS Letters
$creadList :: ReadS [Letters]
readList :: ReadS [Letters]
$creadPrec :: ReadPrec Letters
readPrec :: ReadPrec Letters
$creadListPrec :: ReadPrec [Letters]
readListPrec :: ReadPrec [Letters]
Read, Int -> Letters -> String -> String
[Letters] -> String -> String
Letters -> String
(Int -> Letters -> String -> String)
-> (Letters -> String)
-> ([Letters] -> String -> String)
-> Show Letters
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Letters -> String -> String
showsPrec :: Int -> Letters -> String -> String
$cshow :: Letters -> String
show :: Letters -> String
$cshowList :: [Letters] -> String -> String
showList :: [Letters] -> String -> String
Show)

instance IsString Letters where
  fromString :: String -> Letters
fromString = String -> Letters
Letters

instance Reader Letters where
  atomic_readerPrec :: Int -> Parser Letters
atomic_readerPrec = Int -> Parser Letters
parseLettersPrec

instance ToDoc Letters where
  toDocPrec :: Int -> Letters -> Doc
toDocPrec Int
_ = String -> Doc
text (String -> Doc) -> (Letters -> String) -> Letters -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Letters -> String
showLetters

showLetters :: Letters -> String
showLetters :: Letters -> String
showLetters = Letters -> String
lettersList

parseLettersPrec :: Int -> Parser Letters
parseLettersPrec :: Int -> Parser Letters
parseLettersPrec Int
_ = do
  Parser ()
skipSpaces
  String -> Letters
Letters (String -> Letters)
-> ParsecT String () Identity String -> Parser Letters
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT String () Identity Char
-> Parser () -> ParsecT String () Identity String
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
endBy ((Char -> Bool) -> ParsecT String () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
satisfy Char -> Bool
isAlpha) Parser ()
skipSpaces

newtype NameMapping = NameMapping { NameMapping -> Bimap Name Name
nameMapping :: Bimap Name Name }
  deriving (NameMapping -> NameMapping -> Bool
(NameMapping -> NameMapping -> Bool)
-> (NameMapping -> NameMapping -> Bool) -> Eq NameMapping
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NameMapping -> NameMapping -> Bool
== :: NameMapping -> NameMapping -> Bool
$c/= :: NameMapping -> NameMapping -> Bool
/= :: NameMapping -> NameMapping -> Bool
Eq, (forall x. NameMapping -> Rep NameMapping x)
-> (forall x. Rep NameMapping x -> NameMapping)
-> Generic NameMapping
forall x. Rep NameMapping x -> NameMapping
forall x. NameMapping -> Rep NameMapping x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NameMapping -> Rep NameMapping x
from :: forall x. NameMapping -> Rep NameMapping x
$cto :: forall x. Rep NameMapping x -> NameMapping
to :: forall x. Rep NameMapping x -> NameMapping
Generic, Eq NameMapping
Eq NameMapping =>
(Int -> NameMapping -> Int)
-> (NameMapping -> Int) -> Hashable NameMapping
Int -> NameMapping -> Int
NameMapping -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> NameMapping -> Int
hashWithSalt :: Int -> NameMapping -> Int
$chash :: NameMapping -> Int
hash :: NameMapping -> Int
Hashable, Parser [NameMapping]
Parser NameMapping
Int -> Parser NameMapping
Parser NameMapping
-> (Int -> Parser NameMapping)
-> Parser NameMapping
-> (Int -> Parser NameMapping)
-> Parser [NameMapping]
-> Reader NameMapping
forall a.
Parser a
-> (Int -> Parser a)
-> Parser a
-> (Int -> Parser a)
-> Parser [a]
-> Reader a
$catomic_reader :: Parser NameMapping
atomic_reader :: Parser NameMapping
$catomic_readerPrec :: Int -> Parser NameMapping
atomic_readerPrec :: Int -> Parser NameMapping
$creader :: Parser NameMapping
reader :: Parser NameMapping
$creaderPrec :: Int -> Parser NameMapping
readerPrec :: Int -> Parser NameMapping
$creaderList :: Parser [NameMapping]
readerList :: Parser [NameMapping]
Reader, Int -> NameMapping -> Doc
[NameMapping] -> Doc
(Int -> NameMapping -> Doc)
-> ([NameMapping] -> Doc) -> ToDoc NameMapping
forall a. (Int -> a -> Doc) -> ([a] -> Doc) -> ToDoc a
$ctoDocPrec :: Int -> NameMapping -> Doc
toDocPrec :: Int -> NameMapping -> Doc
$ctoDocList :: [NameMapping] -> Doc
toDocList :: [NameMapping] -> Doc
ToDoc)

fromNameMapping :: NameMapping -> Bimap String String
fromNameMapping :: NameMapping -> Bimap String String
fromNameMapping = (Name -> String) -> Bimap Name String -> Bimap String String
forall a c b. (a -> c) -> Bimap a b -> Bimap c b
BM.mapMonotonic Name -> String
unName (Bimap Name String -> Bimap String String)
-> (NameMapping -> Bimap Name String)
-> NameMapping
-> Bimap String String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Name -> String) -> Bimap Name Name -> Bimap Name String
forall b c a. (b -> c) -> Bimap a b -> Bimap a c
BM.mapMonotonicR Name -> String
unName (Bimap Name Name -> Bimap Name String)
-> (NameMapping -> Bimap Name Name)
-> NameMapping
-> Bimap Name String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NameMapping -> Bimap Name Name
nameMapping

toNameMapping :: Bimap String String -> NameMapping
toNameMapping :: Bimap String String -> NameMapping
toNameMapping = Bimap Name Name -> NameMapping
NameMapping (Bimap Name Name -> NameMapping)
-> (Bimap String String -> Bimap Name Name)
-> Bimap String String
-> NameMapping
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Name) -> Bimap String Name -> Bimap Name Name
forall a c b. (a -> c) -> Bimap a b -> Bimap c b
BM.mapMonotonic String -> Name
Name (Bimap String Name -> Bimap Name Name)
-> (Bimap String String -> Bimap String Name)
-> Bimap String String
-> Bimap Name Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Name) -> Bimap String String -> Bimap String Name
forall b c a. (b -> c) -> Bimap a b -> Bimap a c
BM.mapMonotonicR String -> Name
Name

instance Show NameMapping where
  show :: NameMapping -> String
show = [(Name, Name)] -> String
forall a. Show a => a -> String
show ([(Name, Name)] -> String)
-> (NameMapping -> [(Name, Name)]) -> NameMapping -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bimap Name Name -> [(Name, Name)]
forall a b. Bimap a b -> [(a, b)]
BM.toList (Bimap Name Name -> [(Name, Name)])
-> (NameMapping -> Bimap Name Name)
-> NameMapping
-> [(Name, Name)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NameMapping -> Bimap Name Name
nameMapping

instance Read NameMapping where
  readsPrec :: Int -> ReadS NameMapping
readsPrec Int
p String
xs = [(Bimap Name Name -> NameMapping
NameMapping (Bimap Name Name -> NameMapping) -> Bimap Name Name -> NameMapping
forall a b. (a -> b) -> a -> b
$ [(Name, Name)] -> Bimap Name Name
forall a b. (Ord a, Ord b) => [(a, b)] -> Bimap a b
BM.fromList [(Name, Name)]
y, String
ys) | ([(Name, Name)]
y, String
ys) <- Int -> ReadS [(Name, Name)]
forall a. Read a => Int -> ReadS a
readsPrec Int
p String
xs]

data Change a = Change {
    forall a. Change a -> Maybe a
add    :: Maybe a,
    forall a. Change a -> Maybe a
remove :: Maybe a
  }
  deriving (Change a -> Change a -> Bool
(Change a -> Change a -> Bool)
-> (Change a -> Change a -> Bool) -> Eq (Change a)
forall a. Eq a => Change a -> Change a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Change a -> Change a -> Bool
== :: Change a -> Change a -> Bool
$c/= :: forall a. Eq a => Change a -> Change a -> Bool
/= :: Change a -> Change a -> Bool
Eq, (forall m. Monoid m => Change m -> m)
-> (forall m a. Monoid m => (a -> m) -> Change a -> m)
-> (forall m a. Monoid m => (a -> m) -> Change a -> m)
-> (forall a b. (a -> b -> b) -> b -> Change a -> b)
-> (forall a b. (a -> b -> b) -> b -> Change a -> b)
-> (forall b a. (b -> a -> b) -> b -> Change a -> b)
-> (forall b a. (b -> a -> b) -> b -> Change a -> b)
-> (forall a. (a -> a -> a) -> Change a -> a)
-> (forall a. (a -> a -> a) -> Change a -> a)
-> (forall a. Change a -> [a])
-> (forall a. Change a -> Bool)
-> (forall a. Change a -> Int)
-> (forall a. Eq a => a -> Change a -> Bool)
-> (forall a. Ord a => Change a -> a)
-> (forall a. Ord a => Change a -> a)
-> (forall a. Num a => Change a -> a)
-> (forall a. Num a => Change a -> a)
-> Foldable Change
forall a. Eq a => a -> Change a -> Bool
forall a. Num a => Change a -> a
forall a. Ord a => Change a -> a
forall m. Monoid m => Change m -> m
forall a. Change a -> Bool
forall a. Change a -> Int
forall a. Change a -> [a]
forall a. (a -> a -> a) -> Change a -> a
forall m a. Monoid m => (a -> m) -> Change a -> m
forall b a. (b -> a -> b) -> b -> Change a -> b
forall a b. (a -> b -> b) -> b -> Change a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Change m -> m
fold :: forall m. Monoid m => Change m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Change a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Change a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Change a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Change a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Change a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Change a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Change a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Change a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Change a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Change a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Change a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Change a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Change a -> a
foldr1 :: forall a. (a -> a -> a) -> Change a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Change a -> a
foldl1 :: forall a. (a -> a -> a) -> Change a -> a
$ctoList :: forall a. Change a -> [a]
toList :: forall a. Change a -> [a]
$cnull :: forall a. Change a -> Bool
null :: forall a. Change a -> Bool
$clength :: forall a. Change a -> Int
length :: forall a. Change a -> Int
$celem :: forall a. Eq a => a -> Change a -> Bool
elem :: forall a. Eq a => a -> Change a -> Bool
$cmaximum :: forall a. Ord a => Change a -> a
maximum :: forall a. Ord a => Change a -> a
$cminimum :: forall a. Ord a => Change a -> a
minimum :: forall a. Ord a => Change a -> a
$csum :: forall a. Num a => Change a -> a
sum :: forall a. Num a => Change a -> a
$cproduct :: forall a. Num a => Change a -> a
product :: forall a. Num a => Change a -> a
Foldable, (forall a b. (a -> b) -> Change a -> Change b)
-> (forall a b. a -> Change b -> Change a) -> Functor Change
forall a b. a -> Change b -> Change a
forall a b. (a -> b) -> Change a -> Change 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) -> Change a -> Change b
fmap :: forall a b. (a -> b) -> Change a -> Change b
$c<$ :: forall a b. a -> Change b -> Change a
<$ :: forall a b. a -> Change b -> Change a
Functor, (forall x. Change a -> Rep (Change a) x)
-> (forall x. Rep (Change a) x -> Change a) -> Generic (Change a)
forall x. Rep (Change a) x -> Change a
forall x. Change a -> Rep (Change a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Change a) x -> Change a
forall a x. Change a -> Rep (Change a) x
$cfrom :: forall a x. Change a -> Rep (Change a) x
from :: forall x. Change a -> Rep (Change a) x
$cto :: forall a x. Rep (Change a) x -> Change a
to :: forall x. Rep (Change a) x -> Change a
Generic, Eq (Change a)
Eq (Change a) =>
(Int -> Change a -> Int)
-> (Change a -> Int) -> Hashable (Change a)
Int -> Change a -> Int
Change a -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
forall a. Hashable a => Eq (Change a)
forall a. Hashable a => Int -> Change a -> Int
forall a. Hashable a => Change a -> Int
$chashWithSalt :: forall a. Hashable a => Int -> Change a -> Int
hashWithSalt :: Int -> Change a -> Int
$chash :: forall a. Hashable a => Change a -> Int
hash :: Change a -> Int
Hashable, ReadPrec [Change a]
ReadPrec (Change a)
Int -> ReadS (Change a)
ReadS [Change a]
(Int -> ReadS (Change a))
-> ReadS [Change a]
-> ReadPrec (Change a)
-> ReadPrec [Change a]
-> Read (Change a)
forall a. Read a => ReadPrec [Change a]
forall a. Read a => ReadPrec (Change a)
forall a. Read a => Int -> ReadS (Change a)
forall a. Read a => ReadS [Change a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (Change a)
readsPrec :: Int -> ReadS (Change a)
$creadList :: forall a. Read a => ReadS [Change a]
readList :: ReadS [Change a]
$creadPrec :: forall a. Read a => ReadPrec (Change a)
readPrec :: ReadPrec (Change a)
$creadListPrec :: forall a. Read a => ReadPrec [Change a]
readListPrec :: ReadPrec [Change a]
Read, Parser [Change a]
Parser (Change a)
Int -> Parser (Change a)
Parser (Change a)
-> (Int -> Parser (Change a))
-> Parser (Change a)
-> (Int -> Parser (Change a))
-> Parser [Change a]
-> Reader (Change a)
forall a.
Parser a
-> (Int -> Parser a)
-> Parser a
-> (Int -> Parser a)
-> Parser [a]
-> Reader a
forall a. Reader a => Parser [Change a]
forall a. Reader a => Parser (Change a)
forall a. Reader a => Int -> Parser (Change a)
$catomic_reader :: forall a. Reader a => Parser (Change a)
atomic_reader :: Parser (Change a)
$catomic_readerPrec :: forall a. Reader a => Int -> Parser (Change a)
atomic_readerPrec :: Int -> Parser (Change a)
$creader :: forall a. Reader a => Parser (Change a)
reader :: Parser (Change a)
$creaderPrec :: forall a. Reader a => Int -> Parser (Change a)
readerPrec :: Int -> Parser (Change a)
$creaderList :: forall a. Reader a => Parser [Change a]
readerList :: Parser [Change a]
Reader, Int -> Change a -> String -> String
[Change a] -> String -> String
Change a -> String
(Int -> Change a -> String -> String)
-> (Change a -> String)
-> ([Change a] -> String -> String)
-> Show (Change a)
forall a. Show a => Int -> Change a -> String -> String
forall a. Show a => [Change a] -> String -> String
forall a. Show a => Change a -> String
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Change a -> String -> String
showsPrec :: Int -> Change a -> String -> String
$cshow :: forall a. Show a => Change a -> String
show :: Change a -> String
$cshowList :: forall a. Show a => [Change a] -> String -> String
showList :: [Change a] -> String -> String
Show, Int -> Change a -> Doc
[Change a] -> Doc
(Int -> Change a -> Doc) -> ([Change a] -> Doc) -> ToDoc (Change a)
forall a. ToDoc a => Int -> Change a -> Doc
forall a. ToDoc a => [Change a] -> Doc
forall a. (Int -> a -> Doc) -> ([a] -> Doc) -> ToDoc a
$ctoDocPrec :: forall a. ToDoc a => Int -> Change a -> Doc
toDocPrec :: Int -> Change a -> Doc
$ctoDocList :: forall a. ToDoc a => [Change a] -> Doc
toDocList :: [Change a] -> Doc
ToDoc, Functor Change
Foldable Change
(Functor Change, Foldable Change) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Change a -> f (Change b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Change (f a) -> f (Change a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Change a -> m (Change b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Change (m a) -> m (Change a))
-> Traversable Change
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Change (m a) -> m (Change a)
forall (f :: * -> *) a.
Applicative f =>
Change (f a) -> f (Change a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Change a -> m (Change b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Change a -> f (Change b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Change a -> f (Change b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Change a -> f (Change b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Change (f a) -> f (Change a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Change (f a) -> f (Change a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Change a -> m (Change b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Change a -> m (Change b)
$csequence :: forall (m :: * -> *) a. Monad m => Change (m a) -> m (Change a)
sequence :: forall (m :: * -> *) a. Monad m => Change (m a) -> m (Change a)
Traversable)

deriving instance Generic GraphvizCommand
deriving instance Data GraphvizCommand
instance Hashable GraphvizCommand
instance Reader GraphvizCommand
instance ToDoc GraphvizCommand