aboutsummaryrefslogtreecommitdiff
path: root/stdlib/source/lux/data/text/format.lux
blob: 1c56f1cb978fdfb06a19b9006426383f24138b83 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
(.module:
  lux
  (lux (control [monad #+ do Monad]
                ["p" parser])
       (data [bool]
             [number]
             [text]
             [ident]
             (coll [list "list/" Monad<List>])
             (format [xml]
                     [json]))
       (time [instant]
             [duration]
             [date])
       [macro]
       (macro [code]
              ["s" syntax #+ syntax: Syntax])
       (lang [type])
       ))

## [Syntax]
(syntax: #export (format [fragments (p.many s.any)])
  {#.doc (doc "Text interpolation."
              (format "Static part " (%t static) " does not match URI: " uri))}
  (macro.with-gensyms [g!compose]
    (wrap (list (` (let [(~ g!compose) (:: (~! text.Monoid<Text>) (~' compose))]
                     ($_ (~ g!compose) (~+ fragments))))))))

## [Formatters]
(type: #export (Formatter a)
  {#.doc "A way to produce readable text from values."}
  (-> a Text))

(do-template [<name> <type> <formatter>]
  [(def: #export <name>
     (Formatter <type>)
     <formatter>)]

  [%b        Bool              (:: bool.Codec<Text,Bool> encode)]
  [%n        Nat               (:: number.Codec<Text,Nat> encode)]
  [%i        Int               (:: number.Codec<Text,Int> encode)]
  [%d        Deg               (:: number.Codec<Text,Deg> encode)]
  [%f        Frac              (:: number.Codec<Text,Frac> encode)]
  [%t        Text              text.encode]
  [%ident    Ident             (:: ident.Codec<Text,Ident> encode)]
  [%code     Code              code.to-text]
  [%type     Type              type.to-text]
  [%bin      Nat               (:: number.Binary@Codec<Text,Nat> encode)]
  [%oct      Nat               (:: number.Octal@Codec<Text,Nat> encode)]
  [%hex      Nat               (:: number.Hex@Codec<Text,Nat> encode)]
  [%xml      xml.XML           (:: xml.Codec<Text,XML> encode)]
  [%json     json.JSON         (:: json.Codec<Text,JSON> encode)]
  [%instant  instant.Instant   (:: instant.Codec<Text,Instant> encode)]
  [%duration duration.Duration (:: duration.Codec<Text,Duration> encode)]
  [%date     date.Date         (:: date.Codec<Text,Date> encode)]
  )

(def: #export (%list formatter)
  (All [a] (-> (Formatter a) (Formatter (List a))))
  (function [values]
    (case values
      #.Nil
      "(list)"

      _
      (format "(list " (text.join-with " " (list/map formatter values)) ")"))))