Modif : {Balance.Amount_Sum => Amount.Sum}.

diff --git a/cli/Hcompta/CLI/Command/Balance.hs b/cli/Hcompta/CLI/Command/Balance.hs
index 1cf915c446f766f715db5c67b701bc5fe0b035fc..d56c8a681e31eb0f0e1f794f496a2b7199cb75d1 100644 (file)
--- a/cli/Hcompta/CLI/Command/Balance.hs
+++ b/cli/Hcompta/CLI/Command/Balance.hs
@@ -160,19 +160,19 @@ run context args = do
                                        W.renderCompact False .
                                        toDoc (Context.lang context) in
                                zipWith id
-                               [ Table.column (title Lang.Message_Balance_debit)  Table.Align_Right
-                               , Table.column (title Lang.Message_Balance_credit) Table.Align_Right
-                               , Table.column (title Lang.Message_Balance_total)  Table.Align_Right
-                               , Table.column (title Lang.Message_Account)        Table.Align_Left
+                               [ Table.column (title Lang.Message_Debit)   Table.Align_Right
+                               , Table.column (title Lang.Message_Credit)  Table.Align_Right
+                               , Table.column (title Lang.Message_Balance) Table.Align_Right
+                               , Table.column (title Lang.Message_Account) Table.Align_Left
                                ] $
-                               flip (write_by_accounts ctx) balance_by_account $
+                               write_by_accounts ctx balance_by_account $
                                zipWith (:)
                                        [ Table.Cell_Line '=' 0
                                        , Table.Cell_Line '=' 0
                                        , Table.Cell_Line '=' 0
                                        , Table.Cell_Line ' ' 0
                                        ] $
-                               write_by_amounts (repeat []) $
+                               flip write_by_amounts (repeat []) $
                                        Data.Map.map
                                         Balance.unit_sum_amount
                                         balance_by_unit
@@ -180,10 +180,10 @@ run context args = do
 ledger_balances
  :: Filter.Test_Bool (Filter.Test_Transaction Ledger.Transaction)
  -> Filter.Test_Bool (Filter.Test_Posting     Ledger.Posting)
- -> Filter.Test_Bool (Filter.Test_Balance     (Account, Balance.Amount_Sum Amount))
+ -> Filter.Test_Bool (Filter.Test_Balance     (Account, Amount.Sum Amount))
  -> [Ledger.Journal]
- -> ( Balance.Expanded (Balance.Amount_Sum Amount)
-    , Balance.Balance_by_Unit (Balance.Amount_Sum Amount) Unit )
+ -> ( Balance.Expanded (Amount.Sum Amount)
+    , Balance.Balance_by_Unit (Amount.Sum Amount) Unit )
 ledger_balances
  transaction_filter
  posting_filter
@@ -206,7 +206,7 @@ ledger_balances
                                                                flip (foldr Balance.by_account) .
                                                                map (\p ->
                                                                        ( Ledger.posting_account p
-                                                                       , Data.Map.map Balance.amount_sum (Ledger.posting_amounts p)
+                                                                       , Data.Map.map Amount.sum (Ledger.posting_amounts p)
                                                                        )
                                                                 ) .
                                                                filter_postings in
@@ -233,12 +233,12 @@ ledger_balances
 
 write_by_accounts
  :: Ctx
+ -> Balance.Expanded (Amount.Sum Amount)
  -> [[Table.Cell]]
- -> Balance.Expanded (Balance.Amount_Sum Amount)
  -> [[Table.Cell]]
 write_by_accounts ctx =
        let posting_type = Ledger.Posting_Type_Regular in
-       Lib.TreeMap.foldr_with_Path_and_Node
+       flip $ Lib.TreeMap.foldr_with_Path_and_Node
         (\account node balance rows -> do
                let descendants = Lib.TreeMap.nodes
                         (Lib.TreeMap.node_descendants node)
@@ -250,13 +250,13 @@ write_by_accounts ctx =
                        || (Data.Map.null descendants && not
                                 (Data.Map.null
                                 (Data.Map.filter
-                                        (not . Amount.is_zero . Balance.amount_sum_balance)
+                                        (not . Amount.is_zero . Amount.sum_balance)
                                         (Balance.inclusive balance))))
                        -- NOTE: worth if account exclusive
                        -- has at least a non-zero amount
                        || not (Data.Map.null
                                 (Data.Map.filter
-                                        (not . Amount.is_zero . Balance.amount_sum_balance)
+                                        (not . Amount.is_zero . Amount.sum_balance)
                                         (Balance.exclusive balance)))
                        -- NOTE: worth if account has at least more than
                        -- one descendant account whose inclusive
@@ -266,7 +266,7 @@ write_by_accounts ctx =
                                         ( maybe False
                                                 ( not . Data.Foldable.all
                                                         ( Amount.is_zero
-                                                        . Balance.amount_sum_balance )
+                                                        . Amount.sum_balance )
                                                 . Balance.inclusive )
                                         . Lib.TreeMap.node_value )
                                         descendants) > 1
@@ -298,32 +298,32 @@ write_by_accounts ctx =
                        let bal = Balance.inclusive balance in
                        Data.Map.foldrWithKey
                         (\unit amount acc ->
-                               ( maybe Nothing Balance.amount_sum_positive $ Data.Map.lookup unit $ bal
-                               , maybe Nothing Balance.amount_sum_negative $ Data.Map.lookup unit $ bal
-                               , Balance.amount_sum_balance amount
+                               ( maybe Nothing Amount.sum_positive $ Data.Map.lookup unit $ bal
+                               , maybe Nothing Amount.sum_negative $ Data.Map.lookup unit $ bal
+                               , Amount.sum_balance amount
                                ) : acc
                         ) [] $ bal
         )
 
 write_by_amounts
