firefly-compiler 0.5.35 → 0.5.37

package/core/SourceLocation.ff

@@ -1,68 +1,68 @@
-newtype SourceLocation(location: String) // E.g. "directory/Module:line:column,group,package>Type>function"
-
-here(location: SourceLocation = SourceLocation.callSite()): SourceLocation {
-    location
-}
-
-callSite(): SourceLocation {
-    panic("SourceLocation.callSite() can only occur as the default value of an argument")
-}
-
-extend self: SourceLocation {
-
-    group(): String {
-        self.location.dropWhile {_ != ','}.dropFirst().takeWhile {_ != ','}
-    }
-    
-    package(): String {
-        self.location.dropWhile {_ != ','}.dropFirst().dropWhile {_ != ','}.dropFirst().takeWhile {_ != '>'}
-    }
-    
-    directory(): String {
-        self.location.takeWhile {_ != ':'}.reverse().dropWhile {_ != '/'}.dropFirst().reverse()
-    }
-
-    module(): String {
-        self.location.takeWhile {_ != ':'}.reverse().takeWhile {_ != '/'}.reverse()
-    }
-    
-    line(): Int {
-        self.location.dropWhile {_ != ':'}.dropFirst().takeWhile {_ != ':'}.grabInt()
-    }
-
-    column(): Int {
-        self.location.dropWhile {_ != ':'}.dropFirst().dropWhile {_ != ':'}.dropFirst().takeWhile {_ != ','}.grabInt()
-    }
-    
-    breadcrumbs(): List[String] {
-        self.location.dropWhile {_ != '>'}.dropFirst().split('>')
-    }
-
-}
-
-instance SourceLocation: Show {
-    show(self: SourceLocation): String {
-        self.location
-    }
-}
-
-instance SourceLocation: Equal {
-    equals(a: SourceLocation, b: SourceLocation): Bool {
-        a.location == b.location
-    }
-}
-
-instance SourceLocation: Order {
-    compare(a: SourceLocation, b: SourceLocation): Ordering {
-        Ordering.compare(a.location, b.location)
-    }
-}
-
-instance SourceLocation: Serializable {
-    serializeUsing(serialization: Serialization, self: SourceLocation) {
-        Serializable.serializeUsing(serialization, self.location)
-    }
-    deserializeUsing(serialization: Serialization): SourceLocation {
-        SourceLocation(Serializable.deserializeUsing(serialization))
-    }
-}
+newtype SourceLocation(location: String) // E.g. "directory/Module:line:column,group,package>Type>function"
+
+here(location: SourceLocation = SourceLocation.callSite()): SourceLocation {
+    location
+}
+
+callSite(): SourceLocation {
+    panic("SourceLocation.callSite() can only occur as the default value of an argument")
+}
+
+extend self: SourceLocation {
+
+    group(): String {
+        self.location.dropWhile {_ != ','}.dropFirst().takeWhile {_ != ','}
+    }
+    
+    package(): String {
+        self.location.dropWhile {_ != ','}.dropFirst().dropWhile {_ != ','}.dropFirst().takeWhile {_ != '>'}
+    }
+    
+    directory(): String {
+        self.location.takeWhile {_ != ':'}.reverse().dropWhile {_ != '/'}.dropFirst().reverse()
+    }
+
+    module(): String {
+        self.location.takeWhile {_ != ':'}.reverse().takeWhile {_ != '/'}.reverse()
+    }
+    
+    line(): Int {
+        self.location.dropWhile {_ != ':'}.dropFirst().takeWhile {_ != ':'}.grabInt()
+    }
+
+    column(): Int {
+        self.location.dropWhile {_ != ':'}.dropFirst().dropWhile {_ != ':'}.dropFirst().takeWhile {_ != ','}.grabInt()
+    }
+    
+    breadcrumbs(): List[String] {
+        self.location.dropWhile {_ != '>'}.dropFirst().split('>')
+    }
+
+}
+
+instance SourceLocation: Show {
+    show(self: SourceLocation): String {
+        self.location
+    }
+}
+
+instance SourceLocation: Equal {
+    equals(a: SourceLocation, b: SourceLocation): Bool {
+        a.location == b.location
+    }
+}
+
+instance SourceLocation: Order {
+    compare(a: SourceLocation, b: SourceLocation): Ordering {
+        Ordering.compare(a.location, b.location)
+    }
+}
+
+instance SourceLocation: Serializable {
+    serializeUsing(serialization: Serialization, self: SourceLocation) {
+        Serializable.serializeUsing(serialization, self.location)
+    }
+    deserializeUsing(serialization: Serialization): SourceLocation {
+        SourceLocation(Serializable.deserializeUsing(serialization))
+    }
+}

