prop 0.47.0

Propositional logic with types in Rust
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

// Rust-syntax in Piston-Meta for recursive analysis

_seps: "|!:.,;<>(){}[]"

29 , = [.w? "," .w?]
28 ; = [.w? ";" .w?]

27 trait_call_args = .s?(, ty)
26 trait_inh = {
    ["Fn" "(" .w? .s?(, ty) .w? ")" .w! "->" .w! ty]
  }
25 trait_arg = .._seps!
24 trait_args = .s?(, trait_arg)

27 type_args = .s?(, .._seps!)
26 branch = {
    [branch_pat .w! "=>" .w! {
      [expr {"," ?[.w? !.."}"!]}]
      ["{" .w? exprs .w? "}"]
    }]
  }
25 branch_pat = {
    [?.._seps! "(" .w? .s!(, branch_pat) .w? ")"]
    .._seps!
  }

24 call_gen_args = .s?(, ty)
23 call_args = .s?(, expr)
22 call = [.._seps!:"name" .r?({
    ["::<" .w? call_gen_args .w? ">"]
    ["::" .._seps!]
  }) {
    ["!" .r?({
      ["{" .w? macro_args .w? "}"]
      ["(" .w? macro_args .w? ")"]
    })]
    .r?(["(" .w? call_args .w? ")"])
  }
    ?[.w? "." call]
  ]

21 gen_constr = [.._seps! ?["<" .w? .s?(, ty) .w? ">"]]
20 where_expr = [.._seps! ?["<" .w? .s?(, .._seps!) .w? ">"] .w? ":" .w? gen_constr]
19 fn_decl_arg = [{
    branch_pat
    .._seps!
  } .w? ":" .w? struct_call]
18 fn_decl_args = .s?(, fn_decl_arg)
17 fn_decl = ["fn" .w! .._seps!:"name" ?["<" .w? gen_args .w? ">"]
  "(" .w? fn_decl_args .w? ")" .w? ?["->" .w? struct_call] .w?
  ?["where " .w? .s!.(, where_expr) .w?]
  "{" .w? ?["use " ...";"? ";"] .w? exprs .w? "}"]

16 impl_method = ["fn" .w! .._seps! "(" .w? .w? ")" .w? "->" .w? struct_call .w?
  "{" .w? exprs .w? "}"]

15 struct_args = .s?(, struct_call)
14 struct_call = [.._seps! ?["<" .w? struct_args .w? ">"]]
13 trait_call = [.._seps! ?["<" .w? trait_call_args .w? ">"]]
12 ty_fn_args = .s?(, ty)
11 ty = {
    ["fn" "(" .w? ty_fn_args .w? ")" .w! "->" .w! ty]
    struct_call
    .._seps!
  }

10 gen_args = .s?(, gen_arg)
9 gen_arg = [.._seps! .w? ?[":" .w? gen_constr]]

8 let = ["let " {
    ["(" .w? .._seps! , .._seps! .w? ")"]
    .._seps!:"name"
  } ?[.w? ":" .w? struct_call] .w! "=" .w! expr]

7 closure_arg = [{
    branch_pat
    .._seps!:"name"
  } .w? ?[":" .w! ty]]
6 closure_args = .s?(, closure_arg)

5 exprs = [.l([.w? fn_decl:"fn"]) .w? .s!.(; expr)]
4 expr = [.r?(["//" ..."\n"? .w?]) {
    ["tauto!(" .w? expr .w? ")"]
    let:"let"
    ["match " expr .w! "{" .w? .r?([.w? branch]) .w? "}"]
    [?"move " "|" .w? closure_args .w? "|" .w! {
      ["{" .w? exprs .w? "}"]
      expr
    }]
    ["(" .w? .s?(, expr) .w? ")"]
    call:"call"
    .._seps!
  }]

3 mod_decl = ["mod " .._seps!:"name" .w! "{" .w? doc .w? "}"]

2 macro_args = .r?([?"," .w? {
    ["$" .._seps! {.w! "," !..")"!}]
    .._seps!
  }])
1 macro_branch = ["(" .w? .r?([.w? {
    ["$" .._seps! ":" "tt" {.w! "," !..")"!}]
    .._seps!
  }]) .w? ")" .w! "=>" .w! "{" .w? doc .w? "}"]

0 doc = .l([.w? {
  ["//" ..."\n"?]
  ["impl<" .w? gen_args .w? ">" .w! trait_call .w! "for" .w! struct_call .w?
    "{" .w? .l(impl_method:"method") .w? "}"]
  ["#[" .._seps! ?["(" .w? .._seps! .w? ")"] "]"]
  ["macro_rules! " .._seps! .w! "{" .w? .s?(; macro_branch) .w? "}"]
  [?"pub " {
    ["use " ...";"? ";"]
    ["mod " ...";"? ";"]
    ["type " .._seps! ?["<" .w? type_args .w? ">"] .w! "=" .w! ty .w? ";"]
    ["trait " .._seps! ?["<" .w? trait_args .w? ">"] ?[":" .w! trait_inh .w!
      "{" .w? .w? "}"]]
    mod_decl:"mod"
    fn_decl:"fn"
  }]
  call
}])