wolfpack-parser 0.2.0

The parser of wolfpack. Internal part of wolfpack-lang, not a stable API
Documentation 
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

---
source: crates/wolf_parser/tests/parser.rs
expression: result.dump
---
file
  module main
  (section imports (import std.string (names join)))
  section types
    (struct doc " A point on a grid." Point (field x Int) (field y Int))
    struct
      doc " An item of the inventory."
      Item
      (field name String)
      (field count Int)
      (field tags (List String))
    (enum Color (variant Red) (variant Green))
  section impl
    impl
      Point
      (for Display)
      (fn to_string (params self) (-> String) (block (f "(" (. self x) ", " (. self y) ")")))
    impl
      Color
      (for Display)
      fn
        to_string
        (params self)
        (-> String)
        (block (match self (=> Color.Red "red") (=> Color.Green "green")))
  section main
    (fn main () (block (call strings) (call patterns) (call loops) (call updates) (call errors)))
  section functions
    fn
      doc " Interpolated, raw and multiline strings."
      strings
      ()
      block
        (let name "Ann")
        (let count 3)
        (call print (f name " has " count " items, ratio " 0.5 ", ready " true))
        (call print (f "literal braces {} and " (call join (list "a" "b") ", ")))
        call
          print
          f
            "nested "
            (f "<" name ">")
            ", point "
            (struct Point (x: 1) (y: 2))
            ", color "
            (. Color Green)
        (call print "a raw string keeps \\n and {braces}")
        (let help "usage: tour <command>\n\ncommands:\n    run    show everything")
        (call print help)
        (let shown (List Display) (list 1 "two" 3.0 (. Color Red)))
        (for value shown (block (call print (call show value))))
    (fn show (generics (T Display)) (params (value T)) (-> String) (block (f "[" value "]")))
    fn
      doc " Destructuring `let`, `if let` and `while let`."
      patterns
      ()
      block
        (let (Point {} x y) (struct Point (x: 5) (y: 6)))
        (call print (f "x = " x ", y = " y))
        if let
          (Some at)
          (call (. "wolfpack" find) "pack")
          (block (call print (f "found at " at)))
          else
            (if let (Some at) (call (. "wolf" find) "w") (block (call print (f "else at " at))))
        (var stack (list 1 2 3))
        (while let (Some top) (call (. stack pop)) (block (call print (f "pop " top))))
    fn
      doc " `loop` with a value, labels."
      loops
      ()
      block
        (var i 0)
        (let first_big (loop (block (+= i 1) (if (> (* i i) 20) (block (break i))))))
        (call print (f "first square above 20: " first_big "^2"))
        rows:
          for
            row
            (.. 0 3)
            block
              for
                col
                (.. 0 3)
                block
                  (if (> col row) (block (continue rows:)))
                  (if (== row 2) (block (break rows:)))
                  (call print (f "cell " row "," col))
    fn
      doc " The update syntax."
      updates
      ()
      block
        (let bolts (struct Item (name: "bolts") (count: 10) (tags: (list "metal"))))
        (let more (struct Item (count: 25) (.. bolts)))
        (call print (f (. more name) ": " (. more count) ", tags " (call join (. more tags) ", ")))
    fn
      doc " `error(message)` and `assert_eq`."
      errors
      ()
      block
        match
          (call parse_count "12")
          (=> (Ok n) (call print (f "count " n)))
          (=> (Err e) (call print (f "error: " (call (. e message)))))
        match
          (call parse_count "-4")
          (=> (Ok n) (call print (f "count " n)))
          (=> (Err e) (call print (f "error: " (call (. e message)))))
        (call assert_eq (+ 1 2) 3)
        (call assert_eq (struct Point (x: 1) (y: 2)) (struct Point (x: 1) (y: 2)))
    fn
      parse_count
      (params (text String))
      (-> (Result Int Error))
      block
        (let n (? (call (. text parse_int))))
        (if (< n 0) (block (return (call Err (call error (f "a count cannot be negative: " n))))))
        (call Ok n)