firefly-compiler 0.5.35 → 0.5.37

package/core/HttpClient.ff

@@ -1,148 +1,142 @@
-capability HttpClient {}
-capability FetchBody {}
-capability FetchResponse {}
-data FetchRedirect {
-    RedirectFollow
-    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, None, FetchOptions(), body)
-    }
-    
-    post[T](
-        url: String
-        headers: List[Pair[String, String]]
-        payload: Buffer
-        body: FetchResponse => T
-    ): T {
-        self.fetch("POST", url, headers, Some(payload), FetchOptions(), body)
-    }
-    
-    put[T](
-        url: String
-        headers: List[Pair[String, String]]
-        payload: Buffer
-        body: FetchResponse => T
-    ): T {
-        self.fetch("PUT", url, headers, Some(payload), FetchOptions(), body)
-    }
-    
-    delete[T](
-        url: String
-        headers: List[Pair[String, String]]
-        body: FetchResponse => T
-    ): T {
-        self.fetch("DELETE", url, headers, None, FetchOptions(), body)
-    }
-
-    fetch[T](
-        method: String
-        url: String
-        headers: List[Pair[String, String]] = []
-        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(payload_.value_) options.body = payload_.value_;
-                if(options_.redirect_.RedirectError) options.redirect = "error";
-                else if(options_.redirect_.RedirectManual) options.redirect = "manual";
-                if(options_.referrer_.value_) options.referrer = options_.referrer_.value_;
-                if(options_.integrity_.value_) options.integrity = options_.integrity_.value_;
-                if(options_.mode_.value_) options.mode = options_.mode_.value_;
-                if(options_.credentials_.value_) options.credentials = options_.credentials_.value_;
-                if(options_.cache_.value_) options.cache = options_.cache_.value_;
-                fetchResponse.response = await self_.fetch(url_, options);
-                const result = await body_(fetchResponse, $task);
-                internalCheck_(fetchResponse);
-                return result;
-            } finally {
-                fetchResponse.response = null;
-                if($task.controller.signal.aborted) $task.controller = new AbortController()
-            }
-        """
-
-}
-
-extend self: FetchResponse {
-
-    ok(): Bool
-        target js async """
-            self_.statusChecked = true;
-            internalCheck_(self_);
-            return self_.response.ok;
-        """
-
-    status(): Int
-        target js async """
-            self_.statusChecked = true;
-            internalCheck_(self_);
-            return self_.response.status;
-        """
-
-    statusText(): String
-        target js async """
-            self_.statusChecked = true;
-            internalCheck_(self_);
-            return self_.response.statusText;
-        """
-
-    header(name: String): Option[String]
-        target js async """
-            internalCheck_(self_);
-            const header = self_.response.headers.get(name_);
-            return header != null
-                ? ff_core_Option.Some(header)
-                : ff_core_Option.None();
-        """
-
-    readText(): String
-        target js async """
-            internalCheck_(self_);
-            return await self_.response.text();
-        """
-
-    readJson(): Json
-        target js async """
-            internalCheck_(self_);
-            return await self_.response.json();
-        """
-
-    readBuffer(): Buffer
-        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);
-        }
-    """
+capability HttpClient {}
+capability FetchBody {}
+capability FetchResponse {}
+data FetchRedirect {
+    RedirectFollow
+    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, None, FetchOptions(), body)
+    }
+    
+    post[T](
+        url: String
+        headers: List[Pair[String, String]]
+        payload: Buffer
+        body: FetchResponse => T
+    ): T {
+        self.fetch("POST", url, headers, Some(payload), FetchOptions(), body)
+    }
+    
+    put[T](
+        url: String
+        headers: List[Pair[String, String]]
+        payload: Buffer
+        body: FetchResponse => T
+    ): T {
+        self.fetch("PUT", url, headers, Some(payload), FetchOptions(), body)
+    }
+    
+    delete[T](
+        url: String
+        headers: List[Pair[String, String]]
+        body: FetchResponse => T
+    ): T {
+        self.fetch("DELETE", url, headers, None, FetchOptions(), body)
+    }
+
+    fetch[T](
+        method: String
+        url: String
+        headers: List[Pair[String, String]] = []
+        payload: Option[Buffer] = None
+        options: FetchOptions = FetchOptions()
+        body: FetchResponse => T
+    ): T {
+        let fetchResponse = Js->(response = Js.null(), statusChecked = False)
+        Js.withSignal {signal =>
+            try {
+                let fetchOptions = Js->(headers = Js->(), signal = signal, method = method)
+                headers.each {| Pair(k, v) =>
+                    fetchOptions->headers.set(k, v)
+                }
+                payload.each {v => fetchOptions->body = v}
+                options.redirect.{
+                    | RedirectError => fetchOptions->redirect = "error"
+                    | RedirectFollow => 
+                    | RedirectManual => fetchOptions->redirect = "manual"
+                }
+                options.referrer.each {v => fetchOptions->referrer = v}
+                options.integrity.each {v => fetchOptions->integrity = v}
+                options.mode.each {v => fetchOptions->mode = v}
+                options.credentials.each {v => fetchOptions->credentials = v}
+                options.cache.each {v => fetchOptions->cache = v}
+                fetchResponse->response = Js.await(self!->fetch(url, fetchOptions))
+                let result = Js.await(body(fetchResponse?)!)
+                internalCheck(fetchResponse?)
+                result?
+            } finally {
+                fetchResponse->response = Js.null()
+            }
+        }
+    }
+
+}
+
+extend self: FetchResponse {
+
+    ok(): Bool {
+        self!->statusChecked = True
+        internalCheck(self)
+        self!->response->ok?
+    }
+
+    status(): Int {
+        self!->statusChecked = True
+        internalCheck(self)
+        self!->response->status?
+    }
+
+    statusText(): String {
+        self!->statusChecked = True
+        internalCheck(self)
+        self!->response->statusText?
+    }
+
+    header(name: String): Option[String] {
+        internalCheck(self)
+        let header = self!->response->headers->get(name)
+        if(!header.isNullOrUndefined()) {header?}
+    }
+
+    readText(): String {
+        internalCheck(self)
+        Js.await(self!->response->text())?
+    }
+
+    readJson(): Json {
+        internalCheck(self)
+        Js.await(self!->response->json())?
+    }
+
+    readBuffer(): Buffer {
+        internalCheck(self)
+        Js->DataView->(Js.await(self!->response->arrayBuffer()))?
+    }
+
+}
+
+internalCheck(fetchResponse: FetchResponse) {
+    if(fetchResponse!->response.isNull()) {
+        Js.throw(Js->Error->("Response closed"))
+    }
+    if(!fetchResponse!->statusChecked? && !fetchResponse!->response->ok?) {
+        Js.throw(Js->Error->("Unchecked HTTP status code: " + fetchResponse!->response->status?))
+    }
+}

package/core/Instant.ff

@@ -13,14 +13,12 @@ extend self: Instant {
         Instant(Duration(self.since1970.seconds + duration.seconds))
     }
     
-    toIso(): String
-        target js sync """
-            return new Date(self_ * 1000).toISOString();
-        """
+    toIso(): String {
+        Js->Date->(self.since1970.seconds * 1000.0)->toISOString()?
+    }
 
 }
 
-internalParseDate(date: String): Instant
-    target js sync """
-        return Date.parse(date_) * 0.001;
-    """
+internalParseDate(date: String): Instant {
+    Instant(Duration(Js->Date->parse(date)? * 0.001))
+}

package/core/Int.ff

@@ -2,32 +2,45 @@ data Int {}
 
 extend self: Int {
 
-    abs(): Int
-        target js sync "return Math.abs(self_)"
+    abs(): Int {
+        Js->Math->abs(self)?
+    }
 
-    toFloat(): Float
-        target js sync "return self_"
+    toFloat(): Float {
+        self!?
+    }
 
-    bitNot(): Int
-        target js sync "return ~self_;"
+    bitNot(): Int {
+        Js.unaryOperator("~", self)?
+    }
 
-    bitOr(that: Int): Int
-        target js sync "return self_ | that_;"
+    bitOr(that: Int): Int {
+        Js.binaryOperator("|", self, that)?
+    }
 
-    bitAnd(that: Int): Int
-        target js sync "return self_ & that_;"
+    bitAnd(that: Int): Int {
+        Js.binaryOperator("&", self, that)?
+    }
 
-    bitXor(that: Int): Int
-        target js sync "return self_ ^ that_;"
+    bitXor(that: Int): Int {
+        Js.binaryOperator("^", self, that)?
+    }
 
-    bitLeft(bits: Int): Int
-        target js sync "return self_ << bits_;"
+    bitLeft(bits: Int): Int {
+        Js.binaryOperator("<<", self, bits)?
+    }
 
-    bitRight(bits: Int, signed: Bool = True): Int
-        target js sync "return signed_ ? self_ >> bits_ : self_ >>> bits_;"
+    bitRight(bits: Int): Int {
+        Js.binaryOperator(">>", self, bits)?
+    }
 
-    bitLeadingZeros(): Int
-        target js sync "return Math.clz32(self_);"
+    bitRightUnsigned(bits: Int): Int {
+        Js.binaryOperator(">>>", self, bits)?
+    }
+    
+    bitLeadingZeros(): Int {
+        Js->Math->clz32(self)?
+    }
 
     to(inclusiveEnd: Int): List[Int] {
         let result = Array.new()
@@ -49,14 +62,17 @@ extend self: Int {
         result.drain()
     }
 
-    min(that: Int): Int 
-        target js sync "return Math.min(self_, that_)"
+    min(that: Int): Int {
+        Js->Math->min(self, that)?
+    }
 
-    max(that: Int): Int
-        target js sync "return Math.max(self_, that_)"
+    max(that: Int): Int {
+        Js->Math->max(self, that)?
+    }
 
-    clamp(from: Int, to: Int): Int
-        target js sync "return Math.min(Math.max(self_, from_), to_)"
+    clamp(from: Int, to: Int): Int {
+        self.max(from).min(to)
+    }
     
     pad(padding: String): String {
         ("" + self).padStart(padding.size(), padding)

package/core/IntMap.ff

@@ -1,45 +1,66 @@
 class IntMap[V] {}
 
-new[V](): IntMap[V]
-    target js sync "return new Map()"
-
+new[V](): IntMap[V] {
+    Js->Map->()?
+}
+    
 extend self[V]: IntMap[V] {
 
-    get(key: Int): Option[V]
-        target js sync "return self_.has(key_) ? ff_core_Option.Some(self_.get(key_)) : ff_core_Option.None()"
-
-    grab(key: Int): V
-        target js sync """
-            const result = self_.get(key_)
-            if(key_ === void 0 && !self_.has(key_)) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            return result
-        """
-
-    set(key: Int, value: V): Unit
-        target js sync "self_.set(key_, value_)"
-
-    has(key: Int): Bool
-        target js sync "return self_.has(key_)"
+    get(key: Int): Option[V] {
+        let result = self!->get(key)
+        if(!result.isUndefined() || self!->has(key)?) {result?}
+    }
 
-    remove(key: Int): Bool
-        target js sync "return self_.delete(key_)"
+    grab(key: Int): V {
+        let result = self!->get(key)
+        if(result.isUndefined() && !self.has(key)) {throw(GrabException())}
+        result?
+    }
+        
+    set(key: Int, value: V): Unit {
+        self!->set(key, value!)
+    }
 
-    clear(): Unit
-        target js sync "self_.clear()"
+    has(key: Int): Bool {
+        self!->has(key)?
+    }
 
-    size(): Int
-        target js sync "return self_.size"
+    remove(key: Int): Bool {
+        self!->delete(key)?
+    }
 
-    each(body: (Int, V) => Unit): Bool
-        target js sync "return self_.forEach((v, k) => body_(k, v))"
-        target js async "for(const [k, v] of self_) await body_(k, v)"
+    clear(): Unit {
+        self!->clear()
+    }
 
-    eachWhile(body: (Int, V) => Bool): Bool
-        target js sync "for(const [k, v] of self_) if(!body_(k, v)) break"
-        target js async "for(const [k, v] of self_) if(!await body_(k, v)) break"
+    size(): Int {
+        self!->size?
+    }
+    
+    isEmpty(): Bool {
+        self.size() == 0
+    }
 
+    each(body: (Int, V) => Unit): Unit {
+        if(Js.inAsync()) {
+            let iterator = self!->entries()
+            mutable result = iterator->next()
+            while {!result->done?} {
+                let value = result->value
+                body(value.get(0)?, value.get(1)?)
+                result = iterator->next()
+            }
+        } else {
+            self!->forEach(Js->{v, k => body(k?, v?)})
+        }
+    }
+    
+    eachWhile(body: (Int, V) => Bool): Unit {
+        self!.eachWhile {value =>
+            body(value.get(0)?, value.get(1)?)
+        }
+    }
+            
     toArray(): Array[Pair[Int, V]] {
         let array = Array.new()
         self.each {k, v => array.push(Pair(k, v))}
@@ -51,7 +72,7 @@ extend self[V]: IntMap[V] {
     }
 
     toStream(): Stream[Pair[Int, V]] {
-        self.toArray().toStream()
+        self.toList().toStream()
     }
 
     toMap(): Map[Int, V] {
@@ -61,23 +82,24 @@ extend self[V]: IntMap[V] {
     keys(): List[Int] {
         let array = Array.new()
         self.each {k, v => array.push(k)}
-        array.toList()
+        array.drain()
     }
 
     values(): List[V] {
         let array = Array.new()
         self.each {k, v => array.push(v)}
-        array.toList()
+        array.drain()
+    }
+
+    copy(): IntMap[V] {
+        Js->Map->(self!)?
     }
 
-    copy(): IntMap[V]
-        target js sync "return new Map(self_)"
-        
     getOrSet(key: Int, body: () => V): V {
         if(!self.has(key)) {self.set(key, body())}
         self.grab(key)
     }
-        
+            
 }
 
 extend self[V]: IntMap[Array[V]] {