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 t, Eq a) => Eq (Letter t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (Letter t a)

Methods

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

show :: Letter t a -> String

showList :: [Letter t a] -> ShowS

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 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

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

Methods

prettyVal :: Letters t a -> Value

listValue :: [Letters t a] -> Value

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

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

Methods

prettyVal :: PostalWord t a -> Value

listValue :: [PostalWord t a] -> Value

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 t, Eq a) => Eq (Space t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (Space t a)

Methods

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

show :: Space t a -> String

showList :: [Space t a] -> ShowS

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 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

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

Methods

prettyVal :: PreSpacedWord t a -> Value

listValue :: [PreSpacedWord t a] -> Value

newtype PreSpacedWord'Star t a

Constructors

PreSpacedWord'Star (Seq (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 t, Eq a) => 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 t, Ord a) => 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 t, Show a) => 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

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 Unwrapped (PreSpacedWord'Star t a)

type Unwrapped (PreSpacedWord'Star t a) = Seq (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 t, Eq a) => Eq (Words t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (Words t a)

Methods

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

show :: Words t a -> String

showList :: [Words t a] -> ShowS

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

Methods

prettyVal :: Words t a -> Value

listValue :: [Words t a] -> Value

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 t, Eq a) => Eq (Comma t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (Comma t a)

Methods

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

show :: Comma t a -> String

showList :: [Comma t a] -> ShowS

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 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

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

Methods

prettyVal :: CommaSpace t a -> Value

listValue :: [CommaSpace t a] -> Value

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 t, Eq a) => Eq (Newline t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (Newline t a)

Methods

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

show :: Newline t a -> String

showList :: [Newline t a] -> ShowS

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 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 t, Eq a) => Eq (Separator t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (Separator t a)

Methods

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

show :: Separator t a -> String

showList :: [Separator t a] -> ShowS

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

Methods

prettyVal :: Separator t a -> Value

listValue :: [Separator t a] -> Value

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

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

Methods

prettyVal :: NameLine t a -> Value

listValue :: [NameLine t a] -> Value

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 t, Eq a) => Eq (Digit t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (Digit t a)

Methods

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

show :: Digit t a -> String

showList :: [Digit t a] -> ShowS

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 Unwrapped (Digit t a)

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

newtype Digit'Plus t a

Constructors

Digit'Plus (NonEmptySeq (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

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 Unwrapped (Digit'Plus t a)

type Unwrapped (Digit'Plus t a) = NonEmptySeq (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 t, Eq a) => Eq (Number t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (Number t a)

Methods

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

show :: Number t a -> String

showList :: [Number t a] -> ShowS

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 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 t, Eq a) => Eq (North t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (North t a)

Methods

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

show :: North t a -> String

showList :: [North t a] -> ShowS

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 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 t, Eq a) => Eq (South t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (South t a)

Methods

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

show :: South t a -> String

showList :: [South t a] -> ShowS

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 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 t, Eq a) => Eq (East t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (East t a)

Methods

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

show :: East t a -> String

showList :: [East t a] -> ShowS

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 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 t, Eq a) => Eq (West t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (West t a)

Methods

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

show :: West t a -> String

showList :: [West t a] -> ShowS

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 Unwrapped (West t a)

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

newtype NE'0 t a

Constructors

NE'0 (t, a)

Instances

Bifunctor NE'0

Methods

bimap :: (a -> b) -> (c -> d) -> NE'0 a c -> NE'0 b d

first :: (a -> b) -> NE'0 a c -> NE'0 b c

second :: (b -> c) -> NE'0 a b -> NE'0 a c

Functor (NE'0 t)

Methods

fmap :: (a -> b) -> NE'0 t a -> NE'0 t b

(<$) :: a -> NE'0 t b -> NE'0 t a

Foldable (NE'0 t)

Methods

fold :: Monoid m => NE'0 t m -> m

foldMap :: Monoid m => (a -> m) -> NE'0 t a -> m

foldr :: (a -> b -> b) -> b -> NE'0 t a -> b

foldr' :: (a -> b -> b) -> b -> NE'0 t a -> b

foldl :: (b -> a -> b) -> b -> NE'0 t a -> b

foldl' :: (b -> a -> b) -> b -> NE'0 t a -> b

foldr1 :: (a -> a -> a) -> NE'0 t a -> a

foldl1 :: (a -> a -> a) -> NE'0 t a -> a

toList :: NE'0 t a -> [a]

null :: NE'0 t a -> Bool

length :: NE'0 t a -> Int

elem :: Eq a => a -> NE'0 t a -> Bool

maximum :: Ord a => NE'0 t a -> a

minimum :: Ord a => NE'0 t a -> a

sum :: Num a => NE'0 t a -> a

product :: Num a => NE'0 t a -> a

Traversable (NE'0 t)

Methods

traverse :: Applicative f => (a -> f b) -> NE'0 t a -> f (NE'0 t b)

sequenceA :: Applicative f => NE'0 t (f a) -> f (NE'0 t a)

mapM :: Monad m => (a -> m b) -> NE'0 t a -> m (NE'0 t b)

sequence :: Monad m => NE'0 t (m a) -> m (NE'0 t a)

(Eq t, Eq a) => Eq (NE'0 t a)

Methods

(==) :: NE'0 t a -> NE'0 t a -> Bool

(/=) :: NE'0 t a -> NE'0 t a -> Bool

(Ord t, Ord a) => Ord (NE'0 t a)

Methods

compare :: NE'0 t a -> NE'0 t a -> Ordering

(<) :: NE'0 t a -> NE'0 t a -> Bool

(<=) :: NE'0 t a -> NE'0 t a -> Bool

(>) :: NE'0 t a -> NE'0 t a -> Bool

(>=) :: NE'0 t a -> NE'0 t a -> Bool

max :: NE'0 t a -> NE'0 t a -> NE'0 t a

min :: NE'0 t a -> NE'0 t a -> NE'0 t a

(Show t, Show a) => Show (NE'0 t a)

Methods

showsPrec :: Int -> NE'0 t a -> ShowS

show :: NE'0 t a -> String

showList :: [NE'0 t a] -> ShowS

Wrapped (NE'0 t a)

Associated Types

type Unwrapped (NE'0 t a) :: *

Methods

_Wrapped' :: Iso' (NE'0 t a) (Unwrapped (NE'0 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (NE'0 t a)

Methods

prettyVal :: NE'0 t a -> Value

listValue :: [NE'0 t a] -> Value

type Unwrapped (NE'0 t a)

type Unwrapped (NE'0 t a) = (t, a)

newtype NE'1 t a

Constructors

NE'1 (t, a)

Instances

Bifunctor NE'1

Methods

bimap :: (a -> b) -> (c -> d) -> NE'1 a c -> NE'1 b d

first :: (a -> b) -> NE'1 a c -> NE'1 b c

second :: (b -> c) -> NE'1 a b -> NE'1 a c

Functor (NE'1 t)

Methods

fmap :: (a -> b) -> NE'1 t a -> NE'1 t b

(<$) :: a -> NE'1 t b -> NE'1 t a

Foldable (NE'1 t)

Methods

fold :: Monoid m => NE'1 t m -> m

foldMap :: Monoid m => (a -> m) -> NE'1 t a -> m

foldr :: (a -> b -> b) -> b -> NE'1 t a -> b

foldr' :: (a -> b -> b) -> b -> NE'1 t a -> b

foldl :: (b -> a -> b) -> b -> NE'1 t a -> b

foldl' :: (b -> a -> b) -> b -> NE'1 t a -> b

foldr1 :: (a -> a -> a) -> NE'1 t a -> a

foldl1 :: (a -> a -> a) -> NE'1 t a -> a

toList :: NE'1 t a -> [a]

null :: NE'1 t a -> Bool

length :: NE'1 t a -> Int

elem :: Eq a => a -> NE'1 t a -> Bool

maximum :: Ord a => NE'1 t a -> a

minimum :: Ord a => NE'1 t a -> a

sum :: Num a => NE'1 t a -> a

product :: Num a => NE'1 t a -> a

Traversable (NE'1 t)

Methods

traverse :: Applicative f => (a -> f b) -> NE'1 t a -> f (NE'1 t b)

sequenceA :: Applicative f => NE'1 t (f a) -> f (NE'1 t a)

mapM :: Monad m => (a -> m b) -> NE'1 t a -> m (NE'1 t b)

sequence :: Monad m => NE'1 t (m a) -> m (NE'1 t a)

(Eq t, Eq a) => Eq (NE'1 t a)

Methods

(==) :: NE'1 t a -> NE'1 t a -> Bool

(/=) :: NE'1 t a -> NE'1 t a -> Bool

(Ord t, Ord a) => Ord (NE'1 t a)

Methods

compare :: NE'1 t a -> NE'1 t a -> Ordering

(<) :: NE'1 t a -> NE'1 t a -> Bool

(<=) :: NE'1 t a -> NE'1 t a -> Bool

(>) :: NE'1 t a -> NE'1 t a -> Bool

(>=) :: NE'1 t a -> NE'1 t a -> Bool

max :: NE'1 t a -> NE'1 t a -> NE'1 t a

min :: NE'1 t a -> NE'1 t a -> NE'1 t a

(Show t, Show a) => Show (NE'1 t a)

Methods

showsPrec :: Int -> NE'1 t a -> ShowS

show :: NE'1 t a -> String

showList :: [NE'1 t a] -> ShowS

Wrapped (NE'1 t a)

Associated Types

type Unwrapped (NE'1 t a) :: *

Methods

_Wrapped' :: Iso' (NE'1 t a) (Unwrapped (NE'1 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (NE'1 t a)

Methods

prettyVal :: NE'1 t a -> Value

listValue :: [NE'1 t a] -> Value

type Unwrapped (NE'1 t a)

type Unwrapped (NE'1 t a) = (t, a)

data NE t a

Constructors

NE

Fields

• _r'NE'0'NE'0 :: (NE'0 t a)
• _r'NE'1'NE'1 :: (NE'1 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 t, Eq a) => Eq (NE t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (NE t a)

Methods

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

show :: NE t a -> String

showList :: [NE t a] -> ShowS

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

Methods

prettyVal :: NE t a -> Value

listValue :: [NE t a] -> Value

newtype NW'0 t a

Constructors

NW'0 (t, a)

Instances

Bifunctor NW'0

Methods

bimap :: (a -> b) -> (c -> d) -> NW'0 a c -> NW'0 b d

first :: (a -> b) -> NW'0 a c -> NW'0 b c

second :: (b -> c) -> NW'0 a b -> NW'0 a c

Functor (NW'0 t)

Methods

fmap :: (a -> b) -> NW'0 t a -> NW'0 t b

(<$) :: a -> NW'0 t b -> NW'0 t a

Foldable (NW'0 t)

Methods

fold :: Monoid m => NW'0 t m -> m

foldMap :: Monoid m => (a -> m) -> NW'0 t a -> m

foldr :: (a -> b -> b) -> b -> NW'0 t a -> b

foldr' :: (a -> b -> b) -> b -> NW'0 t a -> b

foldl :: (b -> a -> b) -> b -> NW'0 t a -> b

foldl' :: (b -> a -> b) -> b -> NW'0 t a -> b

foldr1 :: (a -> a -> a) -> NW'0 t a -> a

foldl1 :: (a -> a -> a) -> NW'0 t a -> a

toList :: NW'0 t a -> [a]

null :: NW'0 t a -> Bool

length :: NW'0 t a -> Int

elem :: Eq a => a -> NW'0 t a -> Bool

maximum :: Ord a => NW'0 t a -> a

minimum :: Ord a => NW'0 t a -> a

sum :: Num a => NW'0 t a -> a

product :: Num a => NW'0 t a -> a

Traversable (NW'0 t)

Methods

traverse :: Applicative f => (a -> f b) -> NW'0 t a -> f (NW'0 t b)

sequenceA :: Applicative f => NW'0 t (f a) -> f (NW'0 t a)

mapM :: Monad m => (a -> m b) -> NW'0 t a -> m (NW'0 t b)

sequence :: Monad m => NW'0 t (m a) -> m (NW'0 t a)

(Eq t, Eq a) => Eq (NW'0 t a)

Methods

(==) :: NW'0 t a -> NW'0 t a -> Bool

(/=) :: NW'0 t a -> NW'0 t a -> Bool

(Ord t, Ord a) => Ord (NW'0 t a)

Methods

compare :: NW'0 t a -> NW'0 t a -> Ordering

(<) :: NW'0 t a -> NW'0 t a -> Bool

(<=) :: NW'0 t a -> NW'0 t a -> Bool

(>) :: NW'0 t a -> NW'0 t a -> Bool

(>=) :: NW'0 t a -> NW'0 t a -> Bool

max :: NW'0 t a -> NW'0 t a -> NW'0 t a

min :: NW'0 t a -> NW'0 t a -> NW'0 t a

(Show t, Show a) => Show (NW'0 t a)

Methods

showsPrec :: Int -> NW'0 t a -> ShowS

show :: NW'0 t a -> String

showList :: [NW'0 t a] -> ShowS

Wrapped (NW'0 t a)

Associated Types

type Unwrapped (NW'0 t a) :: *

Methods

_Wrapped' :: Iso' (NW'0 t a) (Unwrapped (NW'0 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (NW'0 t a)

Methods

prettyVal :: NW'0 t a -> Value

listValue :: [NW'0 t a] -> Value

type Unwrapped (NW'0 t a)

type Unwrapped (NW'0 t a) = (t, a)

newtype NW'1 t a

Constructors

NW'1 (t, a)

Instances

Bifunctor NW'1

Methods

bimap :: (a -> b) -> (c -> d) -> NW'1 a c -> NW'1 b d

first :: (a -> b) -> NW'1 a c -> NW'1 b c

second :: (b -> c) -> NW'1 a b -> NW'1 a c

Functor (NW'1 t)

Methods

fmap :: (a -> b) -> NW'1 t a -> NW'1 t b

(<$) :: a -> NW'1 t b -> NW'1 t a

Foldable (NW'1 t)

Methods

fold :: Monoid m => NW'1 t m -> m

foldMap :: Monoid m => (a -> m) -> NW'1 t a -> m

foldr :: (a -> b -> b) -> b -> NW'1 t a -> b

foldr' :: (a -> b -> b) -> b -> NW'1 t a -> b

foldl :: (b -> a -> b) -> b -> NW'1 t a -> b

foldl' :: (b -> a -> b) -> b -> NW'1 t a -> b

foldr1 :: (a -> a -> a) -> NW'1 t a -> a

foldl1 :: (a -> a -> a) -> NW'1 t a -> a

toList :: NW'1 t a -> [a]

null :: NW'1 t a -> Bool

length :: NW'1 t a -> Int

elem :: Eq a => a -> NW'1 t a -> Bool

maximum :: Ord a => NW'1 t a -> a

minimum :: Ord a => NW'1 t a -> a

sum :: Num a => NW'1 t a -> a

product :: Num a => NW'1 t a -> a

Traversable (NW'1 t)

Methods

traverse :: Applicative f => (a -> f b) -> NW'1 t a -> f (NW'1 t b)

sequenceA :: Applicative f => NW'1 t (f a) -> f (NW'1 t a)

mapM :: Monad m => (a -> m b) -> NW'1 t a -> m (NW'1 t b)

sequence :: Monad m => NW'1 t (m a) -> m (NW'1 t a)

(Eq t, Eq a) => Eq (NW'1 t a)

Methods

(==) :: NW'1 t a -> NW'1 t a -> Bool

(/=) :: NW'1 t a -> NW'1 t a -> Bool

(Ord t, Ord a) => Ord (NW'1 t a)

Methods

compare :: NW'1 t a -> NW'1 t a -> Ordering

(<) :: NW'1 t a -> NW'1 t a -> Bool

(<=) :: NW'1 t a -> NW'1 t a -> Bool

(>) :: NW'1 t a -> NW'1 t a -> Bool

(>=) :: NW'1 t a -> NW'1 t a -> Bool

max :: NW'1 t a -> NW'1 t a -> NW'1 t a

min :: NW'1 t a -> NW'1 t a -> NW'1 t a

(Show t, Show a) => Show (NW'1 t a)

Methods

showsPrec :: Int -> NW'1 t a -> ShowS

show :: NW'1 t a -> String

showList :: [NW'1 t a] -> ShowS

Wrapped (NW'1 t a)

Associated Types

type Unwrapped (NW'1 t a) :: *

Methods

_Wrapped' :: Iso' (NW'1 t a) (Unwrapped (NW'1 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (NW'1 t a)

Methods

prettyVal :: NW'1 t a -> Value

listValue :: [NW'1 t a] -> Value

type Unwrapped (NW'1 t a)

type Unwrapped (NW'1 t a) = (t, a)

data NW t a

Constructors

NW

Fields

• _r'NW'0'NW'0 :: (NW'0 t a)
• _r'NW'1'NW'1 :: (NW'1 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 t, Eq a) => Eq (NW t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (NW t a)

Methods

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

show :: NW t a -> String

showList :: [NW t a] -> ShowS

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

Methods

prettyVal :: NW t a -> Value

listValue :: [NW t a] -> Value

newtype SE'0 t a

Constructors

SE'0 (t, a)

Instances

Bifunctor SE'0

Methods

bimap :: (a -> b) -> (c -> d) -> SE'0 a c -> SE'0 b d

first :: (a -> b) -> SE'0 a c -> SE'0 b c

second :: (b -> c) -> SE'0 a b -> SE'0 a c

Functor (SE'0 t)

Methods

fmap :: (a -> b) -> SE'0 t a -> SE'0 t b

(<$) :: a -> SE'0 t b -> SE'0 t a

Foldable (SE'0 t)

Methods

fold :: Monoid m => SE'0 t m -> m

foldMap :: Monoid m => (a -> m) -> SE'0 t a -> m

foldr :: (a -> b -> b) -> b -> SE'0 t a -> b

foldr' :: (a -> b -> b) -> b -> SE'0 t a -> b

foldl :: (b -> a -> b) -> b -> SE'0 t a -> b

foldl' :: (b -> a -> b) -> b -> SE'0 t a -> b

foldr1 :: (a -> a -> a) -> SE'0 t a -> a

foldl1 :: (a -> a -> a) -> SE'0 t a -> a

toList :: SE'0 t a -> [a]

null :: SE'0 t a -> Bool

length :: SE'0 t a -> Int

elem :: Eq a => a -> SE'0 t a -> Bool

maximum :: Ord a => SE'0 t a -> a

minimum :: Ord a => SE'0 t a -> a

sum :: Num a => SE'0 t a -> a

product :: Num a => SE'0 t a -> a

Traversable (SE'0 t)

Methods

traverse :: Applicative f => (a -> f b) -> SE'0 t a -> f (SE'0 t b)

sequenceA :: Applicative f => SE'0 t (f a) -> f (SE'0 t a)

mapM :: Monad m => (a -> m b) -> SE'0 t a -> m (SE'0 t b)

sequence :: Monad m => SE'0 t (m a) -> m (SE'0 t a)

(Eq t, Eq a) => Eq (SE'0 t a)

Methods

(==) :: SE'0 t a -> SE'0 t a -> Bool

(/=) :: SE'0 t a -> SE'0 t a -> Bool

(Ord t, Ord a) => Ord (SE'0 t a)

Methods

compare :: SE'0 t a -> SE'0 t a -> Ordering

(<) :: SE'0 t a -> SE'0 t a -> Bool

(<=) :: SE'0 t a -> SE'0 t a -> Bool

(>) :: SE'0 t a -> SE'0 t a -> Bool

(>=) :: SE'0 t a -> SE'0 t a -> Bool

max :: SE'0 t a -> SE'0 t a -> SE'0 t a

min :: SE'0 t a -> SE'0 t a -> SE'0 t a

(Show t, Show a) => Show (SE'0 t a)

Methods

showsPrec :: Int -> SE'0 t a -> ShowS

show :: SE'0 t a -> String

showList :: [SE'0 t a] -> ShowS

Wrapped (SE'0 t a)

Associated Types

type Unwrapped (SE'0 t a) :: *

Methods

_Wrapped' :: Iso' (SE'0 t a) (Unwrapped (SE'0 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (SE'0 t a)

Methods

prettyVal :: SE'0 t a -> Value

listValue :: [SE'0 t a] -> Value

type Unwrapped (SE'0 t a)

type Unwrapped (SE'0 t a) = (t, a)

newtype SE'1 t a

Constructors

SE'1 (t, a)

Instances

Bifunctor SE'1

Methods

bimap :: (a -> b) -> (c -> d) -> SE'1 a c -> SE'1 b d

first :: (a -> b) -> SE'1 a c -> SE'1 b c

second :: (b -> c) -> SE'1 a b -> SE'1 a c

Functor (SE'1 t)

Methods

fmap :: (a -> b) -> SE'1 t a -> SE'1 t b

(<$) :: a -> SE'1 t b -> SE'1 t a

Foldable (SE'1 t)

Methods

fold :: Monoid m => SE'1 t m -> m

foldMap :: Monoid m => (a -> m) -> SE'1 t a -> m

foldr :: (a -> b -> b) -> b -> SE'1 t a -> b

foldr' :: (a -> b -> b) -> b -> SE'1 t a -> b

foldl :: (b -> a -> b) -> b -> SE'1 t a -> b

foldl' :: (b -> a -> b) -> b -> SE'1 t a -> b

foldr1 :: (a -> a -> a) -> SE'1 t a -> a

foldl1 :: (a -> a -> a) -> SE'1 t a -> a

toList :: SE'1 t a -> [a]

null :: SE'1 t a -> Bool

length :: SE'1 t a -> Int

elem :: Eq a => a -> SE'1 t a -> Bool

maximum :: Ord a => SE'1 t a -> a

minimum :: Ord a => SE'1 t a -> a

sum :: Num a => SE'1 t a -> a

product :: Num a => SE'1 t a -> a

Traversable (SE'1 t)

Methods

traverse :: Applicative f => (a -> f b) -> SE'1 t a -> f (SE'1 t b)

sequenceA :: Applicative f => SE'1 t (f a) -> f (SE'1 t a)

mapM :: Monad m => (a -> m b) -> SE'1 t a -> m (SE'1 t b)

sequence :: Monad m => SE'1 t (m a) -> m (SE'1 t a)

(Eq t, Eq a) => Eq (SE'1 t a)

Methods

(==) :: SE'1 t a -> SE'1 t a -> Bool

(/=) :: SE'1 t a -> SE'1 t a -> Bool

(Ord t, Ord a) => Ord (SE'1 t a)

Methods

compare :: SE'1 t a -> SE'1 t a -> Ordering

(<) :: SE'1 t a -> SE'1 t a -> Bool

(<=) :: SE'1 t a -> SE'1 t a -> Bool

(>) :: SE'1 t a -> SE'1 t a -> Bool

(>=) :: SE'1 t a -> SE'1 t a -> Bool

max :: SE'1 t a -> SE'1 t a -> SE'1 t a

min :: SE'1 t a -> SE'1 t a -> SE'1 t a

(Show t, Show a) => Show (SE'1 t a)

Methods

showsPrec :: Int -> SE'1 t a -> ShowS

show :: SE'1 t a -> String

showList :: [SE'1 t a] -> ShowS

Wrapped (SE'1 t a)

Associated Types

type Unwrapped (SE'1 t a) :: *

Methods

_Wrapped' :: Iso' (SE'1 t a) (Unwrapped (SE'1 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (SE'1 t a)

Methods

prettyVal :: SE'1 t a -> Value

listValue :: [SE'1 t a] -> Value

type Unwrapped (SE'1 t a)

type Unwrapped (SE'1 t a) = (t, a)

data SE t a

Constructors

SE

Fields

• _r'SE'0'SE'0 :: (SE'0 t a)
• _r'SE'1'SE'1 :: (SE'1 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 t, Eq a) => Eq (SE t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (SE t a)

Methods

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

show :: SE t a -> String

showList :: [SE t a] -> ShowS

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

Methods

prettyVal :: SE t a -> Value

listValue :: [SE t a] -> Value

newtype SW'0 t a

Constructors

SW'0 (t, a)

Instances

Bifunctor SW'0

Methods

bimap :: (a -> b) -> (c -> d) -> SW'0 a c -> SW'0 b d

first :: (a -> b) -> SW'0 a c -> SW'0 b c

second :: (b -> c) -> SW'0 a b -> SW'0 a c

Functor (SW'0 t)

Methods

fmap :: (a -> b) -> SW'0 t a -> SW'0 t b

(<$) :: a -> SW'0 t b -> SW'0 t a

Foldable (SW'0 t)

Methods

fold :: Monoid m => SW'0 t m -> m

foldMap :: Monoid m => (a -> m) -> SW'0 t a -> m

foldr :: (a -> b -> b) -> b -> SW'0 t a -> b

foldr' :: (a -> b -> b) -> b -> SW'0 t a -> b

foldl :: (b -> a -> b) -> b -> SW'0 t a -> b

foldl' :: (b -> a -> b) -> b -> SW'0 t a -> b

foldr1 :: (a -> a -> a) -> SW'0 t a -> a

foldl1 :: (a -> a -> a) -> SW'0 t a -> a

toList :: SW'0 t a -> [a]

null :: SW'0 t a -> Bool

length :: SW'0 t a -> Int

elem :: Eq a => a -> SW'0 t a -> Bool

maximum :: Ord a => SW'0 t a -> a

minimum :: Ord a => SW'0 t a -> a

sum :: Num a => SW'0 t a -> a

product :: Num a => SW'0 t a -> a

Traversable (SW'0 t)

Methods

traverse :: Applicative f => (a -> f b) -> SW'0 t a -> f (SW'0 t b)

sequenceA :: Applicative f => SW'0 t (f a) -> f (SW'0 t a)

mapM :: Monad m => (a -> m b) -> SW'0 t a -> m (SW'0 t b)

sequence :: Monad m => SW'0 t (m a) -> m (SW'0 t a)

(Eq t, Eq a) => Eq (SW'0 t a)

Methods

(==) :: SW'0 t a -> SW'0 t a -> Bool

(/=) :: SW'0 t a -> SW'0 t a -> Bool

(Ord t, Ord a) => Ord (SW'0 t a)

Methods

compare :: SW'0 t a -> SW'0 t a -> Ordering

(<) :: SW'0 t a -> SW'0 t a -> Bool

(<=) :: SW'0 t a -> SW'0 t a -> Bool

(>) :: SW'0 t a -> SW'0 t a -> Bool

(>=) :: SW'0 t a -> SW'0 t a -> Bool

max :: SW'0 t a -> SW'0 t a -> SW'0 t a

min :: SW'0 t a -> SW'0 t a -> SW'0 t a

(Show t, Show a) => Show (SW'0 t a)

Methods

showsPrec :: Int -> SW'0 t a -> ShowS

show :: SW'0 t a -> String

showList :: [SW'0 t a] -> ShowS

Wrapped (SW'0 t a)

Associated Types

type Unwrapped (SW'0 t a) :: *

Methods

_Wrapped' :: Iso' (SW'0 t a) (Unwrapped (SW'0 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (SW'0 t a)

Methods

prettyVal :: SW'0 t a -> Value

listValue :: [SW'0 t a] -> Value

type Unwrapped (SW'0 t a)

type Unwrapped (SW'0 t a) = (t, a)

newtype SW'1 t a

Constructors

SW'1 (t, a)

Instances

Bifunctor SW'1

Methods

bimap :: (a -> b) -> (c -> d) -> SW'1 a c -> SW'1 b d

first :: (a -> b) -> SW'1 a c -> SW'1 b c

second :: (b -> c) -> SW'1 a b -> SW'1 a c

Functor (SW'1 t)

Methods

fmap :: (a -> b) -> SW'1 t a -> SW'1 t b

(<$) :: a -> SW'1 t b -> SW'1 t a

Foldable (SW'1 t)

Methods

fold :: Monoid m => SW'1 t m -> m

foldMap :: Monoid m => (a -> m) -> SW'1 t a -> m

foldr :: (a -> b -> b) -> b -> SW'1 t a -> b

foldr' :: (a -> b -> b) -> b -> SW'1 t a -> b

foldl :: (b -> a -> b) -> b -> SW'1 t a -> b

foldl' :: (b -> a -> b) -> b -> SW'1 t a -> b

foldr1 :: (a -> a -> a) -> SW'1 t a -> a

foldl1 :: (a -> a -> a) -> SW'1 t a -> a

toList :: SW'1 t a -> [a]

null :: SW'1 t a -> Bool

length :: SW'1 t a -> Int

elem :: Eq a => a -> SW'1 t a -> Bool

maximum :: Ord a => SW'1 t a -> a

minimum :: Ord a => SW'1 t a -> a

sum :: Num a => SW'1 t a -> a

product :: Num a => SW'1 t a -> a

Traversable (SW'1 t)

Methods

traverse :: Applicative f => (a -> f b) -> SW'1 t a -> f (SW'1 t b)

sequenceA :: Applicative f => SW'1 t (f a) -> f (SW'1 t a)

mapM :: Monad m => (a -> m b) -> SW'1 t a -> m (SW'1 t b)

sequence :: Monad m => SW'1 t (m a) -> m (SW'1 t a)

(Eq t, Eq a) => Eq (SW'1 t a)

Methods

(==) :: SW'1 t a -> SW'1 t a -> Bool

(/=) :: SW'1 t a -> SW'1 t a -> Bool

(Ord t, Ord a) => Ord (SW'1 t a)

Methods

compare :: SW'1 t a -> SW'1 t a -> Ordering

(<) :: SW'1 t a -> SW'1 t a -> Bool

(<=) :: SW'1 t a -> SW'1 t a -> Bool

(>) :: SW'1 t a -> SW'1 t a -> Bool

(>=) :: SW'1 t a -> SW'1 t a -> Bool

max :: SW'1 t a -> SW'1 t a -> SW'1 t a

min :: SW'1 t a -> SW'1 t a -> SW'1 t a

(Show t, Show a) => Show (SW'1 t a)

Methods

showsPrec :: Int -> SW'1 t a -> ShowS

show :: SW'1 t a -> String

showList :: [SW'1 t a] -> ShowS

Wrapped (SW'1 t a)

Associated Types

type Unwrapped (SW'1 t a) :: *

Methods

_Wrapped' :: Iso' (SW'1 t a) (Unwrapped (SW'1 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (SW'1 t a)

Methods

prettyVal :: SW'1 t a -> Value

listValue :: [SW'1 t a] -> Value

type Unwrapped (SW'1 t a)

type Unwrapped (SW'1 t a) = (t, a)

data SW t a

Constructors

SW

Fields

• _r'SW'0'SW'0 :: (SW'0 t a)
• _r'SW'1'SW'1 :: (SW'1 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 t, Eq a) => Eq (SW t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (SW t a)

Methods

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

show :: SW t a -> String

showList :: [SW t a] -> ShowS

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

Methods

prettyVal :: SW t a -> Value

listValue :: [SW t a] -> Value

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

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

Methods

prettyVal :: Direction t a -> Value

listValue :: [Direction t a] -> Value

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 t, Eq a) => Eq (DirectionSpace t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (DirectionSpace t a)

Methods

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

show :: DirectionSpace t a -> String

showList :: [DirectionSpace t a] -> ShowS

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

Methods

prettyVal :: DirectionSpace t a -> Value

listValue :: [DirectionSpace t a] -> Value

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

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 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

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 Unwrapped (StreetName t a)

type Unwrapped (StreetName t a) = Words t a

newtype Street'0 t a

Constructors

Street'0 (t, a)

Instances

Bifunctor Street'0

Methods

bimap :: (a -> b) -> (c -> d) -> Street'0 a c -> Street'0 b d

first :: (a -> b) -> Street'0 a c -> Street'0 b c

second :: (b -> c) -> Street'0 a b -> Street'0 a c

Functor (Street'0 t)

Methods

fmap :: (a -> b) -> Street'0 t a -> Street'0 t b

(<$) :: a -> Street'0 t b -> Street'0 t a

Foldable (Street'0 t)

Methods

fold :: Monoid m => Street'0 t m -> m

foldMap :: Monoid m => (a -> m) -> Street'0 t a -> m

foldr :: (a -> b -> b) -> b -> Street'0 t a -> b

foldr' :: (a -> b -> b) -> b -> Street'0 t a -> b

foldl :: (b -> a -> b) -> b -> Street'0 t a -> b

foldl' :: (b -> a -> b) -> b -> Street'0 t a -> b

foldr1 :: (a -> a -> a) -> Street'0 t a -> a

foldl1 :: (a -> a -> a) -> Street'0 t a -> a

toList :: Street'0 t a -> [a]

null :: Street'0 t a -> Bool

length :: Street'0 t a -> Int

elem :: Eq a => a -> Street'0 t a -> Bool

maximum :: Ord a => Street'0 t a -> a

minimum :: Ord a => Street'0 t a -> a

sum :: Num a => Street'0 t a -> a

product :: Num a => Street'0 t a -> a

Traversable (Street'0 t)

Methods

traverse :: Applicative f => (a -> f b) -> Street'0 t a -> f (Street'0 t b)

sequenceA :: Applicative f => Street'0 t (f a) -> f (Street'0 t a)

mapM :: Monad m => (a -> m b) -> Street'0 t a -> m (Street'0 t b)

sequence :: Monad m => Street'0 t (m a) -> m (Street'0 t a)

(Eq t, Eq a) => Eq (Street'0 t a)

Methods

(==) :: Street'0 t a -> Street'0 t a -> Bool

(/=) :: Street'0 t a -> Street'0 t a -> Bool

(Ord t, Ord a) => Ord (Street'0 t a)

Methods

compare :: Street'0 t a -> Street'0 t a -> Ordering

(<) :: Street'0 t a -> Street'0 t a -> Bool

(<=) :: Street'0 t a -> Street'0 t a -> Bool

(>) :: Street'0 t a -> Street'0 t a -> Bool

(>=) :: Street'0 t a -> Street'0 t a -> Bool

max :: Street'0 t a -> Street'0 t a -> Street'0 t a

min :: Street'0 t a -> Street'0 t a -> Street'0 t a

(Show t, Show a) => Show (Street'0 t a)

Methods

showsPrec :: Int -> Street'0 t a -> ShowS

show :: Street'0 t a -> String

showList :: [Street'0 t a] -> ShowS

Wrapped (Street'0 t a)

Associated Types

type Unwrapped (Street'0 t a) :: *

Methods

_Wrapped' :: Iso' (Street'0 t a) (Unwrapped (Street'0 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Street'0 t a)

Methods

prettyVal :: Street'0 t a -> Value

listValue :: [Street'0 t a] -> Value

type Unwrapped (Street'0 t a)

type Unwrapped (Street'0 t a) = (t, a)

newtype Street'1 t a

Constructors

Street'1 (t, a)

Instances

Bifunctor Street'1

Methods

bimap :: (a -> b) -> (c -> d) -> Street'1 a c -> Street'1 b d

first :: (a -> b) -> Street'1 a c -> Street'1 b c

second :: (b -> c) -> Street'1 a b -> Street'1 a c

Functor (Street'1 t)

Methods

fmap :: (a -> b) -> Street'1 t a -> Street'1 t b

(<$) :: a -> Street'1 t b -> Street'1 t a

Foldable (Street'1 t)

Methods

fold :: Monoid m => Street'1 t m -> m

foldMap :: Monoid m => (a -> m) -> Street'1 t a -> m

foldr :: (a -> b -> b) -> b -> Street'1 t a -> b

foldr' :: (a -> b -> b) -> b -> Street'1 t a -> b

foldl :: (b -> a -> b) -> b -> Street'1 t a -> b

foldl' :: (b -> a -> b) -> b -> Street'1 t a -> b

foldr1 :: (a -> a -> a) -> Street'1 t a -> a

foldl1 :: (a -> a -> a) -> Street'1 t a -> a

toList :: Street'1 t a -> [a]

null :: Street'1 t a -> Bool

length :: Street'1 t a -> Int

elem :: Eq a => a -> Street'1 t a -> Bool

maximum :: Ord a => Street'1 t a -> a

minimum :: Ord a => Street'1 t a -> a

sum :: Num a => Street'1 t a -> a

product :: Num a => Street'1 t a -> a

Traversable (Street'1 t)

Methods

traverse :: Applicative f => (a -> f b) -> Street'1 t a -> f (Street'1 t b)

sequenceA :: Applicative f => Street'1 t (f a) -> f (Street'1 t a)

mapM :: Monad m => (a -> m b) -> Street'1 t a -> m (Street'1 t b)

sequence :: Monad m => Street'1 t (m a) -> m (Street'1 t a)

(Eq t, Eq a) => Eq (Street'1 t a)

Methods

(==) :: Street'1 t a -> Street'1 t a -> Bool

(/=) :: Street'1 t a -> Street'1 t a -> Bool

(Ord t, Ord a) => Ord (Street'1 t a)

Methods

compare :: Street'1 t a -> Street'1 t a -> Ordering

(<) :: Street'1 t a -> Street'1 t a -> Bool

(<=) :: Street'1 t a -> Street'1 t a -> Bool

(>) :: Street'1 t a -> Street'1 t a -> Bool

(>=) :: Street'1 t a -> Street'1 t a -> Bool

max :: Street'1 t a -> Street'1 t a -> Street'1 t a

min :: Street'1 t a -> Street'1 t a -> Street'1 t a

(Show t, Show a) => Show (Street'1 t a)

Methods

showsPrec :: Int -> Street'1 t a -> ShowS

show :: Street'1 t a -> String

showList :: [Street'1 t a] -> ShowS

Wrapped (Street'1 t a)

Associated Types

type Unwrapped (Street'1 t a) :: *

Methods

_Wrapped' :: Iso' (Street'1 t a) (Unwrapped (Street'1 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Street'1 t a)

Methods

prettyVal :: Street'1 t a -> Value

listValue :: [Street'1 t a] -> Value

type Unwrapped (Street'1 t a)

type Unwrapped (Street'1 t a) = (t, a)

data Street t a

Constructors

Street

Fields

• _r'Street'0'Street'0 :: (Street'0 t a)
• _r'Street'1'Street'1 :: (Street'1 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 t, Eq a) => Eq (Street t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (Street t a)

Methods

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

show :: Street t a -> String

showList :: [Street t a] -> ShowS

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

Methods

prettyVal :: Street t a -> Value

listValue :: [Street t a] -> Value

newtype Avenue'0 t a

Constructors

Avenue'0 (t, a)

Instances

Bifunctor Avenue'0

Methods

bimap :: (a -> b) -> (c -> d) -> Avenue'0 a c -> Avenue'0 b d

first :: (a -> b) -> Avenue'0 a c -> Avenue'0 b c

second :: (b -> c) -> Avenue'0 a b -> Avenue'0 a c

Functor (Avenue'0 t)

Methods

fmap :: (a -> b) -> Avenue'0 t a -> Avenue'0 t b

(<$) :: a -> Avenue'0 t b -> Avenue'0 t a

Foldable (Avenue'0 t)

Methods

fold :: Monoid m => Avenue'0 t m -> m

foldMap :: Monoid m => (a -> m) -> Avenue'0 t a -> m

foldr :: (a -> b -> b) -> b -> Avenue'0 t a -> b

foldr' :: (a -> b -> b) -> b -> Avenue'0 t a -> b

foldl :: (b -> a -> b) -> b -> Avenue'0 t a -> b

foldl' :: (b -> a -> b) -> b -> Avenue'0 t a -> b

foldr1 :: (a -> a -> a) -> Avenue'0 t a -> a

foldl1 :: (a -> a -> a) -> Avenue'0 t a -> a

toList :: Avenue'0 t a -> [a]

null :: Avenue'0 t a -> Bool

length :: Avenue'0 t a -> Int

elem :: Eq a => a -> Avenue'0 t a -> Bool

maximum :: Ord a => Avenue'0 t a -> a

minimum :: Ord a => Avenue'0 t a -> a

sum :: Num a => Avenue'0 t a -> a

product :: Num a => Avenue'0 t a -> a

Traversable (Avenue'0 t)

Methods

traverse :: Applicative f => (a -> f b) -> Avenue'0 t a -> f (Avenue'0 t b)

sequenceA :: Applicative f => Avenue'0 t (f a) -> f (Avenue'0 t a)

mapM :: Monad m => (a -> m b) -> Avenue'0 t a -> m (Avenue'0 t b)

sequence :: Monad m => Avenue'0 t (m a) -> m (Avenue'0 t a)

(Eq t, Eq a) => Eq (Avenue'0 t a)

Methods

(==) :: Avenue'0 t a -> Avenue'0 t a -> Bool

(/=) :: Avenue'0 t a -> Avenue'0 t a -> Bool

(Ord t, Ord a) => Ord (Avenue'0 t a)

Methods

compare :: Avenue'0 t a -> Avenue'0 t a -> Ordering

(<) :: Avenue'0 t a -> Avenue'0 t a -> Bool

(<=) :: Avenue'0 t a -> Avenue'0 t a -> Bool

(>) :: Avenue'0 t a -> Avenue'0 t a -> Bool

(>=) :: Avenue'0 t a -> Avenue'0 t a -> Bool

max :: Avenue'0 t a -> Avenue'0 t a -> Avenue'0 t a

min :: Avenue'0 t a -> Avenue'0 t a -> Avenue'0 t a

(Show t, Show a) => Show (Avenue'0 t a)

Methods

showsPrec :: Int -> Avenue'0 t a -> ShowS

show :: Avenue'0 t a -> String

showList :: [Avenue'0 t a] -> ShowS

Wrapped (Avenue'0 t a)

Associated Types

type Unwrapped (Avenue'0 t a) :: *

Methods

_Wrapped' :: Iso' (Avenue'0 t a) (Unwrapped (Avenue'0 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Avenue'0 t a)

Methods

prettyVal :: Avenue'0 t a -> Value

listValue :: [Avenue'0 t a] -> Value

type Unwrapped (Avenue'0 t a)

type Unwrapped (Avenue'0 t a) = (t, a)

newtype Avenue'1 t a

Constructors

Avenue'1 (t, a)

Instances

Bifunctor Avenue'1

Methods

bimap :: (a -> b) -> (c -> d) -> Avenue'1 a c -> Avenue'1 b d

first :: (a -> b) -> Avenue'1 a c -> Avenue'1 b c

second :: (b -> c) -> Avenue'1 a b -> Avenue'1 a c

Functor (Avenue'1 t)

Methods

fmap :: (a -> b) -> Avenue'1 t a -> Avenue'1 t b

(<$) :: a -> Avenue'1 t b -> Avenue'1 t a

Foldable (Avenue'1 t)

Methods

fold :: Monoid m => Avenue'1 t m -> m

foldMap :: Monoid m => (a -> m) -> Avenue'1 t a -> m

foldr :: (a -> b -> b) -> b -> Avenue'1 t a -> b

foldr' :: (a -> b -> b) -> b -> Avenue'1 t a -> b

foldl :: (b -> a -> b) -> b -> Avenue'1 t a -> b

foldl' :: (b -> a -> b) -> b -> Avenue'1 t a -> b

foldr1 :: (a -> a -> a) -> Avenue'1 t a -> a

foldl1 :: (a -> a -> a) -> Avenue'1 t a -> a

toList :: Avenue'1 t a -> [a]

null :: Avenue'1 t a -> Bool

length :: Avenue'1 t a -> Int

elem :: Eq a => a -> Avenue'1 t a -> Bool

maximum :: Ord a => Avenue'1 t a -> a

minimum :: Ord a => Avenue'1 t a -> a

sum :: Num a => Avenue'1 t a -> a

product :: Num a => Avenue'1 t a -> a

Traversable (Avenue'1 t)

Methods

traverse :: Applicative f => (a -> f b) -> Avenue'1 t a -> f (Avenue'1 t b)

sequenceA :: Applicative f => Avenue'1 t (f a) -> f (Avenue'1 t a)

mapM :: Monad m => (a -> m b) -> Avenue'1 t a -> m (Avenue'1 t b)

sequence :: Monad m => Avenue'1 t (m a) -> m (Avenue'1 t a)

(Eq t, Eq a) => Eq (Avenue'1 t a)

Methods

(==) :: Avenue'1 t a -> Avenue'1 t a -> Bool

(/=) :: Avenue'1 t a -> Avenue'1 t a -> Bool

(Ord t, Ord a) => Ord (Avenue'1 t a)

Methods

compare :: Avenue'1 t a -> Avenue'1 t a -> Ordering

(<) :: Avenue'1 t a -> Avenue'1 t a -> Bool

(<=) :: Avenue'1 t a -> Avenue'1 t a -> Bool

(>) :: Avenue'1 t a -> Avenue'1 t a -> Bool

(>=) :: Avenue'1 t a -> Avenue'1 t a -> Bool

max :: Avenue'1 t a -> Avenue'1 t a -> Avenue'1 t a

min :: Avenue'1 t a -> Avenue'1 t a -> Avenue'1 t a

(Show t, Show a) => Show (Avenue'1 t a)

Methods

showsPrec :: Int -> Avenue'1 t a -> ShowS

show :: Avenue'1 t a -> String

showList :: [Avenue'1 t a] -> ShowS

Wrapped (Avenue'1 t a)

Associated Types

type Unwrapped (Avenue'1 t a) :: *

Methods

_Wrapped' :: Iso' (Avenue'1 t a) (Unwrapped (Avenue'1 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Avenue'1 t a)

Methods

prettyVal :: Avenue'1 t a -> Value

listValue :: [Avenue'1 t a] -> Value

type Unwrapped (Avenue'1 t a)

type Unwrapped (Avenue'1 t a) = (t, a)

newtype Avenue'2 t a

Constructors

Avenue'2 (t, a)

Instances

Bifunctor Avenue'2

Methods

bimap :: (a -> b) -> (c -> d) -> Avenue'2 a c -> Avenue'2 b d

first :: (a -> b) -> Avenue'2 a c -> Avenue'2 b c

second :: (b -> c) -> Avenue'2 a b -> Avenue'2 a c

Functor (Avenue'2 t)

Methods

fmap :: (a -> b) -> Avenue'2 t a -> Avenue'2 t b

(<$) :: a -> Avenue'2 t b -> Avenue'2 t a

Foldable (Avenue'2 t)

Methods

fold :: Monoid m => Avenue'2 t m -> m

foldMap :: Monoid m => (a -> m) -> Avenue'2 t a -> m

foldr :: (a -> b -> b) -> b -> Avenue'2 t a -> b

foldr' :: (a -> b -> b) -> b -> Avenue'2 t a -> b

foldl :: (b -> a -> b) -> b -> Avenue'2 t a -> b

foldl' :: (b -> a -> b) -> b -> Avenue'2 t a -> b

foldr1 :: (a -> a -> a) -> Avenue'2 t a -> a

foldl1 :: (a -> a -> a) -> Avenue'2 t a -> a

toList :: Avenue'2 t a -> [a]

null :: Avenue'2 t a -> Bool

length :: Avenue'2 t a -> Int

elem :: Eq a => a -> Avenue'2 t a -> Bool

maximum :: Ord a => Avenue'2 t a -> a

minimum :: Ord a => Avenue'2 t a -> a

sum :: Num a => Avenue'2 t a -> a

product :: Num a => Avenue'2 t a -> a

Traversable (Avenue'2 t)

Methods

traverse :: Applicative f => (a -> f b) -> Avenue'2 t a -> f (Avenue'2 t b)

sequenceA :: Applicative f => Avenue'2 t (f a) -> f (Avenue'2 t a)

mapM :: Monad m => (a -> m b) -> Avenue'2 t a -> m (Avenue'2 t b)

sequence :: Monad m => Avenue'2 t (m a) -> m (Avenue'2 t a)

(Eq t, Eq a) => Eq (Avenue'2 t a)

Methods

(==) :: Avenue'2 t a -> Avenue'2 t a -> Bool

(/=) :: Avenue'2 t a -> Avenue'2 t a -> Bool

(Ord t, Ord a) => Ord (Avenue'2 t a)

Methods

compare :: Avenue'2 t a -> Avenue'2 t a -> Ordering

(<) :: Avenue'2 t a -> Avenue'2 t a -> Bool

(<=) :: Avenue'2 t a -> Avenue'2 t a -> Bool

(>) :: Avenue'2 t a -> Avenue'2 t a -> Bool

(>=) :: Avenue'2 t a -> Avenue'2 t a -> Bool

max :: Avenue'2 t a -> Avenue'2 t a -> Avenue'2 t a

min :: Avenue'2 t a -> Avenue'2 t a -> Avenue'2 t a

(Show t, Show a) => Show (Avenue'2 t a)

Methods

showsPrec :: Int -> Avenue'2 t a -> ShowS

show :: Avenue'2 t a -> String

showList :: [Avenue'2 t a] -> ShowS

Wrapped (Avenue'2 t a)

Associated Types

type Unwrapped (Avenue'2 t a) :: *

Methods

_Wrapped' :: Iso' (Avenue'2 t a) (Unwrapped (Avenue'2 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Avenue'2 t a)

Methods

prettyVal :: Avenue'2 t a -> Value

listValue :: [Avenue'2 t a] -> Value

type Unwrapped (Avenue'2 t a)

type Unwrapped (Avenue'2 t a) = (t, a)

data Avenue t a

Constructors

Avenue

Fields

• _r'Avenue'0'Avenue'0 :: (Avenue'0 t a)
• _r'Avenue'1'Avenue'1 :: (Avenue'1 t a)
• _r'Avenue'2'Avenue'2 :: (Avenue'2 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 t, Eq a) => Eq (Avenue t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (Avenue t a)

Methods

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

show :: Avenue t a -> String

showList :: [Avenue t a] -> ShowS

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

Methods

prettyVal :: Avenue t a -> Value

listValue :: [Avenue t a] -> Value

newtype Way'0 t a

Constructors

Way'0 (t, a)

Instances

Bifunctor Way'0

Methods

bimap :: (a -> b) -> (c -> d) -> Way'0 a c -> Way'0 b d

first :: (a -> b) -> Way'0 a c -> Way'0 b c

second :: (b -> c) -> Way'0 a b -> Way'0 a c

Functor (Way'0 t)

Methods

fmap :: (a -> b) -> Way'0 t a -> Way'0 t b

(<$) :: a -> Way'0 t b -> Way'0 t a

Foldable (Way'0 t)

Methods

fold :: Monoid m => Way'0 t m -> m

foldMap :: Monoid m => (a -> m) -> Way'0 t a -> m

foldr :: (a -> b -> b) -> b -> Way'0 t a -> b

foldr' :: (a -> b -> b) -> b -> Way'0 t a -> b

foldl :: (b -> a -> b) -> b -> Way'0 t a -> b

foldl' :: (b -> a -> b) -> b -> Way'0 t a -> b

foldr1 :: (a -> a -> a) -> Way'0 t a -> a

foldl1 :: (a -> a -> a) -> Way'0 t a -> a

toList :: Way'0 t a -> [a]

null :: Way'0 t a -> Bool

length :: Way'0 t a -> Int

elem :: Eq a => a -> Way'0 t a -> Bool

maximum :: Ord a => Way'0 t a -> a

minimum :: Ord a => Way'0 t a -> a

sum :: Num a => Way'0 t a -> a

product :: Num a => Way'0 t a -> a

Traversable (Way'0 t)

Methods

traverse :: Applicative f => (a -> f b) -> Way'0 t a -> f (Way'0 t b)

sequenceA :: Applicative f => Way'0 t (f a) -> f (Way'0 t a)

mapM :: Monad m => (a -> m b) -> Way'0 t a -> m (Way'0 t b)

sequence :: Monad m => Way'0 t (m a) -> m (Way'0 t a)

(Eq t, Eq a) => Eq (Way'0 t a)

Methods

(==) :: Way'0 t a -> Way'0 t a -> Bool

(/=) :: Way'0 t a -> Way'0 t a -> Bool

(Ord t, Ord a) => Ord (Way'0 t a)

Methods

compare :: Way'0 t a -> Way'0 t a -> Ordering

(<) :: Way'0 t a -> Way'0 t a -> Bool

(<=) :: Way'0 t a -> Way'0 t a -> Bool

(>) :: Way'0 t a -> Way'0 t a -> Bool

(>=) :: Way'0 t a -> Way'0 t a -> Bool

max :: Way'0 t a -> Way'0 t a -> Way'0 t a

min :: Way'0 t a -> Way'0 t a -> Way'0 t a

(Show t, Show a) => Show (Way'0 t a)

Methods

showsPrec :: Int -> Way'0 t a -> ShowS

show :: Way'0 t a -> String

showList :: [Way'0 t a] -> ShowS

Wrapped (Way'0 t a)

Associated Types

type Unwrapped (Way'0 t a) :: *

Methods

_Wrapped' :: Iso' (Way'0 t a) (Unwrapped (Way'0 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Way'0 t a)

Methods

prettyVal :: Way'0 t a -> Value

listValue :: [Way'0 t a] -> Value

type Unwrapped (Way'0 t a)

type Unwrapped (Way'0 t a) = (t, a)

newtype Way'1 t a

Constructors

Way'1 (t, a)

Instances

Bifunctor Way'1

Methods

bimap :: (a -> b) -> (c -> d) -> Way'1 a c -> Way'1 b d

first :: (a -> b) -> Way'1 a c -> Way'1 b c

second :: (b -> c) -> Way'1 a b -> Way'1 a c

Functor (Way'1 t)

Methods

fmap :: (a -> b) -> Way'1 t a -> Way'1 t b

(<$) :: a -> Way'1 t b -> Way'1 t a

Foldable (Way'1 t)

Methods

fold :: Monoid m => Way'1 t m -> m

foldMap :: Monoid m => (a -> m) -> Way'1 t a -> m

foldr :: (a -> b -> b) -> b -> Way'1 t a -> b

foldr' :: (a -> b -> b) -> b -> Way'1 t a -> b

foldl :: (b -> a -> b) -> b -> Way'1 t a -> b

foldl' :: (b -> a -> b) -> b -> Way'1 t a -> b

foldr1 :: (a -> a -> a) -> Way'1 t a -> a

foldl1 :: (a -> a -> a) -> Way'1 t a -> a

toList :: Way'1 t a -> [a]

null :: Way'1 t a -> Bool

length :: Way'1 t a -> Int

elem :: Eq a => a -> Way'1 t a -> Bool

maximum :: Ord a => Way'1 t a -> a

minimum :: Ord a => Way'1 t a -> a

sum :: Num a => Way'1 t a -> a

product :: Num a => Way'1 t a -> a

Traversable (Way'1 t)

Methods

traverse :: Applicative f => (a -> f b) -> Way'1 t a -> f (Way'1 t b)

sequenceA :: Applicative f => Way'1 t (f a) -> f (Way'1 t a)

mapM :: Monad m => (a -> m b) -> Way'1 t a -> m (Way'1 t b)

sequence :: Monad m => Way'1 t (m a) -> m (Way'1 t a)

(Eq t, Eq a) => Eq (Way'1 t a)

Methods

(==) :: Way'1 t a -> Way'1 t a -> Bool

(/=) :: Way'1 t a -> Way'1 t a -> Bool

(Ord t, Ord a) => Ord (Way'1 t a)

Methods

compare :: Way'1 t a -> Way'1 t a -> Ordering

(<) :: Way'1 t a -> Way'1 t a -> Bool

(<=) :: Way'1 t a -> Way'1 t a -> Bool

(>) :: Way'1 t a -> Way'1 t a -> Bool

(>=) :: Way'1 t a -> Way'1 t a -> Bool

max :: Way'1 t a -> Way'1 t a -> Way'1 t a

min :: Way'1 t a -> Way'1 t a -> Way'1 t a

(Show t, Show a) => Show (Way'1 t a)

Methods

showsPrec :: Int -> Way'1 t a -> ShowS

show :: Way'1 t a -> String

showList :: [Way'1 t a] -> ShowS

Wrapped (Way'1 t a)

Associated Types

type Unwrapped (Way'1 t a) :: *

Methods

_Wrapped' :: Iso' (Way'1 t a) (Unwrapped (Way'1 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Way'1 t a)

Methods

prettyVal :: Way'1 t a -> Value

listValue :: [Way'1 t a] -> Value

type Unwrapped (Way'1 t a)

type Unwrapped (Way'1 t a) = (t, a)

newtype Way'2 t a

Constructors

Way'2 (t, a)

Instances

Bifunctor Way'2

Methods

bimap :: (a -> b) -> (c -> d) -> Way'2 a c -> Way'2 b d

first :: (a -> b) -> Way'2 a c -> Way'2 b c

second :: (b -> c) -> Way'2 a b -> Way'2 a c

Functor (Way'2 t)

Methods

fmap :: (a -> b) -> Way'2 t a -> Way'2 t b

(<$) :: a -> Way'2 t b -> Way'2 t a

Foldable (Way'2 t)

Methods

fold :: Monoid m => Way'2 t m -> m

foldMap :: Monoid m => (a -> m) -> Way'2 t a -> m

foldr :: (a -> b -> b) -> b -> Way'2 t a -> b

foldr' :: (a -> b -> b) -> b -> Way'2 t a -> b

foldl :: (b -> a -> b) -> b -> Way'2 t a -> b

foldl' :: (b -> a -> b) -> b -> Way'2 t a -> b

foldr1 :: (a -> a -> a) -> Way'2 t a -> a

foldl1 :: (a -> a -> a) -> Way'2 t a -> a

toList :: Way'2 t a -> [a]

null :: Way'2 t a -> Bool

length :: Way'2 t a -> Int

elem :: Eq a => a -> Way'2 t a -> Bool

maximum :: Ord a => Way'2 t a -> a

minimum :: Ord a => Way'2 t a -> a

sum :: Num a => Way'2 t a -> a

product :: Num a => Way'2 t a -> a

Traversable (Way'2 t)

Methods

traverse :: Applicative f => (a -> f b) -> Way'2 t a -> f (Way'2 t b)

sequenceA :: Applicative f => Way'2 t (f a) -> f (Way'2 t a)

mapM :: Monad m => (a -> m b) -> Way'2 t a -> m (Way'2 t b)

sequence :: Monad m => Way'2 t (m a) -> m (Way'2 t a)

(Eq t, Eq a) => Eq (Way'2 t a)

Methods

(==) :: Way'2 t a -> Way'2 t a -> Bool

(/=) :: Way'2 t a -> Way'2 t a -> Bool

(Ord t, Ord a) => Ord (Way'2 t a)

Methods

compare :: Way'2 t a -> Way'2 t a -> Ordering

(<) :: Way'2 t a -> Way'2 t a -> Bool

(<=) :: Way'2 t a -> Way'2 t a -> Bool

(>) :: Way'2 t a -> Way'2 t a -> Bool

(>=) :: Way'2 t a -> Way'2 t a -> Bool

max :: Way'2 t a -> Way'2 t a -> Way'2 t a

min :: Way'2 t a -> Way'2 t a -> Way'2 t a

(Show t, Show a) => Show (Way'2 t a)

Methods

showsPrec :: Int -> Way'2 t a -> ShowS

show :: Way'2 t a -> String

showList :: [Way'2 t a] -> ShowS

Wrapped (Way'2 t a)

Associated Types

type Unwrapped (Way'2 t a) :: *

Methods

_Wrapped' :: Iso' (Way'2 t a) (Unwrapped (Way'2 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Way'2 t a)

Methods

prettyVal :: Way'2 t a -> Value

listValue :: [Way'2 t a] -> Value

type Unwrapped (Way'2 t a)

type Unwrapped (Way'2 t a) = (t, a)

data Way t a

Constructors

Way

Fields

• _r'Way'0'Way'0 :: (Way'0 t a)
• _r'Way'1'Way'1 :: (Way'1 t a)
• _r'Way'2'Way'2 :: (Way'2 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 t, Eq a) => Eq (Way t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (Way t a)

Methods

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

show :: Way t a -> String

showList :: [Way t a] -> ShowS

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

Methods

prettyVal :: Way t a -> Value

listValue :: [Way t a] -> Value

newtype Boulevard'0 t a

Constructors

Boulevard'0 (t, a)

Instances

Bifunctor Boulevard'0

Methods

bimap :: (a -> b) -> (c -> d) -> Boulevard'0 a c -> Boulevard'0 b d

first :: (a -> b) -> Boulevard'0 a c -> Boulevard'0 b c

second :: (b -> c) -> Boulevard'0 a b -> Boulevard'0 a c

Functor (Boulevard'0 t)

Methods

fmap :: (a -> b) -> Boulevard'0 t a -> Boulevard'0 t b

(<$) :: a -> Boulevard'0 t b -> Boulevard'0 t a

Foldable (Boulevard'0 t)

Methods

fold :: Monoid m => Boulevard'0 t m -> m

foldMap :: Monoid m => (a -> m) -> Boulevard'0 t a -> m

foldr :: (a -> b -> b) -> b -> Boulevard'0 t a -> b

foldr' :: (a -> b -> b) -> b -> Boulevard'0 t a -> b

foldl :: (b -> a -> b) -> b -> Boulevard'0 t a -> b

foldl' :: (b -> a -> b) -> b -> Boulevard'0 t a -> b

foldr1 :: (a -> a -> a) -> Boulevard'0 t a -> a

foldl1 :: (a -> a -> a) -> Boulevard'0 t a -> a

toList :: Boulevard'0 t a -> [a]

null :: Boulevard'0 t a -> Bool

length :: Boulevard'0 t a -> Int

elem :: Eq a => a -> Boulevard'0 t a -> Bool

maximum :: Ord a => Boulevard'0 t a -> a

minimum :: Ord a => Boulevard'0 t a -> a

sum :: Num a => Boulevard'0 t a -> a

product :: Num a => Boulevard'0 t a -> a

Traversable (Boulevard'0 t)

Methods

traverse :: Applicative f => (a -> f b) -> Boulevard'0 t a -> f (Boulevard'0 t b)

sequenceA :: Applicative f => Boulevard'0 t (f a) -> f (Boulevard'0 t a)

mapM :: Monad m => (a -> m b) -> Boulevard'0 t a -> m (Boulevard'0 t b)

sequence :: Monad m => Boulevard'0 t (m a) -> m (Boulevard'0 t a)

(Eq t, Eq a) => Eq (Boulevard'0 t a)

Methods

(==) :: Boulevard'0 t a -> Boulevard'0 t a -> Bool

(/=) :: Boulevard'0 t a -> Boulevard'0 t a -> Bool

(Ord t, Ord a) => Ord (Boulevard'0 t a)

Methods

compare :: Boulevard'0 t a -> Boulevard'0 t a -> Ordering

(<) :: Boulevard'0 t a -> Boulevard'0 t a -> Bool

(<=) :: Boulevard'0 t a -> Boulevard'0 t a -> Bool

(>) :: Boulevard'0 t a -> Boulevard'0 t a -> Bool

(>=) :: Boulevard'0 t a -> Boulevard'0 t a -> Bool

max :: Boulevard'0 t a -> Boulevard'0 t a -> Boulevard'0 t a

min :: Boulevard'0 t a -> Boulevard'0 t a -> Boulevard'0 t a

(Show t, Show a) => Show (Boulevard'0 t a)

Methods

showsPrec :: Int -> Boulevard'0 t a -> ShowS

show :: Boulevard'0 t a -> String

showList :: [Boulevard'0 t a] -> ShowS

Wrapped (Boulevard'0 t a)

Associated Types

type Unwrapped (Boulevard'0 t a) :: *

Methods

_Wrapped' :: Iso' (Boulevard'0 t a) (Unwrapped (Boulevard'0 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Boulevard'0 t a)

Methods

prettyVal :: Boulevard'0 t a -> Value

listValue :: [Boulevard'0 t a] -> Value

type Unwrapped (Boulevard'0 t a)

type Unwrapped (Boulevard'0 t a) = (t, a)

newtype Boulevard'1 t a

Constructors

Boulevard'1 (t, a)

Instances

Bifunctor Boulevard'1

Methods

bimap :: (a -> b) -> (c -> d) -> Boulevard'1 a c -> Boulevard'1 b d

first :: (a -> b) -> Boulevard'1 a c -> Boulevard'1 b c

second :: (b -> c) -> Boulevard'1 a b -> Boulevard'1 a c

Functor (Boulevard'1 t)

Methods

fmap :: (a -> b) -> Boulevard'1 t a -> Boulevard'1 t b

(<$) :: a -> Boulevard'1 t b -> Boulevard'1 t a

Foldable (Boulevard'1 t)

Methods

fold :: Monoid m => Boulevard'1 t m -> m

foldMap :: Monoid m => (a -> m) -> Boulevard'1 t a -> m

foldr :: (a -> b -> b) -> b -> Boulevard'1 t a -> b

foldr' :: (a -> b -> b) -> b -> Boulevard'1 t a -> b

foldl :: (b -> a -> b) -> b -> Boulevard'1 t a -> b

foldl' :: (b -> a -> b) -> b -> Boulevard'1 t a -> b

foldr1 :: (a -> a -> a) -> Boulevard'1 t a -> a

foldl1 :: (a -> a -> a) -> Boulevard'1 t a -> a

toList :: Boulevard'1 t a -> [a]

null :: Boulevard'1 t a -> Bool

length :: Boulevard'1 t a -> Int

elem :: Eq a => a -> Boulevard'1 t a -> Bool

maximum :: Ord a => Boulevard'1 t a -> a

minimum :: Ord a => Boulevard'1 t a -> a

sum :: Num a => Boulevard'1 t a -> a

product :: Num a => Boulevard'1 t a -> a

Traversable (Boulevard'1 t)

Methods

traverse :: Applicative f => (a -> f b) -> Boulevard'1 t a -> f (Boulevard'1 t b)

sequenceA :: Applicative f => Boulevard'1 t (f a) -> f (Boulevard'1 t a)

mapM :: Monad m => (a -> m b) -> Boulevard'1 t a -> m (Boulevard'1 t b)

sequence :: Monad m => Boulevard'1 t (m a) -> m (Boulevard'1 t a)

(Eq t, Eq a) => Eq (Boulevard'1 t a)

Methods

(==) :: Boulevard'1 t a -> Boulevard'1 t a -> Bool

(/=) :: Boulevard'1 t a -> Boulevard'1 t a -> Bool

(Ord t, Ord a) => Ord (Boulevard'1 t a)

Methods

compare :: Boulevard'1 t a -> Boulevard'1 t a -> Ordering

(<) :: Boulevard'1 t a -> Boulevard'1 t a -> Bool

(<=) :: Boulevard'1 t a -> Boulevard'1 t a -> Bool

(>) :: Boulevard'1 t a -> Boulevard'1 t a -> Bool

(>=) :: Boulevard'1 t a -> Boulevard'1 t a -> Bool

max :: Boulevard'1 t a -> Boulevard'1 t a -> Boulevard'1 t a

min :: Boulevard'1 t a -> Boulevard'1 t a -> Boulevard'1 t a

(Show t, Show a) => Show (Boulevard'1 t a)

Methods

showsPrec :: Int -> Boulevard'1 t a -> ShowS

show :: Boulevard'1 t a -> String

showList :: [Boulevard'1 t a] -> ShowS

Wrapped (Boulevard'1 t a)

Associated Types

type Unwrapped (Boulevard'1 t a) :: *

Methods

_Wrapped' :: Iso' (Boulevard'1 t a) (Unwrapped (Boulevard'1 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Boulevard'1 t a)

Methods

prettyVal :: Boulevard'1 t a -> Value

listValue :: [Boulevard'1 t a] -> Value

type Unwrapped (Boulevard'1 t a)

type Unwrapped (Boulevard'1 t a) = (t, a)

newtype Boulevard'2 t a

Constructors

Boulevard'2 (t, a)

Instances

Bifunctor Boulevard'2

Methods

bimap :: (a -> b) -> (c -> d) -> Boulevard'2 a c -> Boulevard'2 b d

first :: (a -> b) -> Boulevard'2 a c -> Boulevard'2 b c

second :: (b -> c) -> Boulevard'2 a b -> Boulevard'2 a c

Functor (Boulevard'2 t)

Methods

fmap :: (a -> b) -> Boulevard'2 t a -> Boulevard'2 t b

(<$) :: a -> Boulevard'2 t b -> Boulevard'2 t a

Foldable (Boulevard'2 t)

Methods

fold :: Monoid m => Boulevard'2 t m -> m

foldMap :: Monoid m => (a -> m) -> Boulevard'2 t a -> m

foldr :: (a -> b -> b) -> b -> Boulevard'2 t a -> b

foldr' :: (a -> b -> b) -> b -> Boulevard'2 t a -> b

foldl :: (b -> a -> b) -> b -> Boulevard'2 t a -> b

foldl' :: (b -> a -> b) -> b -> Boulevard'2 t a -> b

foldr1 :: (a -> a -> a) -> Boulevard'2 t a -> a

foldl1 :: (a -> a -> a) -> Boulevard'2 t a -> a

toList :: Boulevard'2 t a -> [a]

null :: Boulevard'2 t a -> Bool

length :: Boulevard'2 t a -> Int

elem :: Eq a => a -> Boulevard'2 t a -> Bool

maximum :: Ord a => Boulevard'2 t a -> a

minimum :: Ord a => Boulevard'2 t a -> a

sum :: Num a => Boulevard'2 t a -> a

product :: Num a => Boulevard'2 t a -> a

Traversable (Boulevard'2 t)

Methods

traverse :: Applicative f => (a -> f b) -> Boulevard'2 t a -> f (Boulevard'2 t b)

sequenceA :: Applicative f => Boulevard'2 t (f a) -> f (Boulevard'2 t a)

mapM :: Monad m => (a -> m b) -> Boulevard'2 t a -> m (Boulevard'2 t b)

sequence :: Monad m => Boulevard'2 t (m a) -> m (Boulevard'2 t a)

(Eq t, Eq a) => Eq (Boulevard'2 t a)

Methods

(==) :: Boulevard'2 t a -> Boulevard'2 t a -> Bool

(/=) :: Boulevard'2 t a -> Boulevard'2 t a -> Bool

(Ord t, Ord a) => Ord (Boulevard'2 t a)

Methods

compare :: Boulevard'2 t a -> Boulevard'2 t a -> Ordering

(<) :: Boulevard'2 t a -> Boulevard'2 t a -> Bool

(<=) :: Boulevard'2 t a -> Boulevard'2 t a -> Bool

(>) :: Boulevard'2 t a -> Boulevard'2 t a -> Bool

(>=) :: Boulevard'2 t a -> Boulevard'2 t a -> Bool

max :: Boulevard'2 t a -> Boulevard'2 t a -> Boulevard'2 t a

min :: Boulevard'2 t a -> Boulevard'2 t a -> Boulevard'2 t a

(Show t, Show a) => Show (Boulevard'2 t a)

Methods

showsPrec :: Int -> Boulevard'2 t a -> ShowS

show :: Boulevard'2 t a -> String

showList :: [Boulevard'2 t a] -> ShowS

Wrapped (Boulevard'2 t a)

Associated Types

type Unwrapped (Boulevard'2 t a) :: *

Methods

_Wrapped' :: Iso' (Boulevard'2 t a) (Unwrapped (Boulevard'2 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Boulevard'2 t a)

Methods

prettyVal :: Boulevard'2 t a -> Value

listValue :: [Boulevard'2 t a] -> Value

type Unwrapped (Boulevard'2 t a)

type Unwrapped (Boulevard'2 t a) = (t, a)

newtype Boulevard'3 t a

Constructors

Boulevard'3 (t, a)

Instances

Bifunctor Boulevard'3

Methods

bimap :: (a -> b) -> (c -> d) -> Boulevard'3 a c -> Boulevard'3 b d

first :: (a -> b) -> Boulevard'3 a c -> Boulevard'3 b c

second :: (b -> c) -> Boulevard'3 a b -> Boulevard'3 a c

Functor (Boulevard'3 t)

Methods

fmap :: (a -> b) -> Boulevard'3 t a -> Boulevard'3 t b

(<$) :: a -> Boulevard'3 t b -> Boulevard'3 t a

Foldable (Boulevard'3 t)

Methods

fold :: Monoid m => Boulevard'3 t m -> m

foldMap :: Monoid m => (a -> m) -> Boulevard'3 t a -> m

foldr :: (a -> b -> b) -> b -> Boulevard'3 t a -> b

foldr' :: (a -> b -> b) -> b -> Boulevard'3 t a -> b

foldl :: (b -> a -> b) -> b -> Boulevard'3 t a -> b

foldl' :: (b -> a -> b) -> b -> Boulevard'3 t a -> b

foldr1 :: (a -> a -> a) -> Boulevard'3 t a -> a

foldl1 :: (a -> a -> a) -> Boulevard'3 t a -> a

toList :: Boulevard'3 t a -> [a]

null :: Boulevard'3 t a -> Bool

length :: Boulevard'3 t a -> Int

elem :: Eq a => a -> Boulevard'3 t a -> Bool

maximum :: Ord a => Boulevard'3 t a -> a

minimum :: Ord a => Boulevard'3 t a -> a

sum :: Num a => Boulevard'3 t a -> a

product :: Num a => Boulevard'3 t a -> a

Traversable (Boulevard'3 t)

Methods

traverse :: Applicative f => (a -> f b) -> Boulevard'3 t a -> f (Boulevard'3 t b)

sequenceA :: Applicative f => Boulevard'3 t (f a) -> f (Boulevard'3 t a)

mapM :: Monad m => (a -> m b) -> Boulevard'3 t a -> m (Boulevard'3 t b)

sequence :: Monad m => Boulevard'3 t (m a) -> m (Boulevard'3 t a)

(Eq t, Eq a) => Eq (Boulevard'3 t a)

Methods

(==) :: Boulevard'3 t a -> Boulevard'3 t a -> Bool

(/=) :: Boulevard'3 t a -> Boulevard'3 t a -> Bool

(Ord t, Ord a) => Ord (Boulevard'3 t a)

Methods

compare :: Boulevard'3 t a -> Boulevard'3 t a -> Ordering

(<) :: Boulevard'3 t a -> Boulevard'3 t a -> Bool

(<=) :: Boulevard'3 t a -> Boulevard'3 t a -> Bool

(>) :: Boulevard'3 t a -> Boulevard'3 t a -> Bool

(>=) :: Boulevard'3 t a -> Boulevard'3 t a -> Bool

max :: Boulevard'3 t a -> Boulevard'3 t a -> Boulevard'3 t a

min :: Boulevard'3 t a -> Boulevard'3 t a -> Boulevard'3 t a

(Show t, Show a) => Show (Boulevard'3 t a)

Methods

showsPrec :: Int -> Boulevard'3 t a -> ShowS

show :: Boulevard'3 t a -> String

showList :: [Boulevard'3 t a] -> ShowS

Wrapped (Boulevard'3 t a)

Associated Types

type Unwrapped (Boulevard'3 t a) :: *

Methods

_Wrapped' :: Iso' (Boulevard'3 t a) (Unwrapped (Boulevard'3 t a))

(PrettyVal t, PrettyVal a) => PrettyVal (Boulevard'3 t a)

Methods

prettyVal :: Boulevard'3 t a -> Value

listValue :: [Boulevard'3 t a] -> Value

type Unwrapped (Boulevard'3 t a)

type Unwrapped (Boulevard'3 t a) = (t, a)

data Boulevard t a

Constructors

Boulevard

Fields

• _r'Boulevard'0'Boulevard'0 :: (Boulevard'0 t a)
• _r'Boulevard'1'Boulevard'1 :: (Boulevard'1 t a)
• _r'Boulevard'2'Boulevard'2 :: (Boulevard'2 t a)
• _r'Boulevard'3'Boulevard'3 :: (Boulevard'3 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 t, Eq a) => Eq (Boulevard t a)

Methods

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

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

(Ord t, Ord a) => 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 t, Show a) => Show (Boulevard t a)

Methods

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

show :: Boulevard t a -> String

showList :: [Boulevard t a] -> ShowS

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

Methods

prettyVal :: Boulevard t a -> Value

listValue :: [Boulevard t a] -> Value

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

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

Methods

prettyVal :: Suffix t a -> Value

listValue :: [Suffix t a] -> Value

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

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

Methods

prettyVal :: SpaceSuffix t a -> Value

listValue :: [SpaceSuffix t a] -> Value

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 t, Eq a) => 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 t, Ord a) => 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 t, Show a) => 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

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 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

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

Methods

prettyVal :: StreetLine t a -> Value

listValue :: [StreetLine t a] -> Value

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

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 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

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 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

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

Methods

prettyVal :: ZipCode t a -> Value

listValue :: [ZipCode t a] -> Value

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

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 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

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

Methods

prettyVal :: CityLine t a -> Value

listValue :: [CityLine t a] -> Value

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

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

Methods

prettyVal :: Address t a -> Value

listValue :: [Address t a] -> Value