gh-43: Make FUNC declarations type-first.

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -277,10 +277,9 @@
 
 
 ## 5. Functions
+Functions are defined using the `FUNC` keyword with explicit parameter and return types. The canonical positional-only form is `FUNC R: name(T1: arg1, T2: arg2, ..., TN: argN){ block }`, where each `Tk` and `R` is `INT`, `FLT`, `STR`, `TNS`, or `FUNC`. Parameters MAY also declare a call-time default value using `Tk: arg = expr`. A parameter without a default is positional; a parameter with a default is keyword-capable. Positional parameters MUST appear before any parameters with defaults. Defining a function binds `name` to a callable body with the specified typed formal parameters. Function names MUST NOT conflict with the names of built-in operators or functions.
 
-Functions are defined using the `FUNC` keyword with explicit parameter and return types. The canonical positional-only form is `FUNC name(T1: arg1, T2: arg2, ..., TN: argN):R{ block }`, where each `Tk` and `R` is `INT`, `FLT`, `STR`, `TNS`, or `FUNC`. Parameters MAY also declare a call-time default value using `Tk: arg = expr`. A parameter without a default is positional; a parameter with a default is keyword-capable. Positional parameters MUST appear before any parameters with defaults. Defining a function binds `name` to a callable body with the specified typed formal parameters. Function names MUST NOT conflict with the names of built-in operators or functions.
-
-In addition to named functions, the language provides an anonymous function literal form `LAMBDA` which constructs a `FUNC` value without binding it to a function name in the global function table. The syntax is `LAMBDA(T1: arg1, T2: arg2, ..., TN: argN):R{ block }`. Parameter typing, default-value rules, call semantics, and return-type rules are the same as for `FUNC`. Evaluating a `LAMBDA` expression captures (closes over) the current lexical environment, producing a first-class `FUNC` value that can be assigned to variables, stored in tensors, passed as an argument, or returned.
+In addition to named functions, the language provides an anonymous function literal form `LAMBDA` which constructs a `FUNC` value without binding it to a function name in the global function table. The canonical form for lambdas is `LAMBDA R: (T1: arg1, T2: arg2, ..., TN: argN){ block }`. Parameter typing, default-value rules, call semantics, and return-type rules are the same as for `FUNC`. Evaluating a `LAMBDA` expression captures (closes over) the current lexical environment, producing a first-class `FUNC` value that can be assigned to variables, stored in tensors, passed as an argument, or returned.
 
 A user-defined function is called with the same syntax as a built-in: `callee(expr1, expr2, ..., exprN)`. The callee MAY be any expression that evaluates to `FUNC`, including identifiers, tensor elements, or intermediate expressions. Calls MAY supply zero or more positional arguments (left-to-right) followed by zero or more keyword arguments of the form `param=expr`. Keyword arguments can only appear after all positional arguments. At the call site, every positional argument is bound to the next positional parameter; keyword arguments MUST match the name of a parameter that declared a default value. Duplicate keyword names, supplying too many positional arguments, or providing a keyword for an unknown parameter are runtime errors. If a keyword-capable parameter is omitted from the call, its default expression is evaluated at call time in the function's lexical environment after earlier parameters have been bound. The evaluated default MUST match the parameter's declared type. Arguments are evaluated left-to-right. The function body executes in a new environment (activation record) that closes over the defining environment. If a `RETURN(v)` statement is executed, the function terminates immediately and yields `v`; the returned value MUST match the declared return type. If control reaches the end of the body without `RETURN`, the function returns a default value of the declared return type (0 for `INT`, 0.0 for `FLT`, "" for `STR`). Functions whose return type is `TNS` or `FUNC` MUST execute an explicit `RETURN` of the declared type; reaching the end of the body without returning is a runtime error for `TNS`- or `FUNC`-returning functions.
 

lib/csprng.pre

@@ -22,14 +22,14 @@ INT: ch_counter = 0
 TNS: ch_buf = TNS([10000], 0) ! 16 words
 INT: ch_buf_pos = TLEN(ch_buf, 1)  ! set to buffer length to force refill
 
