firefly-compiler 0.4.88 → 0.4.90

package/compiler/Parser.ff

@@ -1184,7 +1184,40 @@ extend self: Parser {
     }
     
     parseDynamicMember(record: Term): Term {
-        self.skip(LArrowThin)
+        let token = self.skip(LArrowThin)
+        if(self.current().rawIs("(")) {
+            let arguments = self.parseFunctionArguments(token.at(), trailing = False)
+            let effect = self.freshUnificationVariable(record.at)
+            arguments.first.indexWhere {!_.name.isEmpty()}.{
+                | None =>
+                    let target = DynamicCall(EField(token.at(), False, record, "new" + arguments.first.size()), False)
+                    ECall(record.at, target, effect, [], arguments.first, [])
+                | Some(0) => 
+                    let objectTarget = DynamicCall(EField(token.at(), False, record, "object"), False)
+                    mutable result = ECall(record.at, objectTarget, effect, [], [], [])
+                    arguments.first.each {argument =>
+                        if(argument.name.isEmpty()) {
+                            throw(CompileError(argument.at, "Expected a named argument"))
+                        }
+                        let target = DynamicCall(EField(token.at(), False, record, "with"), False)
+                        result = ECall(record.at, target, effect, [], [
+                            Argument(argument.at, None, EString(argument.at, argument.name.grab()))
+                            argument
+                        ], [])
+                    }
+                    result
+                | Some(i) => 
+                    throw(CompileError(arguments.first.grab(i).at, "Unexpected named argument"))
+            }
+        } elseIf {self.current().rawIs("{")} {
+            let lambda = self.parseLambda()
+            let effect = self.freshUnificationVariable(record.at)
+            let arguments = lambda.cases.grabFirst().patterns.size()
+            let target = DynamicCall(EField(token.at(), False, record, "function" + arguments), False)
+            ECall(record.at, target, effect, [], [
+                Argument(lambda.at, None, ELambda(lambda.at, lambda))
+            ], [])
+        } else:
         let token = if(self.current().is(LLower)) {
             self.skip(LLower)
         } elseIf {self.current().is(LUpper)} {
@@ -1195,6 +1228,9 @@ extend self: Parser {
         let member = EString(token.at(), if(token.is(LString)) {token.raw()} else {"\"" + token.raw() + "\""})
         if(self.current().rawIs("(")) {
             let arguments = self.parseFunctionArguments(record.at, False)
+            arguments.first.find {!_.name.isEmpty()}.each {argument =>
+                throw(CompileError(argument.at, "Unexpected named argument"))
+            }
             let effect = self.freshUnificationVariable(record.at)
             let target = DynamicCall(EField(token.at(), False, record, "call" + arguments.first.size()), False)
             ECall(record.at, target, effect, [], [

package/compression/Compression.ff

@@ -4,24 +4,29 @@ capability Compression {}
 
 extend self: Compression {
 
-    compressBrotli(uncompressed: Buffer, level: Int = 4): Buffer
+    compressBrotli(uncompressed: Buffer, level: Int = 4): Buffer {
+        internalCompress("brotli", level, uncompressed)
+    }
 
-    decompressBrotli(compressed: Buffer): Buffer
+    decompressBrotli(compressed: Buffer): Buffer {
+        
+    }
 
-    compressGzip(uncompressed: Buffer, level: Int = 6): Buffer
+    compressGzip(uncompressed: Buffer, level: Int = 6): Buffer {
+        internalCompress("gzip", level, uncompressed)
+    }
 
-    decompressGzip(compressed: Buffer): Buffer
-        target js async """
-            async function DecompressBlob(blob) {
-                const ds = new DecompressionStream("gzip");
-                const decompressedStream = blob.stream().pipeThrough(ds);
-                return await new Response(decompressedStream).blob();
-            }
-        """
+    decompressGzip(compressed: Buffer): Buffer {
+        
+    }
 
-    compressDeflate(uncompressed: Buffer, level: Int = 6): Buffer
+    compressDeflate(uncompressed: Buffer, level: Int = 6): Buffer {
+        internalCompress("deflate", level, uncompressed)
+    }
 
-    decompressDeflate(compressed: Buffer): Buffer
+    decompressDeflate(compressed: Buffer): Buffer {
+        
+    }
 
 }
 
@@ -34,17 +39,17 @@ newForNodeSystem(nodeSystem: NodeSystem): Compression
 internalCompress(algorithm: String, level: Int, buffer: Buffer): Buffer {
     let js = UnsafeJs.jsSystem()
     let dataView = UnsafeJs.toJsValue(buffer)
-    let uint8Array = js->"Uint8Array".new3(dataView->buffer, dataView->byteOffset, dataView->byteLength)
-    let stream = js->"ReadableStream".new1(js.object().with("start", 
-        js.function1 {controller =>
+    let uint8Array = js->Uint8Array->(dataView->buffer, dataView->byteOffset, dataView->byteLength)
+    let stream = js->ReadableStream->(js->(
+        start = js->{controller =>
             controller->enqueue(uint8Array)
             controller->close()
         }
     ))
-    let ds = js->"DecompressionStream".new1(algorithm)
+    let ds = js->DecompressionStream->(algorithm)
     let decompressedStream = stream->pipeThrough(ds)
-    let response = UnsafeJs.await {js->"Response".new1(decompressedStream)}
+    let response = UnsafeJs.await {js->Response->(decompressedStream)}
     let decompressedData = UnsafeJs.await {response->arrayBuffer()}
-    js->"DataView".new1(decompressedData).grabBuffer()
+    js->DataView->(decompressedData).grabBuffer()
 }
 

package/output/js/ff/compiler/Parser.mjs

@@ -1539,7 +1539,42 @@ return result_
 }
 
 export function Parser_parseDynamicMember(self_, record_) {
-ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LArrowThin());
+const token_ = ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LArrowThin());
+if(ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "(")) {
+const arguments_ = ff_compiler_Parser.Parser_parseFunctionArguments(self_, ff_compiler_Token.Token_at(token_), false);
+const effect_ = ff_compiler_Parser.Parser_freshUnificationVariable(self_, record_.at_);
+{
+const _1 = ff_core_List.List_indexWhere(arguments_.first_, ((_w1) => {
+return (!ff_core_Option.Option_isEmpty(_w1.name_))
+}));
+if(_1.None) {
+const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, ("new" + ff_core_List.List_size(arguments_.first_))), false);
+return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], arguments_.first_, [])
+}
+if(_1.Some && _1.value_ === 0) {
+const objectTarget_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, "object"), false);
+let result_ = ff_compiler_Syntax.ECall(record_.at_, objectTarget_, effect_, [], [], []);
+ff_core_List.List_each(arguments_.first_, ((argument_) => {
+if(ff_core_Option.Option_isEmpty(argument_.name_)) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(argument_.at_, "Expected a named argument"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+};
+const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, "with"), false);
+result_ = ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(argument_.at_, ff_core_Option.None(), ff_compiler_Syntax.EString(argument_.at_, ff_core_Option.Option_grab(argument_.name_))), argument_], [])
+}));
+return result_
+}
+if(_1.Some) {
+const i_ = _1.value_;
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(ff_core_List.List_grab(arguments_.first_, i_).at_, "Unexpected named argument"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+}
+}
+} else if(ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "{")) {
+const lambda_ = ff_compiler_Parser.Parser_parseLambda(self_, 0, false, false);
+const effect_ = ff_compiler_Parser.Parser_freshUnificationVariable(self_, record_.at_);
+const arguments_ = ff_core_List.List_size(ff_core_List.List_grabFirst(lambda_.cases_).patterns_);
+const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, ("function" + arguments_)), false);
+return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(lambda_.at_, ff_core_Option.None(), ff_compiler_Syntax.ELambda(lambda_.at_, lambda_))], [])
+} else {
 const token_ = (ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LLower())
 ? ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LLower())
 : ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LUpper())