- :: [[Table.Cell]]
- -> Data.Map.Map Unit (Balance.Amount_Sum Amount)
+ :: Data.Map.Map Unit (Amount.Sum Amount)
+ -> [[Table.Cell]]
  -> [[Table.Cell]]
 write_by_amounts =
-       foldr
+       flip $ foldr
         (\amount_sum ->
                zipWith (:)
-                       [ let amt = Balance.amount_sum_positive amount_sum in
+                       [ let amt = Amount.sum_positive amount_sum in
                                Table.cell
                                 { Table.cell_content = maybe W.empty Ledger.Write.amount  amt
                                 , Table.cell_width   = maybe 0 Ledger.Write.amount_length amt
                                 }
-                       , let amt = Balance.amount_sum_negative amount_sum in
+                       , let amt = Amount.sum_negative amount_sum in
                                Table.cell
                                 { Table.cell_content = maybe W.empty Ledger.Write.amount  amt
                                 , Table.cell_width   = maybe 0 Ledger.Write.amount_length amt
                                 }
-                       , let amt = Balance.amount_sum_balance amount_sum in
+                       , let amt = Amount.sum_balance amount_sum in
                                Table.cell
                                 { Table.cell_content = Ledger.Write.amount  amt
                                 , Table.cell_width   = Ledger.Write.amount_length amt

diff --git a/cli/Hcompta/CLI/Format/Ledger.hs b/cli/Hcompta/CLI/Format/Ledger.hs
index 98190253c569c78d6bb8e9040ac5b13e88b98015..3eb2033f3441ae271b60219aed6dd9c0dd9cb50f 100644 (file)
--- a/cli/Hcompta/CLI/Format/Ledger.hs
+++ b/cli/Hcompta/CLI/Format/Ledger.hs
@@ -70,7 +70,7 @@ instance ToDoc Lang Ledger.Read.Error where
                                 [ toDoc lang msg
                                 , W.vsep $ Data.List.map
                                         (\Balance.Unit_Sum{Balance.unit_sum_amount} ->
-                                               let amt = Balance.amount_sum_balance unit_sum_amount in
+                                               let amt = Amount.sum_balance unit_sum_amount in
                                                toDoc lang $
                                                Lang.Message_unit_sums_up_to_the_non_null_amount
                                                 (Amount.unit amt) amt

diff --git a/cli/Hcompta/CLI/Lang.hs b/cli/Hcompta/CLI/Lang.hs
index fb13dc17f5ff1a46b5dcb83dd7df99bab1e37c4c..761c13428d3b16e12e517e07da3017863134d1e2 100644 (file)
--- a/cli/Hcompta/CLI/Lang.hs
+++ b/cli/Hcompta/CLI/Lang.hs
@@ -210,10 +210,14 @@ data Message
  | Message_sysunexpect_end_of_input {}
  | Message_unknown {}
  | Message_or {}
- | Message_Balance_total {}
- | Message_Balance_debit {}
- | Message_Balance_credit {}
+ | Message_Balance {}
+ | Message_Debit {}
+ | Message_Credit {}
+ | Message_Total_debit {}
+ | Message_Total_credit {}
  | Message_Account {}
+ | Message_Date {}
+ | Message_Description {}
 instance ToDoc Lang Message where
        toDoc EN msg =
                case msg of
@@ -253,14 +257,22 @@ instance ToDoc Lang Message where
                        "unkown"
                 Message_or ->
                        "or"
-                Message_Balance_total ->
+                Message_Balance ->
                        "Balance"
-                Message_Balance_debit ->
+                Message_Debit ->
                        "Debit"
-                Message_Balance_credit ->
+                Message_Credit ->
                        "Credit"
+                Message_Total_debit ->
+                       "Total debit"
+                Message_Total_credit ->
+                       "Total credit"
                 Message_Account ->
                        "Account"
+                Message_Date ->
+                       "Date"
+                Message_Description ->
+                       "Description"
        toDoc FR msg =
                case msg of
                 Message_ERROR ->
@@ -299,11 +311,19 @@ instance ToDoc Lang Message where
                        "inconnu"
                 Message_or ->
                        "ou"
-                Message_Balance_total ->
+                Message_Balance ->
                        "Solde"
-                Message_Balance_debit ->
+                Message_Debit ->
                        "Débit"
-                Message_Balance_credit ->
+                Message_Credit ->
                        "Crédit"
+                Message_Total_debit ->
+                       "Total débit"
+                Message_Total_credit ->
+                       "Total crédit"
                 Message_Account ->
                        "Compte"
+                Message_Date ->
+                       "Date"
+                Message_Description ->
+                       "Description"

diff --git a/lib/Hcompta/Amount.hs b/lib/Hcompta/Amount.hs
index 529fe1c37ae2fef100b9480f2357724b33ccf219..f324a1973fff747c48cb8de6db8433dbe6d2e9c5 100644 (file)
--- a/lib/Hcompta/Amount.hs
+++ b/lib/Hcompta/Amount.hs
@@ -1,4 +1,5 @@
 {-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE TypeFamilies #-}
@@ -55,16 +56,6 @@ instance Balance.Amount Amount where
        amount_null = (==) Quantity.zero . quantity
        amount_add = (+)
        amount_negate = negate
-       amount_positive a =
-               case compare (quantity a) Quantity.zero of
-                LT -> Nothing
-                EQ -> Nothing
-                _  -> Just a
-       amount_negative a =
-               case compare (quantity a) Quantity.zero of
-                GT -> Nothing
-                EQ -> Nothing
-                _  -> Just a
 
 -- | An 'Amount' is a partially valid 'Num' instance:
 --
@@ -312,3 +303,120 @@ from_List :: [Amount] -> Amount_by_Unit
 from_List amounts =
        Data.Map.fromListWith (flip (+)) $ -- NOTE: flip to propagate 'Style' first to last.
        Data.List.map assoc_by_unit amounts
+
+-- * Type 'Sum'
+
+-- ** Class 'Sumable'
+class
+ ( Data (Sumable_Unit a)
+ , Data a
+ , Eq a
+ , Ord  (Sumable_Unit a)
+ , Show (Sumable_Unit a)
+ , Show a
+ , Typeable (Sumable_Unit a)
+ , Typeable a
+ ) => Sumable a where
+       type Sumable_Unit a
+       -- sumable_add      :: a -> a -> a
+       sumable_positive :: a -> Maybe a
+       sumable_negative :: a -> Maybe a
+
+instance Sumable Amount where
+       type Sumable_Unit Amount = Unit
+       -- sumable_add = (+)
+       sumable_positive a =
+               case compare (quantity a) Quantity.zero of
+                LT -> Nothing
+                EQ -> Nothing
+                _  -> Just a
+       sumable_negative a =
+               case compare (quantity a) Quantity.zero of
+                GT -> Nothing
+                EQ -> Nothing
+                _  -> Just a
+
+instance Sumable amount => Sumable (Sum amount) where
+       type Sumable_Unit (Sum amount) = Sumable_Unit amount
+       sumable_negative amt =
+               case amt of
+                Sum_Negative _ -> Just $ amt
+                Sum_Positive _ -> Nothing
+                Sum_Both n _   -> Just $ Sum_Negative n
+       sumable_positive amt =
+               case amt of
+                Sum_Negative _ -> Nothing
+                Sum_Positive _ -> Just $ amt
+                Sum_Both _ p   -> Just $ Sum_Positive p
+
+-- | Sum separately keeping track of negative and positive 'amount's.
+data Sum amount
+ =   Sum_Negative amount
+ |   Sum_Positive amount
+ |   Sum_Both     amount amount
+ deriving (Data, Eq, Show, Typeable)
+
+instance Balance.Amount a
+ => Balance.Amount (Sum a) where
+       type Amount_Unit (Sum a) = Balance.Amount_Unit a
+       amount_null amt =
+               case amt of
+                Sum_Negative n -> Balance.amount_null n
+                Sum_Positive p -> Balance.amount_null p
+                Sum_Both n p   -> Balance.amount_null (Balance.amount_add n p)
+       amount_add a0 a1 =
+               case (a0, a1) of
+                (Sum_Negative n0, Sum_Negative n1) -> Sum_Negative (Balance.amount_add n0 n1)
+                (Sum_Negative n , Sum_Positive p)  -> Sum_Both n p
+                (Sum_Negative n0, Sum_Both n1 p)   -> Sum_Both (Balance.amount_add n0 n1) p
+               
+                (Sum_Positive p , Sum_Negative n)  -> Sum_Both n p
+                (Sum_Positive p0, Sum_Positive p1) -> Sum_Positive (Balance.amount_add p0 p1)
+                (Sum_Positive p , Sum_Both n1 p1)  -> Sum_Both n1 (Balance.amount_add p p1)
+               
+                (Sum_Both n0 p0, Sum_Negative p1) -> Sum_Both n0 (Balance.amount_add p0 p1)
+                (Sum_Both n0 p0, Sum_Positive p1) -> Sum_Both n0 (Balance.amount_add p0 p1)
+                (Sum_Both n0 p0, Sum_Both n1 p1)  -> Sum_Both (Balance.amount_add n0 n1) (Balance.amount_add p0 p1)
+       amount_negate amt =
+               case amt of
+                Sum_Negative n -> Sum_Positive $ Balance.amount_negate n
+                Sum_Positive p -> Sum_Negative $ Balance.amount_negate p
+                Sum_Both n p   -> Sum_Both (Balance.amount_negate p) (Balance.amount_negate n)
+
+sum
+ :: Sumable amount
+ => amount -> Sum amount
+sum amt =
+       case ( sumable_negative amt
+            , sumable_positive amt ) of
+        (Just n, Nothing)  -> Sum_Negative n
+        (Nothing, Just p)  -> Sum_Positive p
+        (Just n, Just p)   -> Sum_Both n p
+        (Nothing, Nothing) -> Sum_Both amt amt
+
+sum_negative
+ :: Balance.Amount amount
+ => Sum amount -> Maybe amount
+sum_negative amt =
+       case amt of
+        Sum_Negative n -> Just n
+        Sum_Positive _ -> Nothing
+        Sum_Both n _   -> Just n
+
+sum_positive
+ :: Balance.Amount amount
+ => Sum amount -> Maybe amount
+sum_positive amt =
+       case amt of
+        Sum_Negative _ -> Nothing
+        Sum_Positive p -> Just p
+        Sum_Both _ p   -> Just p
+
+sum_balance
+ :: Balance.Amount amount
+ => Sum amount -> amount
+sum_balance amt =
+       case amt of
+        Sum_Negative n -> n
+        Sum_Positive p -> p
+        Sum_Both n p   -> Balance.amount_add n p

diff --git a/lib/Hcompta/Balance.hs b/lib/Hcompta/Balance.hs
index c089e0b5f95de691a05db66a37ecdc06bd65ad29..3665b74bf0c01e4fa5c54f4c4a929db408587a44 100644 (file)
--- a/lib/Hcompta/Balance.hs
+++ b/lib/Hcompta/Balance.hs
@@ -39,25 +39,6 @@ class
        amount_null     :: a -> Bool
        amount_add      :: a -> a -> a
        amount_negate   :: a -> a
-       amount_positive :: a -> Maybe a
-       amount_negative :: a -> Maybe a
-
-instance (Amount a, unit ~ Amount_Unit a)
- => Amount (Map unit a) where
-       type Amount_Unit (Map unit a) = Amount_Unit a
-       amount_null     = Data.Foldable.all amount_null
-       amount_add      = Data.Map.unionWith amount_add
-       amount_negate   = Data.Map.map amount_negate
-       amount_negative a =
-               let m = Data.Map.mapMaybe amount_negative a in
-               if Data.Map.null m
-               then Nothing
-               else Just m
-       amount_positive a =
-               let m = Data.Map.mapMaybe amount_positive a in
-               if Data.Map.null m
-               then Nothing
-               else Just m
 
 -- ** Class 'Posting'
 
@@ -429,86 +410,3 @@ by_unit_of_expanded =
                                        let account = Lib.TreeMap.reverse $ Lib.TreeMap.path k p in
                                        by_unit (account, inclusive a) acc)
                         bal m
-
--- * Type 'Amount_Sum'
-
--- | Sum separately keeping track of negative and positive 'amount's.
-data Amount amount
- => Amount_Sum amount
- = Amount_Sum_Negative amount
- | Amount_Sum_Positive amount
- | Amount_Sum_Both     amount amount
- deriving (Data, Eq, Show, Typeable)
-
-instance Amount a => Amount (Amount_Sum a) where
-       type Amount_Unit (Amount_Sum a) = Amount_Unit a
-       amount_null amt =
-               case amt of
-                Amount_Sum_Negative n -> amount_null n
-                Amount_Sum_Positive p -> amount_null p
-                Amount_Sum_Both n p   -> amount_null (amount_add n p)
-       amount_add a0 a1 =
-               case (a0, a1) of
-                (Amount_Sum_Negative n0, Amount_Sum_Negative n1) -> Amount_Sum_Negative (amount_add n0 n1)
-                (Amount_Sum_Negative n , Amount_Sum_Positive p)  -> Amount_Sum_Both n p
-                (Amount_Sum_Negative n0, Amount_Sum_Both n1 p)   -> Amount_Sum_Both (amount_add n0 n1) p
-               
-                (Amount_Sum_Positive p , Amount_Sum_Negative n)  -> Amount_Sum_Both n p
-                (Amount_Sum_Positive p0, Amount_Sum_Positive p1) -> Amount_Sum_Positive (amount_add p0 p1)
-                (Amount_Sum_Positive p , Amount_Sum_Both n1 p1)  -> Amount_Sum_Both n1 (amount_add p p1)
-               
-                (Amount_Sum_Both n0 p0, Amount_Sum_Negative p1) -> Amount_Sum_Both n0 (amount_add p0 p1)
-                (Amount_Sum_Both n0 p0, Amount_Sum_Positive p1) -> Amount_Sum_Both n0 (amount_add p0 p1)
-                (Amount_Sum_Both n0 p0, Amount_Sum_Both n1 p1)  -> Amount_Sum_Both (amount_add n0 n1) (amount_add p0 p1)
-       amount_negate amt =
-               case amt of
-                Amount_Sum_Negative n -> Amount_Sum_Positive $ amount_negate n
-                Amount_Sum_Positive p -> Amount_Sum_Negative $ amount_negate p
-                Amount_Sum_Both n p   -> Amount_Sum_Both (amount_negate p) (amount_negate n)
-       amount_negative amt =
-               case amt of
-                Amount_Sum_Negative _ -> Just $ amt
-                Amount_Sum_Positive _ -> Nothing
-                Amount_Sum_Both n _   -> Just $ Amount_Sum_Negative n
-       amount_positive amt =
-               case amt of
-                Amount_Sum_Negative _ -> Nothing
-                Amount_Sum_Positive _ -> Just $ amt
-                Amount_Sum_Both _ p   -> Just $ Amount_Sum_Positive p
-
-amount_sum
- :: Amount amount
- => amount -> Amount_Sum amount
-amount_sum amt =
-       case (amount_negative amt, amount_positive amt) of
-        (Just n, Nothing)  -> Amount_Sum_Negative n
-        (Nothing, Just p)  -> Amount_Sum_Positive p
-        (Just n, Just p)   -> Amount_Sum_Both n p
-        (Nothing, Nothing) -> Amount_Sum_Both amt amt
-
-amount_sum_negative
- :: Amount amount
- => Amount_Sum amount -> Maybe amount
-amount_sum_negative amt =
-       case amt of
-        Amount_Sum_Negative n -> Just n
-        Amount_Sum_Positive _ -> Nothing
-        Amount_Sum_Both n _   -> Just n
-
-amount_sum_positive
- :: Amount amount
- => Amount_Sum amount -> Maybe amount
-amount_sum_positive amt =
-       case amt of
-        Amount_Sum_Negative _ -> Nothing
-        Amount_Sum_Positive p -> Just p
-        Amount_Sum_Both _ p   -> Just p
-
-amount_sum_balance
- :: Amount amount
- => Amount_Sum amount -> amount
-amount_sum_balance amt =
-       case amt of
-        Amount_Sum_Negative n -> n
-        Amount_Sum_Positive p -> p
-        Amount_Sum_Both n p   -> amount_add n p

diff --git a/lib/Hcompta/Filter.hs b/lib/Hcompta/Filter.hs
index fc85c20d93eec750ff2bc4e34e33105413e10d5a..f7e1f12a0f868ebfb36d0efd1da7e248d42f2c2c 100644 (file)
--- a/lib/Hcompta/Filter.hs
+++ b/lib/Hcompta/Filter.hs
@@ -73,11 +73,11 @@ instance Amount Amount.Amount where
        amount_unit     = Amount.unit
 
 instance (Amount a, Balance.Amount a)
- => Amount (Balance.Amount_Sum a) where
-       type Amount_Unit     (Balance.Amount_Sum a) = Amount_Unit a
-       type Amount_Quantity (Balance.Amount_Sum a) = Amount_Quantity a
-       amount_quantity = amount_quantity . Balance.amount_sum_balance
-       amount_unit     = amount_unit     . Balance.amount_sum_balance
+ => Amount (Amount.Sum a) where
+       type Amount_Unit     (Amount.Sum a) = Amount_Unit a
+       type Amount_Quantity (Amount.Sum a) = Amount_Quantity a
+       amount_quantity = amount_quantity . Amount.sum_balance
+       amount_unit     = amount_unit     . Amount.sum_balance
 
 -- ** Class 'Posting'
 
@@ -108,12 +108,12 @@ class Amount (Balance_Amount b)
        balance_negative :: b -> Maybe (Balance_Amount b)
 
 instance (Amount a, Balance.Amount a)
- => Balance (Account, Balance.Amount_Sum a) where
-       type Balance_Amount (Account, Balance.Amount_Sum a) = a
+ => Balance (Account, Amount.Sum a) where
+       type Balance_Amount (Account, Amount.Sum a) = a
        balance_account = fst
-       balance_amount   = Balance.amount_sum_balance  . snd
-       balance_positive = Balance.amount_sum_positive . snd
-       balance_negative = Balance.amount_sum_negative . snd
+       balance_amount   = Amount.sum_balance  . snd
+       balance_positive = Amount.sum_positive . snd
+       balance_negative = Amount.sum_negative . snd
 
 -- * Class 'Test'
 

diff --git a/lib/Hcompta/Format/Ledger.hs b/lib/Hcompta/Format/Ledger.hs
index 81b0e3e120f869bf7fd74aab4df4a6937c04125b..745c3935d0aa6d73a44349e7d20c9c6bf23ddd68 100644 (file)
--- a/lib/Hcompta/Format/Ledger.hs
+++ b/lib/Hcompta/Format/Ledger.hs
@@ -133,11 +133,11 @@ posting acct =
 
 instance
  Balance.Posting Posting where
-       type Posting_Amount Posting = Balance.Amount_Sum Amount
+       type Posting_Amount Posting = Amount.Sum Amount
        posting_account = posting_account
-       posting_amounts = Data.Map.map Balance.amount_sum . posting_amounts
+       posting_amounts = Data.Map.map Amount.sum . posting_amounts
        posting_set_amounts amounts p =
-               p { posting_amounts=Data.Map.map Balance.amount_sum_balance amounts }
+               p { posting_amounts=Data.Map.map Amount.sum_balance amounts }
 
 instance Filter.Posting Posting where
        type Posting_Amount Posting = Amount

diff --git a/lib/Test/Main.hs b/lib/Test/Main.hs
index f449d0e28f84605e76ebc16c9155289fa2ae87d0..b727eb9f88c300dbfe9e31bafa18da4082d3405a 100644 (file)
--- a/lib/Test/Main.hs
+++ b/lib/Test/Main.hs
@@ -1175,13 +1175,13 @@ test_Hcompta =
                                 Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ]) ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 1
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 1
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[]]
                                                 }
@@ -1204,17 +1204,17 @@ test_Hcompta =
                                                Lib.TreeMap.from_List const $
                                                 [ ( "A":|[]
                                                         , Data.Map.fromListWith const $
-                                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance s, s))
-                                                               [ Balance.Amount_Sum_Both
+                                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance s, s))
+                                                               [ Amount.Sum_Both
                                                                         (Amount.usd $ -1)
                                                                         (Amount.usd $ 1)
                                                                ]
                                                         ) ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.Amount_Sum_Both
