Read typed expressions

src/kiss/FieldForms.hx

@@ -77,10 +77,10 @@ class FieldForms {
                             for (funcArg in funcArgs)
                                 {
                                     name: switch (funcArg) {
-                                        case Symbol(name):
+                                        case Symbol(name) | TypedExp(_, Symbol(name)):
                                             name;
                                         default:
-                                            throw '$funcArg should be a symbol for a function argument';
+                                            throw '$funcArg should be a symbol or typed symbol for a function argument';
                                     },
                                     type: null
                                 }

src/kiss/Reader.hx

@@ -8,7 +8,8 @@ enum ReaderExp {
     ListExp(exps:Array<ReaderExp>); // [v1 v2 v3]
     StrExp(s:String); // "literal"
     Symbol(name:String); // s
-    RawHaxe(code:String);
+    RawHaxe(code:String); // #| haxeCode() |#
+    TypedExp(path:String, exp:ReaderExp); // :type [exp]
 }
 
 typedef ReadFunction = (Stream) -> Null<ReaderExp>;
@@ -31,12 +32,19 @@ class Reader {
             null;
         };
         readTable["#|"] = (stream) -> RawHaxe(stream.expect("closing |#", () -> stream.takeUntilAndDrop("|#")));
-        // Unquote is syntactic sugar for calling a Quote (Void->T)
+        // For defmacrofuns, unquoting with , is syntactic sugar for calling a Quote (Void->T)
         readTable[","] = (stream) -> CallExp(assertRead(stream, readTable), []);
+        // If/when proper defmacro is added, reading every Unquote directly as a CallExp won't work anymore
+
+        readTable[":"] = (stream) -> TypedExp(nextToken(stream, "a type path"), assertRead(stream, readTable));
 
         return readTable;
     }
 
+    static function nextToken(stream:Stream, expect:String) {
+        return stream.expect(expect, () -> stream.takeUntilOneOf([")", "]", "/*", "\n", " "]));
+    }
+
     public static function assertRead(stream:Stream, readTable:Map<String, ReadFunction>):ReaderExp {
         var position = stream.position();
         return switch (read(stream, readTable)) {
@@ -66,7 +74,7 @@ class Reader {
             }
         }
 
-        return Some(Symbol(stream.expect("a symbol name", () -> stream.takeUntilOneOf([")", "]", "/*", "\n", " "]))));
+        return Some(Symbol(nextToken(stream, "a symbol name")));
     }
 
     public static function readExpArray(stream:Stream, end:String, readTable:Map<String, ReadFunction>):Array<ReaderExp> {

src/test/cases/BasicTestCase.kiss

@@ -68,7 +68,7 @@
     ,intOp)
 
 // I think this causes doTwiceInt's runtime function to be typed as requiring Quote<Int> and returning Int
-(defun incrementTwice [val]
+(defun incrementTwice [:Int val]
     (doTwiceInt ++val))
 
 (defmacrofun doTwiceString [stringOp]