Pinchot.Examples.SyntaxTrees

This module shows how to use Template Haskell to generate the data types corresponding to your context-free grammar. You will want to look at the source; the Haddocks will show only the generated types and not the Template Haskell that was used to generate them.

Documentation

newtype Letter t a

Constructors

Letter (t, a)

Instances

Bifunctor Letter

Methods

bimap :: (a -> b) -> (c -> d) -> Letter a c -> Letter b d

first :: (a -> b) -> Letter a c -> Letter b c

second :: (b -> c) -> Letter a b -> Letter a c

Functor (Letter t)

Methods

fmap :: (a -> b) -> Letter t a -> Letter t b

(<$) :: a -> Letter t b -> Letter t a

Foldable (Letter t)

Methods

fold :: Monoid m => Letter t m -> m

foldMap :: Monoid m => (a -> m) -> Letter t a -> m

foldr :: (a -> b -> b) -> b -> Letter t a -> b

foldr' :: (a -> b -> b) -> b -> Letter t a -> b

foldl :: (b -> a -> b) -> b -> Letter t a -> b

foldl' :: (b -> a -> b) -> b -> Letter t a -> b

foldr1 :: (a -> a -> a) -> Letter t a -> a

foldl1 :: (a -> a -> a) -> Letter t a -> a

toList :: Letter t a -> [a]

null :: Letter t a -> Bool

length :: Letter t a -> Int

elem :: Eq a => a -> Letter t a -> Bool

maximum :: Ord a => Letter t a -> a

minimum :: Ord a => Letter t a -> a

sum :: Num a => Letter t a -> a

product :: Num a => Letter t a -> a

Traversable (Letter t)

Methods

traverse :: Applicative f => (a -> f b) -> Letter t a -> f (Letter t b)

sequenceA :: Applicative f => Letter t (f a) -> f (Letter t a)

mapM :: Monad m => (a -> m b) -> Letter t a -> m (Letter t b)

sequence :: Monad m => Letter t (m a) -> m (Letter t a)

(Eq a, Eq t) => Eq (Letter t a)

Methods

(==) :: Letter t a -> Letter t a -> Bool

(/=) :: Letter t a -> Letter t a -> Bool

(Ord a, Ord t) => Ord (Letter t a)

Methods

compare :: Letter t a -> Letter t a -> Ordering

(<) :: Letter t a -> Letter t a -> Bool

(<=) :: Letter t a -> Letter t a -> Bool

(>) :: Letter t a -> Letter t a -> Bool

(>=) :: Letter t a -> Letter t a -> Bool

max :: Letter t a -> Letter t a -> Letter t a

min :: Letter t a -> Letter t a -> Letter t a

(Show a, Show t) => Show (Letter t a)

Methods

showsPrec :: Int -> Letter t a -> ShowS

show :: Letter t a -> String

showList :: [Letter t a] -> ShowS

Generic (Letter t a)

Associated Types

type Rep (Letter t a) :: * -> *

Methods

from :: Letter t a -> Rep (Letter t a) x

to :: Rep (Letter t a) x -> Letter t a

Wrapped (Letter t a)

Associated Types

type Unwrapped (Letter t a) :: *

Methods

_Wrapped' :: Iso' (Letter t a) (Unwrapped (Letter t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Letter t a)

Methods

prettyVal :: Letter t a -> Value

listValue :: [Letter t a] -> Value

type Rep (Letter t a)

type Rep (Letter t a) = D1 (MetaData "Letter" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "Letter" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (t, a))))

type Unwrapped (Letter t a)

type Unwrapped (Letter t a) = (t, a)

data Letters t a

Constructors

NoLetter

ConsLetter (Letter t a) (Letters t a)

Instances

Bifunctor Letters

Methods

bimap :: (a -> b) -> (c -> d) -> Letters a c -> Letters b d

first :: (a -> b) -> Letters a c -> Letters b c

second :: (b -> c) -> Letters a b -> Letters a c

Functor (Letters t)

Methods

fmap :: (a -> b) -> Letters t a -> Letters t b

(<$) :: a -> Letters t b -> Letters t a

Foldable (Letters t)

Methods

fold :: Monoid m => Letters t m -> m

foldMap :: Monoid m => (a -> m) -> Letters t a -> m

foldr :: (a -> b -> b) -> b -> Letters t a -> b

foldr' :: (a -> b -> b) -> b -> Letters t a -> b

foldl :: (b -> a -> b) -> b -> Letters t a -> b

foldl' :: (b -> a -> b) -> b -> Letters t a -> b

foldr1 :: (a -> a -> a) -> Letters t a -> a

foldl1 :: (a -> a -> a) -> Letters t a -> a

toList :: Letters t a -> [a]

null :: Letters t a -> Bool

length :: Letters t a -> Int

elem :: Eq a => a -> Letters t a -> Bool

maximum :: Ord a => Letters t a -> a

minimum :: Ord a => Letters t a -> a

sum :: Num a => Letters t a -> a

product :: Num a => Letters t a -> a

Traversable (Letters t)

Methods

traverse :: Applicative f => (a -> f b) -> Letters t a -> f (Letters t b)

sequenceA :: Applicative f => Letters t (f a) -> f (Letters t a)

mapM :: Monad m => (a -> m b) -> Letters t a -> m (Letters t b)

sequence :: Monad m => Letters t (m a) -> m (Letters t a)

(Eq t, Eq a) => Eq (Letters t a)

Methods

(==) :: Letters t a -> Letters t a -> Bool

(/=) :: Letters t a -> Letters t a -> Bool

(Ord t, Ord a) => Ord (Letters t a)

Methods

compare :: Letters t a -> Letters t a -> Ordering

(<) :: Letters t a -> Letters t a -> Bool

(<=) :: Letters t a -> Letters t a -> Bool

(>) :: Letters t a -> Letters t a -> Bool

(>=) :: Letters t a -> Letters t a -> Bool

max :: Letters t a -> Letters t a -> Letters t a

min :: Letters t a -> Letters t a -> Letters t a

(Show t, Show a) => Show (Letters t a)

Methods

showsPrec :: Int -> Letters t a -> ShowS

show :: Letters t a -> String

showList :: [Letters t a] -> ShowS

Generic (Letters t a)

Associated Types

type Rep (Letters t a) :: * -> *

Methods

from :: Letters t a -> Rep (Letters t a) x

to :: Rep (Letters t a) x -> Letters t a

(PrettyVal t, PrettyVal a) => PrettyVal (Letters t a)

Methods

prettyVal :: Letters t a -> Value

listValue :: [Letters t a] -> Value

type Rep (Letters t a)

type Rep (Letters t a) = D1 (MetaData "Letters" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" False) ((:+:) (C1 (MetaCons "NoLetter" PrefixI False) U1) (C1 (MetaCons "ConsLetter" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Letter t a))) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Letters t a))))))

data PostalWord t a

Constructors

PostalWord

Fields

• _r'PostalWord'0'Letter :: (Letter t a)
• _r'PostalWord'1'Letters :: (Letters t a)

Instances

Bifunctor PostalWord

Methods

bimap :: (a -> b) -> (c -> d) -> PostalWord a c -> PostalWord b d

first :: (a -> b) -> PostalWord a c -> PostalWord b c

second :: (b -> c) -> PostalWord a b -> PostalWord a c

Functor (PostalWord t)

Methods

fmap :: (a -> b) -> PostalWord t a -> PostalWord t b

(<$) :: a -> PostalWord t b -> PostalWord t a

Foldable (PostalWord t)

Methods

fold :: Monoid m => PostalWord t m -> m

foldMap :: Monoid m => (a -> m) -> PostalWord t a -> m

foldr :: (a -> b -> b) -> b -> PostalWord t a -> b

foldr' :: (a -> b -> b) -> b -> PostalWord t a -> b

foldl :: (b -> a -> b) -> b -> PostalWord t a -> b

foldl' :: (b -> a -> b) -> b -> PostalWord t a -> b

foldr1 :: (a -> a -> a) -> PostalWord t a -> a

foldl1 :: (a -> a -> a) -> PostalWord t a -> a

toList :: PostalWord t a -> [a]

null :: PostalWord t a -> Bool

length :: PostalWord t a -> Int

elem :: Eq a => a -> PostalWord t a -> Bool

maximum :: Ord a => PostalWord t a -> a

minimum :: Ord a => PostalWord t a -> a

sum :: Num a => PostalWord t a -> a

product :: Num a => PostalWord t a -> a

Traversable (PostalWord t)

Methods

traverse :: Applicative f => (a -> f b) -> PostalWord t a -> f (PostalWord t b)

sequenceA :: Applicative f => PostalWord t (f a) -> f (PostalWord t a)

mapM :: Monad m => (a -> m b) -> PostalWord t a -> m (PostalWord t b)

sequence :: Monad m => PostalWord t (m a) -> m (PostalWord t a)

(Eq t, Eq a) => Eq (PostalWord t a)

Methods

(==) :: PostalWord t a -> PostalWord t a -> Bool

(/=) :: PostalWord t a -> PostalWord t a -> Bool

(Ord t, Ord a) => Ord (PostalWord t a)

Methods

compare :: PostalWord t a -> PostalWord t a -> Ordering

(<) :: PostalWord t a -> PostalWord t a -> Bool

(<=) :: PostalWord t a -> PostalWord t a -> Bool

(>) :: PostalWord t a -> PostalWord t a -> Bool

(>=) :: PostalWord t a -> PostalWord t a -> Bool

max :: PostalWord t a -> PostalWord t a -> PostalWord t a

min :: PostalWord t a -> PostalWord t a -> PostalWord t a

(Show t, Show a) => Show (PostalWord t a)

Methods

showsPrec :: Int -> PostalWord t a -> ShowS

show :: PostalWord t a -> String

showList :: [PostalWord t a] -> ShowS

Generic (PostalWord t a)

Associated Types

type Rep (PostalWord t a) :: * -> *

Methods

from :: PostalWord t a -> Rep (PostalWord t a) x

to :: Rep (PostalWord t a) x -> PostalWord t a

(PrettyVal t, PrettyVal a) => PrettyVal (PostalWord t a)

Methods

prettyVal :: PostalWord t a -> Value

listValue :: [PostalWord t a] -> Value

type Rep (PostalWord t a)

type Rep (PostalWord t a) = D1 (MetaData "PostalWord" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" False) (C1 (MetaCons "PostalWord" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_r'PostalWord'0'Letter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Letter t a))) (S1 (MetaSel (Just Symbol "_r'PostalWord'1'Letters") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Letters t a)))))

newtype Space t a

Constructors

Space (t, a)

Instances

Bifunctor Space

Methods

bimap :: (a -> b) -> (c -> d) -> Space a c -> Space b d

first :: (a -> b) -> Space a c -> Space b c

second :: (b -> c) -> Space a b -> Space a c

Functor (Space t)

Methods

fmap :: (a -> b) -> Space t a -> Space t b

(<$) :: a -> Space t b -> Space t a

Foldable (Space t)

Methods

fold :: Monoid m => Space t m -> m

foldMap :: Monoid m => (a -> m) -> Space t a -> m

foldr :: (a -> b -> b) -> b -> Space t a -> b

foldr' :: (a -> b -> b) -> b -> Space t a -> b

foldl :: (b -> a -> b) -> b -> Space t a -> b

foldl' :: (b -> a -> b) -> b -> Space t a -> b

foldr1 :: (a -> a -> a) -> Space t a -> a

foldl1 :: (a -> a -> a) -> Space t a -> a

toList :: Space t a -> [a]

null :: Space t a -> Bool

length :: Space t a -> Int

elem :: Eq a => a -> Space t a -> Bool

maximum :: Ord a => Space t a -> a

minimum :: Ord a => Space t a -> a

sum :: Num a => Space t a -> a

product :: Num a => Space t a -> a

Traversable (Space t)

Methods

traverse :: Applicative f => (a -> f b) -> Space t a -> f (Space t b)

sequenceA :: Applicative f => Space t (f a) -> f (Space t a)

mapM :: Monad m => (a -> m b) -> Space t a -> m (Space t b)

sequence :: Monad m => Space t (m a) -> m (Space t a)

(Eq a, Eq t) => Eq (Space t a)

Methods

(==) :: Space t a -> Space t a -> Bool

(/=) :: Space t a -> Space t a -> Bool

(Ord a, Ord t) => Ord (Space t a)

Methods

compare :: Space t a -> Space t a -> Ordering

(<) :: Space t a -> Space t a -> Bool

(<=) :: Space t a -> Space t a -> Bool

(>) :: Space t a -> Space t a -> Bool

(>=) :: Space t a -> Space t a -> Bool

max :: Space t a -> Space t a -> Space t a

min :: Space t a -> Space t a -> Space t a

(Show a, Show t) => Show (Space t a)

Methods

showsPrec :: Int -> Space t a -> ShowS

show :: Space t a -> String

showList :: [Space t a] -> ShowS

Generic (Space t a)

Associated Types

type Rep (Space t a) :: * -> *

Methods

from :: Space t a -> Rep (Space t a) x

to :: Rep (Space t a) x -> Space t a

Wrapped (Space t a)

Associated Types

type Unwrapped (Space t a) :: *

Methods

_Wrapped' :: Iso' (Space t a) (Unwrapped (Space t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Space t a)

Methods

prettyVal :: Space t a -> Value

listValue :: [Space t a] -> Value

type Rep (Space t a)

type Rep (Space t a) = D1 (MetaData "Space" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "Space" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (t, a))))

type Unwrapped (Space t a)

type Unwrapped (Space t a) = (t, a)

data PreSpacedWord t a

Constructors

PreSpacedWord

Fields

• _r'PreSpacedWord'0'Space :: (Space t a)
• _r'PreSpacedWord'1'PostalWord :: (PostalWord t a)

Instances

Bifunctor PreSpacedWord

Methods

bimap :: (a -> b) -> (c -> d) -> PreSpacedWord a c -> PreSpacedWord b d

first :: (a -> b) -> PreSpacedWord a c -> PreSpacedWord b c

second :: (b -> c) -> PreSpacedWord a b -> PreSpacedWord a c

Functor (PreSpacedWord t)

Methods

fmap :: (a -> b) -> PreSpacedWord t a -> PreSpacedWord t b

(<$) :: a -> PreSpacedWord t b -> PreSpacedWord t a

Foldable (PreSpacedWord t)

Methods

fold :: Monoid m => PreSpacedWord t m -> m

foldMap :: Monoid m => (a -> m) -> PreSpacedWord t a -> m

foldr :: (a -> b -> b) -> b -> PreSpacedWord t a -> b

foldr' :: (a -> b -> b) -> b -> PreSpacedWord t a -> b

foldl :: (b -> a -> b) -> b -> PreSpacedWord t a -> b

foldl' :: (b -> a -> b) -> b -> PreSpacedWord t a -> b

foldr1 :: (a -> a -> a) -> PreSpacedWord t a -> a

foldl1 :: (a -> a -> a) -> PreSpacedWord t a -> a

toList :: PreSpacedWord t a -> [a]

null :: PreSpacedWord t a -> Bool

length :: PreSpacedWord t a -> Int

elem :: Eq a => a -> PreSpacedWord t a -> Bool

maximum :: Ord a => PreSpacedWord t a -> a

minimum :: Ord a => PreSpacedWord t a -> a

sum :: Num a => PreSpacedWord t a -> a

product :: Num a => PreSpacedWord t a -> a

Traversable (PreSpacedWord t)

Methods

traverse :: Applicative f => (a -> f b) -> PreSpacedWord t a -> f (PreSpacedWord t b)

sequenceA :: Applicative f => PreSpacedWord t (f a) -> f (PreSpacedWord t a)

mapM :: Monad m => (a -> m b) -> PreSpacedWord t a -> m (PreSpacedWord t b)

sequence :: Monad m => PreSpacedWord t (m a) -> m (PreSpacedWord t a)

(Eq t, Eq a) => Eq (PreSpacedWord t a)

Methods

(==) :: PreSpacedWord t a -> PreSpacedWord t a -> Bool

(/=) :: PreSpacedWord t a -> PreSpacedWord t a -> Bool

(Ord t, Ord a) => Ord (PreSpacedWord t a)

Methods

compare :: PreSpacedWord t a -> PreSpacedWord t a -> Ordering

(<) :: PreSpacedWord t a -> PreSpacedWord t a -> Bool

(<=) :: PreSpacedWord t a -> PreSpacedWord t a -> Bool

(>) :: PreSpacedWord t a -> PreSpacedWord t a -> Bool

(>=) :: PreSpacedWord t a -> PreSpacedWord t a -> Bool

max :: PreSpacedWord t a -> PreSpacedWord t a -> PreSpacedWord t a

min :: PreSpacedWord t a -> PreSpacedWord t a -> PreSpacedWord t a

(Show t, Show a) => Show (PreSpacedWord t a)

Methods

showsPrec :: Int -> PreSpacedWord t a -> ShowS

show :: PreSpacedWord t a -> String

showList :: [PreSpacedWord t a] -> ShowS

Generic (PreSpacedWord t a)

Associated Types

type Rep (PreSpacedWord t a) :: * -> *

Methods

from :: PreSpacedWord t a -> Rep (PreSpacedWord t a) x

to :: Rep (PreSpacedWord t a) x -> PreSpacedWord t a

(PrettyVal t, PrettyVal a) => PrettyVal (PreSpacedWord t a)

Methods

prettyVal :: PreSpacedWord t a -> Value

listValue :: [PreSpacedWord t a] -> Value

type Rep (PreSpacedWord t a)

type Rep (PreSpacedWord t a) = D1 (MetaData "PreSpacedWord" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" False) (C1 (MetaCons "PreSpacedWord" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_r'PreSpacedWord'0'Space") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Space t a))) (S1 (MetaSel (Just Symbol "_r'PreSpacedWord'1'PostalWord") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (PostalWord t a)))))

newtype PreSpacedWord'Star t a

Constructors

PreSpacedWord'Star [PreSpacedWord t a]

Instances

Bifunctor PreSpacedWord'Star

Methods

bimap :: (a -> b) -> (c -> d) -> PreSpacedWord'Star a c -> PreSpacedWord'Star b d

first :: (a -> b) -> PreSpacedWord'Star a c -> PreSpacedWord'Star b c

second :: (b -> c) -> PreSpacedWord'Star a b -> PreSpacedWord'Star a c

