```-- | These are the bits that are "open"; that is, their constructors
-- are exported. This includes most bits. Some bits that have open
-- constructors are not in this module because they include other bits
-- that do not have exported constructors.

module Penny.Lincoln.Bits.Open where

import Data.List (sort)
import Data.Monoid ((<>))
import Data.Text (Text)
import qualified Data.Text as X
import qualified Penny.Lincoln.Equivalent as Ev
import Penny.Lincoln.Equivalent ((==~))
import qualified Penny.Lincoln.Serial as S

newtype SubAccount =
SubAccount { unSubAccount :: Text }
deriving (Eq, Ord, Show)

newtype Account = Account { unAccount :: [SubAccount] }
deriving (Eq, Show, Ord)

data Amount q = Amount
{ qty :: q
, commodity :: Commodity }
deriving (Eq, Show, Ord)

instance Functor Amount where
fmap f (Amount q c) = Amount (f q) c

instance Ev.Equivalent q => Ev.Equivalent (Amount q) where
equivalent (Amount q1 c1) (Amount q2 c2) =
q1 ==~ q2 && c1 == c2
compareEv (Amount q1 c1) (Amount q2 c2) =
Ev.compareEv q1 q2 <> c1 `compare` c2

newtype Commodity =
Commodity { unCommodity :: Text }
deriving (Eq, Ord, Show)

data DrCr = Debit | Credit deriving (Eq, Show, Ord)

-- | Debit returns Credit; Credit returns Debit
opposite :: DrCr -> DrCr
opposite d = case d of
Debit -> Credit
Credit -> Debit

data Entry q = Entry
{ drCr :: DrCr
, amount :: Amount q }
deriving (Eq, Show, Ord)

instance Functor Entry where
fmap f (Entry d a) = Entry d (fmap f a)

instance Ev.Equivalent q => Ev.Equivalent (Entry q) where
equivalent (Entry d1 a1) (Entry d2 a2) =
d1 == d2 && a1 ==~ a2
compareEv (Entry d1 a1) (Entry d2 a2) =
d1 `compare` d2 <> Ev.compareEv a1 a2

newtype Flag = Flag { unFlag :: Text }
deriving (Eq, Show, Ord)

-- | There is one item in the list for each line of the memo. Do not
-- include newlines in the texts themselves. However there is nothing
-- to enforce this convention.
newtype Memo = Memo { unMemo :: [Text] }
deriving (Eq, Show, Ord)

newtype Number = Number { unNumber :: Text }
deriving (Eq, Show, Ord)

newtype Payee = Payee { unPayee :: Text }
deriving (Eq, Show, Ord)

newtype Tag = Tag { unTag :: Text }
deriving (Eq, Show, Ord)

newtype Tags = Tags { unTags :: [Tag] }
deriving (Eq, Show, Ord)

-- | Tags are equivalent if they have the same tags (even if in a
-- different order).
instance Ev.Equivalent Tags where
equivalent (Tags t1) (Tags t2) = sort t1 == sort t2
compareEv (Tags t1) (Tags t2) =
compare (sort t1) (sort t2)

-- | The line number that the TopLine starts on (excluding the memo
-- accompanying the TopLine).
newtype TopLineLine = TopLineLine { unTopLineLine :: Int }
deriving (Eq, Show)

-- | The line number that the memo accompanying the TopLine starts on.
newtype TopMemoLine = TopMemoLine { unTopMemoLine :: Int }
deriving (Eq, Show)

-- | The commodity and and the quantity may appear with the commodity
-- on the left (e.g. USD 2.14) or with the commodity on the right
-- (e.g. 2.14 USD).
data Side
= CommodityOnLeft
| CommodityOnRight
deriving (Eq, Show, Ord)

instance Ev.Equivalent Side where
equivalent = (==)
compareEv = compare

-- | There may or may not be a space in between the commodity and the
-- quantity.
data SpaceBetween
= SpaceBetween
| NoSpaceBetween
deriving (Eq, Show, Ord)

instance Ev.Equivalent SpaceBetween where
equivalent = (==)
compareEv = compare

-- | The name of the file in which a transaction appears.
newtype Filename = Filename { unFilename :: X.Text }
deriving (Eq, Show)

-- | The line number on which a price appears.
newtype PriceLine = PriceLine { unPriceLine :: Int }
deriving (Eq, Show)

-- | The line number on which a posting appears.
newtype PostingLine = PostingLine { unPostingLine :: Int }
deriving (Eq, Show)

-- | All postings are numbered in order, beginning with the first
-- posting in the first file and ending with the last posting
-- in the last file.
newtype GlobalPosting =
GlobalPosting { unGlobalPosting :: S.Serial }
deriving (Eq, Show)

-- | The postings in each file are numbered in order.
newtype FilePosting =
FilePosting { unFilePosting :: S.Serial }
deriving (Eq, Show)

-- | All transactions are numbered in order, beginning with the first
-- transaction in the first file and ending with the last transaction
-- in the last file.
newtype GlobalTransaction =
GlobalTransaction { unGlobalTransaction :: S.Serial }
deriving (Eq, Show)

-- | The transactions in each file are numbered in order.
newtype FileTransaction =
FileTransaction { unFileTransaction :: S.Serial }
deriving (Eq, Show)

```