@@ -1550,6 +1585,11 @@ const member_ = ff_compiler_Syntax.EString(ff_compiler_Token.Token_at(token_), (
 : (("\"" + ff_compiler_Token.Token_raw(token_)) + "\"")));
 if(ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "(")) {
 const arguments_ = ff_compiler_Parser.Parser_parseFunctionArguments(self_, record_.at_, false);
+ff_core_Option.Option_each(ff_core_List.List_find(arguments_.first_, ((_w1) => {
+return (!ff_core_Option.Option_isEmpty(_w1.name_))
+})), ((argument_) => {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(argument_.at_, "Unexpected named argument"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+}));
 const effect_ = ff_compiler_Parser.Parser_freshUnificationVariable(self_, record_.at_);
 const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, ("call" + ff_core_List.List_size(arguments_.first_))), false);
 return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(member_.at_, ff_core_Option.None(), member_), ...arguments_.first_], [])
@@ -1578,6 +1618,7 @@ const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_comp
 return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(member_.at_, ff_core_Option.None(), member_)], [])
 }
 }
+}
 
 export function Parser_parseAtom(self_) {
 if(ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LString())) {
@@ -3108,7 +3149,42 @@ return result_
 }
 
 export async function Parser_parseDynamicMember$(self_, record_, $task) {
-ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LArrowThin());
+const token_ = ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LArrowThin());
+if(ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "(")) {
+const arguments_ = ff_compiler_Parser.Parser_parseFunctionArguments(self_, ff_compiler_Token.Token_at(token_), false);
+const effect_ = ff_compiler_Parser.Parser_freshUnificationVariable(self_, record_.at_);
+{
+const _1 = ff_core_List.List_indexWhere(arguments_.first_, ((_w1) => {
+return (!ff_core_Option.Option_isEmpty(_w1.name_))
+}));
+if(_1.None) {
+const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, ("new" + ff_core_List.List_size(arguments_.first_))), false);
+return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], arguments_.first_, [])
+}
+if(_1.Some && _1.value_ === 0) {
+const objectTarget_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, "object"), false);
+let result_ = ff_compiler_Syntax.ECall(record_.at_, objectTarget_, effect_, [], [], []);
+ff_core_List.List_each(arguments_.first_, ((argument_) => {
+if(ff_core_Option.Option_isEmpty(argument_.name_)) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(argument_.at_, "Expected a named argument"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+};
+const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, "with"), false);
+result_ = ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(argument_.at_, ff_core_Option.None(), ff_compiler_Syntax.EString(argument_.at_, ff_core_Option.Option_grab(argument_.name_))), argument_], [])
+}));
+return result_
+}
+if(_1.Some) {
+const i_ = _1.value_;
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(ff_core_List.List_grab(arguments_.first_, i_).at_, "Unexpected named argument"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+}
+}
+} else if(ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "{")) {
+const lambda_ = ff_compiler_Parser.Parser_parseLambda(self_, 0, false, false);
+const effect_ = ff_compiler_Parser.Parser_freshUnificationVariable(self_, record_.at_);
+const arguments_ = ff_core_List.List_size(ff_core_List.List_grabFirst(lambda_.cases_).patterns_);
+const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, ("function" + arguments_)), false);
+return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(lambda_.at_, ff_core_Option.None(), ff_compiler_Syntax.ELambda(lambda_.at_, lambda_))], [])
+} else {
 const token_ = (ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LLower())
 ? ff_compiler_Parser.Parser_skip(self_, ff_compiler_Token.LLower())
 : ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LUpper())