Functor (PreSpacedWord'Star t)

Methods

fmap :: (a -> b) -> PreSpacedWord'Star t a -> PreSpacedWord'Star t b

(<$) :: a -> PreSpacedWord'Star t b -> PreSpacedWord'Star t a

Foldable (PreSpacedWord'Star t)

Methods

fold :: Monoid m => PreSpacedWord'Star t m -> m

foldMap :: Monoid m => (a -> m) -> PreSpacedWord'Star t a -> m

foldr :: (a -> b -> b) -> b -> PreSpacedWord'Star t a -> b

foldr' :: (a -> b -> b) -> b -> PreSpacedWord'Star t a -> b

foldl :: (b -> a -> b) -> b -> PreSpacedWord'Star t a -> b

foldl' :: (b -> a -> b) -> b -> PreSpacedWord'Star t a -> b

foldr1 :: (a -> a -> a) -> PreSpacedWord'Star t a -> a

foldl1 :: (a -> a -> a) -> PreSpacedWord'Star t a -> a

toList :: PreSpacedWord'Star t a -> [a]

null :: PreSpacedWord'Star t a -> Bool

length :: PreSpacedWord'Star t a -> Int

elem :: Eq a => a -> PreSpacedWord'Star t a -> Bool

maximum :: Ord a => PreSpacedWord'Star t a -> a

minimum :: Ord a => PreSpacedWord'Star t a -> a

sum :: Num a => PreSpacedWord'Star t a -> a

product :: Num a => PreSpacedWord'Star t a -> a

Traversable (PreSpacedWord'Star t)

Methods

traverse :: Applicative f => (a -> f b) -> PreSpacedWord'Star t a -> f (PreSpacedWord'Star t b)

sequenceA :: Applicative f => PreSpacedWord'Star t (f a) -> f (PreSpacedWord'Star t a)

mapM :: Monad m => (a -> m b) -> PreSpacedWord'Star t a -> m (PreSpacedWord'Star t b)

sequence :: Monad m => PreSpacedWord'Star t (m a) -> m (PreSpacedWord'Star t a)

