HAX.Bookkeeping.Internal

This module contains the internal type and functions not to be used directly as most of them are unsafe, meaning that they allow actions that violate double-entry contraints or actions on accounts other than the current body's accounts (via UNSAFE_AccountN).

Therefore, do not use this module directly, use HAX.Bookkeeping instead.

Account Names and Numbers

type AccountNumber = Int

type AssetName = String

type EntityName = String

data FullAccountName

uniquely identifying name used to lookup the account numbers

Constructors

FAN

Fields

• fEntity :: EntityName
• fAccount :: String

Instances

Eq FullAccountName

Methods

(==) :: FullAccountName -> FullAccountName -> Bool

(/=) :: FullAccountName -> FullAccountName -> Bool

Ord FullAccountName

Methods

compare :: FullAccountName -> FullAccountName -> Ordering

(<) :: FullAccountName -> FullAccountName -> Bool

(<=) :: FullAccountName -> FullAccountName -> Bool

(>) :: FullAccountName -> FullAccountName -> Bool

(>=) :: FullAccountName -> FullAccountName -> Bool

max :: FullAccountName -> FullAccountName -> FullAccountName

min :: FullAccountName -> FullAccountName -> FullAccountName

Show FullAccountName

Methods

showsPrec :: Int -> FullAccountName -> ShowS

show :: FullAccountName -> String

showList :: [FullAccountName] -> ShowS

Generic FullAccountName

Associated Types

type Rep FullAccountName :: * -> *

Methods

from :: FullAccountName -> Rep FullAccountName x

to :: Rep FullAccountName x -> FullAccountName

type Rep FullAccountName

type Rep FullAccountName = D1 (MetaData "FullAccountName" "HAX.Bookkeeping.Internal" "hax-0.0.2-Lj8gOWDiNX5LEcFpshI2lz" False) (C1 (MetaCons "FAN" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "fEntity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 EntityName)) (S1 (MetaSel (Just Symbol "fAccount") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))))

swapFAN :: FullAccountName -> FullAccountName

data AccountName

this type is used to make functions taking AccountNames polymorphic.

Constructors

AccountN String

account for the current entity. Only these accounts should be accessible in accounting actions

UNSAFE_AccountN FullAccountName

full account for internal use only

Instances

Eq AccountName

Methods

(==) :: AccountName -> AccountName -> Bool

(/=) :: AccountName -> AccountName -> Bool

Ord AccountName

Methods

compare :: AccountName -> AccountName -> Ordering

(<) :: AccountName -> AccountName -> Bool

(<=) :: AccountName -> AccountName -> Bool

(>) :: AccountName -> AccountName -> Bool

(>=) :: AccountName -> AccountName -> Bool

max :: AccountName -> AccountName -> AccountName

min :: AccountName -> AccountName -> AccountName

Show AccountName

Methods

showsPrec :: Int -> AccountName -> ShowS

show :: AccountName -> String

showList :: [AccountName] -> ShowS

IsString AccountName

Strings are automatically converted to (safe) AccoutNames, if the -XOverloadedStrings extensions is active. (See Data.String).

Methods

fromString :: String -> AccountName

PrintfArg AccountName

Methods

formatArg :: AccountName -> FieldFormatter

parseFormat :: AccountName -> ModifierParser

type AccountsMap = Map FullAccountName AccountNumber

The map from FullAccountNames to AccountNumbers used internally to address the efficient Ledger array storage

sortedAccountNames :: AccountsMap -> [FullAccountName]

Extract accounts names order by their internal account numbers

internalAccountNumber :: FullAccountName -> AccountsMap -> AccountNumber

extract the AccountNumber for a FullAccountName from an AccountsMap

Postings and Transactions

type Posting = (AccountName, Amount)

type InternalPosting = (AccountNumber, Amount)

data Tx

A transaction that is already balanced. Such an object can only be built from BalancingTx using balanceTx and is never needed as function input. This format is used to log the transactions in the Ledger 's LogEntry.

Constructors

UNSAFE_Tx

Fields

• tComment :: Comment
• tPostings :: [InternalPosting]

Instances

Show Tx

Methods

showsPrec :: Int -> Tx -> ShowS

show :: Tx -> String

showList :: [Tx] -> ShowS

Generic Tx

Associated Types

type Rep Tx :: * -> *

Methods

from :: Tx -> Rep Tx x

to :: Rep Tx x -> Tx

type Rep Tx

type Rep Tx = D1 (MetaData "Tx" "HAX.Bookkeeping.Internal" "hax-0.0.2-Lj8gOWDiNX5LEcFpshI2lz" False) (C1 (MetaCons "UNSAFE_Tx" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "tComment") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Comment)) (S1 (MetaSel (Just Symbol "tPostings") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [InternalPosting]))))

data BalancingTx

A transaction involving only accounts relative to a body, and that is self balancing through the use of an account for the remains