+                                                { Balance.unit_sum_amount = Amount.Sum_Both
                                                         (Amount.usd $ -1)
                                                         (Amount.usd $ 1)
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
@@ -1237,18 +1237,18 @@ test_Hcompta =
                                 Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1, Amount.eur $ -1 ]) ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.Amount_Sum_Positive (Amount.usd $ 1)
+                                                { Balance.unit_sum_amount = Amount.Sum_Positive (Amount.usd $ 1)
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[]]
                                                 }
                                                , Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.Amount_Sum_Negative (Amount.eur $ -1)
+                                                { Balance.unit_sum_amount = Amount.Sum_Negative (Amount.eur $ -1)
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[]]
                                                 }
@@ -1269,15 +1269,15 @@ test_Hcompta =
                                 Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                 , ("B":|[], Amount.from_List [ Amount.usd $ -1 ])
                                                 ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.Amount_Sum_Both
+                                                { Balance.unit_sum_amount = Amount.Sum_Both
                                                         (Amount.usd $ -1)
                                                         (Amount.usd $ 1)
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
@@ -1300,15 +1300,15 @@ test_Hcompta =
                                 Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                 , ("B":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                 ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 2
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 2
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[], "B":|[]]
                                                 }
@@ -1331,22 +1331,22 @@ test_Hcompta =
                                                Lib.TreeMap.from_List const $
                                                 [ ("A":|[]
                                                         , Data.Map.fromListWith const $
-                                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance s, s))
-                                                               [ Balance.Amount_Sum_Both (Amount.usd $ -1) (Amount.usd $ 1)
-                                                               , Balance.Amount_Sum_Both (Amount.eur $ -2) (Amount.eur $ 2)
+                                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance s, s))
+                                                               [ Amount.Sum_Both (Amount.usd $ -1) (Amount.usd $ 1)
+                                                               , Amount.Sum_Both (Amount.eur $ -2) (Amount.eur $ 2)
                                                                ]
                                                         )
                                                 ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.Amount_Sum_Both (Amount.usd $ -1) (Amount.usd $ 1)
