wolfpack-parser 0.1.1

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

---
source: crates/wolf_parser/tests/parser.rs
expression: result.dump
---
file
  doc! " A binary search tree: a recursive enum, `own self` and `match own`, recursion."
  module main
  (section imports (import std.string))
  section types
    enum
      doc " Recursive through the enum; the Rust backend adds `Box` (chapter 4, section 7.4)."
      Tree
      (variant Leaf)
      (variant Node (tuple Tree Int Tree))
  section impl
    impl
      Tree
      fn
        doc " Consumes the tree and returns a new one that also holds `value`."
        insert
        (params own self (value Int))
        (-> Tree)
        block
          match
            (own self)
            (=> Tree.Leaf (call (. Tree Node) (. Tree Leaf) value (. Tree Leaf)))
            =>
              (Tree.Node left v right)
              if
                (< value v)
                (block (call (. Tree Node) (call (. left insert) value) v right))
                (else (block (call (. Tree Node) left v (call (. right insert) value))))
      fn
        contains
        (params self (value Int))
        (-> Bool)
        block
          match
            self
            (=> Tree.Leaf false)
            =>
              (Tree.Node left v right)
              if
                (== value v)
                (block true)
                else
                  if
                    (< value v)
                    (block (call (. left contains) value))
                    (else (block (call (. right contains) value)))
      fn
        doc " Appends the values in ascending order."
        collect
        (params self (mut out (List Int)))
        block
          match
            self
            (=> Tree.Leaf ())
            =>
              (Tree.Node left v right)
              block
                (call (. left collect) (mut out))
                (call (. out push) v)
                (call (. right collect) (mut out))
      fn
        depth
        (params self)
        (-> Int)
        block
          match
            self
            (=> Tree.Leaf 0)
            =>
              (Tree.Node left _ right)
              (+ 1 (call (. (call (. left depth)) max) (call (. right depth))))
  section functions
    fn
      join_ints
      (params (values (List Int)))
      (-> String)
      block
        call
          (. string join)
          (call (. values map) (closure (params v) (call (. v to_string))))
          ", "
    fn
      main
      ()
      block
        (var tree (. Tree Leaf))
        (for value (list 50 30 70 20 40 60 80 35) (block (= tree (call (. tree insert) value))))
        (var sorted (List Int) [])
        (call (. tree collect) (mut sorted))
        (call print (+ "in order: " (call join_ints sorted)))
        (call print (+ "depth: " (call (. (call (. tree depth)) to_string))))
        (call print (+ "contains 35: " (call (. (call (. tree contains) 35) to_string))))
        (call print (+ "contains 36: " (call (. (call (. tree contains) 36) to_string))))
  section tests
    test
      "values come out sorted"
      block
        (var tree (. Tree Leaf))
        (for value (list 3 1 2) (block (= tree (call (. tree insert) value))))
        (var out (List Int) [])
        (call (. tree collect) (mut out))
        (call assert (== out (list 1 2 3)))