firefly-compiler 0.4.66 → 0.4.67

package/compiler/Inference.ff

@@ -914,9 +914,25 @@ extend self: Inference {
                         self.unification.unify(e.at, expected, TConstructor(e.at, core("Bool"), []))
                         e.ECall(target = target, arguments = [a1.Argument(value = e1), a2.Argument(value = e2)])
                     | [a1, a2] {
-                        operator == "+" || operator == "-" ||
-                        operator == "*" || operator == "/" || operator == "%" ||
-                        operator == "^"
+                        operator == "/" || operator == "%"
+                    } =>
+                        let t1 = self.unification.freshUnificationVariable(e.at)
+                        let t2 = self.unification.freshUnificationVariable(e.at)
+                        let e1 = self.inferTerm(environment, t1, a1.value)
+                        let e2 = self.inferTerm(environment, t2, a2.value)
+                        let magic: Type => Unit = {t =>
+                            self.unification.substitute(t).{
+                                | TConstructor(_, name, []) {name == core("Float")} =>
+                                | TConstructor(_, name, []) {name == core("Int")} =>
+                                | _ => self.unification.unify(e.at, t, TConstructor(e.at, core("Float"), []))
+                            }
+                        }
+                        magic(t1)
+                        magic(t2)
+                        self.unification.unify(e.at, expected, TConstructor(e.at, core("Float"), []))
+                        e.ECall(target = target, arguments = [a1.Argument(value = e1), a2.Argument(value = e2)])
+                    | [a1, a2] {
+                        operator == "+" || operator == "-" || operator == "*" || operator == "^"
                     } =>
                         let t1 = self.unification.freshUnificationVariable(e.at)
                         let t2 = self.unification.freshUnificationVariable(e.at)

package/core/Array.ff

@@ -235,7 +235,7 @@ instance Array[T: Show]: Show {
 sortRange[T](array: Array[T], compare: (T, T) => Ordering, start: Int, end: Int): Unit {
     if(end - start < 2) {} else:
 
-    mutable middle = start + ((end - start) / 2)
+    mutable middle = start + (end - start).div(2)
     sortRange(array, compare, start, middle)
     sortRange(array, compare, middle, end)
 

package/core/Float.ff

@@ -3,7 +3,7 @@ data Float {}
 extend self: Float {
 
     toInt(): Int
-        target js sync "return Math.trunc(Math.abs(self_))"
+        target js sync "return Math.trunc(self_) || 0"
 
     round(): Float
         target js sync "return Math.round(self_)"
@@ -26,16 +26,169 @@ extend self: Float {
     toFixed(digits: Int): String
         target js sync "return self_.toFixed(digits_)"
 
-    min(that: Float): Float {
-        if(self < that) {self} else {that}
-    }
+    min(that: Float): Float 
+        target js sync "return Math.min(self, that)"
 
-    max(that: Float): Float {
-        if(self > that) {self} else {that}
-    }
+    max(that: Float): Float
+        target js sync "return Math.max(self, that)"
 
     clamp(from: Float, to: Float): Float {
         if(self <= from) {from} elseIf {self >= to} {to} else {self}
     }
-
+    
+    acos()
+        target js sync """
+            return Math.acos(self);
+        """
+        
+    acosh()
+        target js sync """
+            return Math.acosh(self);
+        """
+        
+    asin()
+        target js sync """
+            return Math.asin(self);
+        """
+        
+    asinh()
+        target js sync """
+            return Math.asinh(self);
+        """
+        
+    atan()
+        target js sync """
+            return Math.atan(self);
+        """
+        
+    atan2(that: Float)
+        target js sync """
+            return Math.atan2(self, that);
+        """
+        
+    atanh()
+        target js sync """
+            return Math.atanh(self);
+        """
+        
+    cbrt()
+        target js sync """
+            return Math.cbrt(self);
+        """
+        
+    cos()
+        target js sync """
+            return Math.cos(self);
+        """
+        
+    cosh()
+        target js sync """
+            return Math.cosh(self);
+        """
+        
+    exp()
+        target js sync """
+            return Math.exp(self);
+        """
+        
+    expm1()
+        target js sync """
+            return Math.expm1(self);
+        """
+        
+    log(that: Float)
+        target js sync """
+            return Math.log2(self) / Math.log2(that);
+        """
+        
+    log10()
+        target js sync """
+            return Math.log10(self);
+        """
+        
+    log2()
+        target js sync """
+            return Math.log2(self);
+        """
+        
+    ln()
+        target js sync """
+            return Math.log(self);
+        """
+        
+    ln1p()
+        target js sync """
+            return Math.log1p(self);
+        """
+        
+    sin()
+        target js sync """
+            return Math.sin(self);
+        """
+        
+    sinh()
+        target js sync """
+            return Math.sinh(self);
+        """
+        
+    sqrt()
+        target js sync """
+            return Math.sqrt(self);
+        """
+        
+    tan()
+        target js sync """
+            return Math.tan(self);
+        """
+        
+    tanh()
+        target js sync """
+            return Math.tanh(self);
+        """
+        
 }
+
+hypot(values: List[Float]): Float
+    target js sync """
+        return Math.hypot(...values);
+    """
+
+e(): Float
+    target js sync """
+        return Math.E;
+    """
+
+ln10(): Float
+    target js sync """
+        return Math.LN10;
+    """
+
+ln2(): Float
+    target js sync """
+        return Math.LN2;
+    """
+
+log10e(): Float
+    target js sync """
+        return Math.LOG10E;
+    """
+
+log2e(): Float
+    target js sync """
+        return Math.LOG2E;
+    """
+
+pi(): Float
+    target js sync """
+        return Math.PI;
+    """
+
+sqrtHalf(): Float
+    target js sync """
+        return Math.SQRT1_2;
+    """
+
+sqrt2(): Float
+    target js sync """
+        return Math.SQRT2;
+    """

package/core/Int.ff

@@ -61,5 +61,13 @@ extend self: Int {
     pad(padding: String): String {
         ("" + self).padStart(padding.size(), padding)
     }
+    
+    div(divisor: Int): Int {
+        (self / divisor).toInt()
+    }
+
+    rem(divisor: Int): Int {
+        (self % divisor).toInt()
+    }
 
 }

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

@@ -1650,7 +1650,56 @@ return
 if(_1.length === 2) {
 const a1_ = _1[0];
 const a2_ = _1[1];
-if(((((((operator_ === "+") || (operator_ === "-")) || (operator_ === "*")) || (operator_ === "/")) || (operator_ === "%")) || (operator_ === "^"))) {
+if(((operator_ === "/") || (operator_ === "%"))) {
+const t1_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, e_.at_);
+const t2_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, e_.at_);
+const e1_ = ff_compiler_Inference.Inference_inferTerm(self_, environment_, t1_, a1_.value_);
+const e2_ = ff_compiler_Inference.Inference_inferTerm(self_, environment_, t2_, a2_.value_);
+const magic_ = ((t_) => {
+{
+const _1 = ff_compiler_Unification.Unification_substitute(self_.unification_, t_);
+if(_1.TConstructor && _1.generics_.length === 0) {
+const name_ = _1.name_;
+if((name_ === ff_compiler_Inference.core_("Float"))) {
+
+return
+}
+}
+if(_1.TConstructor && _1.generics_.length === 0) {
+const name_ = _1.name_;
+if((name_ === ff_compiler_Inference.core_("Int"))) {
+
+return
+}
+}
+{
+ff_compiler_Unification.Unification_unify(self_.unification_, e_.at_, t_, ff_compiler_Syntax.TConstructor(e_.at_, ff_compiler_Inference.core_("Float"), []))
+return
+}
+}
+});
+magic_(t1_);
+magic_(t2_);
+ff_compiler_Unification.Unification_unify(self_.unification_, e_.at_, expected_, ff_compiler_Syntax.TConstructor(e_.at_, ff_compiler_Inference.core_("Float"), []));
+{
+const _1 = e_;
+{
+const _c = _1;
+return ff_compiler_Syntax.ECall(_c.at_, target_, _c.effect_, _c.typeArguments_, [(((_c) => {
+return ff_compiler_Syntax.Argument(_c.at_, _c.name_, e1_)
+}))(a1_), (((_c) => {
+return ff_compiler_Syntax.Argument(_c.at_, _c.name_, e2_)
+}))(a2_)], _c.dictionaries_)
+return
+}
+}
+return
+}
+}
+if(_1.length === 2) {
+const a1_ = _1[0];
+const a2_ = _1[1];
+if(((((operator_ === "+") || (operator_ === "-")) || (operator_ === "*")) || (operator_ === "^"))) {
 const t1_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, e_.at_);
 const t2_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, e_.at_);
 const e1_ = ff_compiler_Inference.Inference_inferTerm(self_, environment_, t1_, a1_.value_);
@@ -3448,7 +3497,56 @@ return
 if(_1.length === 2) {
 const a1_ = _1[0];
 const a2_ = _1[1];
-if(((((((operator_ === "+") || (operator_ === "-")) || (operator_ === "*")) || (operator_ === "/")) || (operator_ === "%")) || (operator_ === "^"))) {
+if(((operator_ === "/") || (operator_ === "%"))) {
+const t1_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, e_.at_);
+const t2_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, e_.at_);
+const e1_ = ff_compiler_Inference.Inference_inferTerm(self_, environment_, t1_, a1_.value_);
+const e2_ = ff_compiler_Inference.Inference_inferTerm(self_, environment_, t2_, a2_.value_);
+const magic_ = ((t_) => {
+{
+const _1 = ff_compiler_Unification.Unification_substitute(self_.unification_, t_);
+if(_1.TConstructor && _1.generics_.length === 0) {
+const name_ = _1.name_;
+if((name_ === ff_compiler_Inference.core_("Float"))) {
+
+return
+}
+}
+if(_1.TConstructor && _1.generics_.length === 0) {
+const name_ = _1.name_;
+if((name_ === ff_compiler_Inference.core_("Int"))) {
+
+return
+}
+}
+{
+ff_compiler_Unification.Unification_unify(self_.unification_, e_.at_, t_, ff_compiler_Syntax.TConstructor(e_.at_, ff_compiler_Inference.core_("Float"), []))
+return
+}
+}
+});
+magic_(t1_);
+magic_(t2_);
+ff_compiler_Unification.Unification_unify(self_.unification_, e_.at_, expected_, ff_compiler_Syntax.TConstructor(e_.at_, ff_compiler_Inference.core_("Float"), []));
+{
+const _1 = e_;
+{
+const _c = _1;
+return ff_compiler_Syntax.ECall(_c.at_, target_, _c.effect_, _c.typeArguments_, [(((_c) => {
+return ff_compiler_Syntax.Argument(_c.at_, _c.name_, e1_)
+}))(a1_), (((_c) => {
+return ff_compiler_Syntax.Argument(_c.at_, _c.name_, e2_)
+}))(a2_)], _c.dictionaries_)
+return
+}
+}
+return
+}
+}
+if(_1.length === 2) {
+const a1_ = _1[0];
+const a2_ = _1[1];
+if(((((operator_ === "+") || (operator_ === "-")) || (operator_ === "*")) || (operator_ === "^"))) {
 const t1_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, e_.at_);
 const t2_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, e_.at_);
 const e1_ = ff_compiler_Inference.Inference_inferTerm(self_, environment_, t1_, a1_.value_);

package/output/js/ff/core/Array.mjs

@@ -121,7 +121,7 @@ export function sortRange_(array_, compare_, start_, end_) {
 if(((end_ - start_) < 2)) {
 
 } else {
-let middle_ = (start_ + ((end_ - start_) / 2));
+let middle_ = (start_ + ff_core_Int.Int_div((end_ - start_), 2));
 ff_core_Array.sortRange_(array_, compare_, start_, middle_);
 ff_core_Array.sortRange_(array_, compare_, middle_, end_);
 let i_ = start_;
@@ -171,7 +171,7 @@ export async function sortRange_$(array_, compare_, start_, end_, $task) {
 if(((end_ - start_) < 2)) {
 
 } else {
-let middle_ = (start_ + ((end_ - start_) / 2));
+let middle_ = (start_ + ff_core_Int.Int_div((end_ - start_), 2));
 (await ff_core_Array.sortRange_$(array_, compare_, start_, middle_, $task));
 (await ff_core_Array.sortRange_$(array_, compare_, middle_, end_, $task));
 let i_ = start_;

package/output/js/ff/core/Float.mjs

@@ -95,12 +95,98 @@ import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
 
 
+export function hypot_(values_) {
+
+        return Math.hypot(...values);
+    
+}
 
+export function e_() {
+
+        return Math.E;
+    
+}
 
+export function ln10_() {
+
+        return Math.LN10;
+    
+}
 
+export function ln2_() {
+
+        return Math.LN2;
+    
+}
+
+export function log10e_() {
+
+        return Math.LOG10E;
+    
+}
+
+export function log2e_() {
+
+        return Math.LOG2E;
+    
+}
+
+export function pi_() {
+
+        return Math.PI;
+    
+}
+
+export function sqrtHalf_() {
+
+        return Math.SQRT1_2;
+    
+}
+
+export function sqrt2_() {
+
+        return Math.SQRT2;
+    
+}
+
+export async function hypot_$(values_, $task) {
+throw new Error('Function hypot is missing on this target in async context.');
+}
+
+export async function e_$($task) {
+throw new Error('Function e is missing on this target in async context.');
+}
+
+export async function ln10_$($task) {
+throw new Error('Function ln10 is missing on this target in async context.');
+}
+
+export async function ln2_$($task) {
+throw new Error('Function ln2 is missing on this target in async context.');
+}
+
+export async function log10e_$($task) {
+throw new Error('Function log10e is missing on this target in async context.');
+}
+
+export async function log2e_$($task) {
+throw new Error('Function log2e is missing on this target in async context.');
+}
+
+export async function pi_$($task) {
+throw new Error('Function pi is missing on this target in async context.');
+}
+
+export async function sqrtHalf_$($task) {
+throw new Error('Function sqrtHalf is missing on this target in async context.');
+}
+
+export async function sqrt2_$($task) {
+throw new Error('Function sqrt2 is missing on this target in async context.');
+}
 
 export function Float_toInt(self_) {
-return Math.trunc(Math.abs(self_))
+return Math.trunc(self_) || 0
 }
 
 export function Float_round(self_) {
@@ -132,19 +218,11 @@ return self_.toFixed(digits_)
 }
 
 export function Float_min(self_, that_) {
-if((self_ < that_)) {
-return self_
-} else {
-return that_
-}
+return Math.min(self, that)
 }
 
 export function Float_max(self_, that_) {
-if((self_ > that_)) {
-return self_
-} else {
-return that_
-}
+return Math.max(self, that)
 }
 
 export function Float_clamp(self_, from_, to_) {
@@ -157,6 +235,138 @@ return self_
 }
 }
 
+export function Float_acos(self_) {
+
+            return Math.acos(self);
+        
+}
+
+export function Float_acosh(self_) {
+
+            return Math.acosh(self);
+        
+}
+
+export function Float_asin(self_) {
+
+            return Math.asin(self);
+        
+}
+
+export function Float_asinh(self_) {
+
+            return Math.asinh(self);
+        
+}
+
+export function Float_atan(self_) {
+
+            return Math.atan(self);
+        
+}
+
+export function Float_atan2(self_, that_) {
+
+            return Math.atan2(self, that);
+        
+}
+
+export function Float_atanh(self_) {
+
+            return Math.atanh(self);
+        
+}
+
+export function Float_cbrt(self_) {
+
+            return Math.cbrt(self);
+        
+}
+
+export function Float_cos(self_) {
+
+            return Math.cos(self);
+        
+}
+
+export function Float_cosh(self_) {
+
+            return Math.cosh(self);
+        
+}
+
+export function Float_exp(self_) {
+
+            return Math.exp(self);
+        
+}
+
+export function Float_expm1(self_) {
+
+            return Math.expm1(self);
+        
+}
+
+export function Float_log(self_, that_) {
+
+            return Math.log2(self) / Math.log2(that);
+        
+}
+
+export function Float_log10(self_) {
+
+            return Math.log10(self);
+        
+}
+
+export function Float_log2(self_) {
+
+            return Math.log2(self);
+        
+}
+
+export function Float_ln(self_) {
+
+            return Math.log(self);
+        
+}
+
+export function Float_ln1p(self_) {
+
+            return Math.log1p(self);
+        
+}
+
+export function Float_sin(self_) {
+
+            return Math.sin(self);
+        
+}
+
+export function Float_sinh(self_) {
+
+            return Math.sinh(self);
+        
+}
+
+export function Float_sqrt(self_) {
+
+            return Math.sqrt(self);
+        
+}
+
+export function Float_tan(self_) {
+
+            return Math.tan(self);
+        
+}
+
+export function Float_tanh(self_) {
+
+            return Math.tanh(self);
+        
+}
+
 export async function Float_toInt$(self_, $task) {
 throw new Error('Function Float_toInt is missing on this target in async context.');
 }
@@ -190,19 +400,11 @@ throw new Error('Function Float_toFixed is missing on this target in async conte
 }
 
 export async function Float_min$(self_, that_, $task) {
-if((self_ < that_)) {
-return self_
-} else {
-return that_
-}
+throw new Error('Function Float_min is missing on this target in async context.');
 }
 
 export async function Float_max$(self_, that_, $task) {
-if((self_ > that_)) {
-return self_
-} else {
-return that_
-}
+throw new Error('Function Float_max is missing on this target in async context.');
 }
 
 export async function Float_clamp$(self_, from_, to_, $task) {
@@ -215,6 +417,94 @@ return self_
 }
 }
 
+export async function Float_acos$(self_, $task) {
+throw new Error('Function Float_acos is missing on this target in async context.');
+}
+
+export async function Float_acosh$(self_, $task) {
+throw new Error('Function Float_acosh is missing on this target in async context.');
+}
+
+export async function Float_asin$(self_, $task) {
+throw new Error('Function Float_asin is missing on this target in async context.');
+}
+
+export async function Float_asinh$(self_, $task) {
+throw new Error('Function Float_asinh is missing on this target in async context.');
+}
+
+export async function Float_atan$(self_, $task) {
+throw new Error('Function Float_atan is missing on this target in async context.');
+}
+
+export async function Float_atan2$(self_, that_, $task) {
+throw new Error('Function Float_atan2 is missing on this target in async context.');
+}
+
+export async function Float_atanh$(self_, $task) {
+throw new Error('Function Float_atanh is missing on this target in async context.');
+}
+
+export async function Float_cbrt$(self_, $task) {
+throw new Error('Function Float_cbrt is missing on this target in async context.');
+}
+
+export async function Float_cos$(self_, $task) {
+throw new Error('Function Float_cos is missing on this target in async context.');
+}
+
+export async function Float_cosh$(self_, $task) {
+throw new Error('Function Float_cosh is missing on this target in async context.');
+}
+
+export async function Float_exp$(self_, $task) {
+throw new Error('Function Float_exp is missing on this target in async context.');
+}
+
+export async function Float_expm1$(self_, $task) {
+throw new Error('Function Float_expm1 is missing on this target in async context.');
+}
+
+export async function Float_log$(self_, that_, $task) {
+throw new Error('Function Float_log is missing on this target in async context.');
+}
+
+export async function Float_log10$(self_, $task) {
+throw new Error('Function Float_log10 is missing on this target in async context.');
+}
+
+export async function Float_log2$(self_, $task) {
+throw new Error('Function Float_log2 is missing on this target in async context.');
+}
+
+export async function Float_ln$(self_, $task) {
+throw new Error('Function Float_ln is missing on this target in async context.');
+}
+
+export async function Float_ln1p$(self_, $task) {
+throw new Error('Function Float_ln1p is missing on this target in async context.');
+}
+
+export async function Float_sin$(self_, $task) {
+throw new Error('Function Float_sin is missing on this target in async context.');
+}
+
+export async function Float_sinh$(self_, $task) {
+throw new Error('Function Float_sinh is missing on this target in async context.');
+}
+
+export async function Float_sqrt$(self_, $task) {
+throw new Error('Function Float_sqrt is missing on this target in async context.');
+}
+
+export async function Float_tan$(self_, $task) {
+throw new Error('Function Float_tan is missing on this target in async context.');
+}
+
+export async function Float_tanh$(self_, $task) {
+throw new Error('Function Float_tanh is missing on this target in async context.');
+}
+
 export const ff_core_Any_HasAnyTag$ff_core_Float_Float = {
 anyTag_() {
 return ff_core_Any.internalAnyTag_((("ff:core/Float.Float" + "[") + "]"))

package/output/js/ff/core/Int.mjs

@@ -181,6 +181,14 @@ export function Int_pad(self_, padding_) {
 return ff_core_String.String_padStart(("" + self_), ff_core_String.String_size(padding_), padding_)
 }
 
+export function Int_div(self_, divisor_) {
+return ff_core_Float.Float_toInt((self_ / divisor_))
+}
+
+export function Int_rem(self_, divisor_) {
+return ff_core_Float.Float_toInt((self_ % divisor_))
+}
+
 export async function Int_abs$(self_, $task) {
 throw new Error('Function Int_abs is missing on this target in async context.');
 }
@@ -263,6 +271,14 @@ export async function Int_pad$(self_, padding_, $task) {
 return ff_core_String.String_padStart(("" + self_), ff_core_String.String_size(padding_), padding_)
 }
 
+export async function Int_div$(self_, divisor_, $task) {
+return ff_core_Float.Float_toInt((self_ / divisor_))
+}
+
+export async function Int_rem$(self_, divisor_, $task) {
+return ff_core_Float.Float_toInt((self_ % divisor_))
+}
+
 export const ff_core_Any_HasAnyTag$ff_core_Int_Int = {
 anyTag_() {
 return ff_core_Any.internalAnyTag_((("ff:core/Int.Int" + "[") + "]"))

package/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly compiler",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.4.66",
+    "version": "0.4.67",
     "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.66",
+    "version": "0.4.67",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"