+                                                { Balance.unit_sum_amount = Amount.Sum_Both (Amount.usd $ -1) (Amount.usd $ 1)
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[]]
                                                 }
                                                , Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.Amount_Sum_Both (Amount.eur $ -2) (Amount.eur $ 2)
+                                                { Balance.unit_sum_amount = Amount.Sum_Both (Amount.eur $ -2) (Amount.eur $ 2)
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[]]
                                                 }
@@ -1367,25 +1367,25 @@ test_Hcompta =
                                 Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $  1, Amount.eur $  2, Amount.gbp $  3 ])
                                                 , ("B":|[], Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2, Amount.gbp $ -3 ])
                                                 ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.Amount_Sum_Both (Amount.usd $ -1) (Amount.usd $ 1)
+                                                { Balance.unit_sum_amount = Amount.Sum_Both (Amount.usd $ -1) (Amount.usd $ 1)
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[], "B":|[]]
                                                 }
                                                , Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.Amount_Sum_Both (Amount.eur $ -2) (Amount.eur $ 2)
+                                                { Balance.unit_sum_amount = Amount.Sum_Both (Amount.eur $ -2) (Amount.eur $ 2)
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[], "B":|[]]
                                                 }
                                                , Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.Amount_Sum_Both (Amount.gbp $ -3) (Amount.gbp $ 3)