@@ -3119,6 +3195,11 @@ const member_ = ff_compiler_Syntax.EString(ff_compiler_Token.Token_at(token_), (
 : (("\"" + ff_compiler_Token.Token_raw(token_)) + "\"")));
 if(ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "(")) {
 const arguments_ = ff_compiler_Parser.Parser_parseFunctionArguments(self_, record_.at_, false);
+ff_core_Option.Option_each(ff_core_List.List_find(arguments_.first_, ((_w1) => {
+return (!ff_core_Option.Option_isEmpty(_w1.name_))
+})), ((argument_) => {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(argument_.at_, "Unexpected named argument"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+}));
 const effect_ = ff_compiler_Parser.Parser_freshUnificationVariable(self_, record_.at_);
 const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, ("call" + ff_core_List.List_size(arguments_.first_))), false);
 return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(member_.at_, ff_core_Option.None(), member_), ...arguments_.first_], [])
@@ -3147,6 +3228,7 @@ const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_comp
 return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(member_.at_, ff_core_Option.None(), member_)], [])
 }
 }
+}
 
 export async function Parser_parseAtom$(self_, $task) {
 if(ff_compiler_Token.Token_is(ff_compiler_Parser.Parser_current(self_), ff_compiler_Token.LString())) {

package/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly compiler",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.4.88",
+    "version": "0.4.90",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"

package/vscode/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly language support",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.4.88",
+    "version": "0.4.90",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"