From f79f4e47ba5012d467007b2b45e9d52253d44535 Mon Sep 17 00:00:00 2001 From: prod2 <95874442+prod2@users.noreply.github.com> Date: Wed, 9 Feb 2022 06:58:51 +0100 Subject: [PATCH] rename funct to proc --- benchmarks/factorial.nds | 2 +- benchmarks/fib.nds | 2 +- examples/bf.nds | 2 +- src/ndspkg/scanner.nim | 2 +- tests/break.nds | 8 ++--- tests/closures.nds | 76 ++++++++++++++++++++-------------------- tests/collections.nds | 2 +- tests/controlflow.nds | 2 +- tests/precedence.nds | 4 +-- tests/sugar.nds | 12 +++---- 10 files changed, 56 insertions(+), 56 deletions(-) diff --git a/benchmarks/factorial.nds b/benchmarks/factorial.nds index fda6ffd..394a58e 100644 --- a/benchmarks/factorial.nds +++ b/benchmarks/factorial.nds @@ -1,4 +1,4 @@ -var fact = funct(n) +var fact = proc(n) if (n > 0) :result = n * fact(n-1) else diff --git a/benchmarks/fib.nds b/benchmarks/fib.nds index dadc8c3..c40cd2e 100644 --- a/benchmarks/fib.nds +++ b/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) ; diff --git a/examples/bf.nds b/examples/bf.nds index a85a23c..b444201 100644 --- a/examples/bf.nds +++ b/examples/bf.nds @@ -1,4 +1,4 @@ -var main = funct() { +var main = proc() { // source var src = ">++++++++++[<++++++++++>-]<->>>>>+++[>+++>+++<<-]<<<<+<[>[>+>+<<-]>>[-<<+>>]++++>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<[[-]>>>>>>[[-]<++++++++++<->>]<-[>+>+<<-]>[<+>-]+>[[-]<->]<<<<<<<<<->>]<[>+>+<<-]>>[-<<+>>]+>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<<[>>+>+<<<-]>>>[-<<<+>>>]++>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<[>+<[-]]<[>>+<<[-]]>>[<<+>>[-]]<<<[>>+>+<<<-]>>>[-<<<+>>>]++++>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<[>+<[-]]<[>>+<<[-]]>>[<<+>>[-]]<<[[-]>>>++++++++[>>++++++<<-]>[<++++++++[>++++++<-]>.<++++++++[>------<-]>[<<+>>-]]>.<<++++++++[>>------<<-]<[->>+<<]<++++++++[<++++>-]<.>+++++++[>+++++++++<-]>+++.<+++++[>+++++++++<-]>.+++++..--------.-------.++++++++++++++>>[>>>+>+<<<<-]>>>>[-<<<<+>>>>]>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<<<[>>>+>+<<<<-]>>>>[-<<<<+>>>>]+>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<<[>>+<<[-]]>[>+<[-]]++>>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<+<[[-]>-<]>[<<<<<<<.>>>>>>>[-]]<<<<<<<<<.>>----.---------.<<.>>----.+++..+++++++++++++.[-]<<[-]]<[>+>+<<-]>>[-<<+>>]+>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<<[>>+>+<<<-]>>>[-<<<+>>>]++++>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<[>+<[-]]<[>>+<<[-]]>>[<<+>>[-]]<<[[-]>++++++++[<++++>-]<.>++++++++++[>+++++++++++<-]>+.-.<<.>>++++++.------------.---.<<.>++++++[>+++<-]>.<++++++[>----<-]>++.+++++++++++..[-]<<[-]++++++++++.[-]]<[>+>+<<-]>>[-<<+>>]+++>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<[[-]++++++++++. >+++++++++[>+++++++++<-]>+++.+++++++++++++.++++++++++.------.<++++++++[>>++++<<-]>>.<++++++++++.-.---------.>.<-.+++++++++++.++++++++.---------.>.<-------------.+++++++++++++.----------.>.<++++++++++++.---------------.<+++[>++++++<-]>..>.<----------.+++++++++++.>.<<+++[>------<-]>-.+++++++++++++++++.---.++++++.-------.----------.[-]>[-]<<<.[-]]<[>+>+<<-]>>[-<<+>>]++++>+<[-<->]<[[-]>>-<<]>>[[-]<<+>>]<<[[-]++++++++++.[-]<[-]>]<+<]"; var pos = 0; diff --git a/src/ndspkg/scanner.nim b/src/ndspkg/scanner.nim index 3bac4d9..a07f1af 100644 --- a/src/ndspkg/scanner.nim +++ b/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, diff --git a/tests/break.nds b/tests/break.nds index d12d12f..eb34003 100644 --- a/tests/break.nds +++ b/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 diff --git a/tests/closures.nds b/tests/closures.nds index 41bf15c..8f29797 100644 --- a/tests/closures.nds +++ b/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); }; diff --git a/tests/collections.nds b/tests/collections.nds index 74ba376..3d16008 100644 --- a/tests/collections.nds +++ b/tests/collections.nds @@ -1,6 +1,6 @@ // a test about collections, WIP -var returnlist = funct() +var returnlist = proc() @[1, 2, 3, 4] ; diff --git a/tests/controlflow.nds b/tests/controlflow.nds index 03c5c0b..4ae78db 100644 --- a/tests/controlflow.nds +++ b/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 diff --git a/tests/precedence.nds b/tests/precedence.nds index 2d423cf..afd75c3 100644 --- a/tests/precedence.nds +++ b/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 ; diff --git a/tests/sugar.nds b/tests/sugar.nds index ad75ba9..893ad2a 100644 --- a/tests/sugar.nds +++ b/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;