Constructors

BalancingTx

Fields

• txComment :: Comment
• txRemains :: AccountName
• txPostings :: [Posting]

balanceTx :: Monoid w => BalancingTx -> Acc s l w Tx

Balance a BalancingTx and prepend the entitiyName to the comment. This is only used internally

The Ledger

data LogEntry

Information that is logged while the ledger is built

Constructors

LTx Tx

Transactions of the current time period

LComment String

Random comment to be put into the ledger

Instances

Show LogEntry

Methods

showsPrec :: Int -> LogEntry -> ShowS

show :: LogEntry -> String

showList :: [LogEntry] -> ShowS

Generic LogEntry

Associated Types

type Rep LogEntry :: * -> *

Methods

from :: LogEntry -> Rep LogEntry x

to :: Rep LogEntry x -> LogEntry

type Rep LogEntry

type Rep LogEntry = D1 (MetaData "LogEntry" "HAX.Bookkeeping.Internal" "hax-0.0.2-Lj8gOWDiNX5LEcFpshI2lz" False) ((:+:) (C1 (MetaCons "LTx" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Tx))) (C1 (MetaCons "LComment" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 String))))

type EntityLogEntry = (EntityName, LogEntry)

type LedgerIndex = (ADate, AccountNumber)

type LedgerBounds = (LedgerIndex, LedgerIndex)

class Ledger l where

This class defines what a Ledger is:

Minimal complete definition

lBounds, lReadEntry, lAccountHistory, lFix, lunsafeFix

Methods

lBounds :: l -> IO LedgerBounds

it has bounds

lReadEntry :: LedgerIndex -> l -> IO (Amount, [EntityLogEntry])

single entries for a given account and date consisting of the account balance and the log entries for that date can be read.

lAccountHistory :: (ADate, ADate) -> (ADate -> LedgerIndex) -> l -> IO [Amount]

the account history can be read

lFix :: l -> IO FixedLedger

it can be fixed into an immutable type

lunsafeFix :: l -> IO FixedLedger

fix withou making a copy. This is has to be safe to use, if the mutable version is never modified after the freeze operation.

Instances

Ledger FixedLedger

Methods

lBounds :: FixedLedger -> IO LedgerBounds

lReadEntry :: LedgerIndex -> FixedLedger -> IO (Amount, [EntityLogEntry])

lAccountHistory :: (ADate, ADate) -> (ADate -> LedgerIndex) -> FixedLedger -> IO [Amount]

lFix :: FixedLedger -> IO FixedLedger

lunsafeFix :: FixedLedger -> IO FixedLedger

Ledger LedgerRW

Methods

lBounds :: LedgerRW -> IO LedgerBounds

lReadEntry :: LedgerIndex -> LedgerRW -> IO (Amount, [EntityLogEntry])

lAccountHistory :: (ADate, ADate) -> (ADate -> LedgerIndex) -> LedgerRW -> IO [Amount]

lFix :: LedgerRW -> IO FixedLedger

lunsafeFix :: LedgerRW -> IO FixedLedger

data LedgerRW

LedgerRW implements a writable (within the IO monad) Ledger.

The total balance is always zero and no transactions that depend on future values are allowed. This is guaranteed, by not exporting UNSAFE_Ledger and instead, the ledger is only changed using the exported safe functions. E.g. tx, fromTo, ...

Constructors

UNSAFE_Ledger

Fields

• lUNSAFE_Bals :: IOArray LedgerIndex Amount

  Balances for each Date and Account

• lUNSAFE_LogEntries :: IOArray ADate [EntityLogEntry]

  Transactions and Comments for each Date

Instances

Ledger LedgerRW

Methods

lBounds :: LedgerRW -> IO LedgerBounds

lReadEntry :: LedgerIndex -> LedgerRW -> IO (Amount, [EntityLogEntry])

lAccountHistory :: (ADate, ADate) -> (ADate -> LedgerIndex) -> LedgerRW -> IO [Amount]

lFix :: LedgerRW -> IO FixedLedger

lunsafeFix :: LedgerRW -> IO FixedLedger

data FixedLedger

This type implements the Ledger in immutable form, suitable as the main result of the whole program or for accounting accounts that are garantueed to not change the ledger.

Constructors

FixedLedger

Fields

• lBals :: Array LedgerIndex Amount
• lLogEntries :: Array ADate [EntityLogEntry]

Instances

Ledger FixedLedger

Methods

lBounds :: FixedLedger -> IO LedgerBounds

lReadEntry :: LedgerIndex -> FixedLedger -> IO (Amount, [EntityLogEntry])

lAccountHistory :: (ADate, ADate) -> (ADate -> LedgerIndex) -> FixedLedger -> IO [Amount]

lFix :: FixedLedger -> IO FixedLedger

lunsafeFix :: FixedLedger -> IO FixedLedger

