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

Functor (Letter t)

Foldable (Letter t)

Traversable (Letter t)

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

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

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

Wrapped (Letter t a)

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

data Letters t a

Constructors

NoLetter

ConsLetter (Letter t a) (Letters t a)

Instances

Functor (Letters t)

Foldable (Letters t)

Traversable (Letters t)

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

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

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

data PostalWord t a

Constructors

PostalWord

Fields

_r'PostalWord'0'Letter :: Letter t a

_r'PostalWord'1'Letters :: Letters t a

Instances

Functor (PostalWord t)

Foldable (PostalWord t)

Traversable (PostalWord t)

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

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

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

newtype Space t a

Constructors

Space (t, a)

Instances

Functor (Space t)

Foldable (Space t)

Traversable (Space t)

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

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

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

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

Functor (PreSpacedWord t)

Foldable (PreSpacedWord t)

Traversable (PreSpacedWord t)

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

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

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

newtype PreSpacedWord'Star t a

Constructors

PreSpacedWord'Star (Seq (PreSpacedWord t a))

Instances

Functor (PreSpacedWord'Star t)

Foldable (PreSpacedWord'Star t)

Traversable (PreSpacedWord'Star t)

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

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

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

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

Functor (Words t)

Foldable (Words t)

Traversable (Words t)

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

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

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

newtype Comma t a

Constructors

Comma (t, a)

Instances

Functor (Comma t)

Foldable (Comma t)

Traversable (Comma t)

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

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

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

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

Functor (CommaSpace t)

Foldable (CommaSpace t)

Traversable (CommaSpace t)

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

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

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

newtype Newline t a

Constructors

Newline (t, a)

Instances

Functor (Newline t)

Foldable (Newline t)

Traversable (Newline t)

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

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

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

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

Functor (Separator t)

Foldable (Separator t)

Traversable (Separator t)

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

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

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

data NameLine t a

Constructors

NameLine

Fields

_r'NameLine'0'Words :: Words t a

_r'NameLine'1'Separator :: Separator t a

Instances

Functor (NameLine t)

Foldable (NameLine t)

Traversable (NameLine t)

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

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

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

newtype Digit t a

Constructors

Digit (t, a)

Instances

Functor (Digit t)

Foldable (Digit t)

Traversable (Digit t)

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

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

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

Wrapped (Digit t a)

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

newtype Digit'Plus t a

Constructors

Digit'Plus (NonEmpty (Digit t a))

Instances

Functor (Digit'Plus t)

Foldable (Digit'Plus t)

Traversable (Digit'Plus t)

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

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

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

Wrapped (Digit'Plus t a)

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

newtype Number t a

Constructors

Number (Digit'Plus t a)

Instances

Functor (Number t)

Foldable (Number t)

Traversable (Number t)

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

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

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

Wrapped (Number t a)

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

newtype North t a

Constructors

North (t, a)

Instances

Functor (North t)

Foldable (North t)

Traversable (North t)

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

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

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

Wrapped (North t a)

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

newtype South t a

Constructors

South (t, a)

Instances

Functor (South t)

Foldable (South t)

Traversable (South t)

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

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

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

Wrapped (South t a)

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

newtype East t a

Constructors

East (t, a)

Instances

Functor (East t)

Foldable (East t)

Traversable (East t)

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

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

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

Wrapped (East t a)

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

newtype West t a

Constructors

West (t, a)

Instances

Functor (West t)

Foldable (West t)

Traversable (West t)

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

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

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

Wrapped (West t a)

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

newtype NE'0 t a

Constructors

NE'0 (t, a)

Instances

Functor (NE'0 t)

Foldable (NE'0 t)

Traversable (NE'0 t)

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

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

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

Wrapped (NE'0 t a)

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

newtype NE'1 t a

Constructors

NE'1 (t, a)

Instances

Functor (NE'1 t)

Foldable (NE'1 t)

Traversable (NE'1 t)

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

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

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

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

Functor (NE t)

Foldable (NE t)

Traversable (NE t)

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

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

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

newtype NW'0 t a

Constructors

NW'0 (t, a)

Instances

Functor (NW'0 t)

Foldable (NW'0 t)

Traversable (NW'0 t)

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

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

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

Wrapped (NW'0 t a)

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

newtype NW'1 t a

Constructors

NW'1 (t, a)

Instances

Functor (NW'1 t)

Foldable (NW'1 t)

Traversable (NW'1 t)

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

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

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

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

Functor (NW t)

Foldable (NW t)

Traversable (NW t)

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

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

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

newtype SE'0 t a

Constructors

SE'0 (t, a)

Instances

Functor (SE'0 t)

Foldable (SE'0 t)

Traversable (SE'0 t)

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

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

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

Wrapped (SE'0 t a)

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

newtype SE'1 t a

Constructors

SE'1 (t, a)

Instances

Functor (SE'1 t)

Foldable (SE'1 t)

Traversable (SE'1 t)

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

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

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

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

Functor (SE t)

Foldable (SE t)

Traversable (SE t)

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

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

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

newtype SW'0 t a

Constructors

SW'0 (t, a)

Instances

Functor (SW'0 t)

Foldable (SW'0 t)

Traversable (SW'0 t)

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

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

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

Wrapped (SW'0 t a)

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

newtype SW'1 t a

Constructors

SW'1 (t, a)

Instances

Functor (SW'1 t)

Foldable (SW'1 t)

Traversable (SW'1 t)

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

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

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

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

Functor (SW t)

Foldable (SW t)

Traversable (SW t)

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

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

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

data Direction t a

Constructors

Direction'North (North t a)

Direction'South (South t a)

Direction'East (East t a)

Direction'West (West t a)

Direction'NE (NE t a)

Direction'NW (NW t a)

Direction'SE (SE t a)

Direction'SW (SW t a)

Instances

Functor (Direction t)

Foldable (Direction t)

Traversable (Direction t)

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

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

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

data DirectionSpace t a

Constructors

DirectionSpace

Fields

_r'DirectionSpace'0'Direction :: Direction t a

_r'DirectionSpace'1'Space :: Space t a

Instances

Functor (DirectionSpace t)

Foldable (DirectionSpace t)

Traversable (DirectionSpace t)

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

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

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

newtype DirectionSpace'Opt t a

Constructors

DirectionSpace'Opt (Maybe (DirectionSpace t a))

Instances

Functor (DirectionSpace'Opt t)

Foldable (DirectionSpace'Opt t)

Traversable (DirectionSpace'Opt t)

(Eq t, Eq a) => Eq (DirectionSpace'Opt t a)

(Ord t, Ord a) => Ord (DirectionSpace'Opt t a)

(Show t, Show a) => Show (DirectionSpace'Opt t a)

Wrapped (DirectionSpace'Opt t a)

type Unwrapped (DirectionSpace'Opt t a) = Maybe (DirectionSpace t a)

newtype StreetName t a

Constructors

StreetName (Words t a)

Instances

Functor (StreetName t)

Foldable (StreetName t)

Traversable (StreetName t)

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

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

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

Wrapped (StreetName t a)

type Unwrapped (StreetName t a) = Words t a

newtype Street'0 t a

Constructors

Street'0 (t, a)

Instances

Functor (Street'0 t)

Foldable (Street'0 t)

Traversable (Street'0 t)

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

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

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

Wrapped (Street'0 t a)

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

newtype Street'1 t a

Constructors

Street'1 (t, a)

Instances

Functor (Street'1 t)

Foldable (Street'1 t)

Traversable (Street'1 t)

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

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

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

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

Functor (Street t)

Foldable (Street t)

Traversable (Street t)

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

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

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

newtype Avenue'0 t a

Constructors

Avenue'0 (t, a)

Instances

Functor (Avenue'0 t)

Foldable (Avenue'0 t)

Traversable (Avenue'0 t)

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

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

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

Wrapped (Avenue'0 t a)

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

newtype Avenue'1 t a

Constructors

Avenue'1 (t, a)

Instances

Functor (Avenue'1 t)

Foldable (Avenue'1 t)

Traversable (Avenue'1 t)

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

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

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

Wrapped (Avenue'1 t a)

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

newtype Avenue'2 t a

Constructors

Avenue'2 (t, a)

Instances

Functor (Avenue'2 t)

Foldable (Avenue'2 t)

Traversable (Avenue'2 t)

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

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

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

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

Functor (Avenue t)

Foldable (Avenue t)

Traversable (Avenue t)

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

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

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

newtype Way'0 t a

Constructors

Way'0 (t, a)

Instances

Functor (Way'0 t)

Foldable (Way'0 t)

Traversable (Way'0 t)

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

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

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

Wrapped (Way'0 t a)

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

newtype Way'1 t a

Constructors

Way'1 (t, a)

Instances

Functor (Way'1 t)

Foldable (Way'1 t)

Traversable (Way'1 t)

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

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

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

Wrapped (Way'1 t a)

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

newtype Way'2 t a

Constructors

Way'2 (t, a)

Instances

Functor (Way'2 t)

Foldable (Way'2 t)

Traversable (Way'2 t)

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

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

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

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

Functor (Way t)

Foldable (Way t)

Traversable (Way t)

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

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

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

newtype Boulevard'0 t a

Constructors

Boulevard'0 (t, a)

Instances

Functor (Boulevard'0 t)

Foldable (Boulevard'0 t)

Traversable (Boulevard'0 t)

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

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

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

Wrapped (Boulevard'0 t a)

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

newtype Boulevard'1 t a

Constructors

Boulevard'1 (t, a)

Instances

Functor (Boulevard'1 t)

Foldable (Boulevard'1 t)

Traversable (Boulevard'1 t)

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

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

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

Wrapped (Boulevard'1 t a)

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

newtype Boulevard'2 t a

Constructors

Boulevard'2 (t, a)

Instances

Functor (Boulevard'2 t)

Foldable (Boulevard'2 t)

Traversable (Boulevard'2 t)

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

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

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

Wrapped (Boulevard'2 t a)

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

newtype Boulevard'3 t a

Constructors

Boulevard'3 (t, a)

Instances

Functor (Boulevard'3 t)

Foldable (Boulevard'3 t)

Traversable (Boulevard'3 t)

(Eq t, Eq a) => Eq (Boulevard'3 t a)

(Ord t, Ord a) => Ord (Boulevard'3 t a)

(Show t, Show a) => Show (Boulevard'3 t a)

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

Functor (Boulevard t)

Foldable (Boulevard t)

Traversable (Boulevard t)

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

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

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

data Suffix t a

Constructors

Suffix'Street (Street t a)

Suffix'Avenue (Avenue t a)

Suffix'Way (Way t a)

Suffix'Boulevard (Boulevard t a)

Instances

Functor (Suffix t)

Foldable (Suffix t)

Traversable (Suffix t)

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

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

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

data SpaceSuffix t a

Constructors

SpaceSuffix

Fields

_r'SpaceSuffix'0'Space :: Space t a

_r'SpaceSuffix'1'Suffix :: Suffix t a

Instances

Functor (SpaceSuffix t)

Foldable (SpaceSuffix t)

Traversable (SpaceSuffix t)

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

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

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

newtype SpaceSuffix'Opt t a

Constructors

SpaceSuffix'Opt (Maybe (SpaceSuffix t a))

Instances

Functor (SpaceSuffix'Opt t)

Foldable (SpaceSuffix'Opt t)

Traversable (SpaceSuffix'Opt t)

(Eq t, Eq a) => Eq (SpaceSuffix'Opt t a)

(Ord t, Ord a) => Ord (SpaceSuffix'Opt t a)

(Show t, Show a) => Show (SpaceSuffix'Opt t a)

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

Functor (StreetLine t)

Foldable (StreetLine t)

Traversable (StreetLine t)

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

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

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

newtype City t a

Constructors

City (Words t a)

Instances

Functor (City t)

Foldable (City t)

Traversable (City t)

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

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

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

Wrapped (City t a)

type Unwrapped (City t a) = Words t a

newtype State t a

Constructors

State (Words t a)

Instances

Functor (State t)

Foldable (State t)

Traversable (State t)

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

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

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

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

Functor (ZipCode t)

Foldable (ZipCode t)

Traversable (ZipCode t)

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

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

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

newtype Newline'Opt t a

Constructors

Newline'Opt (Maybe (Newline t a))

Instances

Functor (Newline'Opt t)

Foldable (Newline'Opt t)

Traversable (Newline'Opt t)

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

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

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

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

Functor (CityLine t)

Foldable (CityLine t)

Traversable (CityLine t)

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

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

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

data Address t a

Constructors

Address

Fields

_r'Address'0'NameLine :: NameLine t a

_r'Address'1'StreetLine :: StreetLine t a

_r'Address'2'CityLine :: CityLine t a

Instances

Functor (Address t)

Foldable (Address t)

Traversable (Address t)

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

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

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