(Eq a, Eq t) => Eq (PreSpacedWord'Star t a)

Methods

(==) :: PreSpacedWord'Star t a -> PreSpacedWord'Star t a -> Bool

(/=) :: PreSpacedWord'Star t a -> PreSpacedWord'Star t a -> Bool

(Ord a, Ord t) => Ord (PreSpacedWord'Star t a)

Methods

compare :: PreSpacedWord'Star t a -> PreSpacedWord'Star t a -> Ordering

(<) :: PreSpacedWord'Star t a -> PreSpacedWord'Star t a -> Bool

(<=) :: PreSpacedWord'Star t a -> PreSpacedWord'Star t a -> Bool

(>) :: PreSpacedWord'Star t a -> PreSpacedWord'Star t a -> Bool

(>=) :: PreSpacedWord'Star t a -> PreSpacedWord'Star t a -> Bool

max :: PreSpacedWord'Star t a -> PreSpacedWord'Star t a -> PreSpacedWord'Star t a

min :: PreSpacedWord'Star t a -> PreSpacedWord'Star t a -> PreSpacedWord'Star t a

(Show a, Show t) => Show (PreSpacedWord'Star t a)

Methods

showsPrec :: Int -> PreSpacedWord'Star t a -> ShowS

show :: PreSpacedWord'Star t a -> String

showList :: [PreSpacedWord'Star t a] -> ShowS

Generic (PreSpacedWord'Star t a)

Associated Types

type Rep (PreSpacedWord'Star t a) :: * -> *

Methods

from :: PreSpacedWord'Star t a -> Rep (PreSpacedWord'Star t a) x

to :: Rep (PreSpacedWord'Star t a) x -> PreSpacedWord'Star t a

Semigroup (PreSpacedWord'Star t a)

Methods

(<>) :: PreSpacedWord'Star t a -> PreSpacedWord'Star t a -> PreSpacedWord'Star t a

sconcat :: NonEmpty (PreSpacedWord'Star t a) -> PreSpacedWord'Star t a

stimes :: Integral b => b -> PreSpacedWord'Star t a -> PreSpacedWord'Star t a

Monoid (PreSpacedWord'Star t a)

Methods

mempty :: PreSpacedWord'Star t a

mappend :: PreSpacedWord'Star t a -> PreSpacedWord'Star t a -> PreSpacedWord'Star t a

mconcat :: [PreSpacedWord'Star t a] -> PreSpacedWord'Star t a

Wrapped (PreSpacedWord'Star t a)

Associated Types

type Unwrapped (PreSpacedWord'Star t a) :: *

Methods

_Wrapped' :: Iso' (PreSpacedWord'Star t a) (Unwrapped (PreSpacedWord'Star t a))

(PrettyVal t, PrettyVal a) => PrettyVal (PreSpacedWord'Star t a)

Methods

prettyVal :: PreSpacedWord'Star t a -> Value

listValue :: [PreSpacedWord'Star t a] -> Value

type Rep (PreSpacedWord'Star t a)

type Rep (PreSpacedWord'Star t a) = D1 (MetaData "PreSpacedWord'Star" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "PreSpacedWord'Star" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [PreSpacedWord t a])))

type Unwrapped (PreSpacedWord'Star t a)

type Unwrapped (PreSpacedWord'Star t a) = [PreSpacedWord t a]

data Words t a

Constructors

Words

Fields

• _r'Words'0'PostalWord :: (PostalWord t a)
• _r'Words'1'PreSpacedWord'Star :: (PreSpacedWord'Star t a)

Instances

Bifunctor Words

Methods

bimap :: (a -> b) -> (c -> d) -> Words a c -> Words b d

first :: (a -> b) -> Words a c -> Words b c

second :: (b -> c) -> Words a b -> Words a c

Functor (Words t)

Methods

fmap :: (a -> b) -> Words t a -> Words t b

(<$) :: a -> Words t b -> Words t a

Foldable (Words t)

Methods

fold :: Monoid m => Words t m -> m

foldMap :: Monoid m => (a -> m) -> Words t a -> m

foldr :: (a -> b -> b) -> b -> Words t a -> b

foldr' :: (a -> b -> b) -> b -> Words t a -> b

foldl :: (b -> a -> b) -> b -> Words t a -> b

foldl' :: (b -> a -> b) -> b -> Words t a -> b

foldr1 :: (a -> a -> a) -> Words t a -> a

foldl1 :: (a -> a -> a) -> Words t a -> a

toList :: Words t a -> [a]

null :: Words t a -> Bool

length :: Words t a -> Int

elem :: Eq a => a -> Words t a -> Bool

maximum :: Ord a => Words t a -> a

minimum :: Ord a => Words t a -> a

sum :: Num a => Words t a -> a

product :: Num a => Words t a -> a

Traversable (Words t)

Methods

traverse :: Applicative f => (a -> f b) -> Words t a -> f (Words t b)

sequenceA :: Applicative f => Words t (f a) -> f (Words t a)

mapM :: Monad m => (a -> m b) -> Words t a -> m (Words t b)

sequence :: Monad m => Words t (m a) -> m (Words t a)

(Eq a, Eq t) => Eq (Words t a)

Methods

(==) :: Words t a -> Words t a -> Bool

(/=) :: Words t a -> Words t a -> Bool

(Ord a, Ord t) => Ord (Words t a)

Methods

compare :: Words t a -> Words t a -> Ordering

(<) :: Words t a -> Words t a -> Bool

(<=) :: Words t a -> Words t a -> Bool

(>) :: Words t a -> Words t a -> Bool

(>=) :: Words t a -> Words t a -> Bool

max :: Words t a -> Words t a -> Words t a

min :: Words t a -> Words t a -> Words t a

(Show a, Show t) => Show (Words t a)

Methods

showsPrec :: Int -> Words t a -> ShowS

show :: Words t a -> String

showList :: [Words t a] -> ShowS

Generic (Words t a)

Associated Types

type Rep (Words t a) :: * -> *

Methods

from :: Words t a -> Rep (Words t a) x

to :: Rep (Words t a) x -> Words t a

(PrettyVal t, PrettyVal a) => PrettyVal (Words t a)

Methods

prettyVal :: Words t a -> Value

listValue :: [Words t a] -> Value

type Rep (Words t a)

type Rep (Words t a) = D1 (MetaData "Words" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" False) (C1 (MetaCons "Words" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_r'Words'0'PostalWord") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (PostalWord t a))) (S1 (MetaSel (Just Symbol "_r'Words'1'PreSpacedWord'Star") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (PreSpacedWord'Star t a)))))

newtype Comma t a

Constructors

Comma (t, a)

Instances

Bifunctor Comma

Methods

bimap :: (a -> b) -> (c -> d) -> Comma a c -> Comma b d

first :: (a -> b) -> Comma a c -> Comma b c

second :: (b -> c) -> Comma a b -> Comma a c

Functor (Comma t)

Methods

fmap :: (a -> b) -> Comma t a -> Comma t b

(<$) :: a -> Comma t b -> Comma t a

Foldable (Comma t)

Methods

fold :: Monoid m => Comma t m -> m

foldMap :: Monoid m => (a -> m) -> Comma t a -> m

foldr :: (a -> b -> b) -> b -> Comma t a -> b

foldr' :: (a -> b -> b) -> b -> Comma t a -> b

foldl :: (b -> a -> b) -> b -> Comma t a -> b

foldl' :: (b -> a -> b) -> b -> Comma t a -> b

foldr1 :: (a -> a -> a) -> Comma t a -> a

foldl1 :: (a -> a -> a) -> Comma t a -> a

toList :: Comma t a -> [a]

null :: Comma t a -> Bool

length :: Comma t a -> Int

elem :: Eq a => a -> Comma t a -> Bool

maximum :: Ord a => Comma t a -> a

minimum :: Ord a => Comma t a -> a

sum :: Num a => Comma t a -> a

product :: Num a => Comma t a -> a

Traversable (Comma t)

Methods

traverse :: Applicative f => (a -> f b) -> Comma t a -> f (Comma t b)

sequenceA :: Applicative f => Comma t (f a) -> f (Comma t a)

mapM :: Monad m => (a -> m b) -> Comma t a -> m (Comma t b)

sequence :: Monad m => Comma t (m a) -> m (Comma t a)

(Eq a, Eq t) => Eq (Comma t a)

Methods

(==) :: Comma t a -> Comma t a -> Bool

(/=) :: Comma t a -> Comma t a -> Bool

(Ord a, Ord t) => Ord (Comma t a)

Methods

compare :: Comma t a -> Comma t a -> Ordering

(<) :: Comma t a -> Comma t a -> Bool

(<=) :: Comma t a -> Comma t a -> Bool

(>) :: Comma t a -> Comma t a -> Bool

(>=) :: Comma t a -> Comma t a -> Bool

max :: Comma t a -> Comma t a -> Comma t a

min :: Comma t a -> Comma t a -> Comma t a

(Show a, Show t) => Show (Comma t a)

Methods

showsPrec :: Int -> Comma t a -> ShowS

show :: Comma t a -> String

showList :: [Comma t a] -> ShowS

Generic (Comma t a)

Associated Types

type Rep (Comma t a) :: * -> *

Methods

from :: Comma t a -> Rep (Comma t a) x

to :: Rep (Comma t a) x -> Comma t a

Wrapped (Comma t a)

Associated Types

type Unwrapped (Comma t a) :: *

Methods

_Wrapped' :: Iso' (Comma t a) (Unwrapped (Comma t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Comma t a)

Methods

prettyVal :: Comma t a -> Value

listValue :: [Comma t a] -> Value

type Rep (Comma t a)

type Rep (Comma t a) = D1 (MetaData "Comma" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "Comma" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (t, a))))

type Unwrapped (Comma t a)

type Unwrapped (Comma t a) = (t, a)

data CommaSpace t a

Constructors

CommaSpace

Fields

• _r'CommaSpace'0'Comma :: (Comma t a)
• _r'CommaSpace'1'Space :: (Space t a)

Instances

Bifunctor CommaSpace

Methods

bimap :: (a -> b) -> (c -> d) -> CommaSpace a c -> CommaSpace b d

first :: (a -> b) -> CommaSpace a c -> CommaSpace b c

second :: (b -> c) -> CommaSpace a b -> CommaSpace a c

Functor (CommaSpace t)

Methods

fmap :: (a -> b) -> CommaSpace t a -> CommaSpace t b

(<$) :: a -> CommaSpace t b -> CommaSpace t a

Foldable (CommaSpace t)

Methods

fold :: Monoid m => CommaSpace t m -> m

foldMap :: Monoid m => (a -> m) -> CommaSpace t a -> m

foldr :: (a -> b -> b) -> b -> CommaSpace t a -> b

foldr' :: (a -> b -> b) -> b -> CommaSpace t a -> b

foldl :: (b -> a -> b) -> b -> CommaSpace t a -> b

foldl' :: (b -> a -> b) -> b -> CommaSpace t a -> b

foldr1 :: (a -> a -> a) -> CommaSpace t a -> a

foldl1 :: (a -> a -> a) -> CommaSpace t a -> a

toList :: CommaSpace t a -> [a]

null :: CommaSpace t a -> Bool

length :: CommaSpace t a -> Int

elem :: Eq a => a -> CommaSpace t a -> Bool

maximum :: Ord a => CommaSpace t a -> a

minimum :: Ord a => CommaSpace t a -> a

sum :: Num a => CommaSpace t a -> a

product :: Num a => CommaSpace t a -> a

Traversable (CommaSpace t)

Methods

traverse :: Applicative f => (a -> f b) -> CommaSpace t a -> f (CommaSpace t b)

sequenceA :: Applicative f => CommaSpace t (f a) -> f (CommaSpace t a)

mapM :: Monad m => (a -> m b) -> CommaSpace t a -> m (CommaSpace t b)

sequence :: Monad m => CommaSpace t (m a) -> m (CommaSpace t a)

(Eq t, Eq a) => Eq (CommaSpace t a)

Methods

(==) :: CommaSpace t a -> CommaSpace t a -> Bool

(/=) :: CommaSpace t a -> CommaSpace t a -> Bool

(Ord t, Ord a) => Ord (CommaSpace t a)

Methods

compare :: CommaSpace t a -> CommaSpace t a -> Ordering

(<) :: CommaSpace t a -> CommaSpace t a -> Bool

(<=) :: CommaSpace t a -> CommaSpace t a -> Bool

(>) :: CommaSpace t a -> CommaSpace t a -> Bool

(>=) :: CommaSpace t a -> CommaSpace t a -> Bool

max :: CommaSpace t a -> CommaSpace t a -> CommaSpace t a

min :: CommaSpace t a -> CommaSpace t a -> CommaSpace t a

(Show t, Show a) => Show (CommaSpace t a)

Methods

showsPrec :: Int -> CommaSpace t a -> ShowS

show :: CommaSpace t a -> String

showList :: [CommaSpace t a] -> ShowS

Generic (CommaSpace t a)

Associated Types

type Rep (CommaSpace t a) :: * -> *

Methods

from :: CommaSpace t a -> Rep (CommaSpace t a) x

to :: Rep (CommaSpace t a) x -> CommaSpace t a

(PrettyVal t, PrettyVal a) => PrettyVal (CommaSpace t a)

Methods

prettyVal :: CommaSpace t a -> Value

listValue :: [CommaSpace t a] -> Value

type Rep (CommaSpace t a)

type Rep (CommaSpace t a) = D1 (MetaData "CommaSpace" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" False) (C1 (MetaCons "CommaSpace" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_r'CommaSpace'0'Comma") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Comma t a))) (S1 (MetaSel (Just Symbol "_r'CommaSpace'1'Space") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Space t a)))))

newtype Newline t a

Constructors

Newline (t, a)

Instances

Bifunctor Newline

Methods

bimap :: (a -> b) -> (c -> d) -> Newline a c -> Newline b d

first :: (a -> b) -> Newline a c -> Newline b c

second :: (b -> c) -> Newline a b -> Newline a c

Functor (Newline t)

Methods

fmap :: (a -> b) -> Newline t a -> Newline t b

(<$) :: a -> Newline t b -> Newline t a

Foldable (Newline t)

Methods

fold :: Monoid m => Newline t m -> m

foldMap :: Monoid m => (a -> m) -> Newline t a -> m

foldr :: (a -> b -> b) -> b -> Newline t a -> b

foldr' :: (a -> b -> b) -> b -> Newline t a -> b

foldl :: (b -> a -> b) -> b -> Newline t a -> b

foldl' :: (b -> a -> b) -> b -> Newline t a -> b

foldr1 :: (a -> a -> a) -> Newline t a -> a

foldl1 :: (a -> a -> a) -> Newline t a -> a

toList :: Newline t a -> [a]

null :: Newline t a -> Bool

length :: Newline t a -> Int

elem :: Eq a => a -> Newline t a -> Bool

maximum :: Ord a => Newline t a -> a

minimum :: Ord a => Newline t a -> a

sum :: Num a => Newline t a -> a

product :: Num a => Newline t a -> a

Traversable (Newline t)

Methods

traverse :: Applicative f => (a -> f b) -> Newline t a -> f (Newline t b)

sequenceA :: Applicative f => Newline t (f a) -> f (Newline t a)

mapM :: Monad m => (a -> m b) -> Newline t a -> m (Newline t b)

sequence :: Monad m => Newline t (m a) -> m (Newline t a)

(Eq a, Eq t) => Eq (Newline t a)

Methods

(==) :: Newline t a -> Newline t a -> Bool

(/=) :: Newline t a -> Newline t a -> Bool

(Ord a, Ord t) => Ord (Newline t a)

Methods

compare :: Newline t a -> Newline t a -> Ordering

(<) :: Newline t a -> Newline t a -> Bool

(<=) :: Newline t a -> Newline t a -> Bool

(>) :: Newline t a -> Newline t a -> Bool

(>=) :: Newline t a -> Newline t a -> Bool

max :: Newline t a -> Newline t a -> Newline t a

min :: Newline t a -> Newline t a -> Newline t a

(Show a, Show t) => Show (Newline t a)

Methods

showsPrec :: Int -> Newline t a -> ShowS

show :: Newline t a -> String

showList :: [Newline t a] -> ShowS

Generic (Newline t a)

Associated Types

type Rep (Newline t a) :: * -> *

Methods

from :: Newline t a -> Rep (Newline t a) x

to :: Rep (Newline t a) x -> Newline t a

Wrapped (Newline t a)

Associated Types

type Unwrapped (Newline t a) :: *

Methods

_Wrapped' :: Iso' (Newline t a) (Unwrapped (Newline t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Newline t a)

Methods

prettyVal :: Newline t a -> Value

listValue :: [Newline t a] -> Value

type Rep (Newline t a)

type Rep (Newline t a) = D1 (MetaData "Newline" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "Newline" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (t, a))))

type Unwrapped (Newline t a)

type Unwrapped (Newline t a) = (t, a)

data Separator t a

Constructors

Separator'CommaSpace (CommaSpace t a)

Separator'Newline (Newline t a)

Instances

Bifunctor Separator

Methods

bimap :: (a -> b) -> (c -> d) -> Separator a c -> Separator b d

first :: (a -> b) -> Separator a c -> Separator b c

second :: (b -> c) -> Separator a b -> Separator a c

Functor (Separator t)

Methods

fmap :: (a -> b) -> Separator t a -> Separator t b

(<$) :: a -> Separator t b -> Separator t a

Foldable (Separator t)

Methods

fold :: Monoid m => Separator t m -> m

foldMap :: Monoid m => (a -> m) -> Separator t a -> m

foldr :: (a -> b -> b) -> b -> Separator t a -> b

foldr' :: (a -> b -> b) -> b -> Separator t a -> b

foldl :: (b -> a -> b) -> b -> Separator t a -> b

foldl' :: (b -> a -> b) -> b -> Separator t a -> b

foldr1 :: (a -> a -> a) -> Separator t a -> a

foldl1 :: (a -> a -> a) -> Separator t a -> a

toList :: Separator t a -> [a]

null :: Separator t a -> Bool

length :: Separator t a -> Int

elem :: Eq a => a -> Separator t a -> Bool

maximum :: Ord a => Separator t a -> a

minimum :: Ord a => Separator t a -> a

sum :: Num a => Separator t a -> a

product :: Num a => Separator t a -> a

Traversable (Separator t)

Methods

traverse :: Applicative f => (a -> f b) -> Separator t a -> f (Separator t b)

sequenceA :: Applicative f => Separator t (f a) -> f (Separator t a)

mapM :: Monad m => (a -> m b) -> Separator t a -> m (Separator t b)

sequence :: Monad m => Separator t (m a) -> m (Separator t a)

(Eq a, Eq t) => Eq (Separator t a)

Methods

(==) :: Separator t a -> Separator t a -> Bool

(/=) :: Separator t a -> Separator t a -> Bool

(Ord a, Ord t) => Ord (Separator t a)

Methods

compare :: Separator t a -> Separator t a -> Ordering

(<) :: Separator t a -> Separator t a -> Bool

(<=) :: Separator t a -> Separator t a -> Bool

(>) :: Separator t a -> Separator t a -> Bool

(>=) :: Separator t a -> Separator t a -> Bool

max :: Separator t a -> Separator t a -> Separator t a

min :: Separator t a -> Separator t a -> Separator t a

(Show a, Show t) => Show (Separator t a)

Methods

showsPrec :: Int -> Separator t a -> ShowS

show :: Separator t a -> String

showList :: [Separator t a] -> ShowS

Generic (Separator t a)

Associated Types

type Rep (Separator t a) :: * -> *

Methods

from :: Separator t a -> Rep (Separator t a) x

to :: Rep (Separator t a) x -> Separator t a

(PrettyVal t, PrettyVal a) => PrettyVal (Separator t a)

Methods

prettyVal :: Separator t a -> Value

listValue :: [Separator t a] -> Value

type Rep (Separator t a)

type Rep (Separator t a) = D1 (MetaData "Separator" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" False) ((:+:) (C1 (MetaCons "Separator'CommaSpace" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (CommaSpace t a)))) (C1 (MetaCons "Separator'Newline" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Newline t a)))))

data NameLine t a

Constructors

NameLine

Fields

• _r'NameLine'0'Words :: (Words t a)
• _r'NameLine'1'Separator :: (Separator t a)

Instances

Bifunctor NameLine

Methods

bimap :: (a -> b) -> (c -> d) -> NameLine a c -> NameLine b d

first :: (a -> b) -> NameLine a c -> NameLine b c

second :: (b -> c) -> NameLine a b -> NameLine a c

Functor (NameLine t)

Methods

fmap :: (a -> b) -> NameLine t a -> NameLine t b

(<$) :: a -> NameLine t b -> NameLine t a

Foldable (NameLine t)

Methods

fold :: Monoid m => NameLine t m -> m

foldMap :: Monoid m => (a -> m) -> NameLine t a -> m

foldr :: (a -> b -> b) -> b -> NameLine t a -> b

foldr' :: (a -> b -> b) -> b -> NameLine t a -> b

foldl :: (b -> a -> b) -> b -> NameLine t a -> b

foldl' :: (b -> a -> b) -> b -> NameLine t a -> b

foldr1 :: (a -> a -> a) -> NameLine t a -> a

foldl1 :: (a -> a -> a) -> NameLine t a -> a

toList :: NameLine t a -> [a]

null :: NameLine t a -> Bool

length :: NameLine t a -> Int

elem :: Eq a => a -> NameLine t a -> Bool

maximum :: Ord a => NameLine t a -> a

minimum :: Ord a => NameLine t a -> a

sum :: Num a => NameLine t a -> a

product :: Num a => NameLine t a -> a

Traversable (NameLine t)

Methods

traverse :: Applicative f => (a -> f b) -> NameLine t a -> f (NameLine t b)

sequenceA :: Applicative f => NameLine t (f a) -> f (NameLine t a)

mapM :: Monad m => (a -> m b) -> NameLine t a -> m (NameLine t b)

sequence :: Monad m => NameLine t (m a) -> m (NameLine t a)

(Eq t, Eq a) => Eq (NameLine t a)

Methods

(==) :: NameLine t a -> NameLine t a -> Bool

(/=) :: NameLine t a -> NameLine t a -> Bool

(Ord t, Ord a) => Ord (NameLine t a)

Methods

compare :: NameLine t a -> NameLine t a -> Ordering

(<) :: NameLine t a -> NameLine t a -> Bool

(<=) :: NameLine t a -> NameLine t a -> Bool

(>) :: NameLine t a -> NameLine t a -> Bool

(>=) :: NameLine t a -> NameLine t a -> Bool

max :: NameLine t a -> NameLine t a -> NameLine t a

min :: NameLine t a -> NameLine t a -> NameLine t a

(Show t, Show a) => Show (NameLine t a)

Methods

showsPrec :: Int -> NameLine t a -> ShowS

show :: NameLine t a -> String

showList :: [NameLine t a] -> ShowS

Generic (NameLine t a)

Associated Types

type Rep (NameLine t a) :: * -> *

Methods

from :: NameLine t a -> Rep (NameLine t a) x

to :: Rep (NameLine t a) x -> NameLine t a

(PrettyVal t, PrettyVal a) => PrettyVal (NameLine t a)

Methods

prettyVal :: NameLine t a -> Value

listValue :: [NameLine t a] -> Value

type Rep (NameLine t a)

type Rep (NameLine t a) = D1 (MetaData "NameLine" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" False) (C1 (MetaCons "NameLine" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_r'NameLine'0'Words") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Words t a))) (S1 (MetaSel (Just Symbol "_r'NameLine'1'Separator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Separator t a)))))

newtype Digit t a

Constructors

Digit (t, a)

Instances

Bifunctor Digit

Methods

bimap :: (a -> b) -> (c -> d) -> Digit a c -> Digit b d

first :: (a -> b) -> Digit a c -> Digit b c

second :: (b -> c) -> Digit a b -> Digit a c

Functor (Digit t)

Methods

fmap :: (a -> b) -> Digit t a -> Digit t b

(<$) :: a -> Digit t b -> Digit t a

Foldable (Digit t)

Methods

fold :: Monoid m => Digit t m -> m

foldMap :: Monoid m => (a -> m) -> Digit t a -> m

foldr :: (a -> b -> b) -> b -> Digit t a -> b

foldr' :: (a -> b -> b) -> b -> Digit t a -> b

foldl :: (b -> a -> b) -> b -> Digit t a -> b

foldl' :: (b -> a -> b) -> b -> Digit t a -> b

foldr1 :: (a -> a -> a) -> Digit t a -> a

foldl1 :: (a -> a -> a) -> Digit t a -> a

toList :: Digit t a -> [a]

null :: Digit t a -> Bool

length :: Digit t a -> Int

elem :: Eq a => a -> Digit t a -> Bool

maximum :: Ord a => Digit t a -> a

minimum :: Ord a => Digit t a -> a

sum :: Num a => Digit t a -> a

product :: Num a => Digit t a -> a

Traversable (Digit t)

Methods

traverse :: Applicative f => (a -> f b) -> Digit t a -> f (Digit t b)

sequenceA :: Applicative f => Digit t (f a) -> f (Digit t a)

mapM :: Monad m => (a -> m b) -> Digit t a -> m (Digit t b)

sequence :: Monad m => Digit t (m a) -> m (Digit t a)

(Eq a, Eq t) => Eq (Digit t a)

Methods

(==) :: Digit t a -> Digit t a -> Bool

(/=) :: Digit t a -> Digit t a -> Bool

(Ord a, Ord t) => Ord (Digit t a)

Methods

compare :: Digit t a -> Digit t a -> Ordering

(<) :: Digit t a -> Digit t a -> Bool

(<=) :: Digit t a -> Digit t a -> Bool

(>) :: Digit t a -> Digit t a -> Bool

(>=) :: Digit t a -> Digit t a -> Bool

max :: Digit t a -> Digit t a -> Digit t a

min :: Digit t a -> Digit t a -> Digit t a

(Show a, Show t) => Show (Digit t a)

Methods

showsPrec :: Int -> Digit t a -> ShowS

show :: Digit t a -> String

showList :: [Digit t a] -> ShowS

Generic (Digit t a)

Associated Types

type Rep (Digit t a) :: * -> *

Methods

from :: Digit t a -> Rep (Digit t a) x

to :: Rep (Digit t a) x -> Digit t a

Wrapped (Digit t a)

Associated Types

type Unwrapped (Digit t a) :: *

Methods

_Wrapped' :: Iso' (Digit t a) (Unwrapped (Digit t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Digit t a)

Methods

prettyVal :: Digit t a -> Value

listValue :: [Digit t a] -> Value

type Rep (Digit t a)

type Rep (Digit t a) = D1 (MetaData "Digit" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "Digit" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (t, a))))

type Unwrapped (Digit t a)

type Unwrapped (Digit t a) = (t, a)

newtype Digit'Plus t a

Constructors

Digit'Plus (NonEmpty (Digit t a))

Instances

Bifunctor Digit'Plus

Methods

bimap :: (a -> b) -> (c -> d) -> Digit'Plus a c -> Digit'Plus b d

first :: (a -> b) -> Digit'Plus a c -> Digit'Plus b c

second :: (b -> c) -> Digit'Plus a b -> Digit'Plus a c

Functor (Digit'Plus t)

Methods

fmap :: (a -> b) -> Digit'Plus t a -> Digit'Plus t b

(<$) :: a -> Digit'Plus t b -> Digit'Plus t a

Foldable (Digit'Plus t)

Methods

fold :: Monoid m => Digit'Plus t m -> m

foldMap :: Monoid m => (a -> m) -> Digit'Plus t a -> m

foldr :: (a -> b -> b) -> b -> Digit'Plus t a -> b

foldr' :: (a -> b -> b) -> b -> Digit'Plus t a -> b

foldl :: (b -> a -> b) -> b -> Digit'Plus t a -> b

foldl' :: (b -> a -> b) -> b -> Digit'Plus t a -> b

foldr1 :: (a -> a -> a) -> Digit'Plus t a -> a

foldl1 :: (a -> a -> a) -> Digit'Plus t a -> a

toList :: Digit'Plus t a -> [a]

null :: Digit'Plus t a -> Bool

length :: Digit'Plus t a -> Int

elem :: Eq a => a -> Digit'Plus t a -> Bool

maximum :: Ord a => Digit'Plus t a -> a

minimum :: Ord a => Digit'Plus t a -> a

sum :: Num a => Digit'Plus t a -> a

product :: Num a => Digit'Plus t a -> a

Traversable (Digit'Plus t)

Methods

traverse :: Applicative f => (a -> f b) -> Digit'Plus t a -> f (Digit'Plus t b)

sequenceA :: Applicative f => Digit'Plus t (f a) -> f (Digit'Plus t a)

mapM :: Monad m => (a -> m b) -> Digit'Plus t a -> m (Digit'Plus t b)

sequence :: Monad m => Digit'Plus t (m a) -> m (Digit'Plus t a)

(Eq t, Eq a) => Eq (Digit'Plus t a)

Methods

(==) :: Digit'Plus t a -> Digit'Plus t a -> Bool

(/=) :: Digit'Plus t a -> Digit'Plus t a -> Bool

(Ord t, Ord a) => Ord (Digit'Plus t a)

Methods

compare :: Digit'Plus t a -> Digit'Plus t a -> Ordering

(<) :: Digit'Plus t a -> Digit'Plus t a -> Bool

(<=) :: Digit'Plus t a -> Digit'Plus t a -> Bool

(>) :: Digit'Plus t a -> Digit'Plus t a -> Bool

(>=) :: Digit'Plus t a -> Digit'Plus t a -> Bool

max :: Digit'Plus t a -> Digit'Plus t a -> Digit'Plus t a

min :: Digit'Plus t a -> Digit'Plus t a -> Digit'Plus t a

(Show t, Show a) => Show (Digit'Plus t a)

Methods

showsPrec :: Int -> Digit'Plus t a -> ShowS

show :: Digit'Plus t a -> String

showList :: [Digit'Plus t a] -> ShowS

Generic (Digit'Plus t a)

Associated Types

type Rep (Digit'Plus t a) :: * -> *

Methods

from :: Digit'Plus t a -> Rep (Digit'Plus t a) x

to :: Rep (Digit'Plus t a) x -> Digit'Plus t a

Semigroup (Digit'Plus t a)

Methods

(<>) :: Digit'Plus t a -> Digit'Plus t a -> Digit'Plus t a

sconcat :: NonEmpty (Digit'Plus t a) -> Digit'Plus t a

stimes :: Integral b => b -> Digit'Plus t a -> Digit'Plus t a

Wrapped (Digit'Plus t a)

Associated Types

type Unwrapped (Digit'Plus t a) :: *

Methods

_Wrapped' :: Iso' (Digit'Plus t a) (Unwrapped (Digit'Plus t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Digit'Plus t a)

Methods

prettyVal :: Digit'Plus t a -> Value

listValue :: [Digit'Plus t a] -> Value

type Rep (Digit'Plus t a)

type Rep (Digit'Plus t a) = D1 (MetaData "Digit'Plus" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "Digit'Plus" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (Digit t a)))))

type Unwrapped (Digit'Plus t a)

type Unwrapped (Digit'Plus t a) = NonEmpty (Digit t a)

newtype Number t a

Constructors

Number (Digit'Plus t a)

Instances

Bifunctor Number

Methods

bimap :: (a -> b) -> (c -> d) -> Number a c -> Number b d

first :: (a -> b) -> Number a c -> Number b c

second :: (b -> c) -> Number a b -> Number a c

Functor (Number t)

Methods

fmap :: (a -> b) -> Number t a -> Number t b

(<$) :: a -> Number t b -> Number t a

Foldable (Number t)

Methods

fold :: Monoid m => Number t m -> m

foldMap :: Monoid m => (a -> m) -> Number t a -> m

foldr :: (a -> b -> b) -> b -> Number t a -> b

foldr' :: (a -> b -> b) -> b -> Number t a -> b

foldl :: (b -> a -> b) -> b -> Number t a -> b

foldl' :: (b -> a -> b) -> b -> Number t a -> b

foldr1 :: (a -> a -> a) -> Number t a -> a

foldl1 :: (a -> a -> a) -> Number t a -> a

toList :: Number t a -> [a]

null :: Number t a -> Bool

length :: Number t a -> Int

elem :: Eq a => a -> Number t a -> Bool

maximum :: Ord a => Number t a -> a

minimum :: Ord a => Number t a -> a

sum :: Num a => Number t a -> a

product :: Num a => Number t a -> a

Traversable (Number t)

Methods

traverse :: Applicative f => (a -> f b) -> Number t a -> f (Number t b)

sequenceA :: Applicative f => Number t (f a) -> f (Number t a)

mapM :: Monad m => (a -> m b) -> Number t a -> m (Number t b)

sequence :: Monad m => Number t (m a) -> m (Number t a)

(Eq a, Eq t) => Eq (Number t a)

Methods

(==) :: Number t a -> Number t a -> Bool

(/=) :: Number t a -> Number t a -> Bool

(Ord a, Ord t) => Ord (Number t a)

Methods

compare :: Number t a -> Number t a -> Ordering

(<) :: Number t a -> Number t a -> Bool

(<=) :: Number t a -> Number t a -> Bool

(>) :: Number t a -> Number t a -> Bool

(>=) :: Number t a -> Number t a -> Bool

max :: Number t a -> Number t a -> Number t a

min :: Number t a -> Number t a -> Number t a

(Show a, Show t) => Show (Number t a)

Methods

showsPrec :: Int -> Number t a -> ShowS

show :: Number t a -> String

showList :: [Number t a] -> ShowS

Generic (Number t a)

Associated Types

type Rep (Number t a) :: * -> *

Methods

from :: Number t a -> Rep (Number t a) x

to :: Rep (Number t a) x -> Number t a

Semigroup (Number t a)

Methods

(<>) :: Number t a -> Number t a -> Number t a

sconcat :: NonEmpty (Number t a) -> Number t a

stimes :: Integral b => b -> Number t a -> Number t a

Wrapped (Number t a)

Associated Types

type Unwrapped (Number t a) :: *

Methods

_Wrapped' :: Iso' (Number t a) (Unwrapped (Number t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Number t a)

Methods

prettyVal :: Number t a -> Value

listValue :: [Number t a] -> Value

type Rep (Number t a)

type Rep (Number t a) = D1 (MetaData "Number" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "Number" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Digit'Plus t a))))

type Unwrapped (Number t a)

type Unwrapped (Number t a) = Digit'Plus t a

newtype North t a

Constructors

North (t, a)

Instances

Bifunctor North

Methods

bimap :: (a -> b) -> (c -> d) -> North a c -> North b d

first :: (a -> b) -> North a c -> North b c

second :: (b -> c) -> North a b -> North a c

Functor (North t)

Methods

fmap :: (a -> b) -> North t a -> North t b

(<$) :: a -> North t b -> North t a

Foldable (North t)

Methods

fold :: Monoid m => North t m -> m

foldMap :: Monoid m => (a -> m) -> North t a -> m

foldr :: (a -> b -> b) -> b -> North t a -> b

foldr' :: (a -> b -> b) -> b -> North t a -> b

foldl :: (b -> a -> b) -> b -> North t a -> b

foldl' :: (b -> a -> b) -> b -> North t a -> b

foldr1 :: (a -> a -> a) -> North t a -> a

foldl1 :: (a -> a -> a) -> North t a -> a

toList :: North t a -> [a]

null :: North t a -> Bool

length :: North t a -> Int

elem :: Eq a => a -> North t a -> Bool

maximum :: Ord a => North t a -> a

minimum :: Ord a => North t a -> a

sum :: Num a => North t a -> a

product :: Num a => North t a -> a

Traversable (North t)

Methods

traverse :: Applicative f => (a -> f b) -> North t a -> f (North t b)

sequenceA :: Applicative f => North t (f a) -> f (North t a)

mapM :: Monad m => (a -> m b) -> North t a -> m (North t b)

sequence :: Monad m => North t (m a) -> m (North t a)

(Eq a, Eq t) => Eq (North t a)

Methods

(==) :: North t a -> North t a -> Bool

(/=) :: North t a -> North t a -> Bool

(Ord a, Ord t) => Ord (North t a)

Methods

compare :: North t a -> North t a -> Ordering

(<) :: North t a -> North t a -> Bool

(<=) :: North t a -> North t a -> Bool

(>) :: North t a -> North t a -> Bool

(>=) :: North t a -> North t a -> Bool

max :: North t a -> North t a -> North t a

min :: North t a -> North t a -> North t a

(Show a, Show t) => Show (North t a)

Methods

showsPrec :: Int -> North t a -> ShowS

show :: North t a -> String

showList :: [North t a] -> ShowS

Generic (North t a)

Associated Types

type Rep (North t a) :: * -> *

Methods

from :: North t a -> Rep (North t a) x

to :: Rep (North t a) x -> North t a

Wrapped (North t a)

Associated Types

type Unwrapped (North t a) :: *

Methods

_Wrapped' :: Iso' (North t a) (Unwrapped (North t a))

(PrettyVal t, PrettyVal a) => PrettyVal (North t a)

Methods

prettyVal :: North t a -> Value

listValue :: [North t a] -> Value

type Rep (North t a)

type Rep (North t a) = D1 (MetaData "North" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "North" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (t, a))))

type Unwrapped (North t a)

type Unwrapped (North t a) = (t, a)

newtype South t a

Constructors

South (t, a)

Instances

Bifunctor South

Methods

bimap :: (a -> b) -> (c -> d) -> South a c -> South b d

first :: (a -> b) -> South a c -> South b c

second :: (b -> c) -> South a b -> South a c

Functor (South t)

Methods

fmap :: (a -> b) -> South t a -> South t b

(<$) :: a -> South t b -> South t a

Foldable (South t)

Methods

fold :: Monoid m => South t m -> m

foldMap :: Monoid m => (a -> m) -> South t a -> m

foldr :: (a -> b -> b) -> b -> South t a -> b

foldr' :: (a -> b -> b) -> b -> South t a -> b

foldl :: (b -> a -> b) -> b -> South t a -> b

foldl' :: (b -> a -> b) -> b -> South t a -> b

foldr1 :: (a -> a -> a) -> South t a -> a

foldl1 :: (a -> a -> a) -> South t a -> a

toList :: South t a -> [a]

null :: South t a -> Bool

length :: South t a -> Int

elem :: Eq a => a -> South t a -> Bool

maximum :: Ord a => South t a -> a

minimum :: Ord a => South t a -> a

sum :: Num a => South t a -> a

product :: Num a => South t a -> a

Traversable (South t)

Methods

traverse :: Applicative f => (a -> f b) -> South t a -> f (South t b)

sequenceA :: Applicative f => South t (f a) -> f (South t a)

mapM :: Monad m => (a -> m b) -> South t a -> m (South t b)

sequence :: Monad m => South t (m a) -> m (South t a)

(Eq a, Eq t) => Eq (South t a)

Methods

(==) :: South t a -> South t a -> Bool

(/=) :: South t a -> South t a -> Bool

(Ord a, Ord t) => Ord (South t a)

Methods

compare :: South t a -> South t a -> Ordering

(<) :: South t a -> South t a -> Bool

(<=) :: South t a -> South t a -> Bool

(>) :: South t a -> South t a -> Bool

(>=) :: South t a -> South t a -> Bool

max :: South t a -> South t a -> South t a

min :: South t a -> South t a -> South t a

(Show a, Show t) => Show (South t a)

Methods

showsPrec :: Int -> South t a -> ShowS

show :: South t a -> String

showList :: [South t a] -> ShowS

Generic (South t a)

Associated Types

type Rep (South t a) :: * -> *

Methods

from :: South t a -> Rep (South t a) x

to :: Rep (South t a) x -> South t a

Wrapped (South t a)

Associated Types

type Unwrapped (South t a) :: *

Methods

_Wrapped' :: Iso' (South t a) (Unwrapped (South t a))

(PrettyVal t, PrettyVal a) => PrettyVal (South t a)

Methods

prettyVal :: South t a -> Value

listValue :: [South t a] -> Value

type Rep (South t a)

type Rep (South t a) = D1 (MetaData "South" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "South" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (t, a))))

type Unwrapped (South t a)

type Unwrapped (South t a) = (t, a)

newtype East t a

Constructors

East (t, a)

Instances

Bifunctor East

Methods

bimap :: (a -> b) -> (c -> d) -> East a c -> East b d

first :: (a -> b) -> East a c -> East b c

second :: (b -> c) -> East a b -> East a c

Functor (East t)

Methods

fmap :: (a -> b) -> East t a -> East t b

(<$) :: a -> East t b -> East t a

Foldable (East t)

Methods

fold :: Monoid m => East t m -> m

foldMap :: Monoid m => (a -> m) -> East t a -> m

foldr :: (a -> b -> b) -> b -> East t a -> b

foldr' :: (a -> b -> b) -> b -> East t a -> b

foldl :: (b -> a -> b) -> b -> East t a -> b

foldl' :: (b -> a -> b) -> b -> East t a -> b

foldr1 :: (a -> a -> a) -> East t a -> a

foldl1 :: (a -> a -> a) -> East t a -> a

toList :: East t a -> [a]

null :: East t a -> Bool

length :: East t a -> Int

elem :: Eq a => a -> East t a -> Bool

maximum :: Ord a => East t a -> a

minimum :: Ord a => East t a -> a

sum :: Num a => East t a -> a

product :: Num a => East t a -> a

Traversable (East t)

Methods

traverse :: Applicative f => (a -> f b) -> East t a -> f (East t b)

sequenceA :: Applicative f => East t (f a) -> f (East t a)

mapM :: Monad m => (a -> m b) -> East t a -> m (East t b)

sequence :: Monad m => East t (m a) -> m (East t a)

(Eq a, Eq t) => Eq (East t a)

Methods

(==) :: East t a -> East t a -> Bool

(/=) :: East t a -> East t a -> Bool

(Ord a, Ord t) => Ord (East t a)

Methods

compare :: East t a -> East t a -> Ordering

(<) :: East t a -> East t a -> Bool

(<=) :: East t a -> East t a -> Bool

(>) :: East t a -> East t a -> Bool

(>=) :: East t a -> East t a -> Bool

max :: East t a -> East t a -> East t a

min :: East t a -> East t a -> East t a

(Show a, Show t) => Show (East t a)

Methods

showsPrec :: Int -> East t a -> ShowS

show :: East t a -> String

showList :: [East t a] -> ShowS

Generic (East t a)

Associated Types

type Rep (East t a) :: * -> *

Methods

from :: East t a -> Rep (East t a) x

to :: Rep (East t a) x -> East t a

Wrapped (East t a)

Associated Types

type Unwrapped (East t a) :: *

Methods

_Wrapped' :: Iso' (East t a) (Unwrapped (East t a))

(PrettyVal t, PrettyVal a) => PrettyVal (East t a)

Methods

prettyVal :: East t a -> Value

listValue :: [East t a] -> Value

type Rep (East t a)

type Rep (East t a) = D1 (MetaData "East" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "East" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (t, a))))

type Unwrapped (East t a)

type Unwrapped (East t a) = (t, a)

newtype West t a

Constructors

West (t, a)

Instances

Bifunctor West

Methods

bimap :: (a -> b) -> (c -> d) -> West a c -> West b d

first :: (a -> b) -> West a c -> West b c

second :: (b -> c) -> West a b -> West a c

Functor (West t)

Methods

fmap :: (a -> b) -> West t a -> West t b

(<$) :: a -> West t b -> West t a

Foldable (West t)

Methods

fold :: Monoid m => West t m -> m

foldMap :: Monoid m => (a -> m) -> West t a -> m

foldr :: (a -> b -> b) -> b -> West t a -> b

foldr' :: (a -> b -> b) -> b -> West t a -> b

foldl :: (b -> a -> b) -> b -> West t a -> b

foldl' :: (b -> a -> b) -> b -> West t a -> b

foldr1 :: (a -> a -> a) -> West t a -> a

foldl1 :: (a -> a -> a) -> West t a -> a

toList :: West t a -> [a]

null :: West t a -> Bool

length :: West t a -> Int

elem :: Eq a => a -> West t a -> Bool

maximum :: Ord a => West t a -> a

minimum :: Ord a => West t a -> a

sum :: Num a => West t a -> a

product :: Num a => West t a -> a

Traversable (West t)

Methods

traverse :: Applicative f => (a -> f b) -> West t a -> f (West t b)

sequenceA :: Applicative f => West t (f a) -> f (West t a)

mapM :: Monad m => (a -> m b) -> West t a -> m (West t b)

sequence :: Monad m => West t (m a) -> m (West t a)

(Eq a, Eq t) => Eq (West t a)

Methods

(==) :: West t a -> West t a -> Bool

(/=) :: West t a -> West t a -> Bool

(Ord a, Ord t) => Ord (West t a)

Methods

compare :: West t a -> West t a -> Ordering

(<) :: West t a -> West t a -> Bool

(<=) :: West t a -> West t a -> Bool

(>) :: West t a -> West t a -> Bool

(>=) :: West t a -> West t a -> Bool

max :: West t a -> West t a -> West t a

min :: West t a -> West t a -> West t a

(Show a, Show t) => Show (West t a)

Methods

showsPrec :: Int -> West t a -> ShowS

show :: West t a -> String

showList :: [West t a] -> ShowS

Generic (West t a)

Associated Types

type Rep (West t a) :: * -> *

Methods

from :: West t a -> Rep (West t a) x

to :: Rep (West t a) x -> West t a

Wrapped (West t a)

Associated Types

type Unwrapped (West t a) :: *

Methods

_Wrapped' :: Iso' (West t a) (Unwrapped (West t a))

(PrettyVal t, PrettyVal a) => PrettyVal (West t a)

Methods

prettyVal :: West t a -> Value

listValue :: [West t a] -> Value

type Rep (West t a)

type Rep (West t a) = D1 (MetaData "West" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "West" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (t, a))))

type Unwrapped (West t a)

type Unwrapped (West t a) = (t, a)

newtype NE t a

Constructors

NE (NonEmpty (t, a))

Instances

Bifunctor NE

Methods

bimap :: (a -> b) -> (c -> d) -> NE a c -> NE b d

first :: (a -> b) -> NE a c -> NE b c

second :: (b -> c) -> NE a b -> NE a c

Functor (NE t)

Methods

fmap :: (a -> b) -> NE t a -> NE t b

(<$) :: a -> NE t b -> NE t a

Foldable (NE t)

Methods

fold :: Monoid m => NE t m -> m

foldMap :: Monoid m => (a -> m) -> NE t a -> m

foldr :: (a -> b -> b) -> b -> NE t a -> b

foldr' :: (a -> b -> b) -> b -> NE t a -> b

foldl :: (b -> a -> b) -> b -> NE t a -> b

foldl' :: (b -> a -> b) -> b -> NE t a -> b

foldr1 :: (a -> a -> a) -> NE t a -> a

foldl1 :: (a -> a -> a) -> NE t a -> a

toList :: NE t a -> [a]

null :: NE t a -> Bool

length :: NE t a -> Int

elem :: Eq a => a -> NE t a -> Bool

maximum :: Ord a => NE t a -> a

minimum :: Ord a => NE t a -> a

sum :: Num a => NE t a -> a

product :: Num a => NE t a -> a

Traversable (NE t)

Methods

traverse :: Applicative f => (a -> f b) -> NE t a -> f (NE t b)

sequenceA :: Applicative f => NE t (f a) -> f (NE t a)

mapM :: Monad m => (a -> m b) -> NE t a -> m (NE t b)

sequence :: Monad m => NE t (m a) -> m (NE t a)

(Eq a, Eq t) => Eq (NE t a)

Methods

(==) :: NE t a -> NE t a -> Bool

(/=) :: NE t a -> NE t a -> Bool

(Ord a, Ord t) => Ord (NE t a)

Methods

compare :: NE t a -> NE t a -> Ordering

(<) :: NE t a -> NE t a -> Bool

(<=) :: NE t a -> NE t a -> Bool

(>) :: NE t a -> NE t a -> Bool

(>=) :: NE t a -> NE t a -> Bool

max :: NE t a -> NE t a -> NE t a

min :: NE t a -> NE t a -> NE t a

(Show a, Show t) => Show (NE t a)

Methods

showsPrec :: Int -> NE t a -> ShowS

show :: NE t a -> String

showList :: [NE t a] -> ShowS

Generic (NE t a)

Associated Types

type Rep (NE t a) :: * -> *

Methods

from :: NE t a -> Rep (NE t a) x

to :: Rep (NE t a) x -> NE t a

(PrettyVal t, PrettyVal a) => PrettyVal (NE t a)

Methods

prettyVal :: NE t a -> Value

listValue :: [NE t a] -> Value

type Rep (NE t a)

type Rep (NE t a) = D1 (MetaData "NE" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "NE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (t, a)))))

newtype NW t a

Constructors

NW (NonEmpty (t, a))

Instances

Bifunctor NW

Methods

bimap :: (a -> b) -> (c -> d) -> NW a c -> NW b d

first :: (a -> b) -> NW a c -> NW b c

second :: (b -> c) -> NW a b -> NW a c

Functor (NW t)

Methods

fmap :: (a -> b) -> NW t a -> NW t b

(<$) :: a -> NW t b -> NW t a

Foldable (NW t)

Methods

fold :: Monoid m => NW t m -> m

foldMap :: Monoid m => (a -> m) -> NW t a -> m

foldr :: (a -> b -> b) -> b -> NW t a -> b

foldr' :: (a -> b -> b) -> b -> NW t a -> b

foldl :: (b -> a -> b) -> b -> NW t a -> b

foldl' :: (b -> a -> b) -> b -> NW t a -> b

foldr1 :: (a -> a -> a) -> NW t a -> a

foldl1 :: (a -> a -> a) -> NW t a -> a

toList :: NW t a -> [a]

null :: NW t a -> Bool

length :: NW t a -> Int

elem :: Eq a => a -> NW t a -> Bool

maximum :: Ord a => NW t a -> a

minimum :: Ord a => NW t a -> a

sum :: Num a => NW t a -> a

product :: Num a => NW t a -> a

Traversable (NW t)

Methods

traverse :: Applicative f => (a -> f b) -> NW t a -> f (NW t b)

sequenceA :: Applicative f => NW t (f a) -> f (NW t a)

mapM :: Monad m => (a -> m b) -> NW t a -> m (NW t b)

sequence :: Monad m => NW t (m a) -> m (NW t a)

(Eq a, Eq t) => Eq (NW t a)

Methods

(==) :: NW t a -> NW t a -> Bool

(/=) :: NW t a -> NW t a -> Bool

(Ord a, Ord t) => Ord (NW t a)

Methods

compare :: NW t a -> NW t a -> Ordering

(<) :: NW t a -> NW t a -> Bool

(<=) :: NW t a -> NW t a -> Bool

(>) :: NW t a -> NW t a -> Bool

(>=) :: NW t a -> NW t a -> Bool

max :: NW t a -> NW t a -> NW t a

min :: NW t a -> NW t a -> NW t a

(Show a, Show t) => Show (NW t a)

Methods

showsPrec :: Int -> NW t a -> ShowS

show :: NW t a -> String

showList :: [NW t a] -> ShowS

Generic (NW t a)

Associated Types

type Rep (NW t a) :: * -> *

Methods

from :: NW t a -> Rep (NW t a) x

to :: Rep (NW t a) x -> NW t a

(PrettyVal t, PrettyVal a) => PrettyVal (NW t a)

Methods

prettyVal :: NW t a -> Value

listValue :: [NW t a] -> Value

type Rep (NW t a)

type Rep (NW t a) = D1 (MetaData "NW" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "NW" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (t, a)))))

newtype SE t a

Constructors

SE (NonEmpty (t, a))

Instances

Bifunctor SE

Methods

bimap :: (a -> b) -> (c -> d) -> SE a c -> SE b d

first :: (a -> b) -> SE a c -> SE b c

second :: (b -> c) -> SE a b -> SE a c

Functor (SE t)

Methods

fmap :: (a -> b) -> SE t a -> SE t b

(<$) :: a -> SE t b -> SE t a

Foldable (SE t)

Methods

fold :: Monoid m => SE t m -> m

foldMap :: Monoid m => (a -> m) -> SE t a -> m

foldr :: (a -> b -> b) -> b -> SE t a -> b

foldr' :: (a -> b -> b) -> b -> SE t a -> b

foldl :: (b -> a -> b) -> b -> SE t a -> b

foldl' :: (b -> a -> b) -> b -> SE t a -> b

foldr1 :: (a -> a -> a) -> SE t a -> a

foldl1 :: (a -> a -> a) -> SE t a -> a

toList :: SE t a -> [a]

null :: SE t a -> Bool

length :: SE t a -> Int

elem :: Eq a => a -> SE t a -> Bool

maximum :: Ord a => SE t a -> a

minimum :: Ord a => SE t a -> a

sum :: Num a => SE t a -> a

product :: Num a => SE t a -> a

Traversable (SE t)

Methods

traverse :: Applicative f => (a -> f b) -> SE t a -> f (SE t b)

sequenceA :: Applicative f => SE t (f a) -> f (SE t a)

mapM :: Monad m => (a -> m b) -> SE t a -> m (SE t b)

sequence :: Monad m => SE t (m a) -> m (SE t a)

(Eq a, Eq t) => Eq (SE t a)

Methods

(==) :: SE t a -> SE t a -> Bool

(/=) :: SE t a -> SE t a -> Bool

(Ord a, Ord t) => Ord (SE t a)

Methods

compare :: SE t a -> SE t a -> Ordering

(<) :: SE t a -> SE t a -> Bool

(<=) :: SE t a -> SE t a -> Bool

(>) :: SE t a -> SE t a -> Bool

(>=) :: SE t a -> SE t a -> Bool

max :: SE t a -> SE t a -> SE t a

min :: SE t a -> SE t a -> SE t a

(Show a, Show t) => Show (SE t a)

Methods

showsPrec :: Int -> SE t a -> ShowS

show :: SE t a -> String

showList :: [SE t a] -> ShowS

Generic (SE t a)

Associated Types

type Rep (SE t a) :: * -> *

Methods

from :: SE t a -> Rep (SE t a) x

to :: Rep (SE t a) x -> SE t a

(PrettyVal t, PrettyVal a) => PrettyVal (SE t a)

Methods

prettyVal :: SE t a -> Value

listValue :: [SE t a] -> Value

type Rep (SE t a)

type Rep (SE t a) = D1 (MetaData "SE" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "SE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (t, a)))))

newtype SW t a

Constructors

SW (NonEmpty (t, a))

Instances

Bifunctor SW

Methods

bimap :: (a -> b) -> (c -> d) -> SW a c -> SW b d

first :: (a -> b) -> SW a c -> SW b c

second :: (b -> c) -> SW a b -> SW a c

Functor (SW t)

Methods

fmap :: (a -> b) -> SW t a -> SW t b

(<$) :: a -> SW t b -> SW t a

Foldable (SW t)

Methods

fold :: Monoid m => SW t m -> m

foldMap :: Monoid m => (a -> m) -> SW t a -> m

foldr :: (a -> b -> b) -> b -> SW t a -> b

foldr' :: (a -> b -> b) -> b -> SW t a -> b

foldl :: (b -> a -> b) -> b -> SW t a -> b

foldl' :: (b -> a -> b) -> b -> SW t a -> b

foldr1 :: (a -> a -> a) -> SW t a -> a

foldl1 :: (a -> a -> a) -> SW t a -> a

toList :: SW t a -> [a]

null :: SW t a -> Bool

length :: SW t a -> Int

elem :: Eq a => a -> SW t a -> Bool

maximum :: Ord a => SW t a -> a

minimum :: Ord a => SW t a -> a

sum :: Num a => SW t a -> a

product :: Num a => SW t a -> a

Traversable (SW t)

Methods

traverse :: Applicative f => (a -> f b) -> SW t a -> f (SW t b)

sequenceA :: Applicative f => SW t (f a) -> f (SW t a)

mapM :: Monad m => (a -> m b) -> SW t a -> m (SW t b)

sequence :: Monad m => SW t (m a) -> m (SW t a)

(Eq a, Eq t) => Eq (SW t a)

Methods

(==) :: SW t a -> SW t a -> Bool

(/=) :: SW t a -> SW t a -> Bool

(Ord a, Ord t) => Ord (SW t a)

Methods

compare :: SW t a -> SW t a -> Ordering

(<) :: SW t a -> SW t a -> Bool

(<=) :: SW t a -> SW t a -> Bool

(>) :: SW t a -> SW t a -> Bool

(>=) :: SW t a -> SW t a -> Bool

max :: SW t a -> SW t a -> SW t a

min :: SW t a -> SW t a -> SW t a

(Show a, Show t) => Show (SW t a)

Methods

showsPrec :: Int -> SW t a -> ShowS

show :: SW t a -> String

showList :: [SW t a] -> ShowS

Generic (SW t a)

Associated Types

type Rep (SW t a) :: * -> *

Methods

from :: SW t a -> Rep (SW t a) x

to :: Rep (SW t a) x -> SW t a

(PrettyVal t, PrettyVal a) => PrettyVal (SW t a)

Methods

prettyVal :: SW t a -> Value

listValue :: [SW t a] -> Value

type Rep (SW t a)

type Rep (SW t a) = D1 (MetaData "SW" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "SW" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (t, a)))))

data Direction t a

Constructors

Direction'North (North t a)

Direction'South (South t a)

Direction'East (East t a)

Direction'West (West t a)

Direction'NE (NE t a)

Direction'NW (NW t a)

Direction'SE (SE t a)

Direction'SW (SW t a)

Instances

Bifunctor Direction

Methods

bimap :: (a -> b) -> (c -> d) -> Direction a c -> Direction b d

first :: (a -> b) -> Direction a c -> Direction b c

second :: (b -> c) -> Direction a b -> Direction a c

Functor (Direction t)

Methods

fmap :: (a -> b) -> Direction t a -> Direction t b

(<$) :: a -> Direction t b -> Direction t a

Foldable (Direction t)

Methods

fold :: Monoid m => Direction t m -> m

foldMap :: Monoid m => (a -> m) -> Direction t a -> m

foldr :: (a -> b -> b) -> b -> Direction t a -> b

foldr' :: (a -> b -> b) -> b -> Direction t a -> b

foldl :: (b -> a -> b) -> b -> Direction t a -> b

foldl' :: (b -> a -> b) -> b -> Direction t a -> b

foldr1 :: (a -> a -> a) -> Direction t a -> a

foldl1 :: (a -> a -> a) -> Direction t a -> a

toList :: Direction t a -> [a]

null :: Direction t a -> Bool

length :: Direction t a -> Int

elem :: Eq a => a -> Direction t a -> Bool

maximum :: Ord a => Direction t a -> a

minimum :: Ord a => Direction t a -> a

sum :: Num a => Direction t a -> a

product :: Num a => Direction t a -> a

Traversable (Direction t)

Methods

traverse :: Applicative f => (a -> f b) -> Direction t a -> f (Direction t b)

sequenceA :: Applicative f => Direction t (f a) -> f (Direction t a)

mapM :: Monad m => (a -> m b) -> Direction t a -> m (Direction t b)

sequence :: Monad m => Direction t (m a) -> m (Direction t a)

(Eq t, Eq a) => Eq (Direction t a)

Methods

(==) :: Direction t a -> Direction t a -> Bool

(/=) :: Direction t a -> Direction t a -> Bool

(Ord t, Ord a) => Ord (Direction t a)

Methods

compare :: Direction t a -> Direction t a -> Ordering

(<) :: Direction t a -> Direction t a -> Bool

(<=) :: Direction t a -> Direction t a -> Bool

(>) :: Direction t a -> Direction t a -> Bool

(>=) :: Direction t a -> Direction t a -> Bool

max :: Direction t a -> Direction t a -> Direction t a

min :: Direction t a -> Direction t a -> Direction t a

(Show t, Show a) => Show (Direction t a)

Methods

showsPrec :: Int -> Direction t a -> ShowS

show :: Direction t a -> String

showList :: [Direction t a] -> ShowS

Generic (Direction t a)

Associated Types

type Rep (Direction t a) :: * -> *

Methods

from :: Direction t a -> Rep (Direction t a) x

to :: Rep (Direction t a) x -> Direction t a

(PrettyVal t, PrettyVal a) => PrettyVal (Direction t a)

Methods

prettyVal :: Direction t a -> Value

listValue :: [Direction t a] -> Value

type Rep (Direction t a)

type Rep (Direction t a) = D1 (MetaData "Direction" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" False) ((:+:) ((:+:) ((:+:) (C1 (MetaCons "Direction'North" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (North t a)))) (C1 (MetaCons "Direction'South" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (South t a))))) ((:+:) (C1 (MetaCons "Direction'East" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (East t a)))) (C1 (MetaCons "Direction'West" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (West t a)))))) ((:+:) ((:+:) (C1 (MetaCons "Direction'NE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NE t a)))) (C1 (MetaCons "Direction'NW" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NW t a))))) ((:+:) (C1 (MetaCons "Direction'SE" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (SE t a)))) (C1 (MetaCons "Direction'SW" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (SW t a)))))))

data DirectionSpace t a

Constructors

DirectionSpace

Fields

• _r'DirectionSpace'0'Direction :: (Direction t a)
• _r'DirectionSpace'1'Space :: (Space t a)

Instances

Bifunctor DirectionSpace

Methods

bimap :: (a -> b) -> (c -> d) -> DirectionSpace a c -> DirectionSpace b d

first :: (a -> b) -> DirectionSpace a c -> DirectionSpace b c

second :: (b -> c) -> DirectionSpace a b -> DirectionSpace a c

Functor (DirectionSpace t)

Methods

fmap :: (a -> b) -> DirectionSpace t a -> DirectionSpace t b

(<$) :: a -> DirectionSpace t b -> DirectionSpace t a

Foldable (DirectionSpace t)

Methods

fold :: Monoid m => DirectionSpace t m -> m

foldMap :: Monoid m => (a -> m) -> DirectionSpace t a -> m

foldr :: (a -> b -> b) -> b -> DirectionSpace t a -> b

foldr' :: (a -> b -> b) -> b -> DirectionSpace t a -> b

foldl :: (b -> a -> b) -> b -> DirectionSpace t a -> b

foldl' :: (b -> a -> b) -> b -> DirectionSpace t a -> b

foldr1 :: (a -> a -> a) -> DirectionSpace t a -> a

foldl1 :: (a -> a -> a) -> DirectionSpace t a -> a

toList :: DirectionSpace t a -> [a]

null :: DirectionSpace t a -> Bool

length :: DirectionSpace t a -> Int

elem :: Eq a => a -> DirectionSpace t a -> Bool

maximum :: Ord a => DirectionSpace t a -> a

minimum :: Ord a => DirectionSpace t a -> a

sum :: Num a => DirectionSpace t a -> a

product :: Num a => DirectionSpace t a -> a

Traversable (DirectionSpace t)

Methods

traverse :: Applicative f => (a -> f b) -> DirectionSpace t a -> f (DirectionSpace t b)

sequenceA :: Applicative f => DirectionSpace t (f a) -> f (DirectionSpace t a)

mapM :: Monad m => (a -> m b) -> DirectionSpace t a -> m (DirectionSpace t b)

sequence :: Monad m => DirectionSpace t (m a) -> m (DirectionSpace t a)

(Eq a, Eq t) => Eq (DirectionSpace t a)

Methods

(==) :: DirectionSpace t a -> DirectionSpace t a -> Bool

(/=) :: DirectionSpace t a -> DirectionSpace t a -> Bool

(Ord a, Ord t) => Ord (DirectionSpace t a)

Methods

compare :: DirectionSpace t a -> DirectionSpace t a -> Ordering

(<) :: DirectionSpace t a -> DirectionSpace t a -> Bool

(<=) :: DirectionSpace t a -> DirectionSpace t a -> Bool

(>) :: DirectionSpace t a -> DirectionSpace t a -> Bool

(>=) :: DirectionSpace t a -> DirectionSpace t a -> Bool

max :: DirectionSpace t a -> DirectionSpace t a -> DirectionSpace t a

min :: DirectionSpace t a -> DirectionSpace t a -> DirectionSpace t a

(Show a, Show t) => Show (DirectionSpace t a)

Methods

showsPrec :: Int -> DirectionSpace t a -> ShowS

show :: DirectionSpace t a -> String

showList :: [DirectionSpace t a] -> ShowS

Generic (DirectionSpace t a)

Associated Types

type Rep (DirectionSpace t a) :: * -> *

Methods

from :: DirectionSpace t a -> Rep (DirectionSpace t a) x

to :: Rep (DirectionSpace t a) x -> DirectionSpace t a

(PrettyVal t, PrettyVal a) => PrettyVal (DirectionSpace t a)

Methods

prettyVal :: DirectionSpace t a -> Value

listValue :: [DirectionSpace t a] -> Value

type Rep (DirectionSpace t a)

type Rep (DirectionSpace t a) = D1 (MetaData "DirectionSpace" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" False) (C1 (MetaCons "DirectionSpace" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_r'DirectionSpace'0'Direction") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Direction t a))) (S1 (MetaSel (Just Symbol "_r'DirectionSpace'1'Space") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Space t a)))))

newtype DirectionSpace'Opt t a

Constructors

DirectionSpace'Opt (Maybe (DirectionSpace t a))

Instances

Bifunctor DirectionSpace'Opt

Methods

bimap :: (a -> b) -> (c -> d) -> DirectionSpace'Opt a c -> DirectionSpace'Opt b d

first :: (a -> b) -> DirectionSpace'Opt a c -> DirectionSpace'Opt b c

second :: (b -> c) -> DirectionSpace'Opt a b -> DirectionSpace'Opt a c

Functor (DirectionSpace'Opt t)

Methods

fmap :: (a -> b) -> DirectionSpace'Opt t a -> DirectionSpace'Opt t b

(<$) :: a -> DirectionSpace'Opt t b -> DirectionSpace'Opt t a

Foldable (DirectionSpace'Opt t)

Methods

fold :: Monoid m => DirectionSpace'Opt t m -> m

foldMap :: Monoid m => (a -> m) -> DirectionSpace'Opt t a -> m

foldr :: (a -> b -> b) -> b -> DirectionSpace'Opt t a -> b

foldr' :: (a -> b -> b) -> b -> DirectionSpace'Opt t a -> b

foldl :: (b -> a -> b) -> b -> DirectionSpace'Opt t a -> b

foldl' :: (b -> a -> b) -> b -> DirectionSpace'Opt t a -> b

foldr1 :: (a -> a -> a) -> DirectionSpace'Opt t a -> a

foldl1 :: (a -> a -> a) -> DirectionSpace'Opt t a -> a

toList :: DirectionSpace'Opt t a -> [a]

null :: DirectionSpace'Opt t a -> Bool

length :: DirectionSpace'Opt t a -> Int

elem :: Eq a => a -> DirectionSpace'Opt t a -> Bool

maximum :: Ord a => DirectionSpace'Opt t a -> a

minimum :: Ord a => DirectionSpace'Opt t a -> a

sum :: Num a => DirectionSpace'Opt t a -> a

product :: Num a => DirectionSpace'Opt t a -> a

Traversable (DirectionSpace'Opt t)

Methods

traverse :: Applicative f => (a -> f b) -> DirectionSpace'Opt t a -> f (DirectionSpace'Opt t b)

sequenceA :: Applicative f => DirectionSpace'Opt t (f a) -> f (DirectionSpace'Opt t a)

mapM :: Monad m => (a -> m b) -> DirectionSpace'Opt t a -> m (DirectionSpace'Opt t b)

sequence :: Monad m => DirectionSpace'Opt t (m a) -> m (DirectionSpace'Opt t a)

(Eq t, Eq a) => Eq (DirectionSpace'Opt t a)

Methods

(==) :: DirectionSpace'Opt t a -> DirectionSpace'Opt t a -> Bool

(/=) :: DirectionSpace'Opt t a -> DirectionSpace'Opt t a -> Bool

(Ord t, Ord a) => Ord (DirectionSpace'Opt t a)

Methods

compare :: DirectionSpace'Opt t a -> DirectionSpace'Opt t a -> Ordering

(<) :: DirectionSpace'Opt t a -> DirectionSpace'Opt t a -> Bool

(<=) :: DirectionSpace'Opt t a -> DirectionSpace'Opt t a -> Bool

(>) :: DirectionSpace'Opt t a -> DirectionSpace'Opt t a -> Bool

(>=) :: DirectionSpace'Opt t a -> DirectionSpace'Opt t a -> Bool

max :: DirectionSpace'Opt t a -> DirectionSpace'Opt t a -> DirectionSpace'Opt t a

min :: DirectionSpace'Opt t a -> DirectionSpace'Opt t a -> DirectionSpace'Opt t a

(Show t, Show a) => Show (DirectionSpace'Opt t a)

Methods

showsPrec :: Int -> DirectionSpace'Opt t a -> ShowS

show :: DirectionSpace'Opt t a -> String

showList :: [DirectionSpace'Opt t a] -> ShowS

Generic (DirectionSpace'Opt t a)

Associated Types

type Rep (DirectionSpace'Opt t a) :: * -> *

Methods

from :: DirectionSpace'Opt t a -> Rep (DirectionSpace'Opt t a) x

to :: Rep (DirectionSpace'Opt t a) x -> DirectionSpace'Opt t a

Wrapped (DirectionSpace'Opt t a)

Associated Types

type Unwrapped (DirectionSpace'Opt t a) :: *

Methods

_Wrapped' :: Iso' (DirectionSpace'Opt t a) (Unwrapped (DirectionSpace'Opt t a))

(PrettyVal t, PrettyVal a) => PrettyVal (DirectionSpace'Opt t a)

Methods

prettyVal :: DirectionSpace'Opt t a -> Value

listValue :: [DirectionSpace'Opt t a] -> Value

type Rep (DirectionSpace'Opt t a)

type Rep (DirectionSpace'Opt t a) = D1 (MetaData "DirectionSpace'Opt" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "DirectionSpace'Opt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (DirectionSpace t a)))))

type Unwrapped (DirectionSpace'Opt t a)

type Unwrapped (DirectionSpace'Opt t a) = Maybe (DirectionSpace t a)

newtype StreetName t a

Constructors

StreetName (Words t a)

Instances

Bifunctor StreetName

Methods

bimap :: (a -> b) -> (c -> d) -> StreetName a c -> StreetName b d

first :: (a -> b) -> StreetName a c -> StreetName b c

second :: (b -> c) -> StreetName a b -> StreetName a c

Functor (StreetName t)

Methods

fmap :: (a -> b) -> StreetName t a -> StreetName t b

(<$) :: a -> StreetName t b -> StreetName t a

Foldable (StreetName t)

Methods

fold :: Monoid m => StreetName t m -> m

foldMap :: Monoid m => (a -> m) -> StreetName t a -> m

foldr :: (a -> b -> b) -> b -> StreetName t a -> b

foldr' :: (a -> b -> b) -> b -> StreetName t a -> b

foldl :: (b -> a -> b) -> b -> StreetName t a -> b

foldl' :: (b -> a -> b) -> b -> StreetName t a -> b

foldr1 :: (a -> a -> a) -> StreetName t a -> a

foldl1 :: (a -> a -> a) -> StreetName t a -> a

toList :: StreetName t a -> [a]

null :: StreetName t a -> Bool

length :: StreetName t a -> Int

elem :: Eq a => a -> StreetName t a -> Bool

maximum :: Ord a => StreetName t a -> a

minimum :: Ord a => StreetName t a -> a

sum :: Num a => StreetName t a -> a

product :: Num a => StreetName t a -> a

Traversable (StreetName t)

Methods

traverse :: Applicative f => (a -> f b) -> StreetName t a -> f (StreetName t b)

sequenceA :: Applicative f => StreetName t (f a) -> f (StreetName t a)

mapM :: Monad m => (a -> m b) -> StreetName t a -> m (StreetName t b)

sequence :: Monad m => StreetName t (m a) -> m (StreetName t a)

(Eq t, Eq a) => Eq (StreetName t a)

Methods

(==) :: StreetName t a -> StreetName t a -> Bool

(/=) :: StreetName t a -> StreetName t a -> Bool

(Ord t, Ord a) => Ord (StreetName t a)

Methods

compare :: StreetName t a -> StreetName t a -> Ordering

(<) :: StreetName t a -> StreetName t a -> Bool

(<=) :: StreetName t a -> StreetName t a -> Bool

(>) :: StreetName t a -> StreetName t a -> Bool

(>=) :: StreetName t a -> StreetName t a -> Bool

max :: StreetName t a -> StreetName t a -> StreetName t a

min :: StreetName t a -> StreetName t a -> StreetName t a

(Show t, Show a) => Show (StreetName t a)

Methods

showsPrec :: Int -> StreetName t a -> ShowS

show :: StreetName t a -> String

showList :: [StreetName t a] -> ShowS

Generic (StreetName t a)

Associated Types

type Rep (StreetName t a) :: * -> *

Methods

from :: StreetName t a -> Rep (StreetName t a) x

to :: Rep (StreetName t a) x -> StreetName t a

Wrapped (StreetName t a)

Associated Types

type Unwrapped (StreetName t a) :: *

Methods

_Wrapped' :: Iso' (StreetName t a) (Unwrapped (StreetName t a))

(PrettyVal t, PrettyVal a) => PrettyVal (StreetName t a)

Methods

prettyVal :: StreetName t a -> Value

listValue :: [StreetName t a] -> Value

type Rep (StreetName t a)

type Rep (StreetName t a) = D1 (MetaData "StreetName" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "StreetName" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Words t a))))

type Unwrapped (StreetName t a)

type Unwrapped (StreetName t a) = Words t a

newtype Street t a

Constructors

Street (NonEmpty (t, a))

Instances

Bifunctor Street

Methods

bimap :: (a -> b) -> (c -> d) -> Street a c -> Street b d

first :: (a -> b) -> Street a c -> Street b c

second :: (b -> c) -> Street a b -> Street a c

Functor (Street t)

Methods

fmap :: (a -> b) -> Street t a -> Street t b

(<$) :: a -> Street t b -> Street t a

Foldable (Street t)

Methods

fold :: Monoid m => Street t m -> m

foldMap :: Monoid m => (a -> m) -> Street t a -> m

foldr :: (a -> b -> b) -> b -> Street t a -> b

foldr' :: (a -> b -> b) -> b -> Street t a -> b

foldl :: (b -> a -> b) -> b -> Street t a -> b

foldl' :: (b -> a -> b) -> b -> Street t a -> b

foldr1 :: (a -> a -> a) -> Street t a -> a

foldl1 :: (a -> a -> a) -> Street t a -> a

toList :: Street t a -> [a]

null :: Street t a -> Bool

length :: Street t a -> Int

elem :: Eq a => a -> Street t a -> Bool

maximum :: Ord a => Street t a -> a

minimum :: Ord a => Street t a -> a

sum :: Num a => Street t a -> a

product :: Num a => Street t a -> a

Traversable (Street t)

Methods

traverse :: Applicative f => (a -> f b) -> Street t a -> f (Street t b)

sequenceA :: Applicative f => Street t (f a) -> f (Street t a)

mapM :: Monad m => (a -> m b) -> Street t a -> m (Street t b)

sequence :: Monad m => Street t (m a) -> m (Street t a)

(Eq a, Eq t) => Eq (Street t a)

Methods

(==) :: Street t a -> Street t a -> Bool

(/=) :: Street t a -> Street t a -> Bool

(Ord a, Ord t) => Ord (Street t a)

Methods

compare :: Street t a -> Street t a -> Ordering

(<) :: Street t a -> Street t a -> Bool

(<=) :: Street t a -> Street t a -> Bool

(>) :: Street t a -> Street t a -> Bool

(>=) :: Street t a -> Street t a -> Bool

max :: Street t a -> Street t a -> Street t a

min :: Street t a -> Street t a -> Street t a

(Show a, Show t) => Show (Street t a)

Methods

showsPrec :: Int -> Street t a -> ShowS

show :: Street t a -> String

showList :: [Street t a] -> ShowS

Generic (Street t a)

Associated Types

type Rep (Street t a) :: * -> *

Methods

from :: Street t a -> Rep (Street t a) x

to :: Rep (Street t a) x -> Street t a

(PrettyVal t, PrettyVal a) => PrettyVal (Street t a)

Methods

prettyVal :: Street t a -> Value

listValue :: [Street t a] -> Value

type Rep (Street t a)

type Rep (Street t a) = D1 (MetaData "Street" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "Street" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (t, a)))))

newtype Avenue t a

Constructors

Avenue (NonEmpty (t, a))

Instances

Bifunctor Avenue

Methods

bimap :: (a -> b) -> (c -> d) -> Avenue a c -> Avenue b d

first :: (a -> b) -> Avenue a c -> Avenue b c

second :: (b -> c) -> Avenue a b -> Avenue a c

Functor (Avenue t)

Methods

fmap :: (a -> b) -> Avenue t a -> Avenue t b

(<$) :: a -> Avenue t b -> Avenue t a

Foldable (Avenue t)

Methods

fold :: Monoid m => Avenue t m -> m

foldMap :: Monoid m => (a -> m) -> Avenue t a -> m

foldr :: (a -> b -> b) -> b -> Avenue t a -> b

foldr' :: (a -> b -> b) -> b -> Avenue t a -> b

foldl :: (b -> a -> b) -> b -> Avenue t a -> b

foldl' :: (b -> a -> b) -> b -> Avenue t a -> b

foldr1 :: (a -> a -> a) -> Avenue t a -> a

foldl1 :: (a -> a -> a) -> Avenue t a -> a

toList :: Avenue t a -> [a]

null :: Avenue t a -> Bool

length :: Avenue t a -> Int

elem :: Eq a => a -> Avenue t a -> Bool

maximum :: Ord a => Avenue t a -> a

minimum :: Ord a => Avenue t a -> a

sum :: Num a => Avenue t a -> a

product :: Num a => Avenue t a -> a

Traversable (Avenue t)

Methods

traverse :: Applicative f => (a -> f b) -> Avenue t a -> f (Avenue t b)

sequenceA :: Applicative f => Avenue t (f a) -> f (Avenue t a)

mapM :: Monad m => (a -> m b) -> Avenue t a -> m (Avenue t b)

sequence :: Monad m => Avenue t (m a) -> m (Avenue t a)

(Eq a, Eq t) => Eq (Avenue t a)

Methods

(==) :: Avenue t a -> Avenue t a -> Bool

(/=) :: Avenue t a -> Avenue t a -> Bool

(Ord a, Ord t) => Ord (Avenue t a)

Methods

compare :: Avenue t a -> Avenue t a -> Ordering

(<) :: Avenue t a -> Avenue t a -> Bool

(<=) :: Avenue t a -> Avenue t a -> Bool

(>) :: Avenue t a -> Avenue t a -> Bool

(>=) :: Avenue t a -> Avenue t a -> Bool

max :: Avenue t a -> Avenue t a -> Avenue t a

min :: Avenue t a -> Avenue t a -> Avenue t a

(Show a, Show t) => Show (Avenue t a)

Methods

showsPrec :: Int -> Avenue t a -> ShowS

show :: Avenue t a -> String

showList :: [Avenue t a] -> ShowS

Generic (Avenue t a)

Associated Types

type Rep (Avenue t a) :: * -> *

Methods

from :: Avenue t a -> Rep (Avenue t a) x

to :: Rep (Avenue t a) x -> Avenue t a

(PrettyVal t, PrettyVal a) => PrettyVal (Avenue t a)

Methods

prettyVal :: Avenue t a -> Value

listValue :: [Avenue t a] -> Value

type Rep (Avenue t a)

type Rep (Avenue t a) = D1 (MetaData "Avenue" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "Avenue" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (t, a)))))

newtype Way t a

Constructors

Way (NonEmpty (t, a))

Instances

Bifunctor Way

Methods

bimap :: (a -> b) -> (c -> d) -> Way a c -> Way b d

first :: (a -> b) -> Way a c -> Way b c

second :: (b -> c) -> Way a b -> Way a c

Functor (Way t)

Methods

fmap :: (a -> b) -> Way t a -> Way t b

(<$) :: a -> Way t b -> Way t a

Foldable (Way t)

Methods

fold :: Monoid m => Way t m -> m

foldMap :: Monoid m => (a -> m) -> Way t a -> m

foldr :: (a -> b -> b) -> b -> Way t a -> b

foldr' :: (a -> b -> b) -> b -> Way t a -> b

foldl :: (b -> a -> b) -> b -> Way t a -> b

foldl' :: (b -> a -> b) -> b -> Way t a -> b

foldr1 :: (a -> a -> a) -> Way t a -> a

foldl1 :: (a -> a -> a) -> Way t a -> a

toList :: Way t a -> [a]

null :: Way t a -> Bool

length :: Way t a -> Int

elem :: Eq a => a -> Way t a -> Bool

maximum :: Ord a => Way t a -> a

minimum :: Ord a => Way t a -> a

sum :: Num a => Way t a -> a

product :: Num a => Way t a -> a

Traversable (Way t)

Methods

traverse :: Applicative f => (a -> f b) -> Way t a -> f (Way t b)

sequenceA :: Applicative f => Way t (f a) -> f (Way t a)

mapM :: Monad m => (a -> m b) -> Way t a -> m (Way t b)

sequence :: Monad m => Way t (m a) -> m (Way t a)

(Eq a, Eq t) => Eq (Way t a)

Methods

(==) :: Way t a -> Way t a -> Bool

(/=) :: Way t a -> Way t a -> Bool

(Ord a, Ord t) => Ord (Way t a)

Methods

compare :: Way t a -> Way t a -> Ordering

(<) :: Way t a -> Way t a -> Bool

(<=) :: Way t a -> Way t a -> Bool

(>) :: Way t a -> Way t a -> Bool

(>=) :: Way t a -> Way t a -> Bool

max :: Way t a -> Way t a -> Way t a

min :: Way t a -> Way t a -> Way t a

(Show a, Show t) => Show (Way t a)

Methods

showsPrec :: Int -> Way t a -> ShowS

show :: Way t a -> String

showList :: [Way t a] -> ShowS

Generic (Way t a)

Associated Types

type Rep (Way t a) :: * -> *

Methods

from :: Way t a -> Rep (Way t a) x

to :: Rep (Way t a) x -> Way t a

(PrettyVal t, PrettyVal a) => PrettyVal (Way t a)

Methods

prettyVal :: Way t a -> Value

listValue :: [Way t a] -> Value

type Rep (Way t a)

type Rep (Way t a) = D1 (MetaData "Way" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "Way" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (t, a)))))

newtype Boulevard t a

Constructors

Boulevard (NonEmpty (t, a))

Instances

Bifunctor Boulevard

Methods

bimap :: (a -> b) -> (c -> d) -> Boulevard a c -> Boulevard b d

first :: (a -> b) -> Boulevard a c -> Boulevard b c

second :: (b -> c) -> Boulevard a b -> Boulevard a c

Functor (Boulevard t)

Methods

fmap :: (a -> b) -> Boulevard t a -> Boulevard t b

(<$) :: a -> Boulevard t b -> Boulevard t a

Foldable (Boulevard t)

Methods

fold :: Monoid m => Boulevard t m -> m

foldMap :: Monoid m => (a -> m) -> Boulevard t a -> m

foldr :: (a -> b -> b) -> b -> Boulevard t a -> b

foldr' :: (a -> b -> b) -> b -> Boulevard t a -> b

foldl :: (b -> a -> b) -> b -> Boulevard t a -> b

foldl' :: (b -> a -> b) -> b -> Boulevard t a -> b

foldr1 :: (a -> a -> a) -> Boulevard t a -> a

foldl1 :: (a -> a -> a) -> Boulevard t a -> a

toList :: Boulevard t a -> [a]

null :: Boulevard t a -> Bool

length :: Boulevard t a -> Int

elem :: Eq a => a -> Boulevard t a -> Bool

maximum :: Ord a => Boulevard t a -> a

minimum :: Ord a => Boulevard t a -> a

sum :: Num a => Boulevard t a -> a

product :: Num a => Boulevard t a -> a

Traversable (Boulevard t)

Methods

traverse :: Applicative f => (a -> f b) -> Boulevard t a -> f (Boulevard t b)

sequenceA :: Applicative f => Boulevard t (f a) -> f (Boulevard t a)

mapM :: Monad m => (a -> m b) -> Boulevard t a -> m (Boulevard t b)

sequence :: Monad m => Boulevard t (m a) -> m (Boulevard t a)

(Eq a, Eq t) => Eq (Boulevard t a)

Methods

(==) :: Boulevard t a -> Boulevard t a -> Bool

(/=) :: Boulevard t a -> Boulevard t a -> Bool

(Ord a, Ord t) => Ord (Boulevard t a)

Methods

compare :: Boulevard t a -> Boulevard t a -> Ordering

(<) :: Boulevard t a -> Boulevard t a -> Bool

(<=) :: Boulevard t a -> Boulevard t a -> Bool

(>) :: Boulevard t a -> Boulevard t a -> Bool

(>=) :: Boulevard t a -> Boulevard t a -> Bool

max :: Boulevard t a -> Boulevard t a -> Boulevard t a

min :: Boulevard t a -> Boulevard t a -> Boulevard t a

(Show a, Show t) => Show (Boulevard t a)

Methods

showsPrec :: Int -> Boulevard t a -> ShowS

show :: Boulevard t a -> String

showList :: [Boulevard t a] -> ShowS

Generic (Boulevard t a)

Associated Types

type Rep (Boulevard t a) :: * -> *

Methods

from :: Boulevard t a -> Rep (Boulevard t a) x

to :: Rep (Boulevard t a) x -> Boulevard t a

(PrettyVal t, PrettyVal a) => PrettyVal (Boulevard t a)

Methods

prettyVal :: Boulevard t a -> Value

listValue :: [Boulevard t a] -> Value

type Rep (Boulevard t a)

type Rep (Boulevard t a) = D1 (MetaData "Boulevard" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "Boulevard" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NonEmpty (t, a)))))

data Suffix t a

Constructors

Suffix'Street (Street t a)

Suffix'Avenue (Avenue t a)

Suffix'Way (Way t a)

Suffix'Boulevard (Boulevard t a)

Instances

Bifunctor Suffix

Methods

bimap :: (a -> b) -> (c -> d) -> Suffix a c -> Suffix b d

first :: (a -> b) -> Suffix a c -> Suffix b c

second :: (b -> c) -> Suffix a b -> Suffix a c

Functor (Suffix t)

Methods

fmap :: (a -> b) -> Suffix t a -> Suffix t b

(<$) :: a -> Suffix t b -> Suffix t a

Foldable (Suffix t)

Methods

fold :: Monoid m => Suffix t m -> m

foldMap :: Monoid m => (a -> m) -> Suffix t a -> m

foldr :: (a -> b -> b) -> b -> Suffix t a -> b

foldr' :: (a -> b -> b) -> b -> Suffix t a -> b

foldl :: (b -> a -> b) -> b -> Suffix t a -> b

foldl' :: (b -> a -> b) -> b -> Suffix t a -> b

foldr1 :: (a -> a -> a) -> Suffix t a -> a

foldl1 :: (a -> a -> a) -> Suffix t a -> a

toList :: Suffix t a -> [a]

null :: Suffix t a -> Bool

length :: Suffix t a -> Int

elem :: Eq a => a -> Suffix t a -> Bool

maximum :: Ord a => Suffix t a -> a

minimum :: Ord a => Suffix t a -> a

sum :: Num a => Suffix t a -> a

product :: Num a => Suffix t a -> a

Traversable (Suffix t)

Methods

traverse :: Applicative f => (a -> f b) -> Suffix t a -> f (Suffix t b)

sequenceA :: Applicative f => Suffix t (f a) -> f (Suffix t a)

mapM :: Monad m => (a -> m b) -> Suffix t a -> m (Suffix t b)

sequence :: Monad m => Suffix t (m a) -> m (Suffix t a)

(Eq t, Eq a) => Eq (Suffix t a)

Methods

(==) :: Suffix t a -> Suffix t a -> Bool

(/=) :: Suffix t a -> Suffix t a -> Bool

(Ord t, Ord a) => Ord (Suffix t a)

Methods

compare :: Suffix t a -> Suffix t a -> Ordering

(<) :: Suffix t a -> Suffix t a -> Bool

(<=) :: Suffix t a -> Suffix t a -> Bool

(>) :: Suffix t a -> Suffix t a -> Bool

(>=) :: Suffix t a -> Suffix t a -> Bool

max :: Suffix t a -> Suffix t a -> Suffix t a

min :: Suffix t a -> Suffix t a -> Suffix t a

(Show t, Show a) => Show (Suffix t a)

Methods

showsPrec :: Int -> Suffix t a -> ShowS

show :: Suffix t a -> String

showList :: [Suffix t a] -> ShowS

Generic (Suffix t a)

Associated Types

type Rep (Suffix t a) :: * -> *

Methods

from :: Suffix t a -> Rep (Suffix t a) x

to :: Rep (Suffix t a) x -> Suffix t a

(PrettyVal t, PrettyVal a) => PrettyVal (Suffix t a)

Methods

prettyVal :: Suffix t a -> Value

listValue :: [Suffix t a] -> Value

type Rep (Suffix t a)

type Rep (Suffix t a) = D1 (MetaData "Suffix" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" False) ((:+:) ((:+:) (C1 (MetaCons "Suffix'Street" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Street t a)))) (C1 (MetaCons "Suffix'Avenue" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Avenue t a))))) ((:+:) (C1 (MetaCons "Suffix'Way" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Way t a)))) (C1 (MetaCons "Suffix'Boulevard" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Boulevard t a))))))

data SpaceSuffix t a

Constructors

SpaceSuffix

Fields

• _r'SpaceSuffix'0'Space :: (Space t a)
• _r'SpaceSuffix'1'Suffix :: (Suffix t a)

Instances

Bifunctor SpaceSuffix

Methods

bimap :: (a -> b) -> (c -> d) -> SpaceSuffix a c -> SpaceSuffix b d

first :: (a -> b) -> SpaceSuffix a c -> SpaceSuffix b c

second :: (b -> c) -> SpaceSuffix a b -> SpaceSuffix a c

Functor (SpaceSuffix t)

Methods

fmap :: (a -> b) -> SpaceSuffix t a -> SpaceSuffix t b

(<$) :: a -> SpaceSuffix t b -> SpaceSuffix t a

Foldable (SpaceSuffix t)

Methods

fold :: Monoid m => SpaceSuffix t m -> m

foldMap :: Monoid m => (a -> m) -> SpaceSuffix t a -> m

foldr :: (a -> b -> b) -> b -> SpaceSuffix t a -> b

foldr' :: (a -> b -> b) -> b -> SpaceSuffix t a -> b

foldl :: (b -> a -> b) -> b -> SpaceSuffix t a -> b

foldl' :: (b -> a -> b) -> b -> SpaceSuffix t a -> b

foldr1 :: (a -> a -> a) -> SpaceSuffix t a -> a

foldl1 :: (a -> a -> a) -> SpaceSuffix t a -> a

toList :: SpaceSuffix t a -> [a]

null :: SpaceSuffix t a -> Bool

length :: SpaceSuffix t a -> Int

elem :: Eq a => a -> SpaceSuffix t a -> Bool

maximum :: Ord a => SpaceSuffix t a -> a

minimum :: Ord a => SpaceSuffix t a -> a

sum :: Num a => SpaceSuffix t a -> a

product :: Num a => SpaceSuffix t a -> a

Traversable (SpaceSuffix t)

Methods

traverse :: Applicative f => (a -> f b) -> SpaceSuffix t a -> f (SpaceSuffix t b)

sequenceA :: Applicative f => SpaceSuffix t (f a) -> f (SpaceSuffix t a)

mapM :: Monad m => (a -> m b) -> SpaceSuffix t a -> m (SpaceSuffix t b)

sequence :: Monad m => SpaceSuffix t (m a) -> m (SpaceSuffix t a)

(Eq t, Eq a) => Eq (SpaceSuffix t a)

Methods

(==) :: SpaceSuffix t a -> SpaceSuffix t a -> Bool

(/=) :: SpaceSuffix t a -> SpaceSuffix t a -> Bool

(Ord t, Ord a) => Ord (SpaceSuffix t a)

Methods

compare :: SpaceSuffix t a -> SpaceSuffix t a -> Ordering

(<) :: SpaceSuffix t a -> SpaceSuffix t a -> Bool

(<=) :: SpaceSuffix t a -> SpaceSuffix t a -> Bool

(>) :: SpaceSuffix t a -> SpaceSuffix t a -> Bool

(>=) :: SpaceSuffix t a -> SpaceSuffix t a -> Bool

max :: SpaceSuffix t a -> SpaceSuffix t a -> SpaceSuffix t a

min :: SpaceSuffix t a -> SpaceSuffix t a -> SpaceSuffix t a

(Show t, Show a) => Show (SpaceSuffix t a)

Methods

showsPrec :: Int -> SpaceSuffix t a -> ShowS

show :: SpaceSuffix t a -> String

showList :: [SpaceSuffix t a] -> ShowS

Generic (SpaceSuffix t a)

Associated Types

type Rep (SpaceSuffix t a) :: * -> *

Methods

from :: SpaceSuffix t a -> Rep (SpaceSuffix t a) x

to :: Rep (SpaceSuffix t a) x -> SpaceSuffix t a

(PrettyVal t, PrettyVal a) => PrettyVal (SpaceSuffix t a)

Methods

prettyVal :: SpaceSuffix t a -> Value

listValue :: [SpaceSuffix t a] -> Value

type Rep (SpaceSuffix t a)

type Rep (SpaceSuffix t a) = D1 (MetaData "SpaceSuffix" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" False) (C1 (MetaCons "SpaceSuffix" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_r'SpaceSuffix'0'Space") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Space t a))) (S1 (MetaSel (Just Symbol "_r'SpaceSuffix'1'Suffix") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Suffix t a)))))

newtype SpaceSuffix'Opt t a

Constructors

SpaceSuffix'Opt (Maybe (SpaceSuffix t a))

Instances

Bifunctor SpaceSuffix'Opt

Methods

bimap :: (a -> b) -> (c -> d) -> SpaceSuffix'Opt a c -> SpaceSuffix'Opt b d

first :: (a -> b) -> SpaceSuffix'Opt a c -> SpaceSuffix'Opt b c

second :: (b -> c) -> SpaceSuffix'Opt a b -> SpaceSuffix'Opt a c

Functor (SpaceSuffix'Opt t)

Methods

fmap :: (a -> b) -> SpaceSuffix'Opt t a -> SpaceSuffix'Opt t b

(<$) :: a -> SpaceSuffix'Opt t b -> SpaceSuffix'Opt t a

Foldable (SpaceSuffix'Opt t)

Methods

fold :: Monoid m => SpaceSuffix'Opt t m -> m

foldMap :: Monoid m => (a -> m) -> SpaceSuffix'Opt t a -> m

foldr :: (a -> b -> b) -> b -> SpaceSuffix'Opt t a -> b

foldr' :: (a -> b -> b) -> b -> SpaceSuffix'Opt t a -> b

foldl :: (b -> a -> b) -> b -> SpaceSuffix'Opt t a -> b

foldl' :: (b -> a -> b) -> b -> SpaceSuffix'Opt t a -> b

foldr1 :: (a -> a -> a) -> SpaceSuffix'Opt t a -> a

foldl1 :: (a -> a -> a) -> SpaceSuffix'Opt t a -> a

toList :: SpaceSuffix'Opt t a -> [a]

null :: SpaceSuffix'Opt t a -> Bool

length :: SpaceSuffix'Opt t a -> Int

elem :: Eq a => a -> SpaceSuffix'Opt t a -> Bool

maximum :: Ord a => SpaceSuffix'Opt t a -> a

minimum :: Ord a => SpaceSuffix'Opt t a -> a

sum :: Num a => SpaceSuffix'Opt t a -> a

product :: Num a => SpaceSuffix'Opt t a -> a

Traversable (SpaceSuffix'Opt t)

Methods

traverse :: Applicative f => (a -> f b) -> SpaceSuffix'Opt t a -> f (SpaceSuffix'Opt t b)

sequenceA :: Applicative f => SpaceSuffix'Opt t (f a) -> f (SpaceSuffix'Opt t a)

mapM :: Monad m => (a -> m b) -> SpaceSuffix'Opt t a -> m (SpaceSuffix'Opt t b)

sequence :: Monad m => SpaceSuffix'Opt t (m a) -> m (SpaceSuffix'Opt t a)

(Eq a, Eq t) => Eq (SpaceSuffix'Opt t a)

Methods

(==) :: SpaceSuffix'Opt t a -> SpaceSuffix'Opt t a -> Bool

(/=) :: SpaceSuffix'Opt t a -> SpaceSuffix'Opt t a -> Bool

(Ord a, Ord t) => Ord (SpaceSuffix'Opt t a)

Methods

compare :: SpaceSuffix'Opt t a -> SpaceSuffix'Opt t a -> Ordering

(<) :: SpaceSuffix'Opt t a -> SpaceSuffix'Opt t a -> Bool

(<=) :: SpaceSuffix'Opt t a -> SpaceSuffix'Opt t a -> Bool

(>) :: SpaceSuffix'Opt t a -> SpaceSuffix'Opt t a -> Bool

(>=) :: SpaceSuffix'Opt t a -> SpaceSuffix'Opt t a -> Bool

max :: SpaceSuffix'Opt t a -> SpaceSuffix'Opt t a -> SpaceSuffix'Opt t a

min :: SpaceSuffix'Opt t a -> SpaceSuffix'Opt t a -> SpaceSuffix'Opt t a

(Show a, Show t) => Show (SpaceSuffix'Opt t a)

Methods

showsPrec :: Int -> SpaceSuffix'Opt t a -> ShowS

show :: SpaceSuffix'Opt t a -> String

showList :: [SpaceSuffix'Opt t a] -> ShowS

Generic (SpaceSuffix'Opt t a)

Associated Types

type Rep (SpaceSuffix'Opt t a) :: * -> *

Methods

from :: SpaceSuffix'Opt t a -> Rep (SpaceSuffix'Opt t a) x

to :: Rep (SpaceSuffix'Opt t a) x -> SpaceSuffix'Opt t a

Wrapped (SpaceSuffix'Opt t a)

Associated Types

type Unwrapped (SpaceSuffix'Opt t a) :: *

Methods

_Wrapped' :: Iso' (SpaceSuffix'Opt t a) (Unwrapped (SpaceSuffix'Opt t a))

(PrettyVal t, PrettyVal a) => PrettyVal (SpaceSuffix'Opt t a)

Methods

prettyVal :: SpaceSuffix'Opt t a -> Value

listValue :: [SpaceSuffix'Opt t a] -> Value

type Rep (SpaceSuffix'Opt t a)

type Rep (SpaceSuffix'Opt t a) = D1 (MetaData "SpaceSuffix'Opt" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "SpaceSuffix'Opt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (SpaceSuffix t a)))))

type Unwrapped (SpaceSuffix'Opt t a)

type Unwrapped (SpaceSuffix'Opt t a) = Maybe (SpaceSuffix t a)

data StreetLine t a

Constructors

StreetLine

Fields

• _r'StreetLine'0'Number :: (Number t a)
• _r'StreetLine'1'Space :: (Space t a)
• _r'StreetLine'2'DirectionSpace'Opt :: (DirectionSpace'Opt t a)
• _r'StreetLine'3'StreetName :: (StreetName t a)
• _r'StreetLine'4'SpaceSuffix'Opt :: (SpaceSuffix'Opt t a)
• _r'StreetLine'5'Separator :: (Separator t a)

Instances

Bifunctor StreetLine

Methods

bimap :: (a -> b) -> (c -> d) -> StreetLine a c -> StreetLine b d

first :: (a -> b) -> StreetLine a c -> StreetLine b c

second :: (b -> c) -> StreetLine a b -> StreetLine a c

Functor (StreetLine t)

Methods

fmap :: (a -> b) -> StreetLine t a -> StreetLine t b

(<$) :: a -> StreetLine t b -> StreetLine t a

Foldable (StreetLine t)

Methods

fold :: Monoid m => StreetLine t m -> m

foldMap :: Monoid m => (a -> m) -> StreetLine t a -> m

foldr :: (a -> b -> b) -> b -> StreetLine t a -> b

foldr' :: (a -> b -> b) -> b -> StreetLine t a -> b

foldl :: (b -> a -> b) -> b -> StreetLine t a -> b

foldl' :: (b -> a -> b) -> b -> StreetLine t a -> b

foldr1 :: (a -> a -> a) -> StreetLine t a -> a

foldl1 :: (a -> a -> a) -> StreetLine t a -> a

toList :: StreetLine t a -> [a]

null :: StreetLine t a -> Bool

length :: StreetLine t a -> Int

elem :: Eq a => a -> StreetLine t a -> Bool

maximum :: Ord a => StreetLine t a -> a

minimum :: Ord a => StreetLine t a -> a

sum :: Num a => StreetLine t a -> a

product :: Num a => StreetLine t a -> a

Traversable (StreetLine t)

Methods

traverse :: Applicative f => (a -> f b) -> StreetLine t a -> f (StreetLine t b)

sequenceA :: Applicative f => StreetLine t (f a) -> f (StreetLine t a)

mapM :: Monad m => (a -> m b) -> StreetLine t a -> m (StreetLine t b)

sequence :: Monad m => StreetLine t (m a) -> m (StreetLine t a)

(Eq t, Eq a) => Eq (StreetLine t a)

Methods

(==) :: StreetLine t a -> StreetLine t a -> Bool

(/=) :: StreetLine t a -> StreetLine t a -> Bool

(Ord t, Ord a) => Ord (StreetLine t a)

Methods

compare :: StreetLine t a -> StreetLine t a -> Ordering

(<) :: StreetLine t a -> StreetLine t a -> Bool

(<=) :: StreetLine t a -> StreetLine t a -> Bool

(>) :: StreetLine t a -> StreetLine t a -> Bool

(>=) :: StreetLine t a -> StreetLine t a -> Bool

max :: StreetLine t a -> StreetLine t a -> StreetLine t a

min :: StreetLine t a -> StreetLine t a -> StreetLine t a

(Show t, Show a) => Show (StreetLine t a)

Methods

showsPrec :: Int -> StreetLine t a -> ShowS

show :: StreetLine t a -> String

showList :: [StreetLine t a] -> ShowS

Generic (StreetLine t a)

Associated Types

type Rep (StreetLine t a) :: * -> *

Methods

from :: StreetLine t a -> Rep (StreetLine t a) x

to :: Rep (StreetLine t a) x -> StreetLine t a

(PrettyVal t, PrettyVal a) => PrettyVal (StreetLine t a)

Methods

prettyVal :: StreetLine t a -> Value

listValue :: [StreetLine t a] -> Value

type Rep (StreetLine t a)

type Rep (StreetLine t a) = D1 (MetaData "StreetLine" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" False) (C1 (MetaCons "StreetLine" PrefixI True) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "_r'StreetLine'0'Number") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Number t a))) ((:*:) (S1 (MetaSel (Just Symbol "_r'StreetLine'1'Space") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Space t a))) (S1 (MetaSel (Just Symbol "_r'StreetLine'2'DirectionSpace'Opt") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (DirectionSpace'Opt t a))))) ((:*:) (S1 (MetaSel (Just Symbol "_r'StreetLine'3'StreetName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (StreetName t a))) ((:*:) (S1 (MetaSel (Just Symbol "_r'StreetLine'4'SpaceSuffix'Opt") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (SpaceSuffix'Opt t a))) (S1 (MetaSel (Just Symbol "_r'StreetLine'5'Separator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Separator t a)))))))

newtype City t a

Constructors

City (Words t a)

Instances

Bifunctor City

Methods

bimap :: (a -> b) -> (c -> d) -> City a c -> City b d

first :: (a -> b) -> City a c -> City b c

second :: (b -> c) -> City a b -> City a c

Functor (City t)

Methods

fmap :: (a -> b) -> City t a -> City t b

(<$) :: a -> City t b -> City t a

Foldable (City t)

Methods

fold :: Monoid m => City t m -> m

foldMap :: Monoid m => (a -> m) -> City t a -> m

foldr :: (a -> b -> b) -> b -> City t a -> b

foldr' :: (a -> b -> b) -> b -> City t a -> b

foldl :: (b -> a -> b) -> b -> City t a -> b

foldl' :: (b -> a -> b) -> b -> City t a -> b

foldr1 :: (a -> a -> a) -> City t a -> a

foldl1 :: (a -> a -> a) -> City t a -> a

toList :: City t a -> [a]

null :: City t a -> Bool

length :: City t a -> Int

elem :: Eq a => a -> City t a -> Bool

maximum :: Ord a => City t a -> a

minimum :: Ord a => City t a -> a

sum :: Num a => City t a -> a

product :: Num a => City t a -> a

Traversable (City t)

Methods

traverse :: Applicative f => (a -> f b) -> City t a -> f (City t b)

sequenceA :: Applicative f => City t (f a) -> f (City t a)

mapM :: Monad m => (a -> m b) -> City t a -> m (City t b)

sequence :: Monad m => City t (m a) -> m (City t a)

(Eq t, Eq a) => Eq (City t a)

Methods

(==) :: City t a -> City t a -> Bool

(/=) :: City t a -> City t a -> Bool

(Ord t, Ord a) => Ord (City t a)

Methods

compare :: City t a -> City t a -> Ordering

(<) :: City t a -> City t a -> Bool

(<=) :: City t a -> City t a -> Bool

(>) :: City t a -> City t a -> Bool

(>=) :: City t a -> City t a -> Bool

max :: City t a -> City t a -> City t a

min :: City t a -> City t a -> City t a

(Show t, Show a) => Show (City t a)

Methods

showsPrec :: Int -> City t a -> ShowS

show :: City t a -> String

showList :: [City t a] -> ShowS

Generic (City t a)

Associated Types

type Rep (City t a) :: * -> *

Methods

from :: City t a -> Rep (City t a) x

to :: Rep (City t a) x -> City t a

Wrapped (City t a)

Associated Types

type Unwrapped (City t a) :: *

Methods

_Wrapped' :: Iso' (City t a) (Unwrapped (City t a))

(PrettyVal t, PrettyVal a) => PrettyVal (City t a)

Methods

prettyVal :: City t a -> Value

listValue :: [City t a] -> Value

type Rep (City t a)

type Rep (City t a) = D1 (MetaData "City" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "City" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Words t a))))

type Unwrapped (City t a)

type Unwrapped (City t a) = Words t a

newtype State t a

Constructors

State (Words t a)

Instances

Bifunctor State

Methods

bimap :: (a -> b) -> (c -> d) -> State a c -> State b d

first :: (a -> b) -> State a c -> State b c

second :: (b -> c) -> State a b -> State a c

Functor (State t)

Methods

fmap :: (a -> b) -> State t a -> State t b

(<$) :: a -> State t b -> State t a

Foldable (State t)

Methods

fold :: Monoid m => State t m -> m

foldMap :: Monoid m => (a -> m) -> State t a -> m

foldr :: (a -> b -> b) -> b -> State t a -> b

foldr' :: (a -> b -> b) -> b -> State t a -> b

foldl :: (b -> a -> b) -> b -> State t a -> b

foldl' :: (b -> a -> b) -> b -> State t a -> b

foldr1 :: (a -> a -> a) -> State t a -> a

foldl1 :: (a -> a -> a) -> State t a -> a

toList :: State t a -> [a]

null :: State t a -> Bool

length :: State t a -> Int

elem :: Eq a => a -> State t a -> Bool

maximum :: Ord a => State t a -> a

minimum :: Ord a => State t a -> a

sum :: Num a => State t a -> a

product :: Num a => State t a -> a

Traversable (State t)

Methods

traverse :: Applicative f => (a -> f b) -> State t a -> f (State t b)

sequenceA :: Applicative f => State t (f a) -> f (State t a)

mapM :: Monad m => (a -> m b) -> State t a -> m (State t b)

sequence :: Monad m => State t (m a) -> m (State t a)

(Eq t, Eq a) => Eq (State t a)

Methods

(==) :: State t a -> State t a -> Bool

(/=) :: State t a -> State t a -> Bool

(Ord t, Ord a) => Ord (State t a)

Methods

compare :: State t a -> State t a -> Ordering

(<) :: State t a -> State t a -> Bool

(<=) :: State t a -> State t a -> Bool

(>) :: State t a -> State t a -> Bool

(>=) :: State t a -> State t a -> Bool

max :: State t a -> State t a -> State t a

min :: State t a -> State t a -> State t a

(Show t, Show a) => Show (State t a)

Methods

showsPrec :: Int -> State t a -> ShowS

show :: State t a -> String

showList :: [State t a] -> ShowS

Generic (State t a)

Associated Types

type Rep (State t a) :: * -> *

Methods

from :: State t a -> Rep (State t a) x

to :: Rep (State t a) x -> State t a

Wrapped (State t a)

Associated Types

type Unwrapped (State t a) :: *

Methods

_Wrapped' :: Iso' (State t a) (Unwrapped (State t a))

(PrettyVal t, PrettyVal a) => PrettyVal (State t a)

Methods

prettyVal :: State t a -> Value

listValue :: [State t a] -> Value

type Rep (State t a)

type Rep (State t a) = D1 (MetaData "State" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "State" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Words t a))))

type Unwrapped (State t a)

type Unwrapped (State t a) = Words t a

data ZipCode t a

Constructors

ZipCode

Fields

• _r'ZipCode'0'Digit :: (Digit t a)
• _r'ZipCode'1'Digit :: (Digit t a)
• _r'ZipCode'2'Digit :: (Digit t a)
• _r'ZipCode'3'Digit :: (Digit t a)
• _r'ZipCode'4'Digit :: (Digit t a)

Instances

Bifunctor ZipCode

Methods

bimap :: (a -> b) -> (c -> d) -> ZipCode a c -> ZipCode b d

first :: (a -> b) -> ZipCode a c -> ZipCode b c

second :: (b -> c) -> ZipCode a b -> ZipCode a c

Functor (ZipCode t)

Methods

fmap :: (a -> b) -> ZipCode t a -> ZipCode t b

(<$) :: a -> ZipCode t b -> ZipCode t a

Foldable (ZipCode t)

Methods

fold :: Monoid m => ZipCode t m -> m

foldMap :: Monoid m => (a -> m) -> ZipCode t a -> m

foldr :: (a -> b -> b) -> b -> ZipCode t a -> b

foldr' :: (a -> b -> b) -> b -> ZipCode t a -> b

foldl :: (b -> a -> b) -> b -> ZipCode t a -> b

foldl' :: (b -> a -> b) -> b -> ZipCode t a -> b

foldr1 :: (a -> a -> a) -> ZipCode t a -> a

foldl1 :: (a -> a -> a) -> ZipCode t a -> a

toList :: ZipCode t a -> [a]

null :: ZipCode t a -> Bool

length :: ZipCode t a -> Int

elem :: Eq a => a -> ZipCode t a -> Bool

maximum :: Ord a => ZipCode t a -> a

minimum :: Ord a => ZipCode t a -> a

sum :: Num a => ZipCode t a -> a

product :: Num a => ZipCode t a -> a

Traversable (ZipCode t)

Methods

traverse :: Applicative f => (a -> f b) -> ZipCode t a -> f (ZipCode t b)

sequenceA :: Applicative f => ZipCode t (f a) -> f (ZipCode t a)

mapM :: Monad m => (a -> m b) -> ZipCode t a -> m (ZipCode t b)

sequence :: Monad m => ZipCode t (m a) -> m (ZipCode t a)

(Eq t, Eq a) => Eq (ZipCode t a)

Methods

(==) :: ZipCode t a -> ZipCode t a -> Bool

(/=) :: ZipCode t a -> ZipCode t a -> Bool

(Ord t, Ord a) => Ord (ZipCode t a)

Methods

compare :: ZipCode t a -> ZipCode t a -> Ordering

(<) :: ZipCode t a -> ZipCode t a -> Bool

(<=) :: ZipCode t a -> ZipCode t a -> Bool

(>) :: ZipCode t a -> ZipCode t a -> Bool

(>=) :: ZipCode t a -> ZipCode t a -> Bool

max :: ZipCode t a -> ZipCode t a -> ZipCode t a

min :: ZipCode t a -> ZipCode t a -> ZipCode t a

(Show t, Show a) => Show (ZipCode t a)

Methods

showsPrec :: Int -> ZipCode t a -> ShowS

show :: ZipCode t a -> String

showList :: [ZipCode t a] -> ShowS

Generic (ZipCode t a)

Associated Types

type Rep (ZipCode t a) :: * -> *

Methods

from :: ZipCode t a -> Rep (ZipCode t a) x

to :: Rep (ZipCode t a) x -> ZipCode t a

(PrettyVal t, PrettyVal a) => PrettyVal (ZipCode t a)

Methods

prettyVal :: ZipCode t a -> Value

listValue :: [ZipCode t a] -> Value

type Rep (ZipCode t a)

type Rep (ZipCode t a) = D1 (MetaData "ZipCode" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" False) (C1 (MetaCons "ZipCode" PrefixI True) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "_r'ZipCode'0'Digit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Digit t a))) (S1 (MetaSel (Just Symbol "_r'ZipCode'1'Digit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Digit t a)))) ((:*:) (S1 (MetaSel (Just Symbol "_r'ZipCode'2'Digit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Digit t a))) ((:*:) (S1 (MetaSel (Just Symbol "_r'ZipCode'3'Digit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Digit t a))) (S1 (MetaSel (Just Symbol "_r'ZipCode'4'Digit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Digit t a)))))))

newtype Newline'Opt t a

Constructors

Newline'Opt (Maybe (Newline t a))

Instances

Bifunctor Newline'Opt

Methods

bimap :: (a -> b) -> (c -> d) -> Newline'Opt a c -> Newline'Opt b d

first :: (a -> b) -> Newline'Opt a c -> Newline'Opt b c

second :: (b -> c) -> Newline'Opt a b -> Newline'Opt a c

Functor (Newline'Opt t)

Methods

fmap :: (a -> b) -> Newline'Opt t a -> Newline'Opt t b

(<$) :: a -> Newline'Opt t b -> Newline'Opt t a

Foldable (Newline'Opt t)

Methods

fold :: Monoid m => Newline'Opt t m -> m

foldMap :: Monoid m => (a -> m) -> Newline'Opt t a -> m

foldr :: (a -> b -> b) -> b -> Newline'Opt t a -> b

foldr' :: (a -> b -> b) -> b -> Newline'Opt t a -> b

foldl :: (b -> a -> b) -> b -> Newline'Opt t a -> b

foldl' :: (b -> a -> b) -> b -> Newline'Opt t a -> b

foldr1 :: (a -> a -> a) -> Newline'Opt t a -> a

foldl1 :: (a -> a -> a) -> Newline'Opt t a -> a

toList :: Newline'Opt t a -> [a]

null :: Newline'Opt t a -> Bool

length :: Newline'Opt t a -> Int

elem :: Eq a => a -> Newline'Opt t a -> Bool

maximum :: Ord a => Newline'Opt t a -> a

minimum :: Ord a => Newline'Opt t a -> a

sum :: Num a => Newline'Opt t a -> a

product :: Num a => Newline'Opt t a -> a

Traversable (Newline'Opt t)

Methods

traverse :: Applicative f => (a -> f b) -> Newline'Opt t a -> f (Newline'Opt t b)

sequenceA :: Applicative f => Newline'Opt t (f a) -> f (Newline'Opt t a)

mapM :: Monad m => (a -> m b) -> Newline'Opt t a -> m (Newline'Opt t b)

sequence :: Monad m => Newline'Opt t (m a) -> m (Newline'Opt t a)

(Eq t, Eq a) => Eq (Newline'Opt t a)

Methods

(==) :: Newline'Opt t a -> Newline'Opt t a -> Bool

(/=) :: Newline'Opt t a -> Newline'Opt t a -> Bool

(Ord t, Ord a) => Ord (Newline'Opt t a)

Methods

compare :: Newline'Opt t a -> Newline'Opt t a -> Ordering

(<) :: Newline'Opt t a -> Newline'Opt t a -> Bool

(<=) :: Newline'Opt t a -> Newline'Opt t a -> Bool

(>) :: Newline'Opt t a -> Newline'Opt t a -> Bool

(>=) :: Newline'Opt t a -> Newline'Opt t a -> Bool

max :: Newline'Opt t a -> Newline'Opt t a -> Newline'Opt t a

min :: Newline'Opt t a -> Newline'Opt t a -> Newline'Opt t a

(Show t, Show a) => Show (Newline'Opt t a)

Methods

showsPrec :: Int -> Newline'Opt t a -> ShowS

show :: Newline'Opt t a -> String

showList :: [Newline'Opt t a] -> ShowS

Generic (Newline'Opt t a)

Associated Types

type Rep (Newline'Opt t a) :: * -> *

Methods

from :: Newline'Opt t a -> Rep (Newline'Opt t a) x

to :: Rep (Newline'Opt t a) x -> Newline'Opt t a

Wrapped (Newline'Opt t a)

Associated Types

type Unwrapped (Newline'Opt t a) :: *

Methods

_Wrapped' :: Iso' (Newline'Opt t a) (Unwrapped (Newline'Opt t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Newline'Opt t a)

Methods

prettyVal :: Newline'Opt t a -> Value

listValue :: [Newline'Opt t a] -> Value

type Rep (Newline'Opt t a)

type Rep (Newline'Opt t a) = D1 (MetaData "Newline'Opt" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" True) (C1 (MetaCons "Newline'Opt" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (Newline t a)))))

type Unwrapped (Newline'Opt t a)

type Unwrapped (Newline'Opt t a) = Maybe (Newline t a)

data CityLine t a

Constructors

CityLine

Fields

• _r'CityLine'0'City :: (City t a)
• _r'CityLine'1'Comma :: (Comma t a)
• _r'CityLine'2'Space :: (Space t a)
• _r'CityLine'3'State :: (State t a)
• _r'CityLine'4'Space :: (Space t a)
• _r'CityLine'5'ZipCode :: (ZipCode t a)
• _r'CityLine'6'Newline'Opt :: (Newline'Opt t a)

Instances

Bifunctor CityLine

Methods

bimap :: (a -> b) -> (c -> d) -> CityLine a c -> CityLine b d

first :: (a -> b) -> CityLine a c -> CityLine b c

second :: (b -> c) -> CityLine a b -> CityLine a c

Functor (CityLine t)

Methods

fmap :: (a -> b) -> CityLine t a -> CityLine t b

(<$) :: a -> CityLine t b -> CityLine t a

Foldable (CityLine t)

Methods

fold :: Monoid m => CityLine t m -> m

foldMap :: Monoid m => (a -> m) -> CityLine t a -> m

foldr :: (a -> b -> b) -> b -> CityLine t a -> b

foldr' :: (a -> b -> b) -> b -> CityLine t a -> b

foldl :: (b -> a -> b) -> b -> CityLine t a -> b

foldl' :: (b -> a -> b) -> b -> CityLine t a -> b

foldr1 :: (a -> a -> a) -> CityLine t a -> a

foldl1 :: (a -> a -> a) -> CityLine t a -> a

toList :: CityLine t a -> [a]

null :: CityLine t a -> Bool

length :: CityLine t a -> Int

elem :: Eq a => a -> CityLine t a -> Bool

maximum :: Ord a => CityLine t a -> a

minimum :: Ord a => CityLine t a -> a

sum :: Num a => CityLine t a -> a

product :: Num a => CityLine t a -> a

Traversable (CityLine t)

Methods

traverse :: Applicative f => (a -> f b) -> CityLine t a -> f (CityLine t b)

sequenceA :: Applicative f => CityLine t (f a) -> f (CityLine t a)

mapM :: Monad m => (a -> m b) -> CityLine t a -> m (CityLine t b)

sequence :: Monad m => CityLine t (m a) -> m (CityLine t a)

(Eq t, Eq a) => Eq (CityLine t a)

Methods

(==) :: CityLine t a -> CityLine t a -> Bool

(/=) :: CityLine t a -> CityLine t a -> Bool

(Ord t, Ord a) => Ord (CityLine t a)

Methods

compare :: CityLine t a -> CityLine t a -> Ordering

(<) :: CityLine t a -> CityLine t a -> Bool

(<=) :: CityLine t a -> CityLine t a -> Bool

(>) :: CityLine t a -> CityLine t a -> Bool

(>=) :: CityLine t a -> CityLine t a -> Bool

max :: CityLine t a -> CityLine t a -> CityLine t a

min :: CityLine t a -> CityLine t a -> CityLine t a

(Show t, Show a) => Show (CityLine t a)

Methods

showsPrec :: Int -> CityLine t a -> ShowS

show :: CityLine t a -> String

showList :: [CityLine t a] -> ShowS

Generic (CityLine t a)

Associated Types

type Rep (CityLine t a) :: * -> *

Methods

from :: CityLine t a -> Rep (CityLine t a) x

to :: Rep (CityLine t a) x -> CityLine t a

(PrettyVal t, PrettyVal a) => PrettyVal (CityLine t a)

Methods

prettyVal :: CityLine t a -> Value

listValue :: [CityLine t a] -> Value

type Rep (CityLine t a)

type Rep (CityLine t a) = D1 (MetaData "CityLine" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" False) (C1 (MetaCons "CityLine" PrefixI True) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "_r'CityLine'0'City") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (City t a))) ((:*:) (S1 (MetaSel (Just Symbol "_r'CityLine'1'Comma") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Comma t a))) (S1 (MetaSel (Just Symbol "_r'CityLine'2'Space") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Space t a))))) ((:*:) ((:*:) (S1 (MetaSel (Just Symbol "_r'CityLine'3'State") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (State t a))) (S1 (MetaSel (Just Symbol "_r'CityLine'4'Space") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Space t a)))) ((:*:) (S1 (MetaSel (Just Symbol "_r'CityLine'5'ZipCode") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ZipCode t a))) (S1 (MetaSel (Just Symbol "_r'CityLine'6'Newline'Opt") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Newline'Opt t a)))))))

data Address t a

Constructors

Address

Fields

• _r'Address'0'NameLine :: (NameLine t a)
• _r'Address'1'StreetLine :: (StreetLine t a)
• _r'Address'2'CityLine :: (CityLine t a)

Instances

Bifunctor Address

Methods

bimap :: (a -> b) -> (c -> d) -> Address a c -> Address b d

first :: (a -> b) -> Address a c -> Address b c

second :: (b -> c) -> Address a b -> Address a c

Functor (Address t)

Methods

fmap :: (a -> b) -> Address t a -> Address t b

(<$) :: a -> Address t b -> Address t a

Foldable (Address t)

Methods

fold :: Monoid m => Address t m -> m

foldMap :: Monoid m => (a -> m) -> Address t a -> m

foldr :: (a -> b -> b) -> b -> Address t a -> b

foldr' :: (a -> b -> b) -> b -> Address t a -> b

foldl :: (b -> a -> b) -> b -> Address t a -> b

foldl' :: (b -> a -> b) -> b -> Address t a -> b

foldr1 :: (a -> a -> a) -> Address t a -> a

foldl1 :: (a -> a -> a) -> Address t a -> a

toList :: Address t a -> [a]

null :: Address t a -> Bool

length :: Address t a -> Int

elem :: Eq a => a -> Address t a -> Bool

maximum :: Ord a => Address t a -> a

minimum :: Ord a => Address t a -> a

sum :: Num a => Address t a -> a

product :: Num a => Address t a -> a

Traversable (Address t)

Methods

traverse :: Applicative f => (a -> f b) -> Address t a -> f (Address t b)

sequenceA :: Applicative f => Address t (f a) -> f (Address t a)

mapM :: Monad m => (a -> m b) -> Address t a -> m (Address t b)

sequence :: Monad m => Address t (m a) -> m (Address t a)

(Eq t, Eq a) => Eq (Address t a)

Methods

(==) :: Address t a -> Address t a -> Bool

(/=) :: Address t a -> Address t a -> Bool

(Ord t, Ord a) => Ord (Address t a)

Methods

compare :: Address t a -> Address t a -> Ordering

(<) :: Address t a -> Address t a -> Bool

(<=) :: Address t a -> Address t a -> Bool

(>) :: Address t a -> Address t a -> Bool

(>=) :: Address t a -> Address t a -> Bool

max :: Address t a -> Address t a -> Address t a

min :: Address t a -> Address t a -> Address t a

(Show t, Show a) => Show (Address t a)

Methods

showsPrec :: Int -> Address t a -> ShowS

show :: Address t a -> String

showList :: [Address t a] -> ShowS

Generic (Address t a)

Associated Types

type Rep (Address t a) :: * -> *

Methods

from :: Address t a -> Rep (Address t a) x

to :: Rep (Address t a) x -> Address t a

(PrettyVal t, PrettyVal a) => PrettyVal (Address t a)

Methods

prettyVal :: Address t a -> Value

listValue :: [Address t a] -> Value

type Rep (Address t a)

type Rep (Address t a) = D1 (MetaData "Address" "Pinchot.Examples.SyntaxTrees" "pinchot-0.24.0.0-FNVmzC3fiVb8ilWRaT4srD" False) (C1 (MetaCons "Address" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "_r'Address'0'NameLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (NameLine t a))) ((:*:) (S1 (MetaSel (Just Symbol "_r'Address'1'StreetLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (StreetLine t a))) (S1 (MetaSel (Just Symbol "_r'Address'2'CityLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (CityLine t a))))))