valkyrie-ast 0.1.4

Strong typed abstract syntax tree of valkyrie language
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

{% for i in b %}

{% end for %}

| Trait          | Formatter |
|:---------------|-----------|
| Show           | `{}`      |
| ShowDetail     | `:?`      |
| ShowPointer    | `:p`      |
| ShowBinary     | `:b`      |
| ShowOctal      | `:o`      |
| ShowHexLower   | `:x`      |
| ShowHexUpper   | `:X`      |
| ShowExpLower   | `:e`      |
| ShowExpUpper   | `:E`      |
| ShowPretty     | `:P`      |
| ShowMathInline | `:m`      |
| ShowMathBlock  | `:M`      |

```
# std.show

triat Show {
    show(self, f: Formatter): Unit;
}

# std.show

trait ShowDetail {
    show_detail(self, f: Formatter): Unit;
}

# std.show, std.show.math

trait ShowMath {
    show_math(self, f: MathFormatter): MathDisplay;
}

class MathDisplay {
    attributes: Dict<String>,
}

class MathRoot(MathDisplay) {
    children: List<MathDisplay>,
}






# std.show, std.show.pretty

trait ShowPretty {
    show_pretty(self) -> Result<Pretty, PrettyError>;
}
# std.show, std.show.html

trait ShowHtml {
    show_html(self) -> Result<Html, HtmlError>;
}
```



```
vouch T {
}
class A(U<T>) {

}

effect async {
    await<T>(k: T -> IO()): T
}
vow {
    return Unit;
    effect [async];
}
fun sleep(d: duration): () / async {
    await {
        
    }
}

```


if { a > 0 { a }; _ { 0 } }
match { 
    case Case(a) | Case(b)
    when a > 0:

    case var is Type:
    case Variant
    case Class(unapply)
    case "3" { }
}


if let Some(a) = b {

}

match n {
    type Integer:
        print("n is integer")
    when n > 0:
        print("n is > 0")
    case a if a > 5:
        print("n is > 5")
    else:
        print("n is unknown")