data FullLedger

Constructors

FullLedger

Fields

• flLedger :: FixedLedger
• flAccounts :: AccountsMap

Accounting Environment

data Environment body ledger

Represents the environment an accounting action is run on.

Constructors

Env

Fields

• eLedger :: ledger

  the ledger of the whole world (i.e. all bodys

• eAccounts :: AccountsMap

  map of all accounts managed by the ledger

• eDate :: ADate

  current date

• eBody :: body

  current body

• eName :: Maybe EntityName

  current body's name

Instances

Monoid w => Eq (AmountA s l w)

Methods

(==) :: AmountA s l w -> AmountA s l w -> Bool

(/=) :: AmountA s l w -> AmountA s l w -> Bool

Monoid w => Fractional (AmountA s l w)

Methods

(/) :: AmountA s l w -> AmountA s l w -> AmountA s l w

recip :: AmountA s l w -> AmountA s l w

fromRational :: Rational -> AmountA s l w

Monoid w => Num (AmountA s l w)

Allows to use +,-,*,negate directly on actions that return an amount. Furthermore any numeral can be used directly as (trivial) accounting action:

soll "Cash" + 4 :: AmountA s l

Methods

(+) :: AmountA s l w -> AmountA s l w -> AmountA s l w

(-) :: AmountA s l w -> AmountA s l w -> AmountA s l w

(*) :: AmountA s l w -> AmountA s l w -> AmountA s l w

negate :: AmountA s l w -> AmountA s l w

abs :: AmountA s l w -> AmountA s l w

signum :: AmountA s l w -> AmountA s l w

fromInteger :: Integer -> AmountA s l w

Monoid w => Ord (AmountA s l w)

Allows to use min and max and its derivaties directly on actions that return an amount:

min ( "Cash") (balanceAt date "Cash") :: AmountA s l

Methods

compare :: AmountA s l w -> AmountA s l w -> Ordering

(<) :: AmountA s l w -> AmountA s l w -> Bool

(<=) :: AmountA s l w -> AmountA s l w -> Bool

(>) :: AmountA s l w -> AmountA s l w -> Bool

(>=) :: AmountA s l w -> AmountA s l w -> Bool

max :: AmountA s l w -> AmountA s l w -> AmountA s l w

min :: AmountA s l w -> AmountA s l w -> AmountA s l w

Accounting Actions

type Acc body ledger writer = RWST (Environment body ledger) writer () IO

The Accounting Monad

This monad is a stack of Reader Writer and IO monad.

Actions from this monad can read an immutable environment. This environment however, contains references to mutable arrays (see LedgerRW), which can be modified through IO actions lifted into this monad into this monad.

The body type variable will contain the type of the Body the current accounting action is concerned with.

type AccountingRW body = Acc body LedgerRW ()

A specializations for read-write accounting actions with no (i.e. trivial '()') writer output

type AccountingReadOnly body = Acc body FixedLedger (AccountingRW body ())

A specialization for read-only actions. These actions can however produce read-write actions as output via the Writer Monad. This is used in fixed.

class (Monoid w, Ledger l) => AccPair l w

Short-cut class used in type signatures involving Acc and its derivatives

Instances

(Monoid w, Ledger l) => AccPair l w

type AmountRW body = AccountingRW body Amount

type synonym for an accounting action that has an amount as result

type AmountA body l w = Acc body l w Amount

fixed :: AccountingReadOnly s a -> AccountingRW s a

run a read only action and its genrated read-write output within a general accounting action and pass on its result.

Internal Helper Functions

ledgerBounds :: (Monoid w, Ledger l) => Acc s l w (LedgerIndex, LedgerIndex)

readEntryForNumber :: (Monoid w, Ledger l) => AccountNumber -> Acc s l w (Amount, [EntityLogEntry])

accountsNumbers :: (Monoid w, Ledger l) => Acc s l w [AccountNumber]

timeInterval :: (Monoid w, Ledger l) => Acc s l w (ADate, ADate)

accountNumber :: Monoid w => AccountName -> Acc s l w AccountNumber

nameErr :: MonadReader (Environment body ledger) m => [Char] -> m EntityName

Tries to get the eName of the current entity and throws an error if it is Nothing.

readEntryForName :: (Monoid w, Ledger l) => AccountName -> Acc s l w (Amount, [EntityLogEntry])

Internal UNSAFE Functions

uNSAFE_at :: Monoid w => ADate -> Acc s l w a -> Acc s l w a

perform an accounting action at any date

uNSAFE_addToBalance :: InternalPosting -> AccountingRW s ()

uNSAFE_carryOver :: AccountingRW s ()

add last month's balances to previous month's. This is performed once for every time step in generate

Orphan instances

Monad m => Monoid (m ())

Methods

mempty :: m ()

mappend :: m () -> m () -> m ()

mconcat :: [m ()] -> m ()