package/core/Stream.ff

@@ -7,7 +7,7 @@ new[T](next: () => Option[T], close: () => Unit = {}): Stream[T] {
     Stream(next, close)
 }
 
-init[T](body: () => Stream[T]): Stream[T] {
+do[T](body: () => Stream[T]): Stream[T] {
     mutable initialized = False
     mutable stream = Stream {None} {}
     Stream({

package/core/String.ff

@@ -2,163 +2,157 @@ data String {}
 
 extend self: String {
 
-    size(): Int
-        target js sync "return self_.length"
+    size(): Int {
+        self!->length?
+    }
 
-    grab(index: Int): Char
-        target js sync """
-            if(index_ < 0 || index_ >= self_.length) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            return self_.charCodeAt(index_)
-        """
-
-    replace(needle: String, replacement: String): String
-        target js sync "return self_.replaceAll(needle_, replacement_)"
-
-    replaceFirst(needle: String, replacement: String): String
-        target js sync "return self_.replace(needle_, replacement_)"
-
-    reverse(): String
-        target js sync "return [...self_].reverse().join('')"
-
-    repeat(count: Int): String
-        target js sync "return self_.repeat(count_)"
-
-    trim(): String
-        target js sync "return self_.trim()"
-
-    trimStart(): String
-        target js sync "return self_.trimStart()"
-
-    trimEnd(): String
-        target js sync "return self_.trimEnd()"
-
-    lower(): String
-        target js sync "return self_.toLowerCase()"
-
-    upper(): String
-        target js sync "return self_.toUpperCase()"
-
-    dropWhile(p: Char => Bool): String
-        target js sync """
-            let i = 0
-            for(; i < self_.length && p_(self_.codePointAt(i)); i++);
-            return self_.slice(i)
-        """
-        target js async """
-            let i = 0
-            for(; i < self_.length && await p_(self_.codePointAt(i), $task); i++);
-            return self_.slice(i)
-        """
-
-    takeWhile(p: Char => Bool): String
-        target js sync """
-            let i = 0
-            for(; i < self_.length && p_(self_.codePointAt(i)); i++);
-            return self_.slice(0, i)
-        """
-        target js async """
-            let i = 0
-            for(; i < self_.length && await p_(self_.codePointAt(i), $task); i++);
-            return self_.slice(0, i)
-        """
-
-    slice(from: Int, until: Int): String
-        target js sync "return self_.slice(from_, until_)"
-
-    split(char: Char): List[String]
-        target js sync "return self_.split(String.fromCharCode(char_))"
-
-    splitFirst(char: Char): Option[Pair[String, String]]
-        target js sync """
-            const array = self_.split(String.fromCharCode(char_), 2)
-            return array.length === 2
-                ? ff_core_Option.Some(ff_core_Pair.Pair(array[0], array[1]))
-                : ff_core_Option.None()
-        """
-
-    lines(): List[String]
-        target js sync """
-            return self_.split(
-                new RegExp("[" + String.fromCharCode(13) + "]?[" + String.fromCharCode(10) + "]", "g")
-            )
-        """
-
-    dropFirst(count: Int = 1): String
-        target js sync "return self_.slice(count_)"
-
-    dropLast(count: Int = 1): String
-        target js sync "return self_.slice(0, self_.length - count_)"
-
-    getInt(): Option[Int]
-        target js sync """
-            if(self_.length == 0) {
-                return ff_core_Option.None()
-            }
-            for(let i = 0; i < self_.length; i++) {
-                const c = self_.codePointAt(i)
-                if(c < 48 || c > 57) return ff_core_Option.None()
-            }
-            return ff_core_Option.Some(parseInt(self_, 10));
-        """
-        
-    getFloat(): Float
-        target js sync """
-            const result = parseFloat(self_, 10);
-            if(!isFinite(result)) {
-                return ff_core_Option.None()
-            }
-            return ff_core_Option.Some(result);
-        """        
+    grab(index: Int): Char {
+        if(index < 0 || index >= self.size()) {
+            throw(GrabException())
+        }
+        self!->charCodeAt(index)?
+    }
+    
+    replace(needle: String, replacement: String): String {
+        self!->replaceAll(needle, replacement)?
+    }
 
-    grabInt(): Int
-        target js sync """
-            if(self_.length == 0) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            for(let i = 0; i < self_.length; i++) {
-                const c = self_.codePointAt(i)
-                if(c < 48 || c > 57) ff_core_Try.internalThrowGrabException_()
-            }
-            return parseInt(self_, 10);
-        """
+    replaceFirst(needle: String, replacement: String): String {
+        self!->replace(needle, replacement)?
+    }
+
+    reverse(): String {
+        self!->split("")->reverse()->join("")?
+    }
+
+    repeat(count: Int): String {
+        self!->repeat(count)?
+    }
+
+    trim(): String {
+        self!->trim()?
+    }
+
+    trimStart(): String {
+        self!->trimStart()?
+    }
+
+    trimEnd(): String {
+        self!->trimEnd()?
+    }
+
+    lower(): String {
+        self!->toLowerCase()?
+    }
+
+    upper(): String {
+        self!->toUpperCase()?
+    }
+
+    dropWhile(p: Char => Bool): String {
+        mutable i = 0
+        while {i < self.size() && p(self!->charCodeAt(i)?)} {
+            i += 1
+        }
+        self!->slice(i)?
+    }
+
+    takeWhile(p: Char => Bool): String {
+        mutable i = 0
+        while {i < self.size() && p(self!->charCodeAt(i)?)} {
+            i += 1
+        }
+        self!->slice(0, i)?
+    }
+
+    slice(from: Int, until: Int): String {
+        self!->slice(from, until)?
+    }
+
+    split(char: Char): List[String] {
+        self!->split(Js->String->fromCharCode(char))?
+    }
+    
+    splitFirst(char: Char): Option[Pair[String, String]] {
+        let array: List[String] = self!->split(Js->String->fromCharCode(char), 2)?
+        if(array.size() == 2) {
+            Pair(array!.get(0)?, array!.get(1)?)
+        }
+    }    
+
+    lines(): List[String] {
+        self!->split(
+            Js->RegExp->("[" + Js->String->fromCharCode(13)? + "]?[" + Js->String->fromCharCode(10)? + "]", "g")
+        )?
+    }
+
+    dropFirst(count: Int = 1): String {
+        self!->slice(count)?
+    }
+
+    dropLast(count: Int = 1): String {
+        self!->slice(0, self.size() - count)?
+    }
+    
+    getInt(): Option[Int] {
+        if(self.size() > 0 && self.all {c => 48 <= c.codeUnit && c.codeUnit <= 57}) {
+            Js->parseInt(self!, 10)?
+        }
+    }
+            
+    getFloat(): Option[Float] {
+        // TODO return None for invalid input
+        let result = Js->parseFloat(self!, 10)
+        if(Js->isFinite(result)?) {result?}
+    }
+
+    grabInt(): Int {
+        self.getInt().else {
+            throw(GrabException())
+        }
+    }
         
-    grabFloat(): Float
-        target js sync """
-            const result = parseFloat(self_, 10);
-            if(!isFinite(result)) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            return result;
-        """    
+    grabFloat(): Float {
+        self.getFloat().else {
+            throw(GrabException())
+        }
+    }
 
-    first(): Option[Char]
-        target js sync """
-            return self_.length > 0
-                ? ff_core_Option.Some(self_.charCodeAt(0))
-                : ff_core_Option.None()
-        """
+    first(): Option[Char] {
+        if(self.size() > 0) {
+            Char(self!->charCodeAt(0)?)
+        }
+    }
 
-    last(): Option[Char]
-        target js sync """
-            return self_.length > 0
-                ? ff_core_Option.Some(self_.charCodeAt(self_.length - 1))
-                : ff_core_Option.None()
-        """
+    last(): Option[Char] {
+        if(self.size() > 0) {
+            Char(self!->charCodeAt(self.size() - 1)?)
+        }
+    }
 
-    grabFirst(): Char {self.first().else {Try.internalThrowGrabException()}}
+    grabFirst(): Char {
+        self.first().else {
+            throw(GrabException())
+        }
+    }
 
-    grabLast(): Char {self.last().else {Try.internalThrowGrabException()}}
+    grabLast(): Char {
+        self.last().else {
+            throw(GrabException())
+        }
+    }
 
-    contains(substring: String): Bool
-        target js sync "return self_.includes(substring_)"
+    contains(substring: String): Bool {
+        self!->includes(substring)?
+    }
 
-    startsWith(prefix: String, offset: Int = 0): Bool
-        target js sync "return self_.startsWith(prefix_, offset_)"
+    startsWith(prefix: String, offset: Int = 0): Bool {
+        self!->startsWith(prefix, offset)?
+    }
 
-    endsWith(prefix: String): Bool
-        target js sync "return self_.endsWith(prefix_)"
+    endsWith(prefix: String): Bool {
+        self!->endsWith(prefix)?
+    }
 
     removeFirst(prefix: String): Option[String] {
         if(self.startsWith(prefix)) {Some(self.dropFirst(prefix.size()))} else {None}
@@ -168,64 +162,92 @@ extend self: String {
         if(self.endsWith(suffix)) {Some(self.dropLast(suffix.size()))} else {None}
     }
     
-    padStart(length: Int, padding: String = " "): String
-        target js sync """
-            return self_.padStart(length_, padding_);
-        """
-
-    padEnd(length: Int, padding: String = " "): String
-        target js sync """
-            return self_.padEnd(length_, padding_);
-        """
-
-    any(body: Char => Bool): Bool
-        target js sync """
-            for(let i = 0; i < self_.length; i++) {
-                if(body_(self_.charCodeAt(i))) return true;
-            }
-            return false;
-        """
-        target js async """
-            for(let i = 0; i < self_.length; i++) {
-                if(await body_(self_.charCodeAt(i), $task)) return true;
-            }
-            return false;
-        """
+    padStart(length: Int, padding: String = " "): String {
+        self!->padStart(length, padding)?
+    }
 
-    all(body: Char => Bool): Bool
-        target js sync """
-            for(let i = 0; i < self_.length; i++) {
-                if(!body_(self_.charCodeAt(i))) return false;
-            }
-            return true;
-        """
-        target js async """
-            for(let i = 0; i < self_.length; i++) {
-                if(!await body_(self_.charCodeAt(i), $task)) return false;
-            }
-            return true;
-        """
-
-    filter(body: Char => Bool): String
-        target js sync """
-            const result = [];
-            for(let i = 0; i < self_.length; i++) {
-                if(body_(self_.charCodeAt(i))) result.push(self_.charAt(i));
+    padEnd(length: Int, padding: String = " "): String {
+        self!->padEnd(length, padding)?
+    }
+    
+    each(body: Char => Unit): Unit {
+        mutable i = 0
+        while {i < self.size()} {
+            body(Char(self!->charCodeAt(i)?))
+            i += 1
+        }
+    }
+
+    eachWhile(body: Char => Bool): Unit {
+        mutable i = 0
+        while {i < self.size()} {
+            if(body(Char(self!->charCodeAt(i)?))) {
+                i += 1
+            } else {
+                i = self.size()
             }
-            return result.join("");
-        """
-        target js async """
-            const result = [];
-            for(let i = 0; i < self_.length; i++) {
-                if(await body_(self_.charCodeAt(i))) result.push(self_.charAt(i));
+        }
+    }    
+    
+    all(body: Char => Bool): Bool {
+        mutable result = True
+        self.eachWhile {x =>
+            result = body(x)
+            result
+        }
+        result
+    }
+
+    any(body: Char => Bool): Bool {
+        mutable result = False
+        self.eachWhile {x =>
+            result = body(x)
+            (!result)
+        }
+        result
+    }
+    
+    find(body: Char => Bool): Option[Char] {
+        mutable result = None
+        self.eachWhile {x =>
+            if(body(x)) {
+                result = Some(x)
+                False
+            } else {
+                True
             }
-            return result.join("");
-        """
+        }
+        result
+    }
 
-    toBuffer(): Buffer
-        target js sync """
-            const encoded = new TextEncoder().encode(self_)
-            return new DataView(encoded.buffer, encoded.byteOffset, encoded.byteLength)
-        """
+    indexOf(needle: String, position: Int = 0): Option[Int] {
+        let index = self!->indexOf(needle, position)?
+        if(index != -1) {index}
+    }
+    
+    indexWhere(body: Char => Bool): Option[Int] {
+        mutable i = -1
+        mutable result = False
+        self.eachWhile {x =>
+            i += 1
+            result = body(x)
+            (!result)
+        }
+        if(result) {i}
+    }    
+    
+    filter(body: Char => Bool): String {
+        let result = Array.new()
+        self.each {x =>
+            if(body(x)) {
+                result.push(x.toString())
+            }
+        }
+        result.join()
+    }    
 
+    toBuffer(): Buffer {
+        let encoded = Js->TextEncoder->()->encode(self)
+        Js->DataView->(encoded->buffer, encoded->byteOffset, encoded->byteLength)?
+    }
 }