Tidy up some function annotations to use func(x,y:Foo) syntax instead of

func(x:Foo,y:Foo)

1 files changed, 44 insertions, 44 deletions

diff --git a/environment.c b/environment.c
index 80dcb003..f6e45574 100644
--- a/environment.c
+++ b/environment.c
@@ -98,44 +98,44 @@ env_t *new_compilation_unit(CORD libname)
         )},
         {"Int", Type(BigIntType), "Int_t", "Int$info", TypedArray(ns_entry_t,
             {"abs", "Int$abs", "func(x:Int)->Int"},
-            {"bit_and", "Int$bit_and", "func(x:Int,y:Int)->Int"},
-            {"bit_or", "Int$bit_or", "func(x:Int,y:Int)->Int"},
-            {"bit_xor", "Int$bit_xor", "func(x:Int,y:Int)->Int"},
-            {"clamped", "Int$clamped", "func(x:Int,low:Int,high:Int)->Int"},
-            {"divided_by", "Int$divided_by", "func(x:Int,y:Int)->Int"},
+            {"bit_and", "Int$bit_and", "func(x,y:Int)->Int"},
+            {"bit_or", "Int$bit_or", "func(x,y:Int)->Int"},
+            {"bit_xor", "Int$bit_xor", "func(x,y:Int)->Int"},
+            {"clamped", "Int$clamped", "func(x,low,high:Int)->Int"},
+            {"divided_by", "Int$divided_by", "func(x,y:Int)->Int"},
             {"format", "Int$format", "func(i:Int, digits=0)->Text"},
             {"from_text", "Int$from_text", "func(text:Text)->Int?"},
             {"hex", "Int$hex", "func(i:Int, digits=0, uppercase=yes, prefix=yes)->Text"},
             {"is_prime", "Int$is_prime", "func(x:Int,reps=50)->Bool"},
-            {"left_shifted", "Int$left_shifted", "func(x:Int,y:Int)->Int"},
-            {"minus", "Int$minus", "func(x:Int,y:Int)->Int"},
-            {"modulo", "Int$modulo", "func(x:Int,y:Int)->Int"},
-            {"modulo1", "Int$modulo1", "func(x:Int,y:Int)->Int"},
+            {"left_shifted", "Int$left_shifted", "func(x,y:Int)->Int"},
+            {"minus", "Int$minus", "func(x,y:Int)->Int"},
+            {"modulo", "Int$modulo", "func(x,y:Int)->Int"},
+            {"modulo1", "Int$modulo1", "func(x,y:Int)->Int"},
             {"negated", "Int$negated", "func(x:Int)->Int"},
             {"negative", "Int$negative", "func(x:Int)->Int"},
             {"next_prime", "Int$next_prime", "func(x:Int)->Int"},
             {"octal", "Int$octal", "func(i:Int, digits=0, prefix=yes)->Text"},
-            {"plus", "Int$plus", "func(x:Int,y:Int)->Int"},
+            {"plus", "Int$plus", "func(x,y:Int)->Int"},
             {"power", "Int$power", "func(base:Int,exponent:Int)->Int"},
             {"prev_prime", "Int$prev_prime", "func(x:Int)->Int"},
-            {"random", "Int$random", "func(min:Int, max:Int)->Int"},
-            {"right_shifted", "Int$right_shifted", "func(x:Int,y:Int)->Int"},
+            {"random", "Int$random", "func(min,max:Int)->Int"},
+            {"right_shifted", "Int$right_shifted", "func(x,y:Int)->Int"},
             {"sqrt", "Int$sqrt", "func(x:Int)->Int"},
-            {"times", "Int$times", "func(x:Int,y:Int)->Int"},
+            {"times", "Int$times", "func(x,y:Int)->Int"},
             {"to", "Int$to", "func(from:Int,to:Int)->Range"},
         )},
         {"Int64", Type(IntType, .bits=TYPE_IBITS64), "Int64_t", "Int64$info", TypedArray(ns_entry_t,
             {"abs", "labs", "func(i:Int64)->Int64"},
             {"bits", "Int64$bits", "func(x:Int64)->[Bool]"},
-            {"clamped", "Int64$clamped", "func(x:Int64,low:Int64,high:Int64)->Int64"},
-            {"divided_by", "Int64$divided_by", "func(x:Int64,y:Int64)->Int64"},
+            {"clamped", "Int64$clamped", "func(x,low,high:Int64)->Int64"},
+            {"divided_by", "Int64$divided_by", "func(x,y:Int64)->Int64"},
             {"format", "Int64$format", "func(i:Int64, digits=0)->Text"},
             {"from_text", "Int64$from_text", "func(text:Text)->Int64?"},
             {"hex", "Int64$hex", "func(i:Int64, digits=0, uppercase=yes, prefix=yes)->Text"},
             {"max", "Int64$max", "Int64"},
             {"min", "Int64$min", "Int64"},
-            {"modulo", "Int64$modulo", "func(x:Int64,y:Int64)->Int64"},
-            {"modulo1", "Int64$modulo1", "func(x:Int64,y:Int64)->Int64"},
+            {"modulo", "Int64$modulo", "func(x,y:Int64)->Int64"},
+            {"modulo1", "Int64$modulo1", "func(x,y:Int64)->Int64"},
             {"octal", "Int64$octal", "func(i:Int64, digits=0, prefix=yes)->Text"},
             {"to", "Int64$to", "func(from:Int64,to:Int64)->Range"},
             // Must be defined after min/max:
@@ -144,15 +144,15 @@ env_t *new_compilation_unit(CORD libname)
         {"Int32", Type(IntType, .bits=TYPE_IBITS32), "Int32_t", "Int32$info", TypedArray(ns_entry_t,
             {"abs", "abs", "func(i:Int32)->Int32"},
             {"bits", "Int32$bits", "func(x:Int32)->[Bool]"},
-            {"clamped", "Int32$clamped", "func(x:Int32,low:Int32,high:Int32)->Int32"},
-            {"divided_by", "Int32$divided_by", "func(x:Int32,y:Int32)->Int32"},
+            {"clamped", "Int32$clamped", "func(x,low,high:Int32)->Int32"},
+            {"divided_by", "Int32$divided_by", "func(x,y:Int32)->Int32"},
             {"format", "Int32$format", "func(i:Int32, digits=0)->Text"},
             {"from_text", "Int32$from_text", "func(text:Text)->Int32?"},
             {"hex", "Int32$hex", "func(i:Int32, digits=0, uppercase=yes, prefix=yes)->Text"},
             {"max", "Int32$max", "Int32"},
             {"min", "Int32$min", "Int32"},
-            {"modulo", "Int32$modulo", "func(x:Int32,y:Int32)->Int32"},
-            {"modulo1", "Int32$modulo1", "func(x:Int32,y:Int32)->Int32"},
+            {"modulo", "Int32$modulo", "func(x,y:Int32)->Int32"},
+            {"modulo1", "Int32$modulo1", "func(x,y:Int32)->Int32"},
             {"octal", "Int32$octal", "func(i:Int32, digits=0, prefix=yes)->Text"},
             {"to", "Int32$to", "func(from:Int32,to:Int32)->Range"},
             // Must be defined after min/max:
@@ -161,15 +161,15 @@ env_t *new_compilation_unit(CORD libname)
         {"Int16", Type(IntType, .bits=TYPE_IBITS16), "Int16_t", "Int16$info", TypedArray(ns_entry_t,
             {"abs", "abs", "func(i:Int16)->Int16"},
             {"bits", "Int16$bits", "func(x:Int16)->[Bool]"},
-            {"clamped", "Int16$clamped", "func(x:Int16,low:Int16,high:Int16)->Int16"},
-            {"divided_by", "Int16$divided_by", "func(x:Int16,y:Int16)->Int16"},
+            {"clamped", "Int16$clamped", "func(x,low,high:Int16)->Int16"},
+            {"divided_by", "Int16$divided_by", "func(x,y:Int16)->Int16"},
             {"format", "Int16$format", "func(i:Int16, digits=0)->Text"},
             {"from_text", "Int16$from_text", "func(text:Text)->Int16?"},
             {"hex", "Int16$hex", "func(i:Int16, digits=0, uppercase=yes, prefix=yes)->Text"},
             {"max", "Int16$max", "Int16"},
             {"min", "Int16$min", "Int16"},
-            {"modulo", "Int16$modulo", "func(x:Int16,y:Int16)->Int16"},
-            {"modulo1", "Int16$modulo1", "func(x:Int16,y:Int16)->Int16"},
+            {"modulo", "Int16$modulo", "func(x,y:Int16)->Int16"},
+            {"modulo1", "Int16$modulo1", "func(x,y:Int16)->Int16"},
             {"octal", "Int16$octal", "func(i:Int16, digits=0, prefix=yes)->Text"},
             {"to", "Int16$to", "func(from:Int16,to:Int16)->Range"},
             // Must be defined after min/max:
@@ -178,15 +178,15 @@ env_t *new_compilation_unit(CORD libname)
         {"Int8", Type(IntType, .bits=TYPE_IBITS8), "Int8_t", "Int8$info", TypedArray(ns_entry_t,
             {"abs", "abs", "func(i:Int8)->Int8"},
             {"bits", "Int8$bits", "func(x:Int8)->[Bool]"},
-            {"clamped", "Int8$clamped", "func(x:Int8,low:Int8,high:Int8)->Int8"},
-            {"divided_by", "Int8$divided_by", "func(x:Int8,y:Int8)->Int8"},
+            {"clamped", "Int8$clamped", "func(x,low,high:Int8)->Int8"},
+            {"divided_by", "Int8$divided_by", "func(x,y:Int8)->Int8"},
             {"format", "Int8$format", "func(i:Int8, digits=0)->Text"},
             {"from_text", "Int8$from_text", "func(text:Text)->Int8?"},
             {"hex", "Int8$hex", "func(i:Int8, digits=0, uppercase=yes, prefix=yes)->Text"},
             {"max", "Int8$max", "Int8"},
             {"min", "Int8$min", "Int8"},
-            {"modulo", "Int8$modulo", "func(x:Int8,y:Int8)->Int8"},
-            {"modulo1", "Int8$modulo1", "func(x:Int8,y:Int8)->Int8"},
+            {"modulo", "Int8$modulo", "func(x,y:Int8)->Int8"},
+            {"modulo1", "Int8$modulo1", "func(x,y:Int8)->Int8"},
             {"octal", "Int8$octal", "func(i:Int8, digits=0, prefix=yes)->Text"},
             {"to", "Int8$to", "func(from:Int8,to:Int8)->Range"},
             // Must be defined after min/max:
@@ -194,10 +194,10 @@ env_t *new_compilation_unit(CORD libname)
         )},
 #define C(name) {#name, "M_"#name, "Num"}
 #define F(name) {#name, #name, "func(n:Num)->Num"}
-#define F2(name) {#name, #name, "func(x:Num, y:Num)->Num"}
+#define F2(name) {#name, #name, "func(x,y:Num)->Num"}
         {"Num", Type(NumType, .bits=TYPE_NBITS64), "Num_t", "Num$info", TypedArray(ns_entry_t,
-            {"near", "Num$near", "func(x:Num, y:Num, ratio=1e-9, min_epsilon=1e-9)->Bool"},
-            {"clamped", "Num$clamped", "func(x:Num,low:Num,high:Num)->Num"},
+            {"near", "Num$near", "func(x,y:Num, ratio=1e-9, min_epsilon=1e-9)->Bool"},
+            {"clamped", "Num$clamped", "func(x,low,high:Num)->Num"},
             {"format", "Num$format", "func(n:Num, precision=0)->Text"},
             {"scientific", "Num$scientific", "func(n:Num, precision=0)->Text"},
             {"nan", "Num$nan", "func(tag=\"\")->Num"},
@@ -209,7 +209,7 @@ env_t *new_compilation_unit(CORD libname)
             {"INF", "(Num_t)(INFINITY)", "Num"},
             {"TAU", "(Num_t)(2.*M_PI)", "Num"},
             {"random", "Num$random", "func()->Num"},
-            {"mix", "Num$mix", "func(amount:Num, x:Num, y:Num)->Num"},
+            {"mix", "Num$mix", "func(amount,x,y:Num)->Num"},
             {"from_text", "Num$from_text", "func(text:Text)->Num?"},
             {"abs", "fabs", "func(n:Num)->Num"},
             F(acos), F(acosh), F(asin), F(asinh), F(atan), F(atanh), F(cbrt), F(ceil), F(cos), F(cosh), F(erf), F(erfc),
@@ -223,10 +223,10 @@ env_t *new_compilation_unit(CORD libname)
 #undef C
 #define C(name) {#name, "(Num32_t)(M_"#name")", "Num32"}
 #define F(name) {#name, #name"f", "func(n:Num32)->Num32"}
-#define F2(name) {#name, #name"f", "func(x:Num32, y:Num32)->Num32"}
+#define F2(name) {#name, #name"f", "func(x,y:Num32)->Num32"}
         {"Num32", Type(NumType, .bits=TYPE_NBITS32), "Num32_t", "Num32$info", TypedArray(ns_entry_t,
-            {"near", "Num32$near", "func(x:Num32, y:Num32, ratio=1e-9f32, min_epsilon=1e-9f32)->Bool"},
-            {"clamped", "Num32$clamped", "func(x:Num32,low:Num32,high:Num32)->Num32"},
+            {"near", "Num32$near", "func(x,y:Num32, ratio=1e-9f32, min_epsilon=1e-9f32)->Bool"},
+            {"clamped", "Num32$clamped", "func(x,low,high:Num32)->Num32"},
             {"format", "Num32$format", "func(n:Num32, precision=0)->Text"},
             {"scientific", "Num32$scientific", "func(n:Num32, precision=0)->Text"},
             {"nan", "Num32$nan", "func(tag=\"\")->Num32"},
@@ -238,7 +238,7 @@ env_t *new_compilation_unit(CORD libname)
             {"INF", "(Num32_t)(INFINITY)", "Num32"},
             {"TAU", "(Num32_t)(2.f*M_PI)", "Num32"},
             {"random", "Num32$random", "func()->Num32"},
-            {"mix", "Num32$mix", "func(amount:Num32, x:Num32, y:Num32)->Num32"},
+            {"mix", "Num32$mix", "func(amount,x,y:Num32)->Num32"},
             {"from_text", "Num32$from_text", "func(text:Text)->Num32?"},
             {"abs", "fabsf", "func(n:Num32)->Num32"},
             F(acos), F(acosh), F(asin), F(asinh), F(atan), F(atanh), F(cbrt), F(ceil), F(cos), F(cosh), F(erf), F(erfc),
@@ -265,15 +265,15 @@ env_t *new_compilation_unit(CORD libname)
             // Used as a default for functions below:
             {"now", "DateTime$now", "func()->DateTime"},
 
-            {"after", "DateTime$after", "func(dt:DateTime,seconds=0.0,minutes=0.0,hours=0.0,days=0,weeks=0,months=0,years=0,timezone=!Text)->DateTime"},
+            {"after", "DateTime$after", "func(dt:DateTime,seconds,minutes,hours=0.0,days,weeks,months,years=0,timezone=!Text)->DateTime"},
             {"date", "DateTime$date", "func(dt:DateTime,timezone=!Text)->Text"},
             {"format", "DateTime$format", "func(dt:DateTime,format=\"%Y-%m-%dT%H:%M:%S%z\",timezone=!Text)->Text"},
             {"from_unix_timestamp", "DateTime$from_unix_timestamp", "func(timestamp:Int64)->DateTime"},
-            {"get", "DateTime$get", "func(dt:DateTime,year=!&Int,month=!&Int,day=!&Int,hour=!&Int,minute=!&Int,second=!&Int,nanosecond=!&Int,weekday=!&Int, timezone=!Text)"},
+            {"get", "DateTime$get", "func(dt:DateTime,year,month,day,hour,minute,second,nanosecond,weekday=!&Int, timezone=!Text)"},
             {"get_local_timezone", "DateTime$get_local_timezone", "func()->Text"},
-            {"hours_till", "DateTime$hours_till", "func(now:DateTime,then:DateTime)->Num"},
-            {"minutes_till", "DateTime$minutes_till", "func(now:DateTime,then:DateTime)->Num"},
-            {"new", "DateTime$new", "func(year:Int,month:Int,day:Int,hour=0,minute=0,second=0.0,timezone=!Text)->DateTime"},
+            {"hours_till", "DateTime$hours_till", "func(now,then:DateTime)->Num"},
+            {"minutes_till", "DateTime$minutes_till", "func(now,then:DateTime)->Num"},
+            {"new", "DateTime$new", "func(year,month,day:Int,hour,minute=0,second=0.0,timezone=!Text)->DateTime"},
             {"parse", "DateTime$parse", "func(text:Text, format=\"%Y-%m-%dT%H:%M:%S%z\")->DateTime?"},
             {"relative", "DateTime$relative", "func(dt:DateTime,relative_to=DateTime.now(),timezone=!Text)->Text"},
             {"seconds_till", "DateTime$seconds_till", "func(now:DateTime,then:DateTime)->Num"},
@@ -335,7 +335,7 @@ env_t *new_compilation_unit(CORD libname)
         {"Text", TEXT_TYPE, "Text_t", "Text$info", TypedArray(ns_entry_t,
             {"as_c_string", "Text$as_c_string", "func(text:Text)->CString"},
             {"codepoint_names", "Text$codepoint_names", "func(text:Text)->[Text]"},
-            {"ends_with", "Text$ends_with", "func(text:Text, suffix:Text)->Bool"},
+            {"ends_with", "Text$ends_with", "func(text,suffix:Text)->Bool"},
             {"find", "Text$find", "func(text:Text, pattern:Pattern, start=1, length=!&Int64)->Int"},
             {"find_all", "Text$find_all", "func(text:Text, pattern:Pattern)->[Text]"},
             {"from_bytes", "Text$from_bytes", "func(bytes:[Byte])->Text"},
@@ -355,7 +355,7 @@ env_t *new_compilation_unit(CORD libname)
             {"replace_all", "Text$replace_all", "func(text:Text, replacements:{Pattern:Text}, backref=$/\\/, recursive=yes)->Text"},
             {"slice", "Text$slice", "func(text:Text, from=1, to=-1)->Text"},
             {"split", "Text$split", "func(text:Text, pattern=$Pattern'')->[Text]"},
-            {"starts_with", "Text$starts_with", "func(text:Text, prefix:Text)->Bool"},
+            {"starts_with", "Text$starts_with", "func(text,prefix:Text)->Bool"},
             {"title", "Text$title", "func(text:Text)->Text"},
             {"trim", "Text$trim", "func(text:Text, pattern=$/{whitespace}/, trim_left=yes, trim_right=yes)->Text"},
             {"upper", "Text$upper", "func(text:Text)->Text"},