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
|
# Changelog
## v0.4.1 (24 September 2021)
### Improved
- Line edit is improved so that history can be handled by linenoise:
https://github.com/antirez/linenoise
- The priority of rules are changed so that user defined rules can be taken before built-in rules.
### Bug Fix
- Constants were consumed when they are referred to, but these should be kept and it was fixed as so.
- A global name that has evaluated and occurred twice already was able to be defined. Now it is prevented.
- A global name that has evaluated and occurred twice already was able to be defined. Now it is prevented.
## v0.4.0 (17 September 2021)
### New Feature:
- Nested guards are supported. As shown in below, nested guards are supported now:
```
A(r)><B(int a, int b)
| a==1 =>
| b==0 => r~10
| _ =>
| a+b>10 => r~20
| _ => r~2000
| _ => r~100;
```
- Strings that have brackets, such as `inc(x)`, are recognised as agents even if these starts from a not capital letter.
- Built-in rules that match each element for the same built-in agents are implemented. For instance, the following rules are realised as built-in:
```
a:b >< x:y => a~x, b~y;
[] >< [] =>;
(a,b) >< (x,y) => a~x, b~y;
```
## v0.3.2 (3 August 2021)
### New Feature:
- WHNF strategy is supported with -w option. Weak Head Normal Form strategy is available when the Inpla is invoked with -w option. The following is an execution log:
```
$ ./inpla -w
Inpla 0.32 (WHNF) : Interaction nets as a programming language [3 August 2021]
>>> use "sample/processnet1.in";
(2 interactions, 0.00 sec)
>>> ifce; # show interfaces
r
>>> r; # show the connected net from the `r'
[1,<a1>...
>>> h:t ~ r; # decompose it as h:t
(3 interactions, 0.00 sec)
>>> ifce;
h t
>>> h;
1
>>> t;
[2,<b1>...
>>>
```
## v0.3.1 (7 May 2021)
### New Feature:
- New notation for the built-in Cons agent, h:t. The built-in Cons agent is also written as h:t, besides [h|t]. For instance, a reverse list operation is written as follows:
```
Rev(ret, acc) >< [] => ret ~ acc;
Rev(ret, acc) >< h:t => Rev(ret, h:acc) ~ t;
Rev(ret,[]) ~ [1,3,5,8];
ret; // -> [8,5,3,1]
```
- The built-in agent for integer numbers is introduced. Integer numbers are recognised as agents. In addition:
- expressions on attributes are written as agents.
- `Add(ret, m)><(int n)` is implemented as a built-in rule.
For instance, Fibonacci number is obtained as follows:
```
Fib(ret) >< (int n)
| n == 0 => ret~0
| n == 1 => ret~1
| _ => Add(ret,cnt2)~cnt1, Fib(cnt1)~(n-1), Fib(cnt2)~(n-2);
Fib(r)~38;
r; // it should be 39088169.
```
As another example, the greatest common divisor is obtained as follows:
```
Gcd(ret, int a) >< (int b)
| b==0 => ret~a
| _ => Gcd(ret, b) ~ (a%b);
Gcd(r, 14) ~ 21;
r; // it should be 7
```
- Append for two lists is implemented as built-in as follows:
```
Append(r,[1,2,3])~[7,8,9];
r; // it should be [7,8,9,1,2,3]
```
|