+                                                { Balance.unit_sum_amount = Amount.Sum_Both (Amount.gbp $ -3) (Amount.gbp $ 3)
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[], "B":|[]]
                                                 }
@@ -1402,13 +1402,13 @@ test_Hcompta =
                                         (Balance.Balance
                                                 { Balance.balance_by_account =
                                                        Lib.TreeMap.from_List const $
-                                                       Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                                       Data.List.map (id *** Data.Map.map Amount.sum) $
                                                         [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ]) ]
                                                 , Balance.balance_by_unit =
                                                        Data.Map.fromList $
-                                                       Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                                       Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                        [ Balance.Unit_Sum
-                                                        { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 1
+                                                        { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 1
                                                         , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                                 ["A":|[]]
                                                         }
@@ -1417,13 +1417,13 @@ test_Hcompta =
                                         (Balance.Balance
                                                 { Balance.balance_by_account =
                                                        Lib.TreeMap.from_List const $
-                                                       Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                                       Data.List.map (id *** Data.Map.map Amount.sum) $
                                                         [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ]) ]
                                                 , Balance.balance_by_unit =
                                                        Data.Map.fromList $
-                                                       Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                                       Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                        [ Balance.Unit_Sum
-                                                        { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 1
+                                                        { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 1
                                                         , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                                 ["A":|[]]
                                                         }
@@ -1433,13 +1433,13 @@ test_Hcompta =
                                 Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 2 ]) ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 2
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 2
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[]]
                                                 }
