firefly-compiler 0.4.69 → 0.4.71

package/compiler/Dependencies.ff

@@ -91,11 +91,12 @@ extend self: Dependencies {
                     dependencyLock.do(donePath.absolute()) {
                         if(!donePath.exists()) {
                             Log.trace("Fetching " + location)
-                            let response = httpClient.fetch(location, throw = False)
-                            if(!response.ok()) {
-                                panic("Could not download dependency: " + location)
+                            let buffer = httpClient.get(location, []) {response =>
+                                if(!response.ok()) {
+                                    panic("Could not download dependency: " + location)
+                                }
+                                response.readBuffer()
                             }
-                            let buffer = response.readBuffer()
                             if(dependencyPath.exists()) {
                                 dependencyPath.delete()
                             }

package/core/BrowserSystem.ff

@@ -3,7 +3,7 @@ capability BrowserSystem {}
 extend self: BrowserSystem {
 
     httpClient(): HttpClient
-        target js async "return null"
+        target js async "return typeof globalThis !== 'undefined' ? globalThis : window"
     
     mainTask(): Task
         target js async "return self_.task_"

package/core/Float.ff

@@ -27,134 +27,142 @@ extend self: Float {
         target js sync "return self_.toFixed(digits_)"
 
     min(that: Float): Float 
-        target js sync "return Math.min(self, that)"
+        target js sync "return Math.min(self_, that_)"
 
     max(that: Float): Float
-        target js sync "return Math.max(self, that)"
+        target js sync "return Math.max(self_, that_)"
 
-    clamp(from: Float, to: Float): Float {
-        if(self <= from) {from} elseIf {self >= to} {to} else {self}
+    clamp(from: Float, to: Float): Float
+        target js sync "return Math.min(Math.max(self_, from_), to_)"
+    
+    lerp(that: Float, factor: Float): Float {
+        self + factor * (that - self)
+    }
+    
+    smoothstep(that: Float, factor: Float): Float {
+        let t = ((factor - self) / (that - self)).clamp(0.0, 1.0)
+        t * t * (3.0 - 2.0 * t)
     }
     
-    expDecay(that: Float, decay: Float, delta: Duration): Float {
-        that + (self - that) * (-decay * delta.seconds).exp()
+    expDecay(that: Float, decay: Float, factor: Float): Float {
+        that + (self - that) * (-decay * factor).exp()
     }
     
     acos(): Float
         target js sync """
-            return Math.acos(self);
+            return Math.acos(self_);
         """
         
     acosh(): Float
         target js sync """
-            return Math.acosh(self);
+            return Math.acosh(self_);
         """
         
     asin(): Float
         target js sync """
-            return Math.asin(self);
+            return Math.asin(self_);
         """
         
     asinh(): Float
         target js sync """
-            return Math.asinh(self);
+            return Math.asinh(self_);
         """
         
     atan(): Float
         target js sync """
-            return Math.atan(self);
+            return Math.atan(self_);
         """
         
     atan2(that: Float): Float
         target js sync """
-            return Math.atan2(self, that);
+            return Math.atan2(self_, that_);
         """
         
     atanh(): Float
         target js sync """
-            return Math.atanh(self);
+            return Math.atanh(self_);
         """
         
     cbrt(): Float
         target js sync """
-            return Math.cbrt(self);
+            return Math.cbrt(self_);
         """
         
     cos(): Float
         target js sync """
-            return Math.cos(self);
+            return Math.cos(self_);
         """
         
     cosh(): Float
         target js sync """
-            return Math.cosh(self);
+            return Math.cosh(self_);
         """
         
     exp(): Float
         target js sync """
-            return Math.exp(self);
+            return Math.exp(self_);
         """
         
     expm1(): Float
         target js sync """
-            return Math.expm1(self);
+            return Math.expm1(self_);
         """
         
     log(that: Float): Float
         target js sync """
-            return Math.log2(self) / Math.log2(that);
+            return Math.log2(self_) / Math.log2(that_);
         """
         
     log10(): Float
         target js sync """
-            return Math.log10(self);
+            return Math.log10(self_);
         """
         
     log2(): Float
         target js sync """
-            return Math.log2(self);
+            return Math.log2(self_);
         """
         
     ln(): Float
         target js sync """
-            return Math.log(self);
+            return Math.log(self_);
         """
         
     ln1p(): Float
         target js sync """
-            return Math.log1p(self);
+            return Math.log1p(self_);
         """
         
     sin(): Float
         target js sync """
-            return Math.sin(self);
+            return Math.sin(self_);
         """
         
     sinh(): Float
         target js sync """
-            return Math.sinh(self);
+            return Math.sinh(self_);
         """
         
     sqrt(): Float
         target js sync """
-            return Math.sqrt(self);
+            return Math.sqrt(self_);
         """
         
     tan(): Float
         target js sync """
-            return Math.tan(self);
+            return Math.tan(self_);
         """
         
     tanh(): Float
         target js sync """
-            return Math.tanh(self);
+            return Math.tanh(self_);
         """
         
 }
 
 hypot(values: List[Float]): Float
     target js sync """
-        return Math.hypot(...values);
+        return Math.hypot(...values_);
     """
 
 e(): Float

package/core/HttpClient.ff

@@ -6,82 +6,145 @@ data FetchRedirect {
     RedirectError
     RedirectManual
 }
+data FetchOptions(
+    redirect: FetchRedirect = RedirectFollow
+    referrer: Option[String] = None
+    integrity: Option[String] = None
+    mode: Option[String] = None
+    credentials: Option[String] = None
+    cache: Option[String] = None
+)
 
 extend self: HttpClient {
+    
+    get[T](
+        url: String
+        headers: List[Pair[String, String]]
+        body: FetchResponse => T
+    ): T {
+        self.fetch("GET", url, headers.toMap(), None, FetchOptions(), body)
+    }
+    
+    post[T](
+        url: String
+        headers: List[Pair[String, String]]
+        payload: Buffer
+        body: FetchResponse => T
+    ): T {
+        self.fetch("POST", url, headers.toMap(), Some(payload), FetchOptions(), body)
+    }
+    
+    put[T](
+        url: String
+        headers: List[Pair[String, String]]
+        payload: Buffer
+        body: FetchResponse => T
+    ): T {
+        self.fetch("PUT", url, headers.toMap(), Some(payload), FetchOptions(), body)
+    }
+    
+    delete[T](
+        url: String
+        headers: List[Pair[String, String]]
+        body: FetchResponse => T
+    ): T {
+        self.fetch("DELETE", url, headers.toMap(), None, FetchOptions(), body)
+    }
 
-    fetch(
+    fetch[T](
+        method: String
         url: String
-        method: String = "GET"
-        headers: List[Pair[String, String]] = emptyList
-        body: Option[FetchBody] = None
-        redirect: FetchRedirect = RedirectFollow
-        // The rest of the options are only respected by browsers - see the MDN fetch() documentation
-        referrer: Option[String] = None
-        integrity: Option[String] = None
-        mode: Option[String] = None
-        credentials: Option[String] = None
-        cache: Option[String] = None
-        throw: Bool = True
-    ): FetchResponse
+        headers: Map[String, String] = Map.new()
+        payload: Option[Buffer] = None
+        options: FetchOptions = FetchOptions()
+        body: FetchResponse => T
+    ): T
         target js async """
+            const fetchResponse = {response: null, statusChecked: false};
             try {
-                const options = {headers: {}, signal: $task.controller.signal}
-                options.method = method_
-                headers_.forEach(pair => {options.headers[pair.first_] = pair.second_})
-                if(body_.value_) options.body = body_.value_
-                if(redirect_.RedirectError) options.redirect = "error"
-                else if(redirect_.RedirectManual) options.redirect = "manual"
-                if(referrer_.value_) options.referrer = referrer_.value_
-                if(integrity_.value_) options.integrity = integrity_.value_
-                if(mode_.value_) options.mode = mode_.value_
-                if(credentials_.value_) options.credentials = credentials_.value_
-                if(cache_.value_) options.cache = cache_.value_
-                let result = await fetch(url_, options)
-                if(throw_ && !result.ok) throw new Error("Unexpected HTTP status code: " + result.status)
-                return result
+                const options = {headers: {}, signal: $task.controller.signal};
+                options.method = method_;
+                headers_.forEach(pair => {options.headers[pair.first_] = pair.second_});
+                if(body_.value_) options.body = body_.value_;
+                if(redirect_.RedirectError) options.redirect = "error";
+                else if(redirect_.RedirectManual) options.redirect = "manual";
+                if(referrer_.value_) options.referrer = referrer_.value_;
+                if(integrity_.value_) options.integrity = integrity_.value_;
+                if(mode_.value_) options.mode = mode_.value_;
+                if(credentials_.value_) options.credentials = credentials_.value_;
+                if(cache_.value_) options.cache = cache_.value_;
+                fetchResponse.response = await self_.fetch(url_, options);
+                const result = await body_(fetchResponse, $task);
+                if(!statusChecked && !fetchResponse.response.ok) {
+                    throw new Error("Unexpected HTTP status code: " + fetchResponse.response.status);
+                }
+                return result;
             } finally {
+                fetchResponse.response = null;
                 if($task.controller.signal.aborted) $task.controller = new AbortController()
             }
         """
 
 }
 
-emptyList: List[Pair[String, String]] = [] // TODO: Why won't this type check when inlined? Probably some dangling unification variable?
-
-bodyText(body: String): FetchBody
-    target js sync "return body_"
-    target js async "return body_"
-
-bodyBuffer(body: Buffer): FetchBody
-    target js sync "return body_"
-    target js async "return body_"
-
 extend self: FetchResponse {
 
     ok(): Bool
-        target js async "return self_.ok"
+        target js async """
+            self_.statusChecked = true;
+            internalCheck_(self_);
+            return self_.response.ok;
+        """
 
     status(): Int
-        target js async "return self_.status"
+        target js async """
+            self_.statusChecked = true;
+            internalCheck_(self_);
+            return self_.response.status;
+        """
 
     statusText(): String
-        target js async "return self_.statusText"
+        target js async """
+            self_.statusChecked = true;
+            internalCheck_(self_);
+            return self_.response.statusText;
+        """
 
     header(name: String): Option[String]
         target js async """
-            const header = self_.headers.get(name_)
+            internalCheck_(self_);
+            const header = self_.response.headers.get(name_);
             return header != null
                 ? ff_core_Option.Some(header)
-                : ff_core_Option.None()
+                : ff_core_Option.None();
         """
 
     readText(): String
-        target js async "return await self_.text()"
+        target js async """
+            internalCheck_(self_);
+            return await self_.response.text();
+        """
 
     readJson(): Json
-        target js async "return await self_.json()"
+        target js async """
+            internalCheck_(self_);
+            return await self_.response.json();
+        """
 
     readBuffer(): Buffer
-        target js async "return new DataView(await self_.arrayBuffer())"
+        target js async """
+            internalCheck_(self_);
+            return new DataView(await self_.response.arrayBuffer());
+        """
 
 }
+
+internalCheck(fetchResponse: FetchResponse)
+    target js sync """
+        if(fetchResponse_.response === null) {
+            throw new Error("Response closed");
+        }
+        if(!fetchResponse_.statusChecked && !fetchResponse_.response.ok) {
+            throw new Error("Unchecked HTTP status code: " + fetchResponse_.response.status);
+        }
+    """

package/core/Int.ff

@@ -26,6 +26,9 @@ extend self: Int {
     bitRight(bits: Int, signed: Bool = True): Int
         target js sync "return signed_ ? self_ >> bits_ : self_ >>> bits_;"
 
+    bitLeadingZeros(): Int
+        target js sync "return Math.clz32(self_);"
+
     to(inclusiveEnd: Int): List[Int] {
         let result = Array.new()
         mutable n = self
@@ -46,17 +49,14 @@ extend self: Int {
         result.drain()
     }
 
-    min(that: Int): Int {
-        if(self < that) {self} else {that}
-    }
+    min(that: Int): Int 
+        target js sync "return Math.min(self_, that_)"
 
-    max(that: Int): Int {
-        if(self > that) {self} else {that}
-    }
+    max(that: Int): Int
+        target js sync "return Math.max(self_, that_)"
 
-    clamp(from: Int, to: Int): Int {
-        if(self <= from) {from} elseIf {self >= to} {to} else {self}
-    }
+    clamp(from: Int, to: Int): Int
+        target js sync "return Math.min(Math.max(self_, from_), to_)"
     
     pad(padding: String): String {
         ("" + self).padStart(padding.size(), padding)

package/core/NodeSystem.ff

@@ -40,7 +40,7 @@ extend self: NodeSystem {
         """
 
     httpClient(): HttpClient
-        target js async "return null"
+        target js async "return typeof globalThis !== 'undefined' ? globalThis : window"
 
     mainTask(): Task
         target js async "return self_.task_"

package/experimental/random/Scrape.ff

@@ -11,7 +11,7 @@ nodeMain(system: NodeSystem) {
     1.to(1000).each {_ => 
         system.mainTask().spawn {task =>
             let url = urlChannel.read()
-            let html = system.httpClient().fetch(url).readText()
+            let html = system.httpClient().get(url, []) {_.readText()}
             htmlChannel.write(html)
         }
     }

package/experimental/rhymeapp/Main.ff

@@ -11,12 +11,8 @@ browserMain(system: BrowserSystem): Unit {
     let handler = system.js().function1 {event =>
         let text = input.get("value").grabString()
         let serialized = Serializable.serialize(text)
-        let result = system.httpClient().fetch(
-            url = "http://localhost:8080/rhyme"
-            method = "POST"
-            body = Some(HttpClient.bodyBuffer(serialized))
-        )
-        output.set("innerText", result.readText())
+        let innerText = system.httpClient().post("http://localhost:8080/rhyme", [], serialized) {_.readText()}
+        output.set("innerText", innerText)
     }
 
     button.call2("addEventListener", "click", handler)
@@ -41,9 +37,8 @@ nodeMain(system: NodeSystem): Unit {
 
             let buffer = request.readBuffer()
             let deserialized = Serializable.deserialize(buffer)
-            let result = system.httpClient().fetch("https://api.datamuse.com/words?rel_rhy=" + deserialized)
-            let json = system.js().parseJson(result.readText())
-            let rhyme = json.get(0).get("word").grabString()
+            let json = system.httpClient().get("https://api.datamuse.com/words?rel_rhy=" + deserialized, []) {_.readJson()}
+            let rhyme = json.index(0).field("word").grabString()
             response.setHeader("Access-Control-Allow-Origin", ["*"])
             response.writeText(rhyme)
 

package/fireflysite/Main.ff

@@ -1,13 +1,15 @@
-dependency ff:httpserver:0.0.0
-import HttpServer from ff:httpserver
+dependency ff:webserver:0.0.0
+import WebServer from ff:webserver
 
 nodeMain(system: NodeSystem): Unit {
     let host = system.arguments().grab(0)
     let port = system.arguments().grab(1).grabInt()
-    HttpServer.listen(system, host, port) {request, response =>
-        let parameters = request.parameters().map {"?" + _}.else {""}
-        response.setHeader("Location", ["https://www.firefly-lang.org" + request.path() + parameters])
-        response.writeStatus(302, Some("Found"))
+    WebServer.new(system, host, port).listen {request =>
+        let parameters = if(request.readRawQueryString().size() == 0) {""} else {
+            "?" + request.readRawQueryString()
+        }
+        request.writeHeader("Location", "https://www.firefly-lang.org" + request.readPath() + parameters)
+        request.writeStatus("302 Found")
     }
 }