]> Git — Sourcephile - comptalang.git/blob - cli/Hcompta/CLI/Format.hs
Ajout : Lib.TreeMap.Zipper : en prévision de collectes « à la XSLT » sur Chart.
[comptalang.git] / cli / Hcompta / CLI / Format.hs
1 {-# LANGUAGE ConstraintKinds #-}
2 {-# LANGUAGE ExistentialQuantification #-}
3 {-# LANGUAGE FlexibleContexts #-}
4 {-# LANGUAGE FlexibleInstances #-}
5 {-# LANGUAGE MultiParamTypeClasses #-}
6 {-# LANGUAGE NamedFieldPuns #-}
7 {-# LANGUAGE OverloadedStrings #-}
8 {-# LANGUAGE Rank2Types #-}
9 {-# LANGUAGE ScopedTypeVariables #-}
10 {-# LANGUAGE TypeFamilies #-}
11 module Hcompta.CLI.Format where
12
13 import Control.Applicative (Const(..))
14 import Control.Monad.Trans.Except (runExceptT)
15 import Data.Bool (Bool(..), not)
16 import qualified Data.Char as Char
17 import Data.Decimal (Decimal)
18 import Data.Either (Either(..))
19 import Data.Function (($), (.), id)
20 import Data.Functor (Functor(..), (<$>))
21 import qualified Data.List as List
22 import Data.List.NonEmpty (NonEmpty(..))
23 import qualified Data.Map.Strict as Map
24 import Data.Map.Strict (Map)
25 import Data.Maybe (Maybe(..))
26 import Data.Monoid (Monoid(..))
27 import Data.Ord (Ord(..))
28 import Data.Sequence (Seq)
29 import qualified Data.Text as Text
30 import Data.Text (Text)
31 import System.IO (FilePath, IO)
32 import Text.Show (Show)
33
34 import qualified Hcompta.CLI.Lang as Lang
35 import qualified Hcompta.Lib.Leijen as W
36 import qualified Hcompta.Lib.TreeMap as TreeMap
37 import Hcompta.Lib.TreeMap (TreeMap)
38 import qualified Hcompta.Journal as Journal
39 import qualified Hcompta.Tag as Tag
40 import qualified Hcompta.Balance as Balance
41 import qualified Hcompta.GL as GL
42 import qualified Hcompta.Stats as Stats
43 import qualified Hcompta.Chart as Chart
44 import qualified Hcompta.Account as Account
45 import qualified Hcompta.Posting as Posting
46 import qualified Hcompta.Transaction as Transaction
47 -- import qualified Hcompta.Filter.Read as Filter.Read
48 import Hcompta.Date (Date)
49 import qualified Hcompta.Polarize as Polarize
50 import qualified Hcompta.Format.JCC as JCC
51 import qualified Hcompta.Format.JCC.Journal as JCC.Journal
52 import qualified Hcompta.Format.JCC.Read as JCC.Read
53 import qualified Hcompta.Format.JCC.Amount.Style as JCC.Amount.Style
54 import qualified Hcompta.Format.Ledger as Ledger
55 import qualified Hcompta.Format.Ledger.Read as Ledger
56 import qualified Hcompta.Lib.Parsec as R
57 import Hcompta.Lib.Consable (Consable)
58 import qualified Hcompta.CLI.Lib.Leijen.Table as Leijen.Table
59
60 -- * Type 'Format'
61
62 data Format jcc ledger
63 = Format_JCC jcc
64 | Format_Ledger ledger
65 deriving (Show)
66 type Formats = Format () ()
67
68 instance
69 ( Convert jcc ledger
70 , Convert ledger jcc
71 , Monoid jcc
72 , Monoid ledger
73 ) => Monoid (Format jcc ledger) where
74 mempty = Format_JCC mempty
75 mappend x y =
76 case x of
77 Format_JCC xj ->
78 Format_JCC $
79 case y of
80 Format_JCC yj -> mappend xj yj
81 Format_Ledger yj -> mappend xj (convert yj)
82 Format_Ledger xj ->
83 Format_Ledger $
84 case y of
85 Format_JCC yj -> mappend xj (convert yj)
86 Format_Ledger yj -> mappend xj yj
87
88 format :: Formats
89 format = Format_JCC ()
90
91 -- * Type family 'Journal_Account'
92 type family Journal_Account (j:: * -> *)
93 type instance Journal_Account JCC.Journal = JCC.Account
94 type instance Journal_Account Ledger.Journal = Ledger.Account
95
96 -- * Type family 'Journal_Account_Section'
97 type family Journal_Account_Section (j:: * -> *)
98 type instance Journal_Account_Section JCC.Journal = JCC.Account_Section
99 type instance Journal_Account_Section Ledger.Journal = Ledger.Account_Section
100
101 -- * Type family 'Journal_Charted'
102 type family Journal_Charted (j:: * -> *) :: * -> *
103 type instance Journal_Charted JCC.Journal = JCC.Charted
104 type instance Journal_Charted Ledger.Journal = Ledger.Charted
105
106 -- * Type family 'Journal_Quantity'
107 type family Journal_Quantity (j:: * -> *)
108 type instance Journal_Quantity JCC.Journal = JCC.Quantity
109 type instance Journal_Quantity Ledger.Journal = Ledger.Quantity
110
111 -- * Type family 'Journal_Unit'
112 type family Journal_Unit (j:: * -> *)
113 type instance Journal_Unit JCC.Journal = JCC.Unit
114 type instance Journal_Unit Ledger.Journal = Ledger.Unit
115
116 -- * Type family 'Journal_Posting'
117 type family Journal_Posting (j:: * -> *)
118 type instance Journal_Posting JCC.Journal = JCC.Posting
119 type instance Journal_Posting Ledger.Journal = Ledger.Posting
120
121 -- * Type family 'Journal_Transaction'
122 type family Journal_Transaction (j:: * -> *)
123 type instance Journal_Transaction JCC.Journal = JCC.Transaction
124 type instance Journal_Transaction Ledger.Journal = Ledger.Transaction
125
126 -- * Class 'Journal'
127
128 class Journal j where
129 type Journal_Format j
130 journal_format
131 :: j -> Journal_Format j
132
133 -- * Class 'Journal_Empty'
134
135 class Journal_Empty j where
136 journal_empty :: Formats -> j
137
138 -- * Class 'Journal_Files'
139
140 class Journal_Files j where
141 journal_files :: forall m. j m -> [FilePath]
142 instance Journal_Files JCC.Journal where
143 journal_files j = [JCC.journal_file j] -- FIXME: JCC.journal_files
144 instance Journal_Files Ledger.Journal where
145 journal_files = Ledger.journal_files
146
147 -- * Class 'Journal_Read'
148
149 class Journal_Read (j:: * -> *) where
150 type Journal_Read_Error j
151 type Journal_Read_Transaction j
152 journal_read
153 :: forall c m. (Monoid m, Consable c m)
154 => (Journal_Read_Transaction j -> c)
155 -> FilePath
156 -> IO (Either (Journal_Read_Error j) (j m))
157 instance Journal_Read JCC.Journal where
158 type Journal_Read_Error JCC.Journal
159 = [R.Error JCC.Read.Error]
160 type Journal_Read_Transaction JCC.Journal
161 = JCC.Charted JCC.Transaction
162 journal_read cons =
163 runExceptT . JCC.Read.file
164 (JCC.Read.context cons JCC.journal)
165 instance Journal_Read Ledger.Journal where
166 type Journal_Read_Error Ledger.Journal
167 = [R.Error Ledger.Read_Error]
168 type Journal_Read_Transaction Ledger.Journal
169 = Ledger.Charted Ledger.Transaction
170 journal_read cons =
171 runExceptT . Ledger.read
172 (Ledger.read_context cons Ledger.journal)
173
174 -- * Class 'Journal_Chart'
175
176 class Journal_Chart (j:: * -> *) where
177 journal_chart
178 :: forall m. j m
179 -> Chart.Chart (NonEmpty (Journal_Account_Section j))
180 instance Journal_Chart JCC.Journal where
181 journal_chart = JCC.journal_chart
182 instance Journal_Chart Ledger.Journal where
183 journal_chart = Ledger.journal_chart
184
185 -- * Class 'Journal_Monoid'
186
187 class Journal_Monoid j where
188 journal_flatten :: j -> j
189 journal_fold :: (j -> a -> a) -> j -> a -> a
190 instance Monoid m => Journal_Monoid (JCC.Journal m) where
191 journal_flatten = JCC.Journal.flatten
192 journal_fold = JCC.Journal.fold
193 instance Monoid m => Journal_Monoid (Ledger.Journal m) where
194 journal_flatten = Ledger.journal_flatten
195 journal_fold = Ledger.journal_fold
196
197 -- * Class 'Journal_Filter'
198
199 class Functor j => Journal_Filter context j m where
200 journal_filter
201 :: context -> j m -> j m
202
203 -- * Class 'Journal_Functor'
204
205 class Journal_Functor x y where
206 journal_functor_map :: x -> y
207 journal_fmap :: forall j. Functor j => j x -> j y
208 journal_fmap = fmap journal_functor_map
209
210 -- * Class 'Journal_Table'
211
212 -- | A class to render a journal
213 -- into 'Leijen.Table.Cell's.
214 class Journal_Leijen_Table_Cells j m where
215 journal_leijen_table_cells
216 :: j m
217 -> [[Leijen.Table.Cell]]
218 -> [[Leijen.Table.Cell]]
219
220
221 -- * Class 'Journal_Wrap'
222
223 -- | A class dedicated to transform a journal
224 -- to another one using existential quantification
225 -- to gather multiple journals under a single type,
226 -- by writing instances between fully monomorphic types,
227 -- which ease a lot meeting the requirements
228 -- of the constraints in the wrap type.
229 class Journal_Wrap j wrap where
230 journal_wrap :: j -> wrap
231
232 class Journal_Content j where
233 journal_content :: forall m. j m -> m
234 instance Journal_Content JCC.Journal where
235 journal_content = JCC.journal_content
236 instance Journal_Content Ledger.Journal where
237 journal_content = Ledger.journal_content
238
239 -- * Type 'Message'
240
241 -- data Journal jnl m = forall j. jnl j => Journal (j m)
242 data Message w = forall msg. Lang.Translate msg w => Message msg
243 instance Lang.Translate (Message W.Doc) W.Doc where
244 translate lang (Message x) = Lang.translate lang x
245
246 -- * Class 'Convert'
247
248 -- | Generic class dedicated to transform any type
249 -- into another one encoding more or less
250 -- the same data.
251 class Convert from to where
252 convert :: from -> to
253
254 instance Convert () () where
255 convert = id
256
257 -- Journal
258 instance
259 ( Convert ledger jcc
260 , Monoid jcc
261 , Monoid ledger
262 )
263 => Convert (Ledger.Journal ledger) (JCC.Journal jcc) where
264 convert Ledger.Journal
265 { Ledger.journal_amount_styles
266 , Ledger.journal_chart = chart
267 , Ledger.journal_files=jf
268 , Ledger.journal_includes
269 , Ledger.journal_last_read_time
270 , Ledger.journal_content = content
271 } = JCC.Journal
272 { JCC.journal_amount_styles = convert journal_amount_styles
273 , JCC.journal_chart = chart
274 , JCC.journal_file = List.head jf -- FIXME: JCC.journal_files
275 , JCC.journal_includes = fmap convert $ journal_includes
276 , JCC.journal_last_read_time
277 , JCC.journal_content = convert content
278 }
279 instance
280 ( Convert jcc ledger
281 , Monoid jcc
282 , Monoid ledger
283 )
284 => Convert (JCC.Journal jcc) (Ledger.Journal ledger) where
285 convert JCC.Journal
286 { JCC.journal_amount_styles
287 , JCC.journal_chart = chart
288 , JCC.journal_file
289 , JCC.journal_includes
290 , JCC.journal_last_read_time
291 , JCC.journal_content = content
292 } = Ledger.Journal
293 { Ledger.journal_amount_styles = convert journal_amount_styles
294 , Ledger.journal_chart = chart
295 , Ledger.journal_files = [journal_file] -- FIXME: JCC.journal_files
296 , Ledger.journal_includes = fmap convert $ journal_includes
297 , Ledger.journal_last_read_time
298 , Ledger.journal_content = convert content
299 }
300 instance Convert ledger jcc
301 => Convert
302 (Journal.Journal ledger)
303 (Journal.Journal jcc)
304 where
305 convert (Journal.Journal j) =
306 Journal.Journal $
307 fmap convert $
308 Map.mapKeysMonotonic convert j
309
310 -- Unit
311 instance Convert Ledger.Unit JCC.Unit where
312 convert (Ledger.Unit u) =
313 JCC.Unit $
314 Text.map
315 (\c -> case Char.generalCategory c of
316 Char.CurrencySymbol -> c
317 Char.LowercaseLetter -> c
318 Char.ModifierLetter -> c
319 Char.OtherLetter -> c
320 Char.TitlecaseLetter -> c
321 Char.UppercaseLetter -> c
322 _ -> '_') u
323 instance Convert JCC.Unit Ledger.Unit where
324 convert (JCC.Unit u) =
325 Ledger.Unit u
326
327 -- Account
328 instance Convert Account.Account_Anchor Account.Account_Anchor where
329 convert = id
330 instance Convert Account.Account_Tags Account.Account_Tags where
331 convert = id
332
333 -- Amount Style
334 instance Convert Ledger.Amount_Styles JCC.Styles where
335 convert (Ledger.Amount_Styles sty) =
336 JCC.Amount.Style.Styles $ convert sty
337 instance Convert JCC.Styles Ledger.Amount_Styles where
338 convert (JCC.Amount.Style.Styles sty) =
339 Ledger.Amount_Styles $ convert sty
340 instance Convert Ledger.Amount_Style JCC.Style where
341 convert Ledger.Amount_Style
342 { Ledger.amount_style_fractioning=f
343 , Ledger.amount_style_grouping_integral=gi
344 , Ledger.amount_style_grouping_fractional=gf
345 , Ledger.amount_style_unit_side=unit_side
346 , Ledger.amount_style_unit_spaced=unit_spaced
347 } = JCC.Amount.Style.Style
348 { JCC.Amount.Style.fractioning=f
349 , JCC.Amount.Style.grouping_integral =
350 fmap (\(Ledger.Amount_Style_Grouping c l) ->
351 JCC.Amount.Style.Grouping c l) gi
352 , JCC.Amount.Style.grouping_fractional =
353 fmap (\(Ledger.Amount_Style_Grouping c l) ->
354 JCC.Amount.Style.Grouping c l) gf
355 , JCC.Amount.Style.unit_side =
356 fmap (\s ->
357 case s of
358 Ledger.Amount_Style_Side_Left -> JCC.Amount.Style.Side_Left
359 Ledger.Amount_Style_Side_Right -> JCC.Amount.Style.Side_Right
360 ) unit_side
361 , JCC.Amount.Style.unit_spaced
362 }
363 instance Convert JCC.Style Ledger.Amount_Style where
364 convert JCC.Amount.Style.Style
365 { JCC.Amount.Style.fractioning=f
366 , JCC.Amount.Style.grouping_integral=gi
367 , JCC.Amount.Style.grouping_fractional=gf
368 , JCC.Amount.Style.unit_side=unit_side
369 , JCC.Amount.Style.unit_spaced=unit_spaced
370 } = Ledger.Amount_Style
371 { Ledger.amount_style_fractioning=f
372 , Ledger.amount_style_grouping_integral =
373 fmap (\(JCC.Amount.Style.Grouping c l) ->
374 Ledger.Amount_Style_Grouping c l) gi
375 , Ledger.amount_style_grouping_fractional =
376 fmap (\(JCC.Amount.Style.Grouping c l) ->
377 Ledger.Amount_Style_Grouping c l) gf
378 , Ledger.amount_style_unit_side =
379 fmap
380 (\s ->
381 case s of
382 JCC.Amount.Style.Side_Left -> Ledger.Amount_Style_Side_Left
383 JCC.Amount.Style.Side_Right -> Ledger.Amount_Style_Side_Right
384 ) unit_side
385 , Ledger.amount_style_unit_spaced=unit_spaced
386 }
387
388 -- Transaction
389 instance Convert Ledger.Transaction JCC.Transaction where
390 convert Ledger.Transaction
391 { Ledger.transaction_code
392 , Ledger.transaction_comments_after
393 , Ledger.transaction_comments_before
394 , Ledger.transaction_dates
395 , Ledger.transaction_postings
396 , Ledger.transaction_sourcepos
397 , Ledger.transaction_status
398 , Ledger.transaction_tags
399 , Ledger.transaction_wording
400 } = JCC.Transaction
401 { JCC.transaction_anchors = mempty
402 , JCC.transaction_comments =
403 List.filter (not . Text.all Char.isSpace) $
404 Ledger.comments_without_tags $
405 mappend
406 transaction_comments_before
407 transaction_comments_after
408 , JCC.transaction_dates
409 , JCC.transaction_postings = fmap (fmap convert) transaction_postings
410 , JCC.transaction_sourcepos
411 , JCC.transaction_tags =
412 (case transaction_code of
413 t | Text.null t -> id
414 t -> Transaction.tag_cons (Transaction.tag ("Code":|[]) t)
415 ) $
416 case transaction_status of
417 True -> Transaction.tag_cons
418 (Transaction.tag ("Status":|[]) "")
419 transaction_tags
420 False -> transaction_tags
421 , JCC.transaction_wording
422 }
423 instance Convert JCC.Transaction Ledger.Transaction where
424 convert JCC.Transaction
425 { JCC.transaction_anchors=_transaction_anchors
426 , JCC.transaction_comments
427 , JCC.transaction_dates
428 , JCC.transaction_postings
429 , JCC.transaction_sourcepos
430 , JCC.transaction_tags = Transaction.Transaction_Tags (Tag.Tags tags)
431 , JCC.transaction_wording
432 } = Ledger.Transaction
433 { Ledger.transaction_code = mconcat $ Map.findWithDefault [""] ("Code":|[]) tags
434 , Ledger.transaction_comments_after = mempty
435 , Ledger.transaction_comments_before = transaction_comments
436 , Ledger.transaction_dates
437 , Ledger.transaction_postings = fmap (fmap convert) transaction_postings
438 , Ledger.transaction_sourcepos
439 , Ledger.transaction_status =
440 case Map.lookup ("Status":|[]) tags of
441 Nothing -> False
442 Just _ -> True
443 , Ledger.transaction_tags =
444 Transaction.Transaction_Tags $ Tag.Tags $
445 Map.delete ("Code":|[]) $
446 Map.delete ("Status":|[]) $
447 tags
448 , Ledger.transaction_wording
449 }
450
451 -- Posting
452 instance Convert Ledger.Posting JCC.Posting where
453 convert Ledger.Posting
454 { Ledger.posting_account
455 , Ledger.posting_amounts
456 , Ledger.posting_comments
457 , Ledger.posting_dates
458 , Ledger.posting_status
459 , Ledger.posting_sourcepos
460 , Ledger.posting_tags
461 } = JCC.Posting
462 { JCC.posting_account
463 , JCC.posting_account_anchor = Nothing
464 , JCC.posting_amounts =
465 fmap convert $
466 Map.mapKeysMonotonic convert $
467 posting_amounts
468 , JCC.posting_anchors = mempty
469 , JCC.posting_comments =
470 List.filter (not . Text.all Char.isSpace) $
471 Ledger.comments_without_tags posting_comments
472 , JCC.posting_dates
473 , JCC.posting_sourcepos
474 , JCC.posting_tags =
475 case posting_status of
476 True -> Posting.tag_cons
477 (Posting.tag ("Status":|[]) "")
478 posting_tags
479 False -> posting_tags
480 }
481 instance Convert JCC.Posting Ledger.Posting where
482 convert JCC.Posting
483 { JCC.posting_account
484 , JCC.posting_account_anchor=_
485 , JCC.posting_amounts
486 , JCC.posting_anchors = _posting_anchors
487 , JCC.posting_comments
488 , JCC.posting_dates
489 , JCC.posting_sourcepos
490 , JCC.posting_tags = Posting.Posting_Tags (Tag.Tags tags)
491 } = Ledger.Posting
492 { Ledger.posting_account
493 , Ledger.posting_amounts =
494 fmap convert $
495 Map.mapKeysMonotonic convert $
496 posting_amounts
497 , Ledger.posting_comments
498 , Ledger.posting_dates
499 , Ledger.posting_status =
500 case Map.lookup ("Status":|[]) tags of
501 Nothing -> False
502 Just _ -> True
503 , Ledger.posting_sourcepos
504 , Ledger.posting_tags =
505 Posting.Posting_Tags $ Tag.Tags $
506 Map.delete ("Status":|[]) $
507 tags
508 }
509
510 -- Chart
511 instance Convert (Chart.Chart x) (Chart.Chart x) where
512 convert = id
513 {-
514 instance Convert (Chart.Chart JCC.Account) (Chart.Chart Ledger.Account) where
515 convert Chart.Chart
516 { Chart.chart_accounts
517 , Chart.chart_anchors
518 } =
519 Chart.Chart
520 { Chart.chart_accounts = convert chart_accounts
521 , Chart.chart_anchors = convert chart_anchors
522 }
523 -}
524
525 instance
526 ( Convert (Chart.Chart a0) (Chart.Chart a1)
527 , Convert x y
528 ) => Convert (Chart.Charted a0 x) (Chart.Charted a1 y) where
529 convert (Chart.Charted a x) =
530 Chart.Charted (convert a) (convert x)
531
532 -- Balance
533 instance
534 ( Convert unit unit_
535 , Convert quantity quantity_
536 ) => Convert (Balance.Account_Sum unit quantity)
537 (Balance.Account_Sum unit_ quantity_) where
538 convert (Balance.Account_Sum m) =
539 Balance.Account_Sum $
540 fmap convert $
541 Map.mapKeysMonotonic convert m
542
543 -- * GL
544
545 -- ** Class 'GL'
546 class
547 ( Convert (Account.Account_Section (GL.Posting_Account (GL.Transaction_Posting x)))
548 (Account.Account_Section (GL.Posting_Account (GL.Transaction_Posting y)))
549 ) => GL x y
550 instance GL JCC.Transaction Ledger.Transaction
551 instance GL Ledger.Transaction JCC.Transaction
552
553 instance GL ( JCC.Charted JCC.Transaction)
554 (Ledger.Charted Ledger.Transaction)
555 instance GL (Ledger.Charted Ledger.Transaction)
556 (JCC.Charted JCC.Transaction)
557
558 instance
559 ( GL x y
560 , GL_Line x y
561 , GL.Transaction x
562 , GL.Transaction y
563 , Convert x y
564 ) => Convert (GL.GL x)
565 (GL.GL y) where
566 convert (GL.GL m)
567 = GL.GL $ TreeMap.map_monotonic convert (fmap convert) m
568 -- NOTE: Date does not need to be converted,
569 -- thus avoid a useless Map.mapKeysMonotonic
570 -- from the Convert instance on Map.
571
572 -- *** Class 'GL_Line'
573
574 class
575 ( Convert (GL.Transaction_Line x)
576 (GL.Transaction_Line y)
577 , Convert (GL.Transaction_Posting x)
578 (GL.Transaction_Posting y)
579 , Convert (GL.Posting_Quantity (GL.Transaction_Posting x))
580 (GL.Posting_Quantity (GL.Transaction_Posting y))
581 ) => GL_Line x y
582 instance GL_Line JCC.Transaction Ledger.Transaction
583 instance GL_Line Ledger.Transaction JCC.Transaction
584
585 instance GL_Line ( JCC.Charted JCC.Transaction)
586 (Ledger.Charted Ledger.Transaction)
587 instance GL_Line (Ledger.Charted Ledger.Transaction)
588 (JCC.Charted JCC.Transaction)
589
590 instance
591 ( GL_Line x y
592 , GL.Transaction x
593 , GL.Transaction y
594 , Convert x y
595 ) => Convert (GL.GL_Line x)
596 (GL.GL_Line y) where
597 convert GL.GL_Line
598 { GL.gl_line_transaction
599 , GL.gl_line_posting
600 , GL.gl_line_sum
601 } = GL.GL_Line
602 { GL.gl_line_transaction = convert gl_line_transaction
603 , GL.gl_line_posting = convert gl_line_posting
604 , GL.gl_line_sum = convert gl_line_sum
605 }
606
607 -- Class 'GL_Expanded'
608
609 instance
610 ( GL x y
611 , GL_Line x y
612 , GL.Transaction x
613 , GL.Transaction y
614 , Convert x y
615 ) => Convert (GL.Expanded x)
616 (GL.Expanded y) where
617 convert (GL.Expanded m)
618 = GL.Expanded $ convert m
619
620 -- Class 'GL_Line_Expanded'
621
622 instance
623 ( GL_Line x y
624 , GL.Transaction x
625 , GL.Transaction y
626 , Convert x y
627 ) => Convert (GL.GL_Line_Expanded x)
628 (GL.GL_Line_Expanded y) where
629 convert GL.GL_Line_Expanded
630 { GL.exclusive
631 , GL.inclusive
632 } = GL.GL_Line_Expanded
633 { GL.exclusive = convert <$> exclusive
634 , GL.inclusive = convert <$> inclusive
635 }
636
637 -- Const
638 instance Convert x y
639 => Convert (Const x w) (Const y w_) where
640 convert (Const x) = Const $ convert x
641
642 -- Polarized
643 instance Convert x y
644 => Convert (Polarize.Polarized x)
645 (Polarize.Polarized y) where
646 convert = fmap convert
647
648 -- Date
649 instance Convert Date Date where
650 convert = id
651
652 -- Quantity
653 instance Convert Decimal Decimal where
654 convert = id
655
656 -- Text
657 instance Convert Text Text where
658 convert = id
659
660 -- List
661 instance Convert x y => Convert [x] [y] where
662 convert = fmap convert
663 instance Convert x y => Convert (NonEmpty x) (NonEmpty y) where
664 convert = fmap convert
665
666 -- TreeMap
667
668 instance (Convert kx ky, Convert x y, Ord kx, Ord ky)
669 => Convert (TreeMap kx x) (TreeMap ky y) where
670 convert = TreeMap.map_monotonic convert convert
671
672 -- Map
673 instance (Convert kx ky, Convert x y, Ord kx)
674 => Convert (Map kx x) (Map ky y) where
675 convert = Map.mapKeysMonotonic convert . fmap convert
676
677 -- Seq
678 instance Convert x y => Convert (Seq x) (Seq y) where
679 convert = fmap convert
680
681 -- * Stats
682
683 -- ** Class 'Stats'
684 class
685 ( Convert (Stats.Posting_Account (Stats.Transaction_Posting x))
686 (Stats.Posting_Account (Stats.Transaction_Posting y))
687 , Convert (Stats.Posting_Unit (Stats.Transaction_Posting x))
688 (Stats.Posting_Unit (Stats.Transaction_Posting y))
689 ) => Stats x y
690
691 instance Stats JCC.Transaction Ledger.Transaction
692 instance Stats Ledger.Transaction JCC.Transaction
693
694 instance Stats ( JCC.Charted JCC.Transaction)
695 (Ledger.Charted Ledger.Transaction)
696 instance Stats (Ledger.Charted Ledger.Transaction)
697 (JCC.Charted JCC.Transaction)
698
699 instance
700 ( Stats x y
701 , Stats.Transaction x
702 , Stats.Transaction y
703 ) => Convert (Stats.Stats x) (Stats.Stats y) where
704 convert s@Stats.Stats
705 { Stats.stats_accounts
706 , Stats.stats_units
707 } = s
708 { Stats.stats_accounts = Map.mapKeysMonotonic convert stats_accounts
709 , Stats.stats_units = Map.mapKeysMonotonic convert stats_units
710 }