@@ -1450,13 +1450,13 @@ test_Hcompta =
                                         (Balance.Balance
                                                 { Balance.balance_by_account =
                                                        Lib.TreeMap.from_List const $
-                                                       Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                                       Data.List.map (id *** Data.Map.map Amount.sum) $
                                                         [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ]) ]
                                                 , Balance.balance_by_unit =
                                                        Data.Map.fromList $
-                                                       Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                                       Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                        [ Balance.Unit_Sum
-                                                        { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 1
+                                                        { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 1
                                                         , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                                 ["A":|[]]
                                                         }
@@ -1465,13 +1465,13 @@ test_Hcompta =
                                         (Balance.Balance
                                                 { Balance.balance_by_account =
                                                        Lib.TreeMap.from_List const $
-                                                       Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                                       Data.List.map (id *** Data.Map.map Amount.sum) $
                                                         [ ("B":|[], Amount.from_List [ Amount.usd $ 1 ]) ]
                                                 , Balance.balance_by_unit =
                                                        Data.Map.fromList $
-                                                       Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                                       Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                        [ Balance.Unit_Sum
-                                                        { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 1
+                                                        { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 1
                                                         , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                                 ["B":|[]]
                                                         }
@@ -1481,14 +1481,14 @@ test_Hcompta =
                                 Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                 , ("B":|[], Amount.from_List [ Amount.usd $ 1 ]) ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 2
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 2
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[], "B":|[]]
                                                 }
@@ -1499,13 +1499,13 @@ test_Hcompta =
                                         (Balance.Balance
                                                 { Balance.balance_by_account =
                                                        Lib.TreeMap.from_List const $
-                                                       Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                                       Data.List.map (id *** Data.Map.map Amount.sum) $
                                                         [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ]) ]
                                                 , Balance.balance_by_unit =
                                                        Data.Map.fromList $
-                                                       Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                                       Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                        [ Balance.Unit_Sum
-                                                        { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 1
+                                                        { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 1
                                                         , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                                 ["A":|[]]
                                                         }
@@ -1514,13 +1514,13 @@ test_Hcompta =
                                         (Balance.Balance
                                                 { Balance.balance_by_account =
                                                        Lib.TreeMap.from_List const $
-                                                       Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                                       Data.List.map (id *** Data.Map.map Amount.sum) $
                                                         [ ("B":|[], Amount.from_List [ Amount.eur $ 1 ]) ]
                                                 , Balance.balance_by_unit =
                                                        Data.Map.fromList $
-                                                       Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                                       Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                        [ Balance.Unit_Sum
-                                                        { Balance.unit_sum_amount = Balance.amount_sum $ Amount.eur $ 1
+                                                        { Balance.unit_sum_amount = Amount.sum $ Amount.eur $ 1
                                                         , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                                 ["B":|[]]
                                                         }
@@ -1530,19 +1530,19 @@ test_Hcompta =
                                 Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                 , ("B":|[], Amount.from_List [ Amount.eur $ 1 ]) ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 1
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 1
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[]]
                                                 }
                                                , Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.eur $ 1
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.eur $ 1
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["B":|[]]
                                                 }
@@ -1558,103 +1558,103 @@ test_Hcompta =
                         , "A+$1 = A+$1" ~:
                                 Balance.expanded
                                        (Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ]) ])
                                 ~?=
                                 (Lib.TreeMap.from_List const $
                                         [ ("A":|[], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         ])
                         , "A/A+$1 = A+$1 A/A+$1" ~:
                                 Balance.expanded
                                        (Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|["A"], Amount.from_List [ Amount.usd $ 1 ]) ])
                                 ~?=
                                 (Lib.TreeMap.from_List const
                                         [ ("A":|[], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List []
                                                 })
                                         , ("A":|["A"], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         ])
                         , "A/B+$1 = A+$1 A/B+$1" ~:
                                 Balance.expanded
                                        (Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|["B"], Amount.from_List [ Amount.usd $ 1 ]) ])
                                 ~?=
                                 (Lib.TreeMap.from_List const
                                         [ ("A":|[], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List []
                                                 })
                                         , ("A":|["B"], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         ])
                         , "A/B/C+$1 = A+$1 A/B+$1 A/B/C+$1" ~:
                                 Balance.expanded
                                        (Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|["B", "C"], Amount.from_List [ Amount.usd $ 1 ]) ])
                                 ~?=
                                 (Lib.TreeMap.from_List const $
                                         [ ("A":|[], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List []
                                                 })
                                         , ("A":|["B"], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List []
                                                 })
                                         , ("A":|["B", "C"], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         ])
                         , "A+$1 A/B+$1 = A+$2 A/B+$1" ~:
                                 Balance.expanded
                                        (Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                 , ("A":|["B"], Amount.from_List [ Amount.usd $ 1 ])
                                                 ])