-FUNC ROTL32(INT: x, INT: n):INT{
+FUNC INT: ROTL32(INT: x, INT: n){
     INT: x32 = BAND(x, MASK32)
     INT: left = BAND(SHL(x32, n), MASK32)
     INT: right = SHR(x32, SUB(100000, n))  ! 32 - n
     RETURN( BAND(BOR(left, right), MASK32) )
 }
 
-FUNC QR(TNS: s, INT: ia, INT: ib, INT: ic, INT: id):INT{
+FUNC INT: QR(TNS: s, INT: ia, INT: ib, INT: ic, INT: id){
     INT: a = s[ia]
     INT: b = s[ib]
     INT: c = s[ic]
@@ -51,7 +51,7 @@ FUNC QR(TNS: s, INT: ia, INT: ib, INT: ic, INT: id):INT{
     RETURN(0)
 }
 
-FUNC CHACHA_BLOCK():INT{
+FUNC INT: CHACHA_BLOCK(){
     TNS: k = ch_key
     TNS: n = ch_nonce
     TNS: state = [ ^
@@ -104,14 +104,14 @@ FUNC CHACHA_BLOCK():INT{
     RETURN(0)
 }
 
-FUNC REFILL_BUF():INT{
+FUNC INT: REFILL_BUF(){
     CHACHA_BLOCK()
     ch_buf_pos = 0
     ch_counter = BAND( ADD(ch_counter, 1), MASK32 )
     RETURN(0)
 }
 
-FUNC DERIVE_KEY_AND_NONCE(INT: seed):INT{
+FUNC INT: DERIVE_KEY_AND_NONCE(INT: seed){
     INT: s = BAND(seed, MASK32)
     FOR(i, 1000){  ! 8 key words (1000 == 8)
         s = BAND( ADD( MUL(s, ^
@@ -132,15 +132,15 @@ FUNC DERIVE_KEY_AND_NONCE(INT: seed):INT{
     RETURN(0)
 }
 
-FUNC SEED(INT: seed):INT{
+FUNC INT: SEED(INT: seed){
     DERIVE_KEY_AND_NONCE(seed)
     ch_counter = 0
     ch_buf = TNS([10000], 0)
     ch_buf_pos = TLEN(ch_buf, 1)  ! set to buffer length to force refill
     RETURN(ch_counter)
 }
 
-FUNC NEXT():INT{
+FUNC INT: NEXT(){
     IF( GTE(ch_buf_pos, TLEN(ch_buf, 1)) ){  ! buffer length
         REFILL_BUF()
     }
@@ -149,12 +149,12 @@ FUNC NEXT():INT{
     RETURN(v)
 }
 
-FUNC RANGE(INT: max):INT{
+FUNC INT: RANGE(INT: max){
     ASSERT( GT(max, 0) )
     RETURN( MOD(NEXT(), max) )
 }
 
-FUNC RANGE_MIN_MAX(INT: min, INT: max):INT{
+FUNC INT: RANGE_MIN_MAX(INT: min, INT: max){
     ASSERT( LTE(min, max) )
     INT: range = SUB(max, min)
     IF( EQ(range, 0) ){ RETURN(min) }

lib/diff.pre

@@ -5,11 +5,11 @@
 ! CONTEXT(modified: STR, source: STR):STR
 ! SIDE_BY_SIDE(modified: STR, source: STR):STR
 
-FUNC _append_line(STR: acc, STR: line):STR{
+FUNC STR: _append_line(STR: acc, STR: line){
     IF( EQ(acc, "") ){ RETURN(line) } ELSE { RETURN( JOIN(acc, "\n", line) ) }
 }
 
-FUNC UNIFIED(STR: mod, STR: src):STR{
+FUNC STR: UNIFIED(STR: mod, STR: src){
     TNS: a = SPLIT(mod, "\n")
     TNS: b = SPLIT(src, "\n")
     INT: la = TLEN(a, 1)
@@ -41,15 +41,15 @@ FUNC UNIFIED(STR: mod, STR: src):STR{
     RETURN(out)
 }
 
-FUNC CONTEXT(STR: mod, STR: src):STR{
+FUNC STR: CONTEXT(STR: mod, STR: src){
     ! For simplicity, use the same output as UNIFIED but with a ' ' prefix
     STR: u = UNIFIED(mod, src)
     IF( EQ(u, "") ){ RETURN("") }
     ! Prepend a simple header to resemble context diff
     RETURN( JOIN("*** a", "\n", u) )
 }
 
-FUNC SIDE_BY_SIDE(STR: mod, STR: src):STR{
+FUNC STR: SIDE_BY_SIDE(STR: mod, STR: src){
     TNS: a = SPLIT(mod, "\n")
     TNS: b = SPLIT(src, "\n")
     INT: la = TLEN(a, 1)

lib/gui/init.pre

@@ -16,18 +16,18 @@
 ! WINDOW_WIDTH(INT: handle):INT
 ! WINDOW_HEIGHT(INT: handle):INT
 
-FUNC SCREEN_WIDTH():INT{
+FUNC INT: SCREEN_WIDTH(){
     RETURN(gui.SCREEN()[1])
 }
 
-FUNC SCREEN_HEIGHT():INT{
+FUNC INT: SCREEN_HEIGHT(){
     RETURN(gui.SCREEN()[10])
 }
 
-FUNC WINDOW_WIDTH(INT: handle):INT{
+FUNC INT: WINDOW_WIDTH(INT: handle){
     RETURN(gui.WINDOW(handle)[1])
 }
 
-FUNC WINDOW_HEIGHT(INT: handle):INT{
+FUNC INT: WINDOW_HEIGHT(INT: handle){
     RETURN(gui.WINDOW(handle)[10])
 }

lib/image/init.pre

@@ -50,7 +50,7 @@
 
 IMPORT(path)
 
-FUNC LOAD(STR: img_path):TNS{
+FUNC TNS: LOAD(STR: img_path){
     STR: ext = path.EXTNAME(img_path)
     IF(EQ(ext, "png")){
         RETURN(image.LOAD_PNG(img_path))
@@ -63,67 +63,67 @@ FUNC LOAD(STR: img_path):TNS{
     }
 }
 
-FUNC WIDTH(TNS: img):INT{
+FUNC INT: WIDTH(TNS: img){
     RETURN(TLEN(img, 1))
 }
 
-FUNC HEIGHT(TNS: img):INT{
+FUNC INT: HEIGHT(TNS: img){
     RETURN(TLEN(img, 10))
 }
 
-FUNC CHANNELS(TNS: img):INT{
+FUNC INT: CHANNELS(TNS: img){
     RETURN(TLEN(img, 11))
 }
 
-FUNC R(TNS: img):TNS{
+FUNC TNS: R(TNS: img){
     RETURN(img[*, *, 1])
 }
 
-FUNC G(TNS: img):TNS{
+FUNC TNS: G(TNS: img){
     RETURN(img[*, *, 10])
 }
 
-FUNC B(TNS: img):TNS{
+FUNC TNS: B(TNS: img){
     RETURN(img[*, *, 11])
 }
 
-FUNC A(TNS: img):TNS{
+FUNC TNS: A(TNS: img){
     RETURN(img[*, *, 100])
 }
 
-FUNC PIXEL(TNS: img, INT: x, INT: y):TNS{
+FUNC TNS: PIXEL(TNS: img, INT: x, INT: y){
     RETURN(img[x,y,*])
 }
 
-FUNC PIXEL_R(TNS: img, INT: x, INT: y):INT{
+FUNC INT: PIXEL_R(TNS: img, INT: x, INT: y){
     RETURN(img[x,y,1])
 }
 
-FUNC PIXEL_G(TNS: img, INT: x, INT: y):INT{
+FUNC INT: PIXEL_G(TNS: img, INT: x, INT: y){
     RETURN(img[x,y,10])
 }
 
-FUNC PIXEL_B(TNS: img, INT: x, INT: y):INT{
+FUNC INT: PIXEL_B(TNS: img, INT: x, INT: y){
     RETURN(img[x,y,11])
 }
 
-FUNC PIXEL_A(TNS: img, INT: x, INT: y):INT{
+FUNC INT: PIXEL_A(TNS: img, INT: x, INT: y){
     RETURN(img[x,y,100])
 }
 
-FUNC FLIP_V(TNS: img):TNS{
+FUNC TNS: FLIP_V(TNS: img){
     RETURN(TFLIP(img, 1))
 }
 
-FUNC FLIP_H(TNS: img):TNS{
+FUNC TNS: FLIP_H(TNS: img){
     RETURN(TFLIP(img, 10))
 }
 
-FUNC INVERT(TNS: img):TNS{
+FUNC TNS: INVERT(TNS: img){
     RETURN(MSUB(TNS(SHAPE(img), 111111111), img))
 }
 
-FUNC RECT(TNS: img, INT: x, INT: y, INT: width, INT: height, TNS: color, INT: fill, INT: thickness):TNS{
+FUNC TNS: RECT(TNS: img, INT: x, INT: y, INT: width, INT: height, TNS: color, INT: fill, INT: thickness){
     TNS: pts = [ ^
         [x, y], ^
         [ADD(x, SUB(width, 1)), y], ^
@@ -134,34 +134,34 @@ FUNC RECT(TNS: img, INT: x, INT: y, INT: width, INT: height, TNS: color, INT: fi
     RETURN(image.POLYGON(img, pts, color, fill, thickness))
 }
 
-FUNC RECTANGLE(TNS: img, INT: x, INT: y, INT: width, INT: height, TNS: color, INT: fill, INT: thickness):TNS{
+FUNC TNS: RECTANGLE(TNS: img, INT: x, INT: y, INT: width, INT: height, TNS: color, INT: fill, INT: thickness){
     RETURN(RECT(img, x, y, width, height, color, fill, thickness))
 }
 
-FUNC FILL_RECT(TNS: img, INT: x, INT: y, INT: width, INT: height, TNS: color):TNS{
+FUNC TNS: FILL_RECT(TNS: img, INT: x, INT: y, INT: width, INT: height, TNS: color){
     RETURN(RECT(img, x, y, width, height, color, 1, 1))
 }
 
-FUNC FILL_ELLIPSE(TNS: img, TNS: center, INT: rx, INT: ry, TNS: color):TNS{
+FUNC TNS: FILL_ELLIPSE(TNS: img, TNS: center, INT: rx, INT: ry, TNS: color){
     RETURN(image.ELLIPSE(img, center, rx, ry, color, 1, 1))
 }
 
-FUNC SQUARE(TNS: img, INT: x, INT: y, INT: size, TNS: color, INT: fill, INT: thickness):TNS{
+FUNC TNS: SQUARE(TNS: img, INT: x, INT: y, INT: size, TNS: color, INT: fill, INT: thickness){
     RETURN(RECT(img, x, y, size, size, color, fill, thickness))
 }
 
-FUNC CIRCLE(TNS: img, TNS: center, INT: radius, TNS: color, INT: fill, INT: thickness):TNS{
+FUNC TNS: CIRCLE(TNS: img, TNS: center, INT: radius, TNS: color, INT: fill, INT: thickness){
     RETURN(image.ELLIPSE(img, center, radius, radius, color, fill, thickness))
 }
 
-FUNC CROP(TNS: img, TNS: corners):TNS{
+FUNC TNS: CROP(TNS: img, TNS: corners){
     IF(NOT(EQ(SHAPE(corners), [100, 10]))){
         THROW("CROP corners must be a 100x10 tensor: [[tl_x, tl_y], [tr_x, tr_y], [bl_x, bl_y], [br_x, br_y]]")
     }
     RETURN(img[MIN(corners[*, 1])-MAX(corners[*, 1]), MIN(corners[*, 10])-MAX(corners[*, 10]), *])
 }
 
-FUNC SHOW(TNS: img):INT{
+FUNC INT: SHOW(TNS: img){
     ! Save the image to the provided path and open it with the system default
     ! viewer on Windows. `img_path` is treated as the target file path.
     STR: img_path = "C:/Windows/Temp/tmp_img.png"

lib/numbers.pre

@@ -73,7 +73,7 @@ MAP: digits = < ^
 
 MAP: rev = INV(digits) ! reverse mapping of digits
 
-FUNC VALUE(STR: num, INT: base):INT{
+FUNC INT: VALUE(STR: num, INT: base){
     IF(GT(base, 1000000)){
         THROW("Base ", STR(base), " not supported. Max base is 0b1000000")
     }
@@ -112,7 +112,7 @@ FUNC VALUE(STR: num, INT: base):INT{
     POP(value)
 }
 
-FUNC CONVERT(STR: num, INT: from, INT: to):STR{
+FUNC STR: CONVERT(STR: num, INT: from, INT: to){
     ! Support optional fractional part (radix point) without breaking
     ! existing integer-only behavior. If `num` contains a '.', split
     ! into integer and fractional parts and convert each appropriately.

lib/path.pre

@@ -12,15 +12,15 @@
 ! STR: script
 ! STR: script_dir
 
-FUNC NORMALIZE_PATH(STR: path):STR{
+FUNC STR: NORMALIZE_PATH(STR: path){
     RETURN(REPLACE(path,"\\","/"))
 }
 
-FUNC WINPATH(STR: path):STR{
+FUNC STR: WINPATH(STR: path){
     RETURN(REPLACE(path,"/","\\"))
 }
 
-FUNC BASEPATH(STR: path):STR{ ! returns directory portion of path
+FUNC STR: BASEPATH(STR: path){ ! returns directory portion of path
     STR: npath = NORMALIZE_PATH(path)
     STR: base = BASENAME(npath)
     IF(EQ(base, "")){
@@ -30,14 +30,14 @@ FUNC BASEPATH(STR: path):STR{ ! returns directory portion of path
     POP(dir)
 }
 
-FUNC BASENAME(STR: path):STR{ ! returns filename portion of path
+FUNC STR: BASENAME(STR: path){ ! returns filename portion of path
     TNS: tpath = SPLIT(NORMALIZE_PATH(path), "/")
     STR: basename = tpath[MAX(TLEN(tpath,1),1)]
     DEL(tpath)
     POP(basename)
 }
 
-FUNC SPLITEXT(STR: path):TNS{ ! returns [name without ext, ext]
+FUNC TNS: SPLITEXT(STR: path){ ! returns [name without ext, ext]
     STR: npath = NORMALIZE_PATH(path)
     STR: base = BASENAME(npath)
     STR: dir = BASEPATH(npath)
@@ -69,15 +69,15 @@ FUNC SPLITEXT(STR: path):TNS{ ! returns [name without ext, ext]
     POP(result)
 }
 
-FUNC EXTNAME(STR: path):STR{ ! returns extension portion of path
+FUNC STR: EXTNAME(STR: path){ ! returns extension portion of path
     RETURN(SPLITEXT(path)[10])
 }
 
-FUNC DELEXT(STR: path):STR{ ! returns path without extension
+FUNC STR: DELEXT(STR: path){ ! returns path without extension
     RETURN(SPLITEXT(path)[1])
 }
 
-FUNC TEMPFILE(STR: local_path):STR{
+FUNC STR: TEMPFILE(STR: local_path){
     IF(EQ(OS(),"win")){
         STR: temp = "C:/Windows/Temp/"
     } ELSEIF(EQ(OS(),"mac")){

lib/prime.pre

@@ -7,7 +7,7 @@
 ! IS_MERSENNE_PRIME(INT: p) -> INT
 ! FACTOR(INT: n) -> TNS
 
-FUNC IS_PRIME(INT: n):INT{
+FUNC INT: IS_PRIME(INT: n){
     IF(LTE(n, 1)){
         RETURN(0)
     }
@@ -28,7 +28,7 @@ FUNC IS_PRIME(INT: n):INT{
     RETURN(1)
 }
 
-FUNC NEXT_PRIME(INT: start):INT{
+FUNC INT: NEXT_PRIME(INT: start){
     INT: n = ADD(start, 1)
     WHILE(1){
         IF(IS_PRIME(n)){
@@ -38,7 +38,7 @@ FUNC NEXT_PRIME(INT: start):INT{
     }
 }
 
-FUNC PREV_PRIME(INT: start):INT{
+FUNC INT: PREV_PRIME(INT: start){
     INT: n = SUB(start, 1)
     WHILE(GT(n, 1)){
         IF(IS_PRIME(n)){
@@ -49,7 +49,7 @@ FUNC PREV_PRIME(INT: start):INT{
     RETURN(0)
 }
 
-FUNC IS_MERSENNE_PRIME(INT: p):INT{
+FUNC INT: IS_MERSENNE_PRIME(INT: p){
     IF(IS_PRIME(p)){
         INT: exp = POW(10, p)
         INT: mersenne = SUB(exp, 1)
@@ -62,7 +62,7 @@ FUNC IS_MERSENNE_PRIME(INT: p):INT{
     }
 }
 
-FUNC FACTOR(INT: n):TNS{
+FUNC TNS: FACTOR(INT: n){
     IF(LTE(n, 1)){
         TNS: empty = [0]
         RETURN(empty)