File: metaXapply.maude

package info (click to toggle)
maude 2.6-6
  • links: PTS, VCS
  • area: main
  • in suites: jessie, jessie-kfreebsd
  • size: 10,776 kB
  • ctags: 8,613
  • sloc: cpp: 87,637; sh: 3,468; ansic: 3,011; yacc: 1,414; makefile: 1,252; lex: 563
file content (132 lines) | stat: -rw-r--r-- 3,737 bytes parent folder | download | duplicates (7)
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
123
124
125
126
127
128
129
130
131
132
set show timing off .
set show advisories off .

***
***	Test the metaXapply() descent function.
***

fmod TEST is
  pr META-LEVEL .
  op m : -> Module .
  eq m =
(mod 'FOO is
  protecting 'BOOL .
  sorts 'Foo ; 'Bar .
  subsort 'Bar < 'Foo .
  op 'a : nil -> 'Foo [none] .
  op 'b : nil -> 'Foo [none] .
  op 'c : nil -> 'Foo [none] .
  op 'f : 'Foo 'Foo -> 'Foo [assoc comm] .
  op 'g : 'Foo 'Foo -> 'Foo [assoc comm] .
  none
  none
  rl 'f['X:Foo, 'Y:Foo] => 'X:Foo [label('k)] .
  rl 'a.Foo => 'c.Foo [label('k)] .
endm) .
endfm

red metaXapply(m, 'f['a.Foo, 'b.Foo], 'k, none, 0, 100, 0) .
red metaXapply(m, 'f['a.Foo, 'b.Foo], 'k, none, 0, 100, 1) .
red metaXapply(m, 'f['a.Foo, 'b.Foo], 'k, none, 0, 100, 2) .
red metaXapply(m, 'f['a.Foo, 'b.Foo], 'k, none, 0, 100, 3) .
red metaXapply(m, 'f['a.Foo, 'b.Foo], 'k, none, 0, unbounded, 0) .
red metaXapply(m, 'f['a.Foo, 'b.Foo], 'k, none, 0, unbounded, 1) .
red metaXapply(m, 'f['a.Foo, 'b.Foo], 'k, none, 0, unbounded, 2) .
red metaXapply(m, 'f['a.Foo, 'b.Foo], 'k, none, 0, unbounded, 3) .


fmod TEST2 is
  pr META-LEVEL .
  op m : -> Module .
  eq m =
(mod 'FOO is
  protecting 'BOOL .
  sorts 'Foo ; 'Bar .
  subsort 'Bar < 'Foo .
  op 'a : nil -> 'Foo [none] .
  op 'b : nil -> 'Foo [none] .
  op 'c : nil -> 'Foo [none] .
  op 'f : 'Foo 'Foo -> 'Foo [assoc comm] .
  op 'g : 'Foo 'Foo -> 'Foo [assoc comm] .
  none
  none
  rl 'f['X:Foo, 'Y:Foo] => 'X:Foo [label('k)] .
  rl 'a.Foo => 'c.Foo [label('k)] .
endm) .
endfm

red metaXapply(m, 'g['f['a.Foo, 'b.Foo], 'a.Foo], 'k, none, 0, 100, 0) .
red metaXapply(m, 'g['f['a.Foo, 'b.Foo], 'a.Foo], 'k, none, 0, 100, 1) .
red metaXapply(m, 'g['f['a.Foo, 'b.Foo], 'a.Foo], 'k, none, 0, 100, 2) .
red metaXapply(m, 'g['f['a.Foo, 'b.Foo], 'a.Foo], 'k, none, 0, 100, 3) .
red metaXapply(m, 'g['f['a.Foo, 'b.Foo], 'a.Foo], 'k, none, 0, 100, 4) .


fmod TEST3 is
  pr META-LEVEL .
  op m : -> Module .
  eq m =
(mod 'FOO is
  protecting 'BOOL .
  sorts 'Foo ; 'Bar .
  subsort 'Bar < 'Foo .
  op 'a : nil -> 'Foo [none] .
  op 'b : nil -> 'Foo [none] .
  op 'c : nil -> 'Foo [none] .
  op 'f : 'Foo 'Foo -> 'Foo [assoc comm] .
  op 'g : 'Foo 'Foo -> 'Foo [assoc comm] .
  none
  none
  rl 'f['X:Foo, 'Y:Foo] => 'X:Foo [label('k)] .
  rl 'a.Foo => 'f['c.Foo, 'c.Foo] [label('l)] .
endm) .
endfm

red metaXapply(m, 'g['f['a.Foo, 'b.Foo], 'a.Foo], 'l, none, 0, 100, 0) .
red metaXapply(m, 'g['f['a.Foo, 'b.Foo], 'a.Foo], 'l, none, 0, 100, 1) .
red metaXapply(m, 'g['f['a.Foo, 'b.Foo], 'a.Foo], 'l, none, 0, 100, 0) .
red metaXapply(m, 'g['f['a.Foo, 'b.Foo], 'a.Foo], 'l, none, 0, 100, 2) .
red metaXapply(m, 'g['f['a.Foo, 'b.Foo], 'a.Foo], 'l, none, 0, 100, 0) .


fmod ALL-ONE-STEP-REWRITES is
  including META-LEVEL .
  sort TermSet .
  subsort Term < TermSet .
  op _|_ : TermSet TermSet -> TermSet [assoc comm id: mt ctor] .
  op mt : -> TermSet [ctor] .

  var T : Term .        var M : Module .
  var L : Qid .         var N : Nat .

  op findAllRews : Module Term Qid -> TermSet .
  op findAllRewsAux : Module Term Qid Nat -> TermSet .

  eq findAllRews(M, T, L) = findAllRewsAux(M, T, L, 0) .

  eq findAllRewsAux(M, T, L, N) =
    if metaXapply(M, T, L, none, 0, unbounded, N) :: Result4Tuple then
      (getTerm(metaXapply(M, T, L, none, 0, unbounded, N)) |
       findAllRewsAux(M, T, L, N + 1))
    else
      mt
    fi .

  op m : -> Module .
  eq m =
(mod 'FOO is
  protecting 'BOOL .
  sorts 'Foo ; 'Bar .
  subsort 'Bar < 'Foo .
  op 'a : nil -> 'Foo [none] .
  op 'b : nil -> 'Foo [none] .
  op 'c : nil -> 'Foo [none] .
  op 'f : 'Foo 'Foo -> 'Foo [assoc comm] .
  none
  none
  rl 'f['X:Foo, 'Y:Foo] => 'X:Foo [label('k)] .
  rl 'a.Foo => 'c.Foo [label('k)] .
endm) .
endfm

red findAllRews(m, 'f['a.Foo, 'b.Foo], 'k) .