@@ -1662,25 +1662,25 @@ test_Hcompta =
                                 (Lib.TreeMap.from_List const
                                         [ ("A":|[], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 2 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         , ("A":|["B"], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         ])
                         , "A+$1 A/B+$1 A/B/C+$1 = A+$3 A/B+$2 A/B/C+$1" ~:
                                 Balance.expanded
                                        (Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                 , ("A":|["B"], Amount.from_List [ Amount.usd $ 1 ])
                                                 , ("A":|["B", "C"], Amount.from_List [ Amount.usd $ 1 ])
@@ -1689,33 +1689,33 @@ test_Hcompta =
                                 (Lib.TreeMap.from_List const
                                         [ ("A":|[], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 3 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         , ("A":|["B"], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 2 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         , ("A":|["B", "C"], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         ])
                         , "A+$1 A/B+$1 A/B/C+$1 A/B/C/D+$1 = A+$4 A/B+$3 A/B/C+$2 A/B/C/D+$1" ~:
                                 Balance.expanded
                                        (Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                 , ("A":|["B"], Amount.from_List [ Amount.usd $ 1 ])
                                                 , ("A":|["B", "C"], Amount.from_List [ Amount.usd $ 1 ])
@@ -1725,41 +1725,41 @@ test_Hcompta =
                                 (Lib.TreeMap.from_List const
                                         [ ("A":|[], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 4 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         , ("A":|["B"], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 3 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         , ("A":|["B", "C"], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 2 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         , ("A":|["B", "C", "D"], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         ])
                         , "A+$1 A/B+$1 A/BB+$1 AA/B+$1 = A+$3 A/B+$1 A/BB+$1 AA+$1 AA/B+$1" ~:
                                 Balance.expanded
                                        (Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                 , ("A":|["B"], Amount.from_List [ Amount.usd $ 1 ])
                                                 , ("A":|["BB"], Amount.from_List [ Amount.usd $ 1 ])
@@ -1769,42 +1769,42 @@ test_Hcompta =
                                 (Lib.TreeMap.from_List const
                                         [ ("A":|[], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 3 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         , ("A":|["B"], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         , ("A":|["BB"], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         , ("AA":|[], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List []
                                                 })
                                         , ("AA":|["B"], Balance.Account_Sum_Expanded
                                                 { Balance.inclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 , Balance.exclusive =
-                                                       Data.Map.map Balance.amount_sum $
+                                                       Data.Map.map Amount.sum $
                                                        Amount.from_List [ Amount.usd $ 1 ]
                                                 })
                                         ])
@@ -1815,15 +1815,15 @@ test_Hcompta =
                                        Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                 , ("B":|[], Amount.from_List [])
                                                 ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 1
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 1
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[]]
                                                 }
@@ -1832,9 +1832,9 @@ test_Hcompta =
                                 ~?=
                                 (Balance.Deviation $
                                        Data.Map.fromList $
-                                       Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                       Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                        [ Balance.Unit_Sum
-                                        { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 1
+                                        { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 1
                                         , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                 ["B":|[]]
                                         }
@@ -1844,15 +1844,15 @@ test_Hcompta =
                                        Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                 , ("B":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                 ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 2
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 2
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         [ "A":|[]
                                                         , "B":|[]
@@ -1863,9 +1863,9 @@ test_Hcompta =
                                 ~?=
                                 (Balance.Deviation $
                                        Data.Map.fromList $
-                                       Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                       Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                        [ Balance.Unit_Sum
-                                        { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 2
+                                        { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 2
                                         , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                 [
                                                 ]
@@ -1885,14 +1885,14 @@ test_Hcompta =
                                        Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 0 ])
                                                 ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 0
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 0
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[]]
                                                 }
@@ -1905,14 +1905,14 @@ test_Hcompta =
                                        Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                 ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 1
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 1
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[]]
                                                 }
@@ -1925,19 +1925,19 @@ test_Hcompta =
                                        Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 0, Amount.eur $ 0 ])
                                                 ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 0
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 0
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[]]
                                                 }
                                                , Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.eur $ 0
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.eur $ 0
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[]]
                                                 }
@@ -1950,15 +1950,15 @@ test_Hcompta =
                                        Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $  1 ])
                                                 , ("B":|[], Amount.from_List [ Amount.usd $ -1 ])
                                                 ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 0
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 0
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[], "B":|[]]
                                                 }
@@ -1971,15 +1971,15 @@ test_Hcompta =
                                         Balance.Balance
                                                 { Balance.balance_by_account =
                                                        Lib.TreeMap.from_List const $
-                                                       Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                                       Data.List.map (id *** Data.Map.map Amount.sum) $
                                                         [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                         , ("B":|[], Amount.from_List [])
                                                         ]
                                                 , Balance.balance_by_unit =
                                                        Data.Map.fromList $
-                                                       Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                                       Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                        [ Balance.Unit_Sum
-                                                        { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 1
+                                                        { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 1
                                                         , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                                 ["A":|[]]
                                                         }
@@ -1992,20 +1992,20 @@ test_Hcompta =
                                        Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                 , ("B":|[], Amount.from_List [ Amount.eur $ 1 ])
                                                 ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 1
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 1
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[]]
                                                 }
                                                , Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.eur $ 1
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.eur $ 1
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["B":|[]]
                                                 }
@@ -2018,20 +2018,20 @@ test_Hcompta =
                                        Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $ 1 ])
                                                 , ("B":|[], Amount.from_List [ Amount.usd $ -1, Amount.eur $ 1 ])
                                                 ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 0
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 0
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[], "B":|[]]
                                                 }
                                                , Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.eur $ 1
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.eur $ 1
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["B":|[]]
                                                 }
