rename funct to proc

benchmarks/factorial.nds

@@ -1,4 +1,4 @@
-var fact = funct(n)
+var fact = proc(n)
   if (n > 0)
     :result = n * fact(n-1)
   else

benchmarks/fib.nds

@@ -1,4 +1,4 @@
-var fib = funct(n)
+var fib = proc(n)
   if (n < 2) :result = 1
   else :result = fib(n-1) + fib(n-2)
 ;

examples/bf.nds

@@ -1,4 +1,4 @@
-var main = funct() {
+var main = proc() {
   // source
   var src = ">++++++++++[<++++++++++>-]<->>>>>+++[>+++>+++<<-]<<<<+<[>[>+>+<<-]>>[-<<+>>]++++>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<[[-]>>>>>>[[-]<++++++++++<->>]<-[>+>+<<-]>[<+>-]+>[[-]<->]<<<<<<<<<->>]<[>+>+<<-]>>[-<<+>>]+>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<<[>>+>+<<<-]>>>[-<<<+>>>]++>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<[>+<[-]]<[>>+<<[-]]>>[<<+>>[-]]<<<[>>+>+<<<-]>>>[-<<<+>>>]++++>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<[>+<[-]]<[>>+<<[-]]>>[<<+>>[-]]<<[[-]>>>++++++++[>>++++++<<-]>[<++++++++[>++++++<-]>.<++++++++[>------<-]>[<<+>>-]]>.<<++++++++[>>------<<-]<[->>+<<]<++++++++[<++++>-]<.>+++++++[>+++++++++<-]>+++.<+++++[>+++++++++<-]>.+++++..--------.-------.++++++++++++++>>[>>>+>+<<<<-]>>>>[-<<<<+>>>>]>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<<<[>>>+>+<<<<-]>>>>[-<<<<+>>>>]+>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<<[>>+<<[-]]>[>+<[-]]++>>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<+<[[-]>-<]>[<<<<<<<.>>>>>>>[-]]<<<<<<<<<.>>----.---------.<<.>>----.+++..+++++++++++++.[-]<<[-]]<[>+>+<<-]>>[-<<+>>]+>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<<[>>+>+<<<-]>>>[-<<<+>>>]++++>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<[>+<[-]]<[>>+<<[-]]>>[<<+>>[-]]<<[[-]>++++++++[<++++>-]<.>++++++++++[>+++++++++++<-]>+.-.<<.>>++++++.------------.---.<<.>++++++[>+++<-]>.<++++++[>----<-]>++.+++++++++++..[-]<<[-]++++++++++.[-]]<[>+>+<<-]>>[-<<+>>]+++>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<[[-]++++++++++. >+++++++++[>+++++++++<-]>+++.+++++++++++++.++++++++++.------.<++++++++[>>++++<<-]>>.<++++++++++.-.---------.>.<-.+++++++++++.++++++++.---------.>.<-------------.+++++++++++++.----------.>.<++++++++++++.---------------.<+++[>++++++<-]>..>.<----------.+++++++++++.>.<<+++[>------<-]>-.+++++++++++++++++.---.++++++.-------.----------.[-]>[-]<<<.[-]]<[>+>+<<-]>>[-<<+>>]++++>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<[[-]++++++++++.[-]<[-]>]<+<]";
   var pos = 0;

src/ndspkg/scanner.nim

@@ -145,7 +145,7 @@ const keywords = {
   "else": tkElse,
   "false": tkFalse,
   "for": tkFor,
-  "funct": tkFunct, 
+  "proc": tkFunct, 
   # here's a language that uses funct... still waiting for the day when a good de-funct joke comes to my mind that I can abuse
   "goto": tkGoto,
   "if": tkIf,

tests/break.nds

@@ -44,7 +44,7 @@
 
 //expect:5.0
 
-var f = funct() { @result
+var f = proc() { @result
   var y = 1;
   var z = 3;
   var p = 1;
@@ -59,7 +59,7 @@ print (f());
 
 //expect:15.0
 
-f = funct(m, n)
+f = proc(m, n)
   m + n
 ;
 
@@ -68,7 +68,7 @@ print (f(f(5, 5), 5));
 
 //expect:10.0
 
-var g = funct()
+var g = proc()
   {@a
     :a = { @b
       :b = { @c
@@ -82,7 +82,7 @@ print (g());
 
 //expect:9.0
 
-var h = funct()
+var h = proc()
   {@a
     :a = { @b
       :b = { @c

tests/closures.nds

@@ -1,21 +1,21 @@
 // cascade
 
-var f1 = funct() {
+var f1 = proc() {
   var x = 1;
   var y = 5;
-  funct() {
+  proc() {
     var z = 8;
     print (x);
     x = x + 1;
-    funct() {
+    proc() {
       print (x);
       x = x + 1;
-      funct() {
+      proc() {
         print (x);
         print (y);
         print (z);
         x = x + 1;
-        funct() {
+        proc() {
           print (x);
           x = x + 1;
         }
@@ -33,11 +33,11 @@ f1()()()()();
 
 // capturing closures in lists:
 
-var f = funct() {
+var f = proc() {
   var y = 5;
   var x = @[
-    funct() print (y),
-    funct() y = y + 1
+    proc() print (y),
+    proc() y = y + 1
   ];
   x
 };
@@ -52,12 +52,12 @@ inst[0]();
 
 // multiple different labels
 
-var f2 = funct() { @result
+var f2 = proc() { @result
   var x = { @a @b
     // this captures the internal value, not whatever it returns is assigned to
     :result = @{
-      get = funct() print (:a),
-      ["set"] = funct(n) :b = n,
+      get = proc() print (:a),
+      ["set"] = proc(n) :b = n,
     };
   };
   x = 5;
@@ -72,8 +72,8 @@ inst2["get"]();
 
 // capturing args
 
-var argcap = funct(n)
-  funct() print (n)
+var argcap = proc(n)
+  proc() print (n)
 ;
 
 //expect:8.1
@@ -82,12 +82,12 @@ argcap(8.1)();
 
 // oop: constructors, getters, setters
 
-var newAnimal = funct(species, color) { @result
+var newAnimal = proc(species, color) { @result
   var species = species; // copy it so that it's mutable, if args ever get immutable
   var animal = @{
-    ["getSpecies"] = funct() species,
-    ["setSpecies"] = funct(newSpecies) species = newSpecies,
-    ["getColor"] = funct() color, // this captures an argument directly
+    ["getSpecies"] = proc() species,
+    ["setSpecies"] = proc(newSpecies) species = newSpecies,
+    ["getColor"] = proc() color, // this captures an argument directly
   };
   :result = animal;
 };
@@ -116,8 +116,8 @@ print (turtle["getSpecies"]());
 
 // 1:
 
-var makeClosure = funct(value) { @result
-  var closure = funct() {
+var makeClosure = proc(value) { @result
+  var closure = proc() {
     print (value);
   };
   :result = closure;
@@ -132,10 +132,10 @@ bagel();
 
 // 2: (multi level closures)
 
-var outer = funct() { @result
+var outer = proc() { @result
   var x = "value";
-  var middle = funct() { @result
-    var inner = funct() {
+  var middle = proc() { @result
+    var inner = proc() {
       print (x);
     };
 
@@ -157,20 +157,20 @@ in();
 
 // 3: (mixed multi level closures)
 
-outer = funct() { @result
+outer = proc() { @result
   var a = 1;
   var b = 2;
   var result;
-  var middle = funct() {
+  var middle = proc() {
     var c = 3;
     var d = 4;
-    var inner = funct() {
+    var inner = proc() {
       print (a + c + b + d);
     };
     result = inner;
   };
   middle();
-  :result = funct() result;
+  :result = proc() result;
 };
 
 //expect:10.0
@@ -178,9 +178,9 @@ outer()()();
 
 // 4: manipulation of vals from closures
 
-outer = funct() {
+outer = proc() {
   var x = "before";
-  var inner = funct() {
+  var inner = proc() {
     x = "assigned";
   };
   inner();
@@ -195,11 +195,11 @@ outer();
 var globalSet;
 var globalGet;
 
-var main5 = funct() {
+var main5 = proc() {
   var a = "initial";
 
-  var set = funct() { a = "updated"; };
-  var get = funct() { print (a); };
+  var set = proc() { a = "updated"; };
+  var get = proc() { print (a); };
 
   globalSet = set;
   globalGet = get;
@@ -216,15 +216,15 @@ globalGet();
 
 {
   var a = 1;
-  var f = funct() {
+  var f = proc() {
     print (a);
   };
   var b = 2;
-  var g = funct() {
+  var g = proc() {
     print (b);
   };
   var c = 3;
-  var h = funct() {
+  var h = proc() {
     print (c);
   };
 
@@ -238,17 +238,17 @@ globalGet();
 
 // bonus: the last one with a list twist
 
-var bonus = funct() { @result
+var bonus = proc() { @result
   var a = 1;
-  var f = funct() {
+  var f = proc() {
     print (a);
   };
   var b = 2;
-  var g = funct() {
+  var g = proc() {
     print (b);
   };
   var c = 3;
-  var h = funct() {
+  var h = proc() {
     print (c);
   };
 

tests/collections.nds

@@ -1,6 +1,6 @@
 // a test about collections, WIP
 
-var returnlist = funct()
+var returnlist = proc()
   @[1, 2, 3, 4]
 ;
 

tests/controlflow.nds

@@ -60,7 +60,7 @@ if (@[]) print ("6");
 if (@["hi"]) print ("7");
 if (@{}) print ("8");
 if (@{["hi"] = 5}) print ("9");
-if (funct(n) print (n)) print ("10");
+if (proc(n) print (n)) print ("10");
 
 //expect:1
 //expect:2

tests/precedence.nds

@@ -15,7 +15,7 @@ print (-((3 + 2) * 2) + 1);
 
 // calls and indexes
 
-var returnlist = funct() { @result
+var returnlist = proc() { @result
   :result = @[];
   :result[0] = 4;
   :result[1] = 6;
@@ -27,7 +27,7 @@ var returnlist = funct() { @result
 print (returnlist()[2]);
 
 // priority over unary
-var truesayer = funct()
+var truesayer = proc()
   true
 ;
 

tests/sugar.nds

@@ -1,13 +1,13 @@
 // testing syntactic sugars
 
 
-// :: piping function call
+// :: piping procion call
 
-var double = funct(num) num * 2;
+var double = proc(num) num * 2;
 
 var four = 2 :: double();
 
-var multiply = funct(num, factor) num * factor;
+var multiply = proc(num, factor) num * factor;
 
 var six = 2 :: multiply(3);
 
@@ -56,7 +56,7 @@ print(mix.ident, mix["ident2"], mix[3], mix.ident4);
 // -> method call syntax
 
 var class = @{
-  method = funct(self) print ("i was called")
+  method = proc(self) print ("i was called")
 };
 
 // no args needed then no parentheses needed
@@ -65,7 +65,7 @@ class->method;
 
 var multiplier = @{
   multiple = 5,
-  do = funct(self, arg) self.multiple * arg,
+  do = proc(self, arg) self.multiple * arg,
 };
 
 multiplier->do(7) :: print;
@@ -74,7 +74,7 @@ multiplier->do(7) :: print;
 // -> method call syntax with :: - check for precedence
 
 var returner = @{
-  method = funct(self) funct(n) n * 2
+  method = proc(self) proc(n) n * 2
 };
 
 1.7 :: returner->method :: print;