firefly-compiler 0.4.18 → 0.4.19

package/core/IntMap.ff

@@ -40,18 +40,14 @@ extend self[V]: IntMap[V] {
         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"
 
-    toStack(): Stack[Pair[Int, V]] {
-        let stack = Stack.make()
-        self.each {k, v => stack.push(Pair(k, v))}
-        stack
-    }
-
     toArray(): Array[Pair[Int, V]] {
-        self.toStack().drain()
+        let array = Array.make()
+        self.each {k, v => array.push(Pair(k, v))}
+        array
     }
 
     toList(): List[Pair[Int, V]] {
-        self.toArray().toList()
+        self.toArray().drain()
     }
 
     toStream(): Stream[Pair[Int, V]] {
@@ -59,19 +55,19 @@ extend self[V]: IntMap[V] {
     }
 
     toMap(): Map[Int, V] {
-        self.toArray().toMap()
+        self.toList().toMap()
     }
 
     keys(): List[Int] {
-        let stack = Stack.make()
-        self.each {k, v => stack.push(k)}
-        stack.toList()
+        let array = Array.make()
+        self.each {k, v => array.push(k)}
+        array.toList()
     }
 
     values(): List[V] {
-        let stack = Stack.make()
-        self.each {k, v => stack.push(v)}
-        stack.toList()
+        let array = Array.make()
+        self.each {k, v => array.push(v)}
+        array.toList()
     }
 
     copy(): IntMap[V]
@@ -84,12 +80,12 @@ extend self[V]: IntMap[V] {
         
 }
 
-extend self[V]: IntMap[Stack[V]] {
+extend self[V]: IntMap[Array[V]] {
 
     push(key: Int, value: V) {
         self.get(key).{
-            | None => self.set(key, [value].toStack())
-            | Some(stack) => stack.push(value)
+            | None => self.set(key, [value].toArray())
+            | Some(array) => array.push(value)
         }
     }
 

package/core/JsSystem.ff

@@ -21,7 +21,7 @@ extend self: JsSystem {
         target js sync "return {}"
 
     array(values: List[JsValue]): JsValue
-        target js sync "return ff_core_List.List_toArray(values_)"
+        target js sync "return values_.slice()"
         
     json(value: Json): JsValue
         target js sync "return value_"

package/core/JsValue.ff

@@ -17,7 +17,7 @@ extend self: JsValue {
     grabBool(): Bool
         target js sync "return self_"
 
-    grabArray(): Array[JsValue]
+    grabArray(): List[JsValue]
         target js sync "return self_"
 
     grabBuffer(): Buffer
@@ -112,7 +112,7 @@ extend self: JsValue {
 
 
     call(name: String, arguments: List[JsValue]): JsValue
-        target js sync "return self_[name_].apply(this_, ff_core_List.List_toArray(arguments_))"
+        target js sync "return self_[name_].apply(this_, arguments_)"
 
     call0(name: String): JsValue
         target js sync "return self_[name_].call(self_)"
@@ -146,7 +146,7 @@ extend self: JsValue {
 
 
     callValue(this: JsValue, arguments: List[JsValue]): JsValue
-        target js sync "return self_.apply(this_, ff_core_List.List_toArray(arguments_))"
+        target js sync "return self_.apply(this_, arguments_)"
 
     callValue0(): JsValue
         target js sync "return self_.call(self_)"
@@ -180,7 +180,7 @@ extend self: JsValue {
 
 
     new(this: JsValue, arguments: List[JsValue]): JsValue
-        target js sync "return new (Function.prototype.bind.apply(self_, ff_core_List.List_toArray(arguments_)))"
+        target js sync "return new (Function.prototype.bind.apply(self_, arguments_))"
 
     new0(): JsValue
         target js sync "return new self_()"
@@ -216,12 +216,7 @@ extend self: JsValue {
     grabPairs(): List[Pair[String, JsValue]]
         target js sync """
             if(!(self_ instanceof Object)) throw new Error('Expected object, got '+ typeof self_);;
-            let result = ff_core_List.Empty();
-            Object.getOwnPropertyNames(self_).forEach((name, i) => {
-                let pair = ff_core_Pair.Pair(name, self_[name]);
-                result = ff_core_List.Link(pair, result);
-            })
-            return result;
+            return Object.getOwnPropertyNames(self_).map((name, i) => ff_core_Pair.Pair(name, self_[name]));
         """
 
     grabMap(): Map[String, JsValue] {
@@ -240,7 +235,6 @@ extend self: JsValue {
             return self_
         """
 
-    //toArray(): Array[JsValue] // TODO
     //toList(): List[JsValue] // TODO
     // TODO: JS operators
 
@@ -253,7 +247,7 @@ instance Char: IsJsValue {}
 instance Int: IsJsValue {}
 instance Float: IsJsValue {}
 instance Bool: IsJsValue {}
-instance Array[T: IsJsValue]: IsJsValue {}
+instance List[T: IsJsValue]: IsJsValue {}
 instance IntMap[T: IsJsValue]: IsJsValue {}
 instance StringMap[T: IsJsValue]: IsJsValue {}
 instance Error: IsJsValue {}

package/core/Json.ff

@@ -34,15 +34,11 @@ null(): Json
         return null;
     """
 
-array(json: Array[Json]): Json
+array(json: List[Json]): Json
     target js sync """
         return json_;
     """
 
-list(json: List[Json]): Json {
-    array(json.toArray())
-}
-
 object(): Json
     target js sync """
         return {};
@@ -107,7 +103,7 @@ extend self: Json {
             throw new Error('Not a bool: ' + JSON.stringify(self_));
         """
 
-    grabArray(): Array[Json]
+    grabArray(): List[Json]
         target js sync """
             if(!Array.isArray(self_)) throw new Error('Not an array: ' + JSON.stringify(self_));
             return self_;
@@ -137,7 +133,7 @@ extend self: Json {
         if(self.isBool()) {self.grabBool()}
     }
 
-    getArray(): Option[Array[Json]] {
+    getArray(): Option[List[Json]] {
         if(self.isArray()) {self.grabArray()}
     }
 
@@ -207,7 +203,7 @@ extend self: Json {
             return typeof self_ === 'array' ? ff_core_Option.Some(self_[key_] ?? null) : ff_core_Option.None();
         """
         
-    getFields(): Option[Array[String]]
+    getFields(): Option[List[String]]
         target js sync """
             return typeof self_ === 'object' && self_ !== null && !Array.isArray(self_)
                 ? ff_core_Option.Some(Object.keys(self_)) : ff_core_Option.None();
@@ -225,22 +221,22 @@ extend self: Json {
         }
     }
     
-    grabFields(): Array[String] {
+    grabFields(): List[String] {
         self.getFields().else {
             throw(GrabException())
         }
     }
 
-    map[T](body: (String, Json) => T): Array[T] {
-        let stack = Stack.make()
-        self.each {field, value => stack.push(body(field, value))}
-        stack.drain()
+    map[T](body: (String, Json) => T): List[T] {
+        let array = Array.make()
+        self.each {field, value => array.push(body(field, value))}
+        array.drain()
     }
 
-    flatMap[T](body: (String, Json) => Array[T]): Array[T] {
-        let stack = Stack.make()
-        self.each {field, value => stack.pushArray(body(field, value))}
-        stack.drain()
+    flatMap[T](body: (String, Json) => List[T]): List[T] {
+        let array = Array.make()
+        self.each {field, value => array.pushList(body(field, value))}
+        array.drain()
     }
     
     each(body: (String, Json) => Unit) {
@@ -301,29 +297,24 @@ instance Bool: JsonLike {
     fromJson(json: Json): Option[Bool] {_.getBool()}
 }
 
-instance Array[T: JsonLike]: JsonLike {
-    toJson(value: Array[T]): Json {array(value.map(toJson))}
-    fromJson(json: Json): Option[Array[T]] {
+instance List[T: JsonLike]: JsonLike {
+    toJson(value: List[T]): Json {array(value.map(toJson))}
+    fromJson(json: Json): Option[List[T]] {
         json.getArray().flatMap {array => 
             mutable convertible = True
-            let stack = Stack.make()
+            let result = Array.make()
             array.eachWhile {item =>
                 fromJson(item).{
                     | None => convertible = False
-                    | Some(value) => stack.push(value)
+                    | Some(value) => result.push(value)
                 }
                 convertible
             }
-            if(convertible) {stack.drain()}
+            if(convertible) {result.drain()}
         }
     }
 }
 
-instance List[T: JsonLike]: JsonLike {
-    toJson(value: List[T]): Json {list(value.map(toJson))}
-    fromJson(json: Json): Option[List[T]] {fromJson[Array[T]](json).map {_.toList()}}
-}
-
 instance StringMap[T: JsonLike]: JsonLike {
     toJson(value: StringMap[T]): Json {
         Json.fields {setField =>