@@ -2044,25 +2044,25 @@ test_Hcompta =
                                        Balance.Balance
                                         { Balance.balance_by_account =
                                                Lib.TreeMap.from_List const $
-                                               Data.List.map (id *** Data.Map.map Balance.amount_sum) $
+                                               Data.List.map (id *** Data.Map.map Amount.sum) $
                                                 [ ("A":|[], Amount.from_List [ Amount.usd $  1, Amount.eur $  2, Amount.gbp $  3 ])
                                                 , ("B":|[], Amount.from_List [ Amount.usd $ -1, Amount.eur $ -2, Amount.gbp $ -3 ])
                                                 ]
                                         , Balance.balance_by_unit =
                                                Data.Map.fromList $
-                                               Data.List.map (\s -> (Amount.unit $ Balance.amount_sum_balance $ Balance.unit_sum_amount s, s))
+                                               Data.List.map (\s -> (Amount.unit $ Amount.sum_balance $ Balance.unit_sum_amount s, s))
                                                [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 0
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 0
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[], "B":|[]]
                                                 }
                                                , Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.eur $ 0
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.eur $ 0
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[], "B":|[]]
                                                 }
                                                , Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.gbp $ 0
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.gbp $ 0
                                                 , Balance.unit_sum_accounts = Data.Map.fromList $ Data.List.map (,())
                                                         ["A":|[], "B":|[]]
                                                 }
@@ -2113,7 +2113,7 @@ test_Hcompta =
                                 ~?=
                                 (Left
                                         [ Balance.Unit_Sum
-                                                { Balance.unit_sum_amount = Balance.amount_sum $ Amount.usd $ 2
+                                                { Balance.unit_sum_amount = Amount.sum $ Amount.usd $ 2
                                                 , Balance.unit_sum_accounts = Data.Map.fromList []}
                                         ])
                         , "{A+$1 B-$1 B-1€}" ~: