Major changes and experiments.
authorRyan Toth <rtoth256@gmail.com>
Sun, 14 Jul 2019 05:04:52 +0000 (22:04 -0700)
committerRyan Toth <rtoth256@gmail.com>
Sun, 14 Jul 2019 05:04:52 +0000 (22:04 -0700)
modal.py
prelude.modal

index 493d042..e9d0122 100644 (file)
--- a/modal.py
+++ b/modal.py
@@ -188,6 +188,28 @@ def multiply(queue, rules, pattern):
             return (True, queue);
     return (False, roll(queue));
 
+def divide(queue, rules, pattern):
+    context = match(pattern, queue);
+    left    = context["left"];
+    right   = context["right"];
+    if left and right:
+        if left[0][0] == "NUM" and right[0][0] == "NUM":
+            queue = dequeue(queue, len(construct(pattern, context)));
+            queue = enqueue(queue, parse(str(left[0][1] // right[0][1])));
+            return (True, queue);
+    return (False, roll(queue));
+
+def modulo(queue, rules, pattern):
+    context = match(pattern, queue);
+    left    = context["left"];
+    right   = context["right"];
+    if left and right:
+        if left[0][0] == "NUM" and right[0][0] == "NUM":
+            queue = dequeue(queue, len(construct(pattern, context)));
+            queue = enqueue(queue, parse(str(left[0][1] % right[0][1])));
+            return (True, queue);
+    return (False, roll(queue));
+
 def display(queue, rules, pattern):
     context = match(pattern, queue);
     left    = context["left"];
@@ -241,7 +263,7 @@ def literal(string, index=0):
     token = "";
     while index != len(string):
         character = string[index];
-        if character in ['(', ')', '?', ' ', '\t', '\n', '\r']:
+        if character in ['(', ')', '{', '}', '[', ']', '?', ' ', '\t', '\n', '\r']:
             break;
         else:
             token = token + string[index];
@@ -252,18 +274,17 @@ def parse(string, index=0):
     results = [];
     while index != len(string):
         character = string[index];
-        if character in ['(', ')', '?', ' ', '\t', '\n', '\r']:
+        if character in ['(', ')', '{', '}', '[', ']', '?', ' ', '\t', '\n', '\r']:
             index = index + 1;
-        if character == '(':
+        if character in ['(', '{', '[']:
             results.append(["INC"]);
-        elif character == ')':
+        elif character in [')', '}', ']']:
             results.append(["DEC"]);
         elif character not in [' ', '\t', '\n', '\r']:
             token, index = literal(string, index);
             if character == '?':
                 results.append(["VAR", token]);
             elif number(token):
-                results.append(["LIT", "num"]);
                 results.append(["NUM", int(token)]);
             else:
                 results.append(["LIT", token]);
@@ -284,6 +305,9 @@ def run(rules, queue, limit=pow(2, 32)):
             result, queue = operation(queue, rules, pattern, *parameters);
             if result == True:
                 failures = 0;
+            #print("<>:   ", inspect(seek(queue, ["SRT"])))
+            #print("<>:   ", inspect(queue))
+            #input()
         steps = steps + 1;
     if steps == limit:
         print("Execution limit reached.");
@@ -321,13 +345,43 @@ def help():
 
 def main():
     defaults = [
-                   (parse("define ?left ?right"),               define,   []),
-                   (parse("undefine ?left"),                    undefine, []),
-                   (parse("add (num ?left) (num ?right)"),      add,      []),
-                   (parse("subtract (num ?left) (num ?right)"), subtract, []),
-                   (parse("multiply (num ?left) (num ?right)"), multiply, []),
-                   (parse("display (num ?left)"),               display,  []),
-                   (parse("display (?left)"),                   display,  [])
+                   (parse("define ?left ?right"),       define,   []),
+                   (parse("undefine ?left"),            undefine, []),
+                   (parse("add (?left) (?right)"),      add,      []),
+                   (parse("add (?left) ?right"),        add,      []),
+                   (parse("add ?left (?right)"),        add,      []),
+                   (parse("add ?left ?right"),          add,      []),
+                   (parse("subtract (?left) (?right)"), subtract, []),
+                   (parse("subtract (?left) ?right"),   subtract, []),
+                   (parse("subtract ?left (?right)"),   subtract, []),
+                   (parse("subtract ?left ?right"),     subtract, []),
+                   (parse("multiply (?left) (?right)"), multiply, []),
+                   (parse("multiply (?left) ?right"),   multiply, []),
+                   (parse("multiply ?left (?right)"),   multiply, []),
+                   (parse("multiply ?left ?right"),     multiply, []),
+                   (parse("divide   (?left) (?right)"), divide,   []),
+                   (parse("divide   (?left) ?right"),   divide,   []),
+                   (parse("divide   ?left (?right)"),   divide,   []),
+                   (parse("divide   ?left ?right"),     divide,   []),
+                   (parse("modulo   (?left) (?right)"), modulo,   []),
+                   (parse("modulo   (?left) ?right"),   modulo,   []),
+                   (parse("modulo   ?left (?right)"),   modulo,   []),
+                   (parse("modulo   ?left ?right"),     modulo,   []),
+                   (parse("(?left) + (?right)"),        add,      []),
+                   (parse("(?left) + ?right"),          add,      []),
+                   (parse("?left   + (?right)"),        add,      []),
+                   (parse("?left   + ?right"),          add,      []),
+                   (parse("(?left) - (?right)"),        subtract, []),
+                   (parse("(?left) - ?right"),          subtract, []),
+                   (parse("?left   - (?right)"),        subtract, []),
+                   (parse("?left   - ?right"),          subtract, []),
+                   (parse("(?left) * (?right)"),        multiply, []),
+                   (parse("(?left) * ?right"),          multiply, []),
+                   (parse("?left   * (?right)"),        multiply, []),
+                   (parse("?left   * ?right"),          multiply, []),
+                   (parse("?left / ?right"),            divide,   []),
+                   (parse("?left % ?right"),            modulo,   []),
+                   (parse("display ?left"),             display,  []),
                ];
     rules = defaults;
     if len(sys.argv) >= 2:
index 5e2e66b..e38f98c 100644 (file)
-define (def ?x ?y)    (define ?x ?y);
-define (?x -> ?y)     (def ?x ?y);
-define (assert ?x ?y) (?y -> ?x);
-define (fact ?x)      (?x -> true);
-define (?x ::> ?y)    (assert ?x ?y);
-define (:: ?x)        (fact ?x);
-define (?x + ?y)      (add ?x ?y);
-define (?x - ?y)      (subtract ?x ?y);
-define (?x * ?y)      (multiply ?x ?y);
-
-define (if      (true)  ?branch)      (?branch);
-define (if      (false) ?branch)      ();
-define (if/else (true)  ?true ?false) (?true);
-define (if/else (false) ?true ?false) (?false);
-
-define ((true)  and (true))  (true);
-define ((true)  and (false)) (false);
-define ((false) and (true))  (false);
-define ((false) and (false)) (false);
-
-define ((true)  or (true))  (true);
-define ((true)  or (false)) (true);
-define ((false) or (true))  (true);
-define ((false) or (false)) (false);
-
-define (not (true))  (false);
-define (not (false)) (true);
-
-(man ?x) ::> (mortal ?x);
-         ::  (man socrates);
-
-define (factorial (1)) (1);
-define (factorial (num ?x)) ((num ?x) * (factorial ((num ?x) - (1))));
-
-display (factorial (5));
+define [-- ?x] {}
+
+define [form ?x ?y] {
+    define ?x ?y
+}
+
+define [rule ?x ?y] {
+    define ?x ?y
+}
+
+define [?x -> ?y] {
+    define ?x ?y
+}
+
+[(?x) = (?x)] -> {
+    true
+}
+
+[(?x) = (?y)] -> {
+    false
+}
+
+[false or false] -> {
+    false
+}
+
+[true or false] -> {
+    true
+}
+
+[false or true] -> {
+    true
+}
+
+[true  or true] -> {
+    true
+}
+
+[quote ?x] -> {
+    quote ?x
+}
+
+[unquote (quote ?x)] -> {
+    ?x
+}
+
+form [
+    if ?condition
+            ?true
+        else
+            ?false
+]
+{
+    if/else ?condition {
+        quote ?true
+    } {
+        quote ?false
+    }
+}
+
+form [
+    if ?condition
+        ?branch
+]
+{
+    if/q ?condition {
+        quote ?branch
+    }
+}
+
+rule [
+    if/q (true)
+        ?branch
+]
+{
+    unquote ?branch
+}
+
+rule [
+    if/q (false)
+        ?branch
+]
+{}
+
+rule [
+    if/else (true)
+        ?true
+        ?false
+]
+{
+    unquote ?true
+}
+
+rule [
+    if/else (false)
+        ?true
+        ?false
+]
+{
+    unquote ?false
+}
+
+
+[factorial (?x)] -> {
+    if ((?x) = (1)) {
+        1
+    }
+    else {
+        ?x * factorial (?x - 1)
+    }
+}
+
+[fibonacci (?number)] -> {
+    if((?number) = (0) or (?number) = (1)) {
+        ?number
+    }
+    else {
+        fibonacci (?number - 1) + fibonacci (?number - 2)
+    }
+}
+
+[range (?low) (?high)] -> {
+    if((?low) = (?high + 1)) {
+        nil
+    }
+    else {
+        ?low : range (?low + 1) (?high)
+    }
+}
+
+[fold (?operation) (?initial) (nil)] -> {
+    ?initial
+}
+
+[fold (?operation) (?initial) (?head : ?tail)] -> {
+    ?operation ?head (fold (?operation) (?initial) ?tail)
+}
+
+[sum ?list)] -> {
+    fold (add) (0) ?list
+}