    {-|

    Most data types are defined here to avoid import cycles.
    Here is an overview of the hledger data model:

    > Journal                  -- a journal is read from one or more data files. It contains..
    >  [Transaction]           -- journal transactions (aka entries), which have date, cleared status, code, description and..
    >   [Posting]              -- multiple account postings, which have account name and amount
    >  [MarketPrice]           -- historical market prices for commodities
    >
    > Ledger                   -- a ledger is derived from a journal, by applying a filter specification and doing some further processing. It contains..
    >  Journal                 -- a filtered copy of the original journal, containing only the transactions and postings we are interested in
    >  [Account]               -- all accounts, in tree order beginning with a "root" account", with their balances and sub/parent accounts

    For more detailed documentation on each type, see the corresponding modules.

    -}

    -- {-# LANGUAGE DeriveAnyClass #-}  -- https://hackage.haskell.org/package/deepseq-1.4.4.0/docs/Control-DeepSeq.html#v:rnf
    {-# LANGUAGE DeriveGeneric #-}
    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE OverloadedStrings #-}
    {-# LANGUAGE RecordWildCards #-}
    {-# LANGUAGE StandaloneDeriving #-}
    {-# LANGUAGE TypeSynonymInstances #-}

    module Hledger.Data.Types
    where

    import GHC.Generics (Generic)
    import Data.Decimal
    import Data.Default
    import Data.Functor (($>))
    import Data.List (intercalate)
    import Text.Blaze (ToMarkup(..))
    --XXX https://hackage.haskell.org/package/containers/docs/Data-Map.html
    --Note: You should use Data.Map.Strict instead of this module if:
    --You will eventually need all the values stored.
    --The stored values don't represent large virtual data structures to be lazily computed.
    import qualified Data.Map as M
    import Data.Text (Text)
    -- import qualified Data.Text as T
    import Data.Time.Calendar
    import Data.Time.LocalTime
    import Data.Word (Word8)
    import System.Time (ClockTime(..))
    import Text.Printf

    import Hledger.Utils.Regex

    -- | A possibly incomplete year-month-day date provided by the user, to be
    -- interpreted as either a date or a date span depending on context. Missing
    -- parts "on the left" will be filled from the provided reference date, e.g. if
    -- the year and month are missing, the reference date's year and month are used.
    -- Missing parts "on the right" are assumed, when interpreting as a date, to be
    -- 1, (e.g. if the year and month are present but the day is missing, it means
    -- first day of that month); or when interpreting as a date span, to be a
    -- wildcard (so it would mean all days of that month). See the `smartdate`
    -- parser for more examples.
    --
    -- Or, one of the standard periods and an offset relative to the reference date:
    -- (last|this|next) (day|week|month|quarter|year), where "this" means the period
    -- containing the reference date.
    data SmartDate
      = SmartAssumeStart Year (Maybe (Month, Maybe MonthDay))
      | SmartFromReference (Maybe Month) MonthDay
      | SmartMonth Month
      | SmartRelative SmartSequence SmartInterval
      deriving (Int -> SmartDate -> ShowS
    [SmartDate] -> ShowS
    SmartDate -> String
    (Int -> SmartDate -> ShowS)
    -> (SmartDate -> String)
    -> ([SmartDate] -> ShowS)
    -> Show SmartDate
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [SmartDate] -> ShowS
    $cshowList :: [SmartDate] -> ShowS
    show :: SmartDate -> String
    $cshow :: SmartDate -> String
    showsPrec :: Int -> SmartDate -> ShowS
    $cshowsPrec :: Int -> SmartDate -> ShowS
    Show)

    data SmartSequence = Last | This | Next deriving (Int -> SmartSequence -> ShowS
    [SmartSequence] -> ShowS
    SmartSequence -> String
    (Int -> SmartSequence -> ShowS)
    -> (SmartSequence -> String)
    -> ([SmartSequence] -> ShowS)
    -> Show SmartSequence
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [SmartSequence] -> ShowS
    $cshowList :: [SmartSequence] -> ShowS
    show :: SmartSequence -> String
    $cshow :: SmartSequence -> String
    showsPrec :: Int -> SmartSequence -> ShowS
    $cshowsPrec :: Int -> SmartSequence -> ShowS
    Show)
    data SmartInterval = Day | Week | Month | Quarter | Year deriving (Int -> SmartInterval -> ShowS
    [SmartInterval] -> ShowS
    SmartInterval -> String
    (Int -> SmartInterval -> ShowS)
    -> (SmartInterval -> String)
    -> ([SmartInterval] -> ShowS)
    -> Show SmartInterval
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [SmartInterval] -> ShowS
    $cshowList :: [SmartInterval] -> ShowS
    show :: SmartInterval -> String
    $cshow :: SmartInterval -> String
    showsPrec :: Int -> SmartInterval -> ShowS
    $cshowsPrec :: Int -> SmartInterval -> ShowS
    Show)

    data WhichDate = PrimaryDate | SecondaryDate deriving (WhichDate -> WhichDate -> Bool
    (WhichDate -> WhichDate -> Bool)
    -> (WhichDate -> WhichDate -> Bool) -> Eq WhichDate
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: WhichDate -> WhichDate -> Bool
    $c/= :: WhichDate -> WhichDate -> Bool
    == :: WhichDate -> WhichDate -> Bool
    $c== :: WhichDate -> WhichDate -> Bool
    Eq,Int -> WhichDate -> ShowS
    [WhichDate] -> ShowS
    WhichDate -> String
    (Int -> WhichDate -> ShowS)
    -> (WhichDate -> String)
    -> ([WhichDate] -> ShowS)
    -> Show WhichDate
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [WhichDate] -> ShowS
    $cshowList :: [WhichDate] -> ShowS
    show :: WhichDate -> String
    $cshow :: WhichDate -> String
    showsPrec :: Int -> WhichDate -> ShowS
    $cshowsPrec :: Int -> WhichDate -> ShowS
    Show)

    data DateSpan = DateSpan (Maybe Day) (Maybe Day) deriving (DateSpan -> DateSpan -> Bool
    (DateSpan -> DateSpan -> Bool)
    -> (DateSpan -> DateSpan -> Bool) -> Eq DateSpan
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: DateSpan -> DateSpan -> Bool
    $c/= :: DateSpan -> DateSpan -> Bool
    == :: DateSpan -> DateSpan -> Bool
    $c== :: DateSpan -> DateSpan -> Bool
    Eq,Eq DateSpan
    Eq DateSpan =>
    (DateSpan -> DateSpan -> Ordering)
    -> (DateSpan -> DateSpan -> Bool)
    -> (DateSpan -> DateSpan -> Bool)
    -> (DateSpan -> DateSpan -> Bool)
    -> (DateSpan -> DateSpan -> Bool)
    -> (DateSpan -> DateSpan -> DateSpan)
    -> (DateSpan -> DateSpan -> DateSpan)
    -> Ord DateSpan
    DateSpan -> DateSpan -> Bool
    DateSpan -> DateSpan -> Ordering
    DateSpan -> DateSpan -> DateSpan
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: DateSpan -> DateSpan -> DateSpan
    $cmin :: DateSpan -> DateSpan -> DateSpan
    max :: DateSpan -> DateSpan -> DateSpan
    $cmax :: DateSpan -> DateSpan -> DateSpan
    >= :: DateSpan -> DateSpan -> Bool
    $c>= :: DateSpan -> DateSpan -> Bool
    > :: DateSpan -> DateSpan -> Bool
    $c> :: DateSpan -> DateSpan -> Bool
    <= :: DateSpan -> DateSpan -> Bool
    $c<= :: DateSpan -> DateSpan -> Bool
    < :: DateSpan -> DateSpan -> Bool
    $c< :: DateSpan -> DateSpan -> Bool
    compare :: DateSpan -> DateSpan -> Ordering
    $ccompare :: DateSpan -> DateSpan -> Ordering
    $cp1Ord :: Eq DateSpan
    Ord,(forall x. DateSpan -> Rep DateSpan x)
    -> (forall x. Rep DateSpan x -> DateSpan) -> Generic DateSpan
    forall x. Rep DateSpan x -> DateSpan
    forall x. DateSpan -> Rep DateSpan x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep DateSpan x -> DateSpan
    $cfrom :: forall x. DateSpan -> Rep DateSpan x
    Generic)

    instance Default DateSpan where def :: DateSpan
    def = Maybe Day -> Maybe Day -> DateSpan
    DateSpan Maybe Day
    forall a. Maybe a
    Nothing Maybe Day
    forall a. Maybe a
    Nothing

    -- synonyms for various date-related scalars
    type Year = Integer
    type Month = Int     -- 1-12
    type Quarter = Int   -- 1-4
    type YearWeek = Int  -- 1-52
    type MonthWeek = Int -- 1-5
    type YearDay = Int   -- 1-366
    type MonthDay = Int  -- 1-31
    type WeekDay = Int   -- 1-7

    -- Typical report periods (spans of time), both finite and open-ended.
    -- A richer abstraction than DateSpan.
    data Period =
        DayPeriod Day
      | WeekPeriod Day
      | MonthPeriod Year Month
      | QuarterPeriod Year Quarter
      | YearPeriod Year
      | PeriodBetween Day Day
      | PeriodFrom Day
      | PeriodTo Day
      | PeriodAll
      deriving (Period -> Period -> Bool
    (Period -> Period -> Bool)
    -> (Period -> Period -> Bool) -> Eq Period
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Period -> Period -> Bool
    $c/= :: Period -> Period -> Bool
    == :: Period -> Period -> Bool
    $c== :: Period -> Period -> Bool
    Eq,Eq Period
    Eq Period =>
    (Period -> Period -> Ordering)
    -> (Period -> Period -> Bool)
    -> (Period -> Period -> Bool)
    -> (Period -> Period -> Bool)
    -> (Period -> Period -> Bool)
    -> (Period -> Period -> Period)
    -> (Period -> Period -> Period)
    -> Ord Period
    Period -> Period -> Bool
    Period -> Period -> Ordering
    Period -> Period -> Period
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: Period -> Period -> Period
    $cmin :: Period -> Period -> Period
    max :: Period -> Period -> Period
    $cmax :: Period -> Period -> Period
    >= :: Period -> Period -> Bool
    $c>= :: Period -> Period -> Bool
    > :: Period -> Period -> Bool
    $c> :: Period -> Period -> Bool
    <= :: Period -> Period -> Bool
    $c<= :: Period -> Period -> Bool
    < :: Period -> Period -> Bool
    $c< :: Period -> Period -> Bool
    compare :: Period -> Period -> Ordering
    $ccompare :: Period -> Period -> Ordering
    $cp1Ord :: Eq Period
    Ord,Int -> Period -> ShowS
    [Period] -> ShowS
    Period -> String
    (Int -> Period -> ShowS)
    -> (Period -> String) -> ([Period] -> ShowS) -> Show Period
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Period] -> ShowS
    $cshowList :: [Period] -> ShowS
    show :: Period -> String
    $cshow :: Period -> String
    showsPrec :: Int -> Period -> ShowS
    $cshowsPrec :: Int -> Period -> ShowS
    Show,(forall x. Period -> Rep Period x)
    -> (forall x. Rep Period x -> Period) -> Generic Period
    forall x. Rep Period x -> Period
    forall x. Period -> Rep Period x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Period x -> Period
    $cfrom :: forall x. Period -> Rep Period x
    Generic)

    instance Default Period where def :: Period
    def = Period
    PeriodAll

    ---- Typical report period/subperiod durations, from a day to a year.
    --data Duration =
    --    DayLong
    --   WeekLong
    --   MonthLong
    --   QuarterLong
    --   YearLong
    --  deriving (Eq,Ord,Show,Generic)

    -- Ways in which a period can be divided into subperiods.
    data Interval =
        NoInterval
      | Days Int
      | Weeks Int
      | Months Int
      | Quarters Int
      | Years Int
      | DayOfMonth Int
      | WeekdayOfMonth Int Int
      | DayOfWeek Int
      | DayOfYear Int Int -- Month, Day
      -- WeekOfYear Int
      -- MonthOfYear Int
      -- QuarterOfYear Int
      deriving (Interval -> Interval -> Bool
    (Interval -> Interval -> Bool)
    -> (Interval -> Interval -> Bool) -> Eq Interval
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Interval -> Interval -> Bool
    $c/= :: Interval -> Interval -> Bool
    == :: Interval -> Interval -> Bool
    $c== :: Interval -> Interval -> Bool
    Eq,Int -> Interval -> ShowS
    [Interval] -> ShowS
    Interval -> String
    (Int -> Interval -> ShowS)
    -> (Interval -> String) -> ([Interval] -> ShowS) -> Show Interval
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Interval] -> ShowS
    $cshowList :: [Interval] -> ShowS
    show :: Interval -> String
    $cshow :: Interval -> String
    showsPrec :: Int -> Interval -> ShowS
    $cshowsPrec :: Int -> Interval -> ShowS
    Show,Eq Interval
    Eq Interval =>
    (Interval -> Interval -> Ordering)
    -> (Interval -> Interval -> Bool)
    -> (Interval -> Interval -> Bool)
    -> (Interval -> Interval -> Bool)
    -> (Interval -> Interval -> Bool)
    -> (Interval -> Interval -> Interval)
    -> (Interval -> Interval -> Interval)
    -> Ord Interval
    Interval -> Interval -> Bool
    Interval -> Interval -> Ordering
    Interval -> Interval -> Interval
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: Interval -> Interval -> Interval
    $cmin :: Interval -> Interval -> Interval
    max :: Interval -> Interval -> Interval
    $cmax :: Interval -> Interval -> Interval
    >= :: Interval -> Interval -> Bool
    $c>= :: Interval -> Interval -> Bool
    > :: Interval -> Interval -> Bool
    $c> :: Interval -> Interval -> Bool
    <= :: Interval -> Interval -> Bool
    $c<= :: Interval -> Interval -> Bool
    < :: Interval -> Interval -> Bool
    $c< :: Interval -> Interval -> Bool
    compare :: Interval -> Interval -> Ordering
    $ccompare :: Interval -> Interval -> Ordering
    $cp1Ord :: Eq Interval
    Ord,(forall x. Interval -> Rep Interval x)
    -> (forall x. Rep Interval x -> Interval) -> Generic Interval
    forall x. Rep Interval x -> Interval
    forall x. Interval -> Rep Interval x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Interval x -> Interval
    $cfrom :: forall x. Interval -> Rep Interval x
    Generic)

    instance Default Interval where def :: Interval
    def = Interval
    NoInterval

    type AccountName = Text

    data AccountType =
        Asset
      | Liability
      | Equity
      | Revenue
      | Expense
      | Cash  -- ^ a subtype of Asset - liquid assets to show in cashflow report
      deriving (Int -> AccountType -> ShowS
    [AccountType] -> ShowS
    AccountType -> String
    (Int -> AccountType -> ShowS)
    -> (AccountType -> String)
    -> ([AccountType] -> ShowS)
    -> Show AccountType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [AccountType] -> ShowS
    $cshowList :: [AccountType] -> ShowS
    show :: AccountType -> String
    $cshow :: AccountType -> String
    showsPrec :: Int -> AccountType -> ShowS
    $cshowsPrec :: Int -> AccountType -> ShowS
    Show,AccountType -> AccountType -> Bool
    (AccountType -> AccountType -> Bool)
    -> (AccountType -> AccountType -> Bool) -> Eq AccountType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: AccountType -> AccountType -> Bool
    $c/= :: AccountType -> AccountType -> Bool
    == :: AccountType -> AccountType -> Bool
    $c== :: AccountType -> AccountType -> Bool
    Eq,Eq AccountType
    Eq AccountType =>
    (AccountType -> AccountType -> Ordering)
    -> (AccountType -> AccountType -> Bool)
    -> (AccountType -> AccountType -> Bool)
    -> (AccountType -> AccountType -> Bool)
    -> (AccountType -> AccountType -> Bool)
    -> (AccountType -> AccountType -> AccountType)
    -> (AccountType -> AccountType -> AccountType)
    -> Ord AccountType
    AccountType -> AccountType -> Bool
    AccountType -> AccountType -> Ordering
    AccountType -> AccountType -> AccountType
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: AccountType -> AccountType -> AccountType
    $cmin :: AccountType -> AccountType -> AccountType
    max :: AccountType -> AccountType -> AccountType
    $cmax :: AccountType -> AccountType -> AccountType
    >= :: AccountType -> AccountType -> Bool
    $c>= :: AccountType -> AccountType -> Bool
    > :: AccountType -> AccountType -> Bool
    $c> :: AccountType -> AccountType -> Bool
    <= :: AccountType -> AccountType -> Bool
    $c<= :: AccountType -> AccountType -> Bool
    < :: AccountType -> AccountType -> Bool
    $c< :: AccountType -> AccountType -> Bool
    compare :: AccountType -> AccountType -> Ordering
    $ccompare :: AccountType -> AccountType -> Ordering
    $cp1Ord :: Eq AccountType
    Ord,(forall x. AccountType -> Rep AccountType x)
    -> (forall x. Rep AccountType x -> AccountType)
    -> Generic AccountType
    forall x. Rep AccountType x -> AccountType
    forall x. AccountType -> Rep AccountType x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep AccountType x -> AccountType
    $cfrom :: forall x. AccountType -> Rep AccountType x
    Generic)

    -- not worth the trouble, letters defined in accountdirectivep for now
    --instance Read AccountType
    --  where
    --    readsPrec _ ('A' : xs) = [(Asset,     xs)]
    --    readsPrec _ ('L' : xs) = [(Liability, xs)]
    --    readsPrec _ ('E' : xs) = [(Equity,    xs)]
    --    readsPrec _ ('R' : xs) = [(Revenue,   xs)]
    --    readsPrec _ ('X' : xs) = [(Expense,   xs)]
    --    readsPrec _ _ = []

    data AccountAlias = BasicAlias AccountName AccountName
                      | RegexAlias Regexp Replacement
      deriving (AccountAlias -> AccountAlias -> Bool
    (AccountAlias -> AccountAlias -> Bool)
    -> (AccountAlias -> AccountAlias -> Bool) -> Eq AccountAlias
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: AccountAlias -> AccountAlias -> Bool
    $c/= :: AccountAlias -> AccountAlias -> Bool
    == :: AccountAlias -> AccountAlias -> Bool
    $c== :: AccountAlias -> AccountAlias -> Bool
    Eq, ReadPrec [AccountAlias]
    ReadPrec AccountAlias
    Int -> ReadS AccountAlias
    ReadS [AccountAlias]
    (Int -> ReadS AccountAlias)
    -> ReadS [AccountAlias]
    -> ReadPrec AccountAlias
    -> ReadPrec [AccountAlias]
    -> Read AccountAlias
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [AccountAlias]
    $creadListPrec :: ReadPrec [AccountAlias]
    readPrec :: ReadPrec AccountAlias
    $creadPrec :: ReadPrec AccountAlias
    readList :: ReadS [AccountAlias]
    $creadList :: ReadS [AccountAlias]
    readsPrec :: Int -> ReadS AccountAlias
    $creadsPrec :: Int -> ReadS AccountAlias
    Read, Int -> AccountAlias -> ShowS
    [AccountAlias] -> ShowS
    AccountAlias -> String
    (Int -> AccountAlias -> ShowS)
    -> (AccountAlias -> String)
    -> ([AccountAlias] -> ShowS)
    -> Show AccountAlias
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [AccountAlias] -> ShowS
    $cshowList :: [AccountAlias] -> ShowS
    show :: AccountAlias -> String
    $cshow :: AccountAlias -> String
    showsPrec :: Int -> AccountAlias -> ShowS
    $cshowsPrec :: Int -> AccountAlias -> ShowS
    Show, Eq AccountAlias
    Eq AccountAlias =>
    (AccountAlias -> AccountAlias -> Ordering)
    -> (AccountAlias -> AccountAlias -> Bool)
    -> (AccountAlias -> AccountAlias -> Bool)
    -> (AccountAlias -> AccountAlias -> Bool)
    -> (AccountAlias -> AccountAlias -> Bool)
    -> (AccountAlias -> AccountAlias -> AccountAlias)
    -> (AccountAlias -> AccountAlias -> AccountAlias)
    -> Ord AccountAlias
    AccountAlias -> AccountAlias -> Bool
    AccountAlias -> AccountAlias -> Ordering
    AccountAlias -> AccountAlias -> AccountAlias
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: AccountAlias -> AccountAlias -> AccountAlias
    $cmin :: AccountAlias -> AccountAlias -> AccountAlias
    max :: AccountAlias -> AccountAlias -> AccountAlias
    $cmax :: AccountAlias -> AccountAlias -> AccountAlias
    >= :: AccountAlias -> AccountAlias -> Bool
    $c>= :: AccountAlias -> AccountAlias -> Bool
    > :: AccountAlias -> AccountAlias -> Bool
    $c> :: AccountAlias -> AccountAlias -> Bool
    <= :: AccountAlias -> AccountAlias -> Bool
    $c<= :: AccountAlias -> AccountAlias -> Bool
    < :: AccountAlias -> AccountAlias -> Bool
    $c< :: AccountAlias -> AccountAlias -> Bool
    compare :: AccountAlias -> AccountAlias -> Ordering
    $ccompare :: AccountAlias -> AccountAlias -> Ordering
    $cp1Ord :: Eq AccountAlias
    Ord, (forall x. AccountAlias -> Rep AccountAlias x)
    -> (forall x. Rep AccountAlias x -> AccountAlias)
    -> Generic AccountAlias
    forall x. Rep AccountAlias x -> AccountAlias
    forall x. AccountAlias -> Rep AccountAlias x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep AccountAlias x -> AccountAlias
    $cfrom :: forall x. AccountAlias -> Rep AccountAlias x
    Generic)

    data Side = L | R deriving (Side -> Side -> Bool
    (Side -> Side -> Bool) -> (Side -> Side -> Bool) -> Eq Side
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Side -> Side -> Bool
    $c/= :: Side -> Side -> Bool
    == :: Side -> Side -> Bool
    $c== :: Side -> Side -> Bool
    Eq,Int -> Side -> ShowS
    [Side] -> ShowS
    Side -> String
    (Int -> Side -> ShowS)
    -> (Side -> String) -> ([Side] -> ShowS) -> Show Side
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Side] -> ShowS
    $cshowList :: [Side] -> ShowS
    show :: Side -> String
    $cshow :: Side -> String
    showsPrec :: Int -> Side -> ShowS
    $cshowsPrec :: Int -> Side -> ShowS
    Show,ReadPrec [Side]
    ReadPrec Side
    Int -> ReadS Side
    ReadS [Side]
    (Int -> ReadS Side)
    -> ReadS [Side] -> ReadPrec Side -> ReadPrec [Side] -> Read Side
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [Side]
    $creadListPrec :: ReadPrec [Side]
    readPrec :: ReadPrec Side
    $creadPrec :: ReadPrec Side
    readList :: ReadS [Side]
    $creadList :: ReadS [Side]
    readsPrec :: Int -> ReadS Side
    $creadsPrec :: Int -> ReadS Side
    Read,Eq Side
    Eq Side =>
    (Side -> Side -> Ordering)
    -> (Side -> Side -> Bool)
    -> (Side -> Side -> Bool)
    -> (Side -> Side -> Bool)
    -> (Side -> Side -> Bool)
    -> (Side -> Side -> Side)
    -> (Side -> Side -> Side)
    -> Ord Side
    Side -> Side -> Bool
    Side -> Side -> Ordering
    Side -> Side -> Side
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: Side -> Side -> Side
    $cmin :: Side -> Side -> Side
    max :: Side -> Side -> Side
    $cmax :: Side -> Side -> Side
    >= :: Side -> Side -> Bool
    $c>= :: Side -> Side -> Bool
    > :: Side -> Side -> Bool
    $c> :: Side -> Side -> Bool
    <= :: Side -> Side -> Bool
    $c<= :: Side -> Side -> Bool
    < :: Side -> Side -> Bool
    $c< :: Side -> Side -> Bool
    compare :: Side -> Side -> Ordering
    $ccompare :: Side -> Side -> Ordering
    $cp1Ord :: Eq Side
    Ord,(forall x. Side -> Rep Side x)
    -> (forall x. Rep Side x -> Side) -> Generic Side
    forall x. Rep Side x -> Side
    forall x. Side -> Rep Side x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Side x -> Side
    $cfrom :: forall x. Side -> Rep Side x
    Generic)

    -- | The basic numeric type used in amounts.
    type Quantity = Decimal
    -- The following is for hledger-web, and requires blaze-markup.
    -- Doing it here avoids needing a matching flag on the hledger-web package.
    instance ToMarkup Quantity
     where
       toMarkup :: Quantity -> Markup
    toMarkup = String -> Markup
    forall a. ToMarkup a => a -> Markup
    toMarkup (String -> Markup) -> (Quantity -> String) -> Quantity -> Markup
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Quantity -> String
    forall a. Show a => a -> String
    show

    -- | An amount's per-unit or total cost/selling price in another
    -- commodity, as recorded in the journal entry eg with @ or @@.
    -- Docs call this "transaction price". The amount is always positive.
    data AmountPrice = UnitPrice Amount | TotalPrice Amount
      deriving (AmountPrice -> AmountPrice -> Bool
    (AmountPrice -> AmountPrice -> Bool)
    -> (AmountPrice -> AmountPrice -> Bool) -> Eq AmountPrice
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: AmountPrice -> AmountPrice -> Bool
    $c/= :: AmountPrice -> AmountPrice -> Bool
    == :: AmountPrice -> AmountPrice -> Bool
    $c== :: AmountPrice -> AmountPrice -> Bool
    Eq,Eq AmountPrice
    Eq AmountPrice =>
    (AmountPrice -> AmountPrice -> Ordering)
    -> (AmountPrice -> AmountPrice -> Bool)
    -> (AmountPrice -> AmountPrice -> Bool)
    -> (AmountPrice -> AmountPrice -> Bool)
    -> (AmountPrice -> AmountPrice -> Bool)
    -> (AmountPrice -> AmountPrice -> AmountPrice)
    -> (AmountPrice -> AmountPrice -> AmountPrice)
    -> Ord AmountPrice
    AmountPrice -> AmountPrice -> Bool
    AmountPrice -> AmountPrice -> Ordering
    AmountPrice -> AmountPrice -> AmountPrice
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: AmountPrice -> AmountPrice -> AmountPrice
    $cmin :: AmountPrice -> AmountPrice -> AmountPrice
    max :: AmountPrice -> AmountPrice -> AmountPrice
    $cmax :: AmountPrice -> AmountPrice -> AmountPrice
    >= :: AmountPrice -> AmountPrice -> Bool
    $c>= :: AmountPrice -> AmountPrice -> Bool
    > :: AmountPrice -> AmountPrice -> Bool
    $c> :: AmountPrice -> AmountPrice -> Bool
    <= :: AmountPrice -> AmountPrice -> Bool
    $c<= :: AmountPrice -> AmountPrice -> Bool
    < :: AmountPrice -> AmountPrice -> Bool
    $c< :: AmountPrice -> AmountPrice -> Bool
    compare :: AmountPrice -> AmountPrice -> Ordering
    $ccompare :: AmountPrice -> AmountPrice -> Ordering
    $cp1Ord :: Eq AmountPrice
    Ord,(forall x. AmountPrice -> Rep AmountPrice x)
    -> (forall x. Rep AmountPrice x -> AmountPrice)
    -> Generic AmountPrice
    forall x. Rep AmountPrice x -> AmountPrice
    forall x. AmountPrice -> Rep AmountPrice x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep AmountPrice x -> AmountPrice
    $cfrom :: forall x. AmountPrice -> Rep AmountPrice x
    Generic,Int -> AmountPrice -> ShowS
    [AmountPrice] -> ShowS
    AmountPrice -> String
    (Int -> AmountPrice -> ShowS)
    -> (AmountPrice -> String)
    -> ([AmountPrice] -> ShowS)
    -> Show AmountPrice
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [AmountPrice] -> ShowS
    $cshowList :: [AmountPrice] -> ShowS
    show :: AmountPrice -> String
    $cshow :: AmountPrice -> String
    showsPrec :: Int -> AmountPrice -> ShowS
    $cshowsPrec :: Int -> AmountPrice -> ShowS
    Show)

    -- | Display style for an amount.
    data AmountStyle = AmountStyle {
          AmountStyle -> Side
    ascommodityside   :: Side,                 -- ^ does the symbol appear on the left or the right ?
          AmountStyle -> Bool
    ascommodityspaced :: Bool,                 -- ^ space between symbol and quantity ?
          AmountStyle -> AmountPrecision
    asprecision       :: !AmountPrecision,     -- ^ number of digits displayed after the decimal point
          AmountStyle -> Maybe Char
    asdecimalpoint    :: Maybe Char,           -- ^ character used as decimal point: period or comma. Nothing means "unspecified, use default"
          AmountStyle -> Maybe DigitGroupStyle
    asdigitgroups     :: Maybe DigitGroupStyle -- ^ style for displaying digit groups, if any
    } deriving (AmountStyle -> AmountStyle -> Bool
    (AmountStyle -> AmountStyle -> Bool)
    -> (AmountStyle -> AmountStyle -> Bool) -> Eq AmountStyle
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: AmountStyle -> AmountStyle -> Bool
    $c/= :: AmountStyle -> AmountStyle -> Bool
    == :: AmountStyle -> AmountStyle -> Bool
    $c== :: AmountStyle -> AmountStyle -> Bool
    Eq,Eq AmountStyle
    Eq AmountStyle =>
    (AmountStyle -> AmountStyle -> Ordering)
    -> (AmountStyle -> AmountStyle -> Bool)
    -> (AmountStyle -> AmountStyle -> Bool)
    -> (AmountStyle -> AmountStyle -> Bool)
    -> (AmountStyle -> AmountStyle -> Bool)
    -> (AmountStyle -> AmountStyle -> AmountStyle)
    -> (AmountStyle -> AmountStyle -> AmountStyle)
    -> Ord AmountStyle
    AmountStyle -> AmountStyle -> Bool
    AmountStyle -> AmountStyle -> Ordering
    AmountStyle -> AmountStyle -> AmountStyle
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: AmountStyle -> AmountStyle -> AmountStyle
    $cmin :: AmountStyle -> AmountStyle -> AmountStyle
    max :: AmountStyle -> AmountStyle -> AmountStyle
    $cmax :: AmountStyle -> AmountStyle -> AmountStyle
    >= :: AmountStyle -> AmountStyle -> Bool
    $c>= :: AmountStyle -> AmountStyle -> Bool
    > :: AmountStyle -> AmountStyle -> Bool
    $c> :: AmountStyle -> AmountStyle -> Bool
    <= :: AmountStyle -> AmountStyle -> Bool
    $c<= :: AmountStyle -> AmountStyle -> Bool
    < :: AmountStyle -> AmountStyle -> Bool
    $c< :: AmountStyle -> AmountStyle -> Bool
    compare :: AmountStyle -> AmountStyle -> Ordering
    $ccompare :: AmountStyle -> AmountStyle -> Ordering
    $cp1Ord :: Eq AmountStyle
    Ord,ReadPrec [AmountStyle]
    ReadPrec AmountStyle
    Int -> ReadS AmountStyle
    ReadS [AmountStyle]
    (Int -> ReadS AmountStyle)
    -> ReadS [AmountStyle]
    -> ReadPrec AmountStyle
    -> ReadPrec [AmountStyle]
    -> Read AmountStyle
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [AmountStyle]
    $creadListPrec :: ReadPrec [AmountStyle]
    readPrec :: ReadPrec AmountStyle
    $creadPrec :: ReadPrec AmountStyle
    readList :: ReadS [AmountStyle]
    $creadList :: ReadS [AmountStyle]
    readsPrec :: Int -> ReadS AmountStyle
    $creadsPrec :: Int -> ReadS AmountStyle
    Read,(forall x. AmountStyle -> Rep AmountStyle x)
    -> (forall x. Rep AmountStyle x -> AmountStyle)
    -> Generic AmountStyle
    forall x. Rep AmountStyle x -> AmountStyle
    forall x. AmountStyle -> Rep AmountStyle x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep AmountStyle x -> AmountStyle
    $cfrom :: forall x. AmountStyle -> Rep AmountStyle x
    Generic)

    instance Show AmountStyle where
      show :: AmountStyle -> String
    show AmountStyle{..} =
        String -> String -> String -> String -> String -> ShowS
    forall r. PrintfType r => String -> r
    printf "AmountStylePP \"%s %s %s %s %s..\""
        (Side -> String
    forall a. Show a => a -> String
    show Side
    ascommodityside)
        (Bool -> String
    forall a. Show a => a -> String
    show Bool
    ascommodityspaced)
        (AmountPrecision -> String
    forall a. Show a => a -> String
    show AmountPrecision
    asprecision)
        (Maybe Char -> String
    forall a. Show a => a -> String
    show Maybe Char
    asdecimalpoint)
        (Maybe DigitGroupStyle -> String
    forall a. Show a => a -> String
    show Maybe DigitGroupStyle
    asdigitgroups)

    data AmountPrecision = Precision !Word8 | NaturalPrecision deriving (AmountPrecision -> AmountPrecision -> Bool
    (AmountPrecision -> AmountPrecision -> Bool)
    -> (AmountPrecision -> AmountPrecision -> Bool)
    -> Eq AmountPrecision
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: AmountPrecision -> AmountPrecision -> Bool
    $c/= :: AmountPrecision -> AmountPrecision -> Bool
    == :: AmountPrecision -> AmountPrecision -> Bool
    $c== :: AmountPrecision -> AmountPrecision -> Bool
    Eq,Eq AmountPrecision
    Eq AmountPrecision =>
    (AmountPrecision -> AmountPrecision -> Ordering)
    -> (AmountPrecision -> AmountPrecision -> Bool)
    -> (AmountPrecision -> AmountPrecision -> Bool)
    -> (AmountPrecision -> AmountPrecision -> Bool)
    -> (AmountPrecision -> AmountPrecision -> Bool)
    -> (AmountPrecision -> AmountPrecision -> AmountPrecision)
    -> (AmountPrecision -> AmountPrecision -> AmountPrecision)
    -> Ord AmountPrecision
    AmountPrecision -> AmountPrecision -> Bool
    AmountPrecision -> AmountPrecision -> Ordering
    AmountPrecision -> AmountPrecision -> AmountPrecision
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: AmountPrecision -> AmountPrecision -> AmountPrecision
    $cmin :: AmountPrecision -> AmountPrecision -> AmountPrecision
    max :: AmountPrecision -> AmountPrecision -> AmountPrecision
    $cmax :: AmountPrecision -> AmountPrecision -> AmountPrecision
    >= :: AmountPrecision -> AmountPrecision -> Bool
    $c>= :: AmountPrecision -> AmountPrecision -> Bool
    > :: AmountPrecision -> AmountPrecision -> Bool
    $c> :: AmountPrecision -> AmountPrecision -> Bool
    <= :: AmountPrecision -> AmountPrecision -> Bool
    $c<= :: AmountPrecision -> AmountPrecision -> Bool
    < :: AmountPrecision -> AmountPrecision -> Bool
    $c< :: AmountPrecision -> AmountPrecision -> Bool
    compare :: AmountPrecision -> AmountPrecision -> Ordering
    $ccompare :: AmountPrecision -> AmountPrecision -> Ordering
    $cp1Ord :: Eq AmountPrecision
    Ord,ReadPrec [AmountPrecision]
    ReadPrec AmountPrecision
    Int -> ReadS AmountPrecision
    ReadS [AmountPrecision]
    (Int -> ReadS AmountPrecision)
    -> ReadS [AmountPrecision]
    -> ReadPrec AmountPrecision
    -> ReadPrec [AmountPrecision]
    -> Read AmountPrecision
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [AmountPrecision]
    $creadListPrec :: ReadPrec [AmountPrecision]
    readPrec :: ReadPrec AmountPrecision
    $creadPrec :: ReadPrec AmountPrecision
    readList :: ReadS [AmountPrecision]
    $creadList :: ReadS [AmountPrecision]
    readsPrec :: Int -> ReadS AmountPrecision
    $creadsPrec :: Int -> ReadS AmountPrecision
    Read,Int -> AmountPrecision -> ShowS
    [AmountPrecision] -> ShowS
    AmountPrecision -> String
    (Int -> AmountPrecision -> ShowS)
    -> (AmountPrecision -> String)
    -> ([AmountPrecision] -> ShowS)
    -> Show AmountPrecision
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [AmountPrecision] -> ShowS
    $cshowList :: [AmountPrecision] -> ShowS
    show :: AmountPrecision -> String
    $cshow :: AmountPrecision -> String
    showsPrec :: Int -> AmountPrecision -> ShowS
    $cshowsPrec :: Int -> AmountPrecision -> ShowS
    Show,(forall x. AmountPrecision -> Rep AmountPrecision x)
    -> (forall x. Rep AmountPrecision x -> AmountPrecision)
    -> Generic AmountPrecision
    forall x. Rep AmountPrecision x -> AmountPrecision
    forall x. AmountPrecision -> Rep AmountPrecision x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep AmountPrecision x -> AmountPrecision
    $cfrom :: forall x. AmountPrecision -> Rep AmountPrecision x
    Generic)

    -- | A style for displaying digit groups in the integer part of a
    -- floating point number. It consists of the character used to
    -- separate groups (comma or period, whichever is not used as decimal
    -- point), and the size of each group, starting with the one nearest
    -- the decimal point. The last group size is assumed to repeat. Eg,
    -- comma between thousands is DigitGroups ',' [3].
    data DigitGroupStyle = DigitGroups Char [Word8]
      deriving (DigitGroupStyle -> DigitGroupStyle -> Bool
    (DigitGroupStyle -> DigitGroupStyle -> Bool)
    -> (DigitGroupStyle -> DigitGroupStyle -> Bool)
    -> Eq DigitGroupStyle
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: DigitGroupStyle -> DigitGroupStyle -> Bool
    $c/= :: DigitGroupStyle -> DigitGroupStyle -> Bool
    == :: DigitGroupStyle -> DigitGroupStyle -> Bool
    $c== :: DigitGroupStyle -> DigitGroupStyle -> Bool
    Eq,Eq DigitGroupStyle
    Eq DigitGroupStyle =>
    (DigitGroupStyle -> DigitGroupStyle -> Ordering)
    -> (DigitGroupStyle -> DigitGroupStyle -> Bool)
    -> (DigitGroupStyle -> DigitGroupStyle -> Bool)
    -> (DigitGroupStyle -> DigitGroupStyle -> Bool)
    -> (DigitGroupStyle -> DigitGroupStyle -> Bool)
    -> (DigitGroupStyle -> DigitGroupStyle -> DigitGroupStyle)
    -> (DigitGroupStyle -> DigitGroupStyle -> DigitGroupStyle)
    -> Ord DigitGroupStyle
    DigitGroupStyle -> DigitGroupStyle -> Bool
    DigitGroupStyle -> DigitGroupStyle -> Ordering
    DigitGroupStyle -> DigitGroupStyle -> DigitGroupStyle
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: DigitGroupStyle -> DigitGroupStyle -> DigitGroupStyle
    $cmin :: DigitGroupStyle -> DigitGroupStyle -> DigitGroupStyle
    max :: DigitGroupStyle -> DigitGroupStyle -> DigitGroupStyle
    $cmax :: DigitGroupStyle -> DigitGroupStyle -> DigitGroupStyle
    >= :: DigitGroupStyle -> DigitGroupStyle -> Bool
    $c>= :: DigitGroupStyle -> DigitGroupStyle -> Bool
    > :: DigitGroupStyle -> DigitGroupStyle -> Bool
    $c> :: DigitGroupStyle -> DigitGroupStyle -> Bool
    <= :: DigitGroupStyle -> DigitGroupStyle -> Bool
    $c<= :: DigitGroupStyle -> DigitGroupStyle -> Bool
    < :: DigitGroupStyle -> DigitGroupStyle -> Bool
    $c< :: DigitGroupStyle -> DigitGroupStyle -> Bool
    compare :: DigitGroupStyle -> DigitGroupStyle -> Ordering
    $ccompare :: DigitGroupStyle -> DigitGroupStyle -> Ordering
    $cp1Ord :: Eq DigitGroupStyle
    Ord,ReadPrec [DigitGroupStyle]
    ReadPrec DigitGroupStyle
    Int -> ReadS DigitGroupStyle
    ReadS [DigitGroupStyle]
    (Int -> ReadS DigitGroupStyle)
    -> ReadS [DigitGroupStyle]
    -> ReadPrec DigitGroupStyle
    -> ReadPrec [DigitGroupStyle]
    -> Read DigitGroupStyle
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [DigitGroupStyle]
    $creadListPrec :: ReadPrec [DigitGroupStyle]
    readPrec :: ReadPrec DigitGroupStyle
    $creadPrec :: ReadPrec DigitGroupStyle
    readList :: ReadS [DigitGroupStyle]
    $creadList :: ReadS [DigitGroupStyle]
    readsPrec :: Int -> ReadS DigitGroupStyle
    $creadsPrec :: Int -> ReadS DigitGroupStyle
    Read,Int -> DigitGroupStyle -> ShowS
    [DigitGroupStyle] -> ShowS
    DigitGroupStyle -> String
    (Int -> DigitGroupStyle -> ShowS)
    -> (DigitGroupStyle -> String)
    -> ([DigitGroupStyle] -> ShowS)
    -> Show DigitGroupStyle
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [DigitGroupStyle] -> ShowS
    $cshowList :: [DigitGroupStyle] -> ShowS
    show :: DigitGroupStyle -> String
    $cshow :: DigitGroupStyle -> String
    showsPrec :: Int -> DigitGroupStyle -> ShowS
    $cshowsPrec :: Int -> DigitGroupStyle -> ShowS
    Show,(forall x. DigitGroupStyle -> Rep DigitGroupStyle x)
    -> (forall x. Rep DigitGroupStyle x -> DigitGroupStyle)
    -> Generic DigitGroupStyle
    forall x. Rep DigitGroupStyle x -> DigitGroupStyle
    forall x. DigitGroupStyle -> Rep DigitGroupStyle x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep DigitGroupStyle x -> DigitGroupStyle
    $cfrom :: forall x. DigitGroupStyle -> Rep DigitGroupStyle x
    Generic)

    type CommoditySymbol = Text

    data Commodity = Commodity {
      Commodity -> CommoditySymbol
    csymbol :: CommoditySymbol,
      Commodity -> Maybe AmountStyle
    cformat :: Maybe AmountStyle
      } deriving (Int -> Commodity -> ShowS
    [Commodity] -> ShowS
    Commodity -> String
    (Int -> Commodity -> ShowS)
    -> (Commodity -> String)
    -> ([Commodity] -> ShowS)
    -> Show Commodity
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Commodity] -> ShowS
    $cshowList :: [Commodity] -> ShowS
    show :: Commodity -> String
    $cshow :: Commodity -> String
    showsPrec :: Int -> Commodity -> ShowS
    $cshowsPrec :: Int -> Commodity -> ShowS
    Show,Commodity -> Commodity -> Bool
    (Commodity -> Commodity -> Bool)
    -> (Commodity -> Commodity -> Bool) -> Eq Commodity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Commodity -> Commodity -> Bool
    $c/= :: Commodity -> Commodity -> Bool
    == :: Commodity -> Commodity -> Bool
    $c== :: Commodity -> Commodity -> Bool
    Eq,(forall x. Commodity -> Rep Commodity x)
    -> (forall x. Rep Commodity x -> Commodity) -> Generic Commodity
    forall x. Rep Commodity x -> Commodity
    forall x. Commodity -> Rep Commodity x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Commodity x -> Commodity
    $cfrom :: forall x. Commodity -> Rep Commodity x
    Generic) --,Ord)

    data Amount = Amount {
          Amount -> CommoditySymbol
    acommodity  :: CommoditySymbol,   -- commodity symbol, or special value "AUTO"
          Amount -> Quantity
    aquantity   :: Quantity,          -- numeric quantity, or zero in case of "AUTO"
          Amount -> Bool
    aismultiplier :: Bool,            -- ^ kludge: a flag marking this amount and posting as a multiplier
                                            --   in a TMPostingRule. In a regular Posting, should always be false.
          Amount -> AmountStyle
    astyle      :: AmountStyle,
          Amount -> Maybe AmountPrice
    aprice      :: Maybe AmountPrice  -- ^ the (fixed, transaction-specific) price for this amount, if any
        } deriving (Amount -> Amount -> Bool
    (Amount -> Amount -> Bool)
    -> (Amount -> Amount -> Bool) -> Eq Amount
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Amount -> Amount -> Bool
    $c/= :: Amount -> Amount -> Bool
    == :: Amount -> Amount -> Bool
    $c== :: Amount -> Amount -> Bool
    Eq,Eq Amount
    Eq Amount =>
    (Amount -> Amount -> Ordering)
    -> (Amount -> Amount -> Bool)
    -> (Amount -> Amount -> Bool)
    -> (Amount -> Amount -> Bool)
    -> (Amount -> Amount -> Bool)
    -> (Amount -> Amount -> Amount)
    -> (Amount -> Amount -> Amount)
    -> Ord Amount
    Amount -> Amount -> Bool
    Amount -> Amount -> Ordering
    Amount -> Amount -> Amount
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: Amount -> Amount -> Amount
    $cmin :: Amount -> Amount -> Amount
    max :: Amount -> Amount -> Amount
    $cmax :: Amount -> Amount -> Amount
    >= :: Amount -> Amount -> Bool
    $c>= :: Amount -> Amount -> Bool
    > :: Amount -> Amount -> Bool
    $c> :: Amount -> Amount -> Bool
    <= :: Amount -> Amount -> Bool
    $c<= :: Amount -> Amount -> Bool
    < :: Amount -> Amount -> Bool
    $c< :: Amount -> Amount -> Bool
    compare :: Amount -> Amount -> Ordering
    $ccompare :: Amount -> Amount -> Ordering
    $cp1Ord :: Eq Amount
    Ord,(forall x. Amount -> Rep Amount x)
    -> (forall x. Rep Amount x -> Amount) -> Generic Amount
    forall x. Rep Amount x -> Amount
    forall x. Amount -> Rep Amount x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Amount x -> Amount
    $cfrom :: forall x. Amount -> Rep Amount x
    Generic,Int -> Amount -> ShowS
    [Amount] -> ShowS
    Amount -> String
    (Int -> Amount -> ShowS)
    -> (Amount -> String) -> ([Amount] -> ShowS) -> Show Amount
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Amount] -> ShowS
    $cshowList :: [Amount] -> ShowS
    show :: Amount -> String
    $cshow :: Amount -> String
    showsPrec :: Int -> Amount -> ShowS
    $cshowsPrec :: Int -> Amount -> ShowS
    Show)

    newtype MixedAmount = Mixed [Amount] deriving (MixedAmount -> MixedAmount -> Bool
    (MixedAmount -> MixedAmount -> Bool)
    -> (MixedAmount -> MixedAmount -> Bool) -> Eq MixedAmount
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: MixedAmount -> MixedAmount -> Bool
    $c/= :: MixedAmount -> MixedAmount -> Bool
    == :: MixedAmount -> MixedAmount -> Bool
    $c== :: MixedAmount -> MixedAmount -> Bool
    Eq,Eq MixedAmount
    Eq MixedAmount =>
    (MixedAmount -> MixedAmount -> Ordering)
    -> (MixedAmount -> MixedAmount -> Bool)
    -> (MixedAmount -> MixedAmount -> Bool)
    -> (MixedAmount -> MixedAmount -> Bool)
    -> (MixedAmount -> MixedAmount -> Bool)
    -> (MixedAmount -> MixedAmount -> MixedAmount)
    -> (MixedAmount -> MixedAmount -> MixedAmount)
    -> Ord MixedAmount
    MixedAmount -> MixedAmount -> Bool
    MixedAmount -> MixedAmount -> Ordering
    MixedAmount -> MixedAmount -> MixedAmount
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: MixedAmount -> MixedAmount -> MixedAmount
    $cmin :: MixedAmount -> MixedAmount -> MixedAmount
    max :: MixedAmount -> MixedAmount -> MixedAmount
    $cmax :: MixedAmount -> MixedAmount -> MixedAmount
    >= :: MixedAmount -> MixedAmount -> Bool
    $c>= :: MixedAmount -> MixedAmount -> Bool
    > :: MixedAmount -> MixedAmount -> Bool
    $c> :: MixedAmount -> MixedAmount -> Bool
    <= :: MixedAmount -> MixedAmount -> Bool
    $c<= :: MixedAmount -> MixedAmount -> Bool
    < :: MixedAmount -> MixedAmount -> Bool
    $c< :: MixedAmount -> MixedAmount -> Bool
    compare :: MixedAmount -> MixedAmount -> Ordering
    $ccompare :: MixedAmount -> MixedAmount -> Ordering
    $cp1Ord :: Eq MixedAmount
    Ord,(forall x. MixedAmount -> Rep MixedAmount x)
    -> (forall x. Rep MixedAmount x -> MixedAmount)
    -> Generic MixedAmount
    forall x. Rep MixedAmount x -> MixedAmount
    forall x. MixedAmount -> Rep MixedAmount x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep MixedAmount x -> MixedAmount
    $cfrom :: forall x. MixedAmount -> Rep MixedAmount x
    Generic,Int -> MixedAmount -> ShowS
    [MixedAmount] -> ShowS
    MixedAmount -> String
    (Int -> MixedAmount -> ShowS)
    -> (MixedAmount -> String)
    -> ([MixedAmount] -> ShowS)
    -> Show MixedAmount
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [MixedAmount] -> ShowS
    $cshowList :: [MixedAmount] -> ShowS
    show :: MixedAmount -> String
    $cshow :: MixedAmount -> String
    showsPrec :: Int -> MixedAmount -> ShowS
    $cshowsPrec :: Int -> MixedAmount -> ShowS
    Show)

    data PostingType = RegularPosting | VirtualPosting | BalancedVirtualPosting
                       deriving (PostingType -> PostingType -> Bool
    (PostingType -> PostingType -> Bool)
    -> (PostingType -> PostingType -> Bool) -> Eq PostingType
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: PostingType -> PostingType -> Bool
    $c/= :: PostingType -> PostingType -> Bool
    == :: PostingType -> PostingType -> Bool
    $c== :: PostingType -> PostingType -> Bool
    Eq,Int -> PostingType -> ShowS
    [PostingType] -> ShowS
    PostingType -> String
    (Int -> PostingType -> ShowS)
    -> (PostingType -> String)
    -> ([PostingType] -> ShowS)
    -> Show PostingType
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [PostingType] -> ShowS
    $cshowList :: [PostingType] -> ShowS
    show :: PostingType -> String
    $cshow :: PostingType -> String
    showsPrec :: Int -> PostingType -> ShowS
    $cshowsPrec :: Int -> PostingType -> ShowS
    Show,(forall x. PostingType -> Rep PostingType x)
    -> (forall x. Rep PostingType x -> PostingType)
    -> Generic PostingType
    forall x. Rep PostingType x -> PostingType
    forall x. PostingType -> Rep PostingType x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep PostingType x -> PostingType
    $cfrom :: forall x. PostingType -> Rep PostingType x
    Generic)

    type TagName = Text
    type TagValue = Text
    type Tag = (TagName, TagValue)  -- ^ A tag name and (possibly empty) value.
    type DateTag = (TagName, Day)

    -- | The status of a transaction or posting, recorded with a status mark
    -- (nothing, !, or *). What these mean is ultimately user defined.
    data Status = Unmarked | Pending | Cleared
      deriving (Status -> Status -> Bool
    (Status -> Status -> Bool)
    -> (Status -> Status -> Bool) -> Eq Status
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Status -> Status -> Bool
    $c/= :: Status -> Status -> Bool
    == :: Status -> Status -> Bool
    $c== :: Status -> Status -> Bool
    Eq,Eq Status
    Eq Status =>
    (Status -> Status -> Ordering)
    -> (Status -> Status -> Bool)
    -> (Status -> Status -> Bool)
    -> (Status -> Status -> Bool)
    -> (Status -> Status -> Bool)
    -> (Status -> Status -> Status)
    -> (Status -> Status -> Status)
    -> Ord Status
    Status -> Status -> Bool
    Status -> Status -> Ordering
    Status -> Status -> Status
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: Status -> Status -> Status
    $cmin :: Status -> Status -> Status
    max :: Status -> Status -> Status
    $cmax :: Status -> Status -> Status
    >= :: Status -> Status -> Bool
    $c>= :: Status -> Status -> Bool
    > :: Status -> Status -> Bool
    $c> :: Status -> Status -> Bool
    <= :: Status -> Status -> Bool
    $c<= :: Status -> Status -> Bool
    < :: Status -> Status -> Bool
    $c< :: Status -> Status -> Bool
    compare :: Status -> Status -> Ordering
    $ccompare :: Status -> Status -> Ordering
    $cp1Ord :: Eq Status
    Ord,Status
    Status -> Status -> Bounded Status
    forall a. a -> a -> Bounded a
    maxBound :: Status
    $cmaxBound :: Status
    minBound :: Status
    $cminBound :: Status
    Bounded,Int -> Status
    Status -> Int
    Status -> [Status]
    Status -> Status
    Status -> Status -> [Status]
    Status -> Status -> Status -> [Status]
    (Status -> Status)
    -> (Status -> Status)
    -> (Int -> Status)
    -> (Status -> Int)
    -> (Status -> [Status])
    -> (Status -> Status -> [Status])
    -> (Status -> Status -> [Status])
    -> (Status -> Status -> Status -> [Status])
    -> Enum Status
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    enumFromThenTo :: Status -> Status -> Status -> [Status]
    $cenumFromThenTo :: Status -> Status -> Status -> [Status]
    enumFromTo :: Status -> Status -> [Status]
    $cenumFromTo :: Status -> Status -> [Status]
    enumFromThen :: Status -> Status -> [Status]
    $cenumFromThen :: Status -> Status -> [Status]
    enumFrom :: Status -> [Status]
    $cenumFrom :: Status -> [Status]
    fromEnum :: Status -> Int
    $cfromEnum :: Status -> Int
    toEnum :: Int -> Status
    $ctoEnum :: Int -> Status
    pred :: Status -> Status
    $cpred :: Status -> Status
    succ :: Status -> Status
    $csucc :: Status -> Status
    Enum,(forall x. Status -> Rep Status x)
    -> (forall x. Rep Status x -> Status) -> Generic Status
    forall x. Rep Status x -> Status
    forall x. Status -> Rep Status x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Status x -> Status
    $cfrom :: forall x. Status -> Rep Status x
    Generic)

    instance Show Status where -- custom show.. bad idea.. don't do it..
      show :: Status -> String
    show Unmarked = ""
      show Pending   = "!"
      show Cleared   = "*"

    -- | A balance assertion is a declaration about an account's expected balance
    -- at a certain point (posting date and parse order). They provide additional
    -- error checking and readability to a journal file.
    --
    -- The 'BalanceAssertion' type is also used to represent balance assignments,
    -- which instruct hledger what an account's balance should become at a certain
    -- point.
    --
    -- Different kinds of balance assertions are discussed eg on #290.
    -- Variables include:
    --
    -- - which postings are to be summed (real/virtual; unmarked/pending/cleared; this account/this account including subs)
    --
    -- - which commodities within the balance are to be checked
    --
    -- - whether to do a partial or a total check (disallowing other commodities)
    --
    -- I suspect we want:
    --
    -- 1. partial, subaccount-exclusive, Ledger-compatible assertions. Because
    --    they're what we've always had, and removing them would break some
    --    journals unnecessarily.  Implemented with = syntax.
    --
    -- 2. total assertions. Because otherwise assertions are a bit leaky.
    --    Implemented with == syntax.
    --
    -- 3. subaccount-inclusive assertions. Because that's something folks need.
    --    Not implemented.
    --
    -- 4. flexible assertions allowing custom criteria (perhaps arbitrary
    --    queries). Because power users have diverse needs and want to try out
    --    different schemes (assert cleared balances, assert balance from real or
    --    virtual postings, etc.). Not implemented.
    --
    -- 5. multicommodity assertions, asserting the balance of multiple commodities
    --    at once. Not implemented, requires #934.
    --
    data BalanceAssertion = BalanceAssertion {
          BalanceAssertion -> Amount
    baamount    :: Amount,             -- ^ the expected balance in a particular commodity
          BalanceAssertion -> Bool
    batotal     :: Bool,               -- ^ disallow additional non-asserted commodities ?
          BalanceAssertion -> Bool
    bainclusive :: Bool,               -- ^ include subaccounts when calculating the actual balance ?
          BalanceAssertion -> GenericSourcePos
    baposition  :: GenericSourcePos    -- ^ the assertion's file position, for error reporting
        } deriving (BalanceAssertion -> BalanceAssertion -> Bool
    (BalanceAssertion -> BalanceAssertion -> Bool)
    -> (BalanceAssertion -> BalanceAssertion -> Bool)
    -> Eq BalanceAssertion
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: BalanceAssertion -> BalanceAssertion -> Bool
    $c/= :: BalanceAssertion -> BalanceAssertion -> Bool
    == :: BalanceAssertion -> BalanceAssertion -> Bool
    $c== :: BalanceAssertion -> BalanceAssertion -> Bool
    Eq,(forall x. BalanceAssertion -> Rep BalanceAssertion x)
    -> (forall x. Rep BalanceAssertion x -> BalanceAssertion)
    -> Generic BalanceAssertion
    forall x. Rep BalanceAssertion x -> BalanceAssertion
    forall x. BalanceAssertion -> Rep BalanceAssertion x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep BalanceAssertion x -> BalanceAssertion
    $cfrom :: forall x. BalanceAssertion -> Rep BalanceAssertion x
    Generic,Int -> BalanceAssertion -> ShowS
    [BalanceAssertion] -> ShowS
    BalanceAssertion -> String
    (Int -> BalanceAssertion -> ShowS)
    -> (BalanceAssertion -> String)
    -> ([BalanceAssertion] -> ShowS)
    -> Show BalanceAssertion
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [BalanceAssertion] -> ShowS
    $cshowList :: [BalanceAssertion] -> ShowS
    show :: BalanceAssertion -> String
    $cshow :: BalanceAssertion -> String
    showsPrec :: Int -> BalanceAssertion -> ShowS
    $cshowsPrec :: Int -> BalanceAssertion -> ShowS
    Show)

    data Posting = Posting {
          Posting -> Maybe Day
    pdate             :: Maybe Day,         -- ^ this posting's date, if different from the transaction's
          Posting -> Maybe Day
    pdate2            :: Maybe Day,         -- ^ this posting's secondary date, if different from the transaction's
          Posting -> Status
    pstatus           :: Status,
          Posting -> CommoditySymbol
    paccount          :: AccountName,
          Posting -> MixedAmount
    pamount           :: MixedAmount,
          Posting -> CommoditySymbol
    pcomment          :: Text,              -- ^ this posting's comment lines, as a single non-indented multi-line string
          Posting -> PostingType
    ptype             :: PostingType,
          Posting -> [Tag]
    ptags             :: [Tag],                   -- ^ tag names and values, extracted from the comment
          Posting -> Maybe BalanceAssertion
    pbalanceassertion :: Maybe BalanceAssertion,  -- ^ an expected balance in the account after this posting,
                                                        --   in a single commodity, excluding subaccounts.
          Posting -> Maybe Transaction
    ptransaction      :: Maybe Transaction,       -- ^ this posting's parent transaction (co-recursive types).
                                                        --   Tying this knot gets tedious, Maybe makes it easier/optional.
          Posting -> Maybe Posting
    poriginal         :: Maybe Posting            -- ^ When this posting has been transformed in some way
                                                        --   (eg its amount or price was inferred, or the account name was
                                                        --   changed by a pivot or budget report), this references the original
                                                        --   untransformed posting (which will have Nothing in this field).
        } deriving ((forall x. Posting -> Rep Posting x)
    -> (forall x. Rep Posting x -> Posting) -> Generic Posting
    forall x. Rep Posting x -> Posting
    forall x. Posting -> Rep Posting x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Posting x -> Posting
    $cfrom :: forall x. Posting -> Rep Posting x
    Generic)

    -- The equality test for postings ignores the parent transaction's
    -- identity, to avoid recurring ad infinitum.
    -- XXX could check that it's Just or Nothing.
    instance Eq Posting where
        == :: Posting -> Posting -> Bool
    (==) (Posting a1 :: Maybe Day
    a1 b1 :: Maybe Day
    b1 c1 :: Status
    c1 d1 :: CommoditySymbol
    d1 e1 :: MixedAmount
    e1 f1 :: CommoditySymbol
    f1 g1 :: PostingType
    g1 h1 :: [Tag]
    h1 i1 :: Maybe BalanceAssertion
    i1 _ _) (Posting a2 :: Maybe Day
    a2 b2 :: Maybe Day
    b2 c2 :: Status
    c2 d2 :: CommoditySymbol
    d2 e2 :: MixedAmount
    e2 f2 :: CommoditySymbol
    f2 g2 :: PostingType
    g2 h2 :: [Tag]
    h2 i2 :: Maybe BalanceAssertion
    i2 _ _) =  Maybe Day
    a1Maybe Day -> Maybe Day -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Maybe Day
    a2 Bool -> Bool -> Bool
    && Maybe Day
    b1Maybe Day -> Maybe Day -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Maybe Day
    b2 Bool -> Bool -> Bool
    && Status
    c1Status -> Status -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Status
    c2 Bool -> Bool -> Bool
    && CommoditySymbol
    d1CommoditySymbol -> CommoditySymbol -> Bool
    forall a. Eq a => a -> a -> Bool
    ==CommoditySymbol
    d2 Bool -> Bool -> Bool
    && MixedAmount
    e1MixedAmount -> MixedAmount -> Bool
    forall a. Eq a => a -> a -> Bool
    ==MixedAmount
    e2 Bool -> Bool -> Bool
    && CommoditySymbol
    f1CommoditySymbol -> CommoditySymbol -> Bool
    forall a. Eq a => a -> a -> Bool
    ==CommoditySymbol
    f2 Bool -> Bool -> Bool
    && PostingType
    g1PostingType -> PostingType -> Bool
    forall a. Eq a => a -> a -> Bool
    ==PostingType
    g2 Bool -> Bool -> Bool
    && [Tag]
    h1[Tag] -> [Tag] -> Bool
    forall a. Eq a => a -> a -> Bool
    ==[Tag]
    h2 Bool -> Bool -> Bool
    && Maybe BalanceAssertion
    i1Maybe BalanceAssertion -> Maybe BalanceAssertion -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Maybe BalanceAssertion
    i2

    -- | Posting's show instance elides the parent transaction so as not to recurse forever.
    instance Show Posting where
      show :: Posting -> String
    show Posting{..} = "PostingPP {" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String -> [String] -> String
    forall a. [a] -> [[a]] -> [a]
    intercalate ", " [
         "pdate="             String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ ShowS
    forall a. Show a => a -> String
    show (Maybe Day -> String
    forall a. Show a => a -> String
    show Maybe Day
    pdate)
        ,"pdate2="            String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ ShowS
    forall a. Show a => a -> String
    show (Maybe Day -> String
    forall a. Show a => a -> String
    show Maybe Day
    pdate2)
        ,"pstatus="           String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ ShowS
    forall a. Show a => a -> String
    show (Status -> String
    forall a. Show a => a -> String
    show Status
    pstatus)
        ,"paccount="          String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ CommoditySymbol -> String
    forall a. Show a => a -> String
    show CommoditySymbol
    paccount
        ,"pamount="           String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ MixedAmount -> String
    forall a. Show a => a -> String
    show MixedAmount
    pamount
        ,"pcomment="          String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ CommoditySymbol -> String
    forall a. Show a => a -> String
    show CommoditySymbol
    pcomment
        ,"ptype="             String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ PostingType -> String
    forall a. Show a => a -> String
    show PostingType
    ptype
        ,"ptags="             String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ [Tag] -> String
    forall a. Show a => a -> String
    show [Tag]
    ptags
        ,"pbalanceassertion=" String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Maybe BalanceAssertion -> String
    forall a. Show a => a -> String
    show Maybe BalanceAssertion
    pbalanceassertion
        ,"ptransaction="      String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Maybe String -> String
    forall a. Show a => a -> String
    show (Maybe Transaction
    ptransaction Maybe Transaction -> String -> Maybe String
    forall (f :: * -> *) a b. Functor f => f a -> b -> f b
    $> "txn")
        ,"poriginal="         String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Maybe Posting -> String
    forall a. Show a => a -> String
    show Maybe Posting
    poriginal
        ] String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ "}"

    -- TODO: needs renaming, or removal if no longer needed. See also TextPosition in Hledger.UI.Editor
    -- | The position of parse errors (eg), like parsec's SourcePos but generic.
    data GenericSourcePos = GenericSourcePos FilePath Int Int    -- ^ file path, 1-based line number and 1-based column number.
                          | JournalSourcePos FilePath (Int, Int) -- ^ file path, inclusive range of 1-based line numbers (first, last).
      deriving (GenericSourcePos -> GenericSourcePos -> Bool
    (GenericSourcePos -> GenericSourcePos -> Bool)
    -> (GenericSourcePos -> GenericSourcePos -> Bool)
    -> Eq GenericSourcePos
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: GenericSourcePos -> GenericSourcePos -> Bool
    $c/= :: GenericSourcePos -> GenericSourcePos -> Bool
    == :: GenericSourcePos -> GenericSourcePos -> Bool
    $c== :: GenericSourcePos -> GenericSourcePos -> Bool
    Eq, ReadPrec [GenericSourcePos]
    ReadPrec GenericSourcePos
    Int -> ReadS GenericSourcePos
    ReadS [GenericSourcePos]
    (Int -> ReadS GenericSourcePos)
    -> ReadS [GenericSourcePos]
    -> ReadPrec GenericSourcePos
    -> ReadPrec [GenericSourcePos]
    -> Read GenericSourcePos
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    readListPrec :: ReadPrec [GenericSourcePos]
    $creadListPrec :: ReadPrec [GenericSourcePos]
    readPrec :: ReadPrec GenericSourcePos
    $creadPrec :: ReadPrec GenericSourcePos
    readList :: ReadS [GenericSourcePos]
    $creadList :: ReadS [GenericSourcePos]
    readsPrec :: Int -> ReadS GenericSourcePos
    $creadsPrec :: Int -> ReadS GenericSourcePos
    Read, Int -> GenericSourcePos -> ShowS
    [GenericSourcePos] -> ShowS
    GenericSourcePos -> String
    (Int -> GenericSourcePos -> ShowS)
    -> (GenericSourcePos -> String)
    -> ([GenericSourcePos] -> ShowS)
    -> Show GenericSourcePos
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [GenericSourcePos] -> ShowS
    $cshowList :: [GenericSourcePos] -> ShowS
    show :: GenericSourcePos -> String
    $cshow :: GenericSourcePos -> String
    showsPrec :: Int -> GenericSourcePos -> ShowS
    $cshowsPrec :: Int -> GenericSourcePos -> ShowS
    Show, Eq GenericSourcePos
    Eq GenericSourcePos =>
    (GenericSourcePos -> GenericSourcePos -> Ordering)
    -> (GenericSourcePos -> GenericSourcePos -> Bool)
    -> (GenericSourcePos -> GenericSourcePos -> Bool)
    -> (GenericSourcePos -> GenericSourcePos -> Bool)
    -> (GenericSourcePos -> GenericSourcePos -> Bool)
    -> (GenericSourcePos -> GenericSourcePos -> GenericSourcePos)
    -> (GenericSourcePos -> GenericSourcePos -> GenericSourcePos)
    -> Ord GenericSourcePos
    GenericSourcePos -> GenericSourcePos -> Bool
    GenericSourcePos -> GenericSourcePos -> Ordering
    GenericSourcePos -> GenericSourcePos -> GenericSourcePos
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: GenericSourcePos -> GenericSourcePos -> GenericSourcePos
    $cmin :: GenericSourcePos -> GenericSourcePos -> GenericSourcePos
    max :: GenericSourcePos -> GenericSourcePos -> GenericSourcePos
    $cmax :: GenericSourcePos -> GenericSourcePos -> GenericSourcePos
    >= :: GenericSourcePos -> GenericSourcePos -> Bool
    $c>= :: GenericSourcePos -> GenericSourcePos -> Bool
    > :: GenericSourcePos -> GenericSourcePos -> Bool
    $c> :: GenericSourcePos -> GenericSourcePos -> Bool
    <= :: GenericSourcePos -> GenericSourcePos -> Bool
    $c<= :: GenericSourcePos -> GenericSourcePos -> Bool
    < :: GenericSourcePos -> GenericSourcePos -> Bool
    $c< :: GenericSourcePos -> GenericSourcePos -> Bool
    compare :: GenericSourcePos -> GenericSourcePos -> Ordering
    $ccompare :: GenericSourcePos -> GenericSourcePos -> Ordering
    $cp1Ord :: Eq GenericSourcePos
    Ord, (forall x. GenericSourcePos -> Rep GenericSourcePos x)
    -> (forall x. Rep GenericSourcePos x -> GenericSourcePos)
    -> Generic GenericSourcePos
    forall x. Rep GenericSourcePos x -> GenericSourcePos
    forall x. GenericSourcePos -> Rep GenericSourcePos x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep GenericSourcePos x -> GenericSourcePos
    $cfrom :: forall x. GenericSourcePos -> Rep GenericSourcePos x
    Generic)

    --{-# ANN Transaction "HLint: ignore" #-}
    --    Ambiguous type variable ‘p0’ arising from an annotation
    --    prevents the constraint ‘(Data p0)’ from being solved.
    --    Probable fix: use a type annotation to specify what ‘p0’ should be.
    data Transaction = Transaction {
          Transaction -> Integer
    tindex                   :: Integer,   -- ^ this transaction's 1-based position in the transaction stream, or 0 when not available
          Transaction -> CommoditySymbol
    tprecedingcomment        :: Text,      -- ^ any comment lines immediately preceding this transaction
          Transaction -> GenericSourcePos
    tsourcepos               :: GenericSourcePos,  -- ^ the file position where the date starts
          Transaction -> Day
    tdate                    :: Day,
          Transaction -> Maybe Day
    tdate2                   :: Maybe Day,
          Transaction -> Status
    tstatus                  :: Status,
          Transaction -> CommoditySymbol
    tcode                    :: Text,
          Transaction -> CommoditySymbol
    tdescription             :: Text,
          Transaction -> CommoditySymbol
    tcomment                 :: Text,      -- ^ this transaction's comment lines, as a single non-indented multi-line string
          Transaction -> [Tag]
    ttags                    :: [Tag],     -- ^ tag names and values, extracted from the comment
          Transaction -> [Posting]
    tpostings                :: [Posting]  -- ^ this transaction's postings
        } deriving (Transaction -> Transaction -> Bool
    (Transaction -> Transaction -> Bool)
    -> (Transaction -> Transaction -> Bool) -> Eq Transaction
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Transaction -> Transaction -> Bool
    $c/= :: Transaction -> Transaction -> Bool
    == :: Transaction -> Transaction -> Bool
    $c== :: Transaction -> Transaction -> Bool
    Eq,(forall x. Transaction -> Rep Transaction x)
    -> (forall x. Rep Transaction x -> Transaction)
    -> Generic Transaction
    forall x. Rep Transaction x -> Transaction
    forall x. Transaction -> Rep Transaction x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Transaction x -> Transaction
    $cfrom :: forall x. Transaction -> Rep Transaction x
    Generic,Int -> Transaction -> ShowS
    [Transaction] -> ShowS
    Transaction -> String
    (Int -> Transaction -> ShowS)
    -> (Transaction -> String)
    -> ([Transaction] -> ShowS)
    -> Show Transaction
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Transaction] -> ShowS
    $cshowList :: [Transaction] -> ShowS
    show :: Transaction -> String
    $cshow :: Transaction -> String
    showsPrec :: Int -> Transaction -> ShowS
    $cshowsPrec :: Int -> Transaction -> ShowS
    Show)

    -- | A transaction modifier rule. This has a query which matches postings
    -- in the journal, and a list of transformations to apply to those
    -- postings or their transactions. Currently there is one kind of transformation:
    -- the TMPostingRule, which adds a posting ("auto posting") to the transaction,
    -- optionally setting its amount to the matched posting's amount multiplied by a constant.
    data TransactionModifier = TransactionModifier {
          TransactionModifier -> CommoditySymbol
    tmquerytxt :: Text,
          TransactionModifier -> [Posting]
    tmpostingrules :: [TMPostingRule]
        } deriving (TransactionModifier -> TransactionModifier -> Bool
    (TransactionModifier -> TransactionModifier -> Bool)
    -> (TransactionModifier -> TransactionModifier -> Bool)
    -> Eq TransactionModifier
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: TransactionModifier -> TransactionModifier -> Bool
    $c/= :: TransactionModifier -> TransactionModifier -> Bool
    == :: TransactionModifier -> TransactionModifier -> Bool
    $c== :: TransactionModifier -> TransactionModifier -> Bool
    Eq,(forall x. TransactionModifier -> Rep TransactionModifier x)
    -> (forall x. Rep TransactionModifier x -> TransactionModifier)
    -> Generic TransactionModifier
    forall x. Rep TransactionModifier x -> TransactionModifier
    forall x. TransactionModifier -> Rep TransactionModifier x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep TransactionModifier x -> TransactionModifier
    $cfrom :: forall x. TransactionModifier -> Rep TransactionModifier x
    Generic,Int -> TransactionModifier -> ShowS
    [TransactionModifier] -> ShowS
    TransactionModifier -> String
    (Int -> TransactionModifier -> ShowS)
    -> (TransactionModifier -> String)
    -> ([TransactionModifier] -> ShowS)
    -> Show TransactionModifier
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [TransactionModifier] -> ShowS
    $cshowList :: [TransactionModifier] -> ShowS
    show :: TransactionModifier -> String
    $cshow :: TransactionModifier -> String
    showsPrec :: Int -> TransactionModifier -> ShowS
    $cshowsPrec :: Int -> TransactionModifier -> ShowS
    Show)

    nulltransactionmodifier :: TransactionModifier
    nulltransactionmodifier = TransactionModifier :: CommoditySymbol -> [Posting] -> TransactionModifier
    TransactionModifier{
      tmquerytxt :: CommoditySymbol
    tmquerytxt = ""
     ,tmpostingrules :: [Posting]
    tmpostingrules = []
    }

    -- | A transaction modifier transformation, which adds an extra posting
    -- to the matched posting's transaction.
    -- Can be like a regular posting, or the amount can have the aismultiplier flag set,
    -- indicating that it's a multiplier for the matched posting's amount.
    type TMPostingRule = Posting

    -- | A periodic transaction rule, describing a transaction that recurs.
    data PeriodicTransaction = PeriodicTransaction {
          PeriodicTransaction -> CommoditySymbol
    ptperiodexpr   :: Text,     -- ^ the period expression as written
          PeriodicTransaction -> Interval
    ptinterval     :: Interval, -- ^ the interval at which this transaction recurs
          PeriodicTransaction -> DateSpan
    ptspan         :: DateSpan, -- ^ the (possibly unbounded) period during which this transaction recurs. Contains a whole number of intervals.
          --
          PeriodicTransaction -> Status
    ptstatus       :: Status,   -- ^ some of Transaction's fields
          PeriodicTransaction -> CommoditySymbol
    ptcode         :: Text,
          PeriodicTransaction -> CommoditySymbol
    ptdescription  :: Text,
          PeriodicTransaction -> CommoditySymbol
    ptcomment      :: Text,
          PeriodicTransaction -> [Tag]
    pttags         :: [Tag],
          PeriodicTransaction -> [Posting]
    ptpostings     :: [Posting]
        } deriving (PeriodicTransaction -> PeriodicTransaction -> Bool
    (PeriodicTransaction -> PeriodicTransaction -> Bool)
    -> (PeriodicTransaction -> PeriodicTransaction -> Bool)
    -> Eq PeriodicTransaction
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: PeriodicTransaction -> PeriodicTransaction -> Bool
    $c/= :: PeriodicTransaction -> PeriodicTransaction -> Bool
    == :: PeriodicTransaction -> PeriodicTransaction -> Bool
    $c== :: PeriodicTransaction -> PeriodicTransaction -> Bool
    Eq,(forall x. PeriodicTransaction -> Rep PeriodicTransaction x)
    -> (forall x. Rep PeriodicTransaction x -> PeriodicTransaction)
    -> Generic PeriodicTransaction
    forall x. Rep PeriodicTransaction x -> PeriodicTransaction
    forall x. PeriodicTransaction -> Rep PeriodicTransaction x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep PeriodicTransaction x -> PeriodicTransaction
    $cfrom :: forall x. PeriodicTransaction -> Rep PeriodicTransaction x
    Generic) -- , Show in PeriodicTransaction.hs

    nullperiodictransaction :: PeriodicTransaction
    nullperiodictransaction = PeriodicTransaction :: CommoditySymbol
    -> Interval
    -> DateSpan
    -> Status
    -> CommoditySymbol
    -> CommoditySymbol
    -> CommoditySymbol
    -> [Tag]
    -> [Posting]
    -> PeriodicTransaction
    PeriodicTransaction{
          ptperiodexpr :: CommoditySymbol
    ptperiodexpr   = ""
         ,ptinterval :: Interval
    ptinterval     = Interval
    forall a. Default a => a
    def
         ,ptspan :: DateSpan
    ptspan         = DateSpan
    forall a. Default a => a
    def
         ,ptstatus :: Status
    ptstatus       = Status
    Unmarked
         ,ptcode :: CommoditySymbol
    ptcode         = ""
         ,ptdescription :: CommoditySymbol
    ptdescription  = ""
         ,ptcomment :: CommoditySymbol
    ptcomment      = ""
         ,pttags :: [Tag]
    pttags         = []
         ,ptpostings :: [Posting]
    ptpostings     = []
    }

    data TimeclockCode = SetBalance | SetRequiredHours | In | Out | FinalOut deriving (TimeclockCode -> TimeclockCode -> Bool
    (TimeclockCode -> TimeclockCode -> Bool)
    -> (TimeclockCode -> TimeclockCode -> Bool) -> Eq TimeclockCode
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: TimeclockCode -> TimeclockCode -> Bool
    $c/= :: TimeclockCode -> TimeclockCode -> Bool
    == :: TimeclockCode -> TimeclockCode -> Bool
    $c== :: TimeclockCode -> TimeclockCode -> Bool
    Eq,Eq TimeclockCode
    Eq TimeclockCode =>
    (TimeclockCode -> TimeclockCode -> Ordering)
    -> (TimeclockCode -> TimeclockCode -> Bool)
    -> (TimeclockCode -> TimeclockCode -> Bool)
    -> (TimeclockCode -> TimeclockCode -> Bool)
    -> (TimeclockCode -> TimeclockCode -> Bool)
    -> (TimeclockCode -> TimeclockCode -> TimeclockCode)
    -> (TimeclockCode -> TimeclockCode -> TimeclockCode)
    -> Ord TimeclockCode
    TimeclockCode -> TimeclockCode -> Bool
    TimeclockCode -> TimeclockCode -> Ordering
    TimeclockCode -> TimeclockCode -> TimeclockCode
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: TimeclockCode -> TimeclockCode -> TimeclockCode
    $cmin :: TimeclockCode -> TimeclockCode -> TimeclockCode
    max :: TimeclockCode -> TimeclockCode -> TimeclockCode
    $cmax :: TimeclockCode -> TimeclockCode -> TimeclockCode
    >= :: TimeclockCode -> TimeclockCode -> Bool
    $c>= :: TimeclockCode -> TimeclockCode -> Bool
    > :: TimeclockCode -> TimeclockCode -> Bool
    $c> :: TimeclockCode -> TimeclockCode -> Bool
    <= :: TimeclockCode -> TimeclockCode -> Bool
    $c<= :: TimeclockCode -> TimeclockCode -> Bool
    < :: TimeclockCode -> TimeclockCode -> Bool
    $c< :: TimeclockCode -> TimeclockCode -> Bool
    compare :: TimeclockCode -> TimeclockCode -> Ordering
    $ccompare :: TimeclockCode -> TimeclockCode -> Ordering
    $cp1Ord :: Eq TimeclockCode
    Ord,(forall x. TimeclockCode -> Rep TimeclockCode x)
    -> (forall x. Rep TimeclockCode x -> TimeclockCode)
    -> Generic TimeclockCode
    forall x. Rep TimeclockCode x -> TimeclockCode
    forall x. TimeclockCode -> Rep TimeclockCode x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep TimeclockCode x -> TimeclockCode
    $cfrom :: forall x. TimeclockCode -> Rep TimeclockCode x
    Generic)

    data TimeclockEntry = TimeclockEntry {
          TimeclockEntry -> GenericSourcePos
    tlsourcepos   :: GenericSourcePos,
          TimeclockEntry -> TimeclockCode
    tlcode        :: TimeclockCode,
          TimeclockEntry -> LocalTime
    tldatetime    :: LocalTime,
          TimeclockEntry -> CommoditySymbol
    tlaccount     :: AccountName,
          TimeclockEntry -> CommoditySymbol
    tldescription :: Text
        } deriving (TimeclockEntry -> TimeclockEntry -> Bool
    (TimeclockEntry -> TimeclockEntry -> Bool)
    -> (TimeclockEntry -> TimeclockEntry -> Bool) -> Eq TimeclockEntry
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: TimeclockEntry -> TimeclockEntry -> Bool
    $c/= :: TimeclockEntry -> TimeclockEntry -> Bool
    == :: TimeclockEntry -> TimeclockEntry -> Bool
    $c== :: TimeclockEntry -> TimeclockEntry -> Bool
    Eq,Eq TimeclockEntry
    Eq TimeclockEntry =>
    (TimeclockEntry -> TimeclockEntry -> Ordering)
    -> (TimeclockEntry -> TimeclockEntry -> Bool)
    -> (TimeclockEntry -> TimeclockEntry -> Bool)
    -> (TimeclockEntry -> TimeclockEntry -> Bool)
    -> (TimeclockEntry -> TimeclockEntry -> Bool)
    -> (TimeclockEntry -> TimeclockEntry -> TimeclockEntry)
    -> (TimeclockEntry -> TimeclockEntry -> TimeclockEntry)
    -> Ord TimeclockEntry
    TimeclockEntry -> TimeclockEntry -> Bool
    TimeclockEntry -> TimeclockEntry -> Ordering
    TimeclockEntry -> TimeclockEntry -> TimeclockEntry
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: TimeclockEntry -> TimeclockEntry -> TimeclockEntry
    $cmin :: TimeclockEntry -> TimeclockEntry -> TimeclockEntry
    max :: TimeclockEntry -> TimeclockEntry -> TimeclockEntry
    $cmax :: TimeclockEntry -> TimeclockEntry -> TimeclockEntry
    >= :: TimeclockEntry -> TimeclockEntry -> Bool
    $c>= :: TimeclockEntry -> TimeclockEntry -> Bool
    > :: TimeclockEntry -> TimeclockEntry -> Bool
    $c> :: TimeclockEntry -> TimeclockEntry -> Bool
    <= :: TimeclockEntry -> TimeclockEntry -> Bool
    $c<= :: TimeclockEntry -> TimeclockEntry -> Bool
    < :: TimeclockEntry -> TimeclockEntry -> Bool
    $c< :: TimeclockEntry -> TimeclockEntry -> Bool
    compare :: TimeclockEntry -> TimeclockEntry -> Ordering
    $ccompare :: TimeclockEntry -> TimeclockEntry -> Ordering
    $cp1Ord :: Eq TimeclockEntry
    Ord,(forall x. TimeclockEntry -> Rep TimeclockEntry x)
    -> (forall x. Rep TimeclockEntry x -> TimeclockEntry)
    -> Generic TimeclockEntry
    forall x. Rep TimeclockEntry x -> TimeclockEntry
    forall x. TimeclockEntry -> Rep TimeclockEntry x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep TimeclockEntry x -> TimeclockEntry
    $cfrom :: forall x. TimeclockEntry -> Rep TimeclockEntry x
    Generic)

    -- | A market price declaration made by the journal format's P directive.
    -- It declares two things: a historical exchange rate between two commodities,
    -- and an amount display style for the second commodity.
    data PriceDirective = PriceDirective {
       PriceDirective -> Day
    pddate      :: Day
      ,PriceDirective -> CommoditySymbol
    pdcommodity :: CommoditySymbol
      ,PriceDirective -> Amount
    pdamount    :: Amount
      } deriving (PriceDirective -> PriceDirective -> Bool
    (PriceDirective -> PriceDirective -> Bool)
    -> (PriceDirective -> PriceDirective -> Bool) -> Eq PriceDirective
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: PriceDirective -> PriceDirective -> Bool
    $c/= :: PriceDirective -> PriceDirective -> Bool
    == :: PriceDirective -> PriceDirective -> Bool
    $c== :: PriceDirective -> PriceDirective -> Bool
    Eq,Eq PriceDirective
    Eq PriceDirective =>
    (PriceDirective -> PriceDirective -> Ordering)
    -> (PriceDirective -> PriceDirective -> Bool)
    -> (PriceDirective -> PriceDirective -> Bool)
    -> (PriceDirective -> PriceDirective -> Bool)
    -> (PriceDirective -> PriceDirective -> Bool)
    -> (PriceDirective -> PriceDirective -> PriceDirective)
    -> (PriceDirective -> PriceDirective -> PriceDirective)
    -> Ord PriceDirective
    PriceDirective -> PriceDirective -> Bool
    PriceDirective -> PriceDirective -> Ordering
    PriceDirective -> PriceDirective -> PriceDirective
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: PriceDirective -> PriceDirective -> PriceDirective
    $cmin :: PriceDirective -> PriceDirective -> PriceDirective
    max :: PriceDirective -> PriceDirective -> PriceDirective
    $cmax :: PriceDirective -> PriceDirective -> PriceDirective
    >= :: PriceDirective -> PriceDirective -> Bool
    $c>= :: PriceDirective -> PriceDirective -> Bool
    > :: PriceDirective -> PriceDirective -> Bool
    $c> :: PriceDirective -> PriceDirective -> Bool
    <= :: PriceDirective -> PriceDirective -> Bool
    $c<= :: PriceDirective -> PriceDirective -> Bool
    < :: PriceDirective -> PriceDirective -> Bool
    $c< :: PriceDirective -> PriceDirective -> Bool
    compare :: PriceDirective -> PriceDirective -> Ordering
    $ccompare :: PriceDirective -> PriceDirective -> Ordering
    $cp1Ord :: Eq PriceDirective
    Ord,(forall x. PriceDirective -> Rep PriceDirective x)
    -> (forall x. Rep PriceDirective x -> PriceDirective)
    -> Generic PriceDirective
    forall x. Rep PriceDirective x -> PriceDirective
    forall x. PriceDirective -> Rep PriceDirective x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep PriceDirective x -> PriceDirective
    $cfrom :: forall x. PriceDirective -> Rep PriceDirective x
    Generic,Int -> PriceDirective -> ShowS
    [PriceDirective] -> ShowS
    PriceDirective -> String
    (Int -> PriceDirective -> ShowS)
    -> (PriceDirective -> String)
    -> ([PriceDirective] -> ShowS)
    -> Show PriceDirective
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [PriceDirective] -> ShowS
    $cshowList :: [PriceDirective] -> ShowS
    show :: PriceDirective -> String
    $cshow :: PriceDirective -> String
    showsPrec :: Int -> PriceDirective -> ShowS
    $cshowsPrec :: Int -> PriceDirective -> ShowS
    Show)
            -- Show instance derived in Amount.hs (XXX why ?)

    -- | A historical market price (exchange rate) from one commodity to another.
    -- A more concise form of a PriceDirective, without the amount display info.
    data MarketPrice = MarketPrice {
       MarketPrice -> Day
    mpdate :: Day                -- ^ Date on which this price becomes effective.
      ,MarketPrice -> CommoditySymbol
    mpfrom :: CommoditySymbol    -- ^ The commodity being converted from.
      ,MarketPrice -> CommoditySymbol
    mpto   :: CommoditySymbol    -- ^ The commodity being converted to.
      ,MarketPrice -> Quantity
    mprate :: Quantity           -- ^ One unit of the "from" commodity is worth this quantity of the "to" commodity.
      } deriving (MarketPrice -> MarketPrice -> Bool
    (MarketPrice -> MarketPrice -> Bool)
    -> (MarketPrice -> MarketPrice -> Bool) -> Eq MarketPrice
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: MarketPrice -> MarketPrice -> Bool
    $c/= :: MarketPrice -> MarketPrice -> Bool
    == :: MarketPrice -> MarketPrice -> Bool
    $c== :: MarketPrice -> MarketPrice -> Bool
    Eq,Eq MarketPrice
    Eq MarketPrice =>
    (MarketPrice -> MarketPrice -> Ordering)
    -> (MarketPrice -> MarketPrice -> Bool)
    -> (MarketPrice -> MarketPrice -> Bool)
    -> (MarketPrice -> MarketPrice -> Bool)
    -> (MarketPrice -> MarketPrice -> Bool)
    -> (MarketPrice -> MarketPrice -> MarketPrice)
    -> (MarketPrice -> MarketPrice -> MarketPrice)
    -> Ord MarketPrice
    MarketPrice -> MarketPrice -> Bool
    MarketPrice -> MarketPrice -> Ordering
    MarketPrice -> MarketPrice -> MarketPrice
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    min :: MarketPrice -> MarketPrice -> MarketPrice
    $cmin :: MarketPrice -> MarketPrice -> MarketPrice
    max :: MarketPrice -> MarketPrice -> MarketPrice
    $cmax :: MarketPrice -> MarketPrice -> MarketPrice
    >= :: MarketPrice -> MarketPrice -> Bool
    $c>= :: MarketPrice -> MarketPrice -> Bool
    > :: MarketPrice -> MarketPrice -> Bool
    $c> :: MarketPrice -> MarketPrice -> Bool
    <= :: MarketPrice -> MarketPrice -> Bool
    $c<= :: MarketPrice -> MarketPrice -> Bool
    < :: MarketPrice -> MarketPrice -> Bool
    $c< :: MarketPrice -> MarketPrice -> Bool
    compare :: MarketPrice -> MarketPrice -> Ordering
    $ccompare :: MarketPrice -> MarketPrice -> Ordering
    $cp1Ord :: Eq MarketPrice
    Ord,(forall x. MarketPrice -> Rep MarketPrice x)
    -> (forall x. Rep MarketPrice x -> MarketPrice)
    -> Generic MarketPrice
    forall x. Rep MarketPrice x -> MarketPrice
    forall x. MarketPrice -> Rep MarketPrice x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep MarketPrice x -> MarketPrice
    $cfrom :: forall x. MarketPrice -> Rep MarketPrice x
    Generic)
            -- Show instance derived in Amount.hs (XXX why ?)

    -- additional valuation-related types in Valuation.hs

    -- | A Journal, containing transactions and various other things.
    -- The basic data model for hledger.
    --
    -- This is used during parsing (as the type alias ParsedJournal), and
    -- then finalised/validated for use as a Journal. Some extra
    -- parsing-related fields are included for convenience, at least for
    -- now. In a ParsedJournal these are updated as parsing proceeds, in a
    -- Journal they represent the final state at end of parsing (used eg
    -- by the add command).
    --
    data Journal = Journal {
      -- parsing-related data
       Journal -> Maybe Integer
    jparsedefaultyear      :: Maybe Year                            -- ^ the current default year, specified by the most recent Y directive (or current date)
      ,Journal -> Maybe (CommoditySymbol, AmountStyle)
    jparsedefaultcommodity :: Maybe (CommoditySymbol,AmountStyle)   -- ^ the current default commodity and its format, specified by the most recent D directive
      ,Journal -> [CommoditySymbol]
    jparseparentaccounts   :: [AccountName]                         -- ^ the current stack of parent account names, specified by apply account directives
      ,Journal -> [AccountAlias]
    jparsealiases          :: [AccountAlias]                        -- ^ the current account name aliases in effect, specified by alias directives (& options ?)
      -- ,jparsetransactioncount :: Integer                               -- ^ the current count of transactions parsed so far (only journal format txns, currently)
      ,Journal -> [TimeclockEntry]
    jparsetimeclockentries :: [TimeclockEntry]                       -- ^ timeclock sessions which have not been clocked out
      ,Journal -> [String]
    jincludefilestack      :: [FilePath]
      -- principal data
      ,Journal -> [(CommoditySymbol, AccountDeclarationInfo)]
    jdeclaredaccounts      :: [(AccountName,AccountDeclarationInfo)] -- ^ Accounts declared by account directives, in parse order (after journal finalisation)
      ,Journal -> Map AccountType [CommoditySymbol]
    jdeclaredaccounttypes  :: M.Map AccountType [AccountName]        -- ^ Accounts whose type has been declared in account directives (usually 5 top-level accounts)
      ,Journal -> Map CommoditySymbol Commodity
    jcommodities           :: M.Map CommoditySymbol Commodity        -- ^ commodities and formats declared by commodity directives
      ,Journal -> Map CommoditySymbol AmountStyle
    jinferredcommodities   :: M.Map CommoditySymbol AmountStyle      -- ^ commodities and formats inferred from journal amounts  TODO misnamed, should be eg jusedstyles
      ,Journal -> [PriceDirective]
    jpricedirectives       :: [PriceDirective]                       -- ^ Declarations of market prices by P directives, in parse order (after journal finalisation)
      ,Journal -> [MarketPrice]
    jinferredmarketprices  :: [MarketPrice]                          -- ^ Market prices implied by transactions, in parse order (after journal finalisation)
      ,Journal -> [TransactionModifier]
    jtxnmodifiers          :: [TransactionModifier]
      ,Journal -> [PeriodicTransaction]
    jperiodictxns          :: [PeriodicTransaction]
      ,Journal -> [Transaction]
    jtxns                  :: [Transaction]
      ,Journal -> CommoditySymbol
    jfinalcommentlines     :: Text                                   -- ^ any final trailing comments in the (main) journal file
      ,Journal -> [(String, CommoditySymbol)]
    jfiles                 :: [(FilePath, Text)]                     -- ^ the file path and raw text of the main and
                                                                        --   any included journal files. The main file is first,
                                                                        --   followed by any included files in the order encountered.
      ,Journal -> ClockTime
    jlastreadtime          :: ClockTime                              -- ^ when this journal was last read from its file(s)
      } deriving (Journal -> Journal -> Bool
    (Journal -> Journal -> Bool)
    -> (Journal -> Journal -> Bool) -> Eq Journal
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Journal -> Journal -> Bool
    $c/= :: Journal -> Journal -> Bool
    == :: Journal -> Journal -> Bool
    $c== :: Journal -> Journal -> Bool
    Eq, (forall x. Journal -> Rep Journal x)
    -> (forall x. Rep Journal x -> Journal) -> Generic Journal
    forall x. Rep Journal x -> Journal
    forall x. Journal -> Rep Journal x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Journal x -> Journal
    $cfrom :: forall x. Journal -> Rep Journal x
    Generic)

    deriving instance Generic ClockTime

    -- | A journal in the process of being parsed, not yet finalised.
    -- The data is partial, and list fields are in reverse order.
    type ParsedJournal = Journal

    -- | The id of a data format understood by hledger, eg @journal@ or @csv@.
    -- The --output-format option selects one of these for output.
    type StorageFormat = String

    -- | Extra information about an account that can be derived from
    -- its account directive (and the other account directives).
    data AccountDeclarationInfo = AccountDeclarationInfo {
       AccountDeclarationInfo -> CommoditySymbol
    adicomment          :: Text   -- ^ any comment lines following an account directive for this account
      ,AccountDeclarationInfo -> [Tag]
    aditags             :: [Tag]  -- ^ tags extracted from the account comment, if any
      ,AccountDeclarationInfo -> Int
    adideclarationorder :: Int    -- ^ the order in which this account was declared,
                                     --   relative to other account declarations, during parsing (1..)
    } deriving (AccountDeclarationInfo -> AccountDeclarationInfo -> Bool
    (AccountDeclarationInfo -> AccountDeclarationInfo -> Bool)
    -> (AccountDeclarationInfo -> AccountDeclarationInfo -> Bool)
    -> Eq AccountDeclarationInfo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: AccountDeclarationInfo -> AccountDeclarationInfo -> Bool
    $c/= :: AccountDeclarationInfo -> AccountDeclarationInfo -> Bool
    == :: AccountDeclarationInfo -> AccountDeclarationInfo -> Bool
    $c== :: AccountDeclarationInfo -> AccountDeclarationInfo -> Bool
    Eq,Int -> AccountDeclarationInfo -> ShowS
    [AccountDeclarationInfo] -> ShowS
    AccountDeclarationInfo -> String
    (Int -> AccountDeclarationInfo -> ShowS)
    -> (AccountDeclarationInfo -> String)
    -> ([AccountDeclarationInfo] -> ShowS)
    -> Show AccountDeclarationInfo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [AccountDeclarationInfo] -> ShowS
    $cshowList :: [AccountDeclarationInfo] -> ShowS
    show :: AccountDeclarationInfo -> String
    $cshow :: AccountDeclarationInfo -> String
    showsPrec :: Int -> AccountDeclarationInfo -> ShowS
    $cshowsPrec :: Int -> AccountDeclarationInfo -> ShowS
    Show,(forall x. AccountDeclarationInfo -> Rep AccountDeclarationInfo x)
    -> (forall x.
        Rep AccountDeclarationInfo x -> AccountDeclarationInfo)
    -> Generic AccountDeclarationInfo
    forall x. Rep AccountDeclarationInfo x -> AccountDeclarationInfo
    forall x. AccountDeclarationInfo -> Rep AccountDeclarationInfo x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep AccountDeclarationInfo x -> AccountDeclarationInfo
    $cfrom :: forall x. AccountDeclarationInfo -> Rep AccountDeclarationInfo x
    Generic)

    nullaccountdeclarationinfo :: AccountDeclarationInfo
    nullaccountdeclarationinfo = AccountDeclarationInfo :: CommoditySymbol -> [Tag] -> Int -> AccountDeclarationInfo
    AccountDeclarationInfo {
       adicomment :: CommoditySymbol
    adicomment          = ""
      ,aditags :: [Tag]
    aditags             = []
      ,adideclarationorder :: Int
    adideclarationorder = 0
    }

    -- | An account, with its balances, parent/subaccount relationships, etc.
    -- Only the name is required; the other fields are added when needed.
    data Account = Account {
       Account -> CommoditySymbol
    aname                     :: AccountName    -- ^ this account's full name
      ,Account -> Maybe AccountDeclarationInfo
    adeclarationinfo          :: Maybe AccountDeclarationInfo  -- ^ optional extra info from account directives
      -- relationships in the tree
      ,Account -> [Account]
    asubs                     :: [Account]      -- ^ this account's sub-accounts
      ,Account -> Maybe Account
    aparent                   :: Maybe Account  -- ^ parent account
      ,Account -> Bool
    aboring                   :: Bool           -- ^ used in the accounts report to label elidable parents
      -- balance information
      ,Account -> Int
    anumpostings              :: Int            -- ^ the number of postings to this account
      ,Account -> MixedAmount
    aebalance                 :: MixedAmount    -- ^ this account's balance, excluding subaccounts
      ,Account -> MixedAmount
    aibalance                 :: MixedAmount    -- ^ this account's balance, including subaccounts
      } deriving ((forall x. Account -> Rep Account x)
    -> (forall x. Rep Account x -> Account) -> Generic Account
    forall x. Rep Account x -> Account
    forall x. Account -> Rep Account x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Account x -> Account
    $cfrom :: forall x. Account -> Rep Account x
    Generic)

    -- | Whether an account's balance is normally a positive number (in
    -- accounting terms, a debit balance) or a negative number (credit balance).
    -- Assets and expenses are normally positive (debit), while liabilities, equity
    -- and income are normally negative (credit).
    -- https://en.wikipedia.org/wiki/Normal_balance
    data NormalSign = NormallyPositive | NormallyNegative deriving (Int -> NormalSign -> ShowS
    [NormalSign] -> ShowS
    NormalSign -> String
    (Int -> NormalSign -> ShowS)
    -> (NormalSign -> String)
    -> ([NormalSign] -> ShowS)
    -> Show NormalSign
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [NormalSign] -> ShowS
    $cshowList :: [NormalSign] -> ShowS
    show :: NormalSign -> String
    $cshow :: NormalSign -> String
    showsPrec :: Int -> NormalSign -> ShowS
    $cshowsPrec :: Int -> NormalSign -> ShowS
    Show, NormalSign -> NormalSign -> Bool
    (NormalSign -> NormalSign -> Bool)
    -> (NormalSign -> NormalSign -> Bool) -> Eq NormalSign
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: NormalSign -> NormalSign -> Bool
    $c/= :: NormalSign -> NormalSign -> Bool
    == :: NormalSign -> NormalSign -> Bool
    $c== :: NormalSign -> NormalSign -> Bool
    Eq)

    -- | A Ledger has the journal it derives from, and the accounts
    -- derived from that. Accounts are accessible both list-wise and
    -- tree-wise, since each one knows its parent and subs; the first
    -- account is the root of the tree and always exists.
    data Ledger = Ledger {
      Ledger -> Journal
    ljournal  :: Journal,
      Ledger -> [Account]
    laccounts :: [Account]
    }