functionalscript 0.1.608 → 0.1.609

package/nanvm-lib/tests/test.f.mjs

@@ -0,0 +1,79 @@
+/** @type {(a: unknown) => (b: unknown) => void} */
+const e = a => b => {
+    if (a === b) { } else { throw [a, '===', b] }
+}
+
+/** @type {(a: unknown) => (b: unknown) => void} */
+const n = a => b => {
+    if (a !== b) { } else { throw [a, '!==', b] }
+}
+
+export default {
+    eq: {
+        nullish: () => {
+            e(null)(null)
+            e(undefined)(undefined)
+            n(null)(undefined)
+        },
+        boolean: {
+            boolean: () => {
+                e(true)(true)
+                e(false)(false)
+                n(true)(false)
+            },
+            nullish: () => {
+                n(false)(undefined)
+            }
+        },
+        number: {
+            number: () => {
+                e(2.3)(2.3)
+                n(2.3)(-5.4)
+                n(NaN)(NaN)
+                e(0)(-0)
+                if (!Object.is(-0, -0)) { throw -0 }
+                if (Object.is(0, -0)) { throw -0 }
+                e(Infinity)(Infinity)
+                e(-Infinity)(-Infinity)
+                n(Infinity)(-Infinity)
+            },
+            nullish: () => {
+                n(undefined)(NaN)
+                n(undefined)(0)
+            }
+        },
+        string: {
+            string: () => {
+                e("hello")("hello")
+                n("hello")("world")
+            },
+            number: () => {
+                n(0)("0")
+            }
+        },
+        bigint: {
+            bigint: () => {
+                e(12n)(12n)
+                n(12n)(-12n)
+                n(12n)(13n)
+            }
+        },
+        array: {
+            array: () => {
+                /** @type {any} */
+                const a = []
+                e(a)(a)
+                n([])([])
+                const a0 = ['0']
+                e(a0)(a0)
+            }
+        },
+        object: {
+            object: () => {
+                const o = { '0': '0' }
+                e(o)(o)
+                n(o)({ '0': '0' })
+            }
+        }
+    }
+}

package/nanvm-lib/tests/test.rs

@@ -0,0 +1,108 @@
+use nanvm_lib::{interface::{Complex, Container, Extension, Any, Utf8}, naive, nullish::Nullish, sign::Sign, simple::Simple};
+
+fn eq<A: Any>() {
+    // nullish
+    let null0: A = Simple::Nullish(Nullish::Null).to_unknown();
+    let null1 = Simple::Nullish(Nullish::Null).to_unknown();
+    let undefined0 = Simple::Nullish(Nullish::Undefined).to_unknown();
+    let undefined1 = Simple::Nullish(Nullish::Undefined).to_unknown();
+    {
+        assert_eq!(null0, null1);
+        assert_eq!(undefined0, undefined1);
+        assert_ne!(null1, undefined0);
+    }
+    // boolean
+    let true0: A = Simple::Boolean(true).to_unknown();
+    let true1 = Simple::Boolean(true).to_unknown();
+    let false0 = Simple::Boolean(false).to_unknown();
+    let false1 = Simple::Boolean(false).to_unknown();
+    {
+        // boolean
+        {
+            assert_eq!(true0, true1);
+            assert_eq!(false0, false1);
+            assert_ne!(true0, false0);
+        }
+        // nullish
+        {
+            assert_ne!(false0, undefined0);
+        }
+    }
+    // number
+    let number00: A = Simple::Number(2.3).to_unknown();
+    let number01: A = Simple::Number(2.3).to_unknown();
+    let number1: A = Simple::Number(-5.4).to_unknown();
+    let number_nan: A = Simple::Number(f64::NAN).to_unknown();
+    let number_p0: A = Simple::Number(0.0).to_unknown();
+    let number_n0: A = Simple::Number(-0.0).to_unknown();
+    let number_p_inf0: A = Simple::Number(f64::INFINITY).to_unknown();
+    let number_p_inf1: A = Simple::Number(f64::INFINITY).to_unknown();
+    let number_n_inf0: A = Simple::Number(-f64::INFINITY).to_unknown();
+    let number_n_inf1: A = Simple::Number(-f64::INFINITY).to_unknown();
+    {
+        // number
+        {
+            assert_eq!(number00, number01);
+            assert_ne!(number00, number1);
+            assert_ne!(number_nan, number_nan);
+            assert_eq!(number_p0, number_n0);
+            // Object.is()
+            assert_eq!((-0f64).to_bits(), (-0f64).to_bits());
+            assert_ne!(0f64.to_bits(), (-0f64).to_bits());
+            assert_eq!(number_p_inf0, number_p_inf1);
+            assert_eq!(number_n_inf0, number_n_inf1);
+            assert_ne!(number_p_inf0, number_n_inf0);
+        }
+        // nullish
+        {
+            assert_ne!(number_nan, undefined0);
+            assert_ne!(number00, undefined0);
+        }
+    }
+    // string
+    let string_hello0: A = "Hello!".to_unknown();
+    let string_hello1: A = "Hello!".to_unknown();
+    let string_world0: A = "world!".to_unknown();
+    let string0: A = "0".to_unknown();
+    let s0 = "0".to_string16::<A>();
+    {
+        {
+            assert_eq!(string_hello0, string_hello1);
+            assert_ne!(string_hello0, string_world0);
+        }
+        {
+            assert_ne!(number_p0, string0.clone());
+        }
+    }
+    // bigint
+    let bigint12_0: A = A::BigInt::new(Sign::Positive, [12]).to_unknown();
+    let bigint12_1: A = A::BigInt::new(Sign::Positive, [12]).to_unknown();
+    let bigint12m: A =  A::BigInt::new(Sign::Negative, [12]).to_unknown();
+    let bigint13: A =  A::BigInt::new(Sign::Positive, [13]).to_unknown();
+    {
+        assert_eq!(bigint12_0, bigint12_1);
+        assert_ne!(bigint12_0, bigint12m);
+        assert_ne!(bigint12_0, bigint13);
+    }
+    // array
+    let array0: A = [].to_array_unknown();
+    let array1: A = [].to_array_unknown();
+    let array2: A = [string0.clone()].to_array_unknown();
+    {
+        assert_eq!(array0, array0);
+        assert_ne!(array0, array1);
+        assert_eq!(array2, array2);
+    }
+    // object
+    let object0: A = [(s0.clone(), string0.clone())].to_object_unknown();
+    let object1: A = [(s0, string0)].to_object_unknown();
+    {
+        assert_eq!(object0, object0);
+        assert_ne!(object0, object1);
+    }
+}
+
+#[test]
+fn naive_eq() {
+    eq::<naive::Any>();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.1.608",
+  "version": "0.1.609",
   "type": "module",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "scripts": {

package/text/README.md

@@ -34,7 +34,7 @@ Total error states:
 - 34_432
 - < 2^16
 
-### utf8/module.f.cjs
+### utf8/module.f.mjs
 
 ```js
 /** @type {(input: List<u8|null>) => List<i32>} */
@@ -69,7 +69,7 @@ Requirement: no loss for UTF16 => codepoint => UTF16
 
 Total error states: 11 bit
 
-### utf16/module.f.cjs
+### utf16/module.f.mjs
 
 ```js
 /** @type {(input: List<u16|null>) => List<i32>} */

package/issues/lang/2351-property-accessor.md

@@ -1,44 +0,0 @@
-# Property Accessor
-
-- `.`
-- `?.`
-
-FunctionalScript is a strict subset of JavaScript and should behave the same way as JavaScript or reject JS code during compilation as non-valid FS code. However, every object in JavaScript has inherited properties, such as [`constructor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor) and [`__proto__`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto). These properties can cause side effects. For example:
-
-```js
-const f = (() => {}).constructor
-const g = f(`console.log('hello')`)
-g() // we received direct access to I/O
-```
-
-According to FunctionScript principles, an FS compiler should reject such code during compilation. So, the compiler will prohibit the use of `construct` and `__proto__` after `.` and `?.`.
-
-If an object has its own properties with such names (e.g. `constructor`) then we can access it using the [Object.getOwnPropertyDescriptor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor) function instead. The function doesn't return inherited properties.
-
-```js
-const f = (() => {}).constructor
-const g = Object.getOwnPropertyDescriptor(f, 'constructor') // g === undefined
-
-const myObject = { constructor: 42 }
-const c = Object.getOwnPropertyDescriptor(myObject, 'constructor').value // c === 42
-```
-
-Here's the reason why we prohibit `__proto__`:
-
-```js
-const p = (() => {}).__proto__
-const f = Object.getOwnPropertyDescriptor(p, 'constructor').value
-const g = f(`console.log('hello')`)
-g() // side-effect
-```
-
-## Example
-
-```js
-const a = { x: 3}
-export default a.x
-```
-
-Depends on [const](./2120-const.md), [default-import](./2130-default-import.md) and [undefined](./2310-undefined.md).
-
-See <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_accessors>.

package/issues/lang/2352-property-call.md

@@ -1,43 +0,0 @@
-# Function Call With Property Accessor
-
-Operators `a.b()`, `a?.b()`.
-
-```js
-const x = a.b(5)
-```
-
-For `null?.b(x())`. We follow the same behavior as JS, so the `x` function will not be called.
-
-Not allowed (additional to `constructor` and `__proto__`, see [property-accessor](./2351-property-accessor.md)):
-
-- `__defineGetter__`
-- `__defineSetter__`
-- `__lookupGetter__`
-- `__lookupSetter__`
-- `isPrototypeOf` FS has no prototype concept because it has no inheritance.
-- `toLocaleString` because it depends on the locale, which is a side-effect.
-
-Also, from a function:
-
-- `apply`
-- `bind`
-- `call`
-
-Also, from an array:
-
-- `copyWithin`
-- `entries` - returns an iterator.
-- `values` - returns an iterator.
-- `keys` - returns an iterator.
-- `pop`
-- `push`
-- `shift`
-- `unshift`
-- `sort`
-- `reverse`
-
-FunctionalScript doesn't allow direct access to iterators. An iterator can be mutated by `.next()` or `for()`. Indirect access to iterators is allowed through the `Iterable` interface. For example 
-```js
-for (const i of [1, 2]) { }
-```
-In this example, the loop gets a temporary iterator from the iterable interface of `[1, 2]` then use it and discard it. A user can't have direct access to the iterator and can't make a copy of it. 

package/issues/lang/2353-property-at.md

@@ -1,19 +0,0 @@
-# At
-
-`a[42]`, `a['str']`, `a[+i]`.
-
-```js
-import m from './m.f.mjs'
-const a = [2, 3]
-export default {
-    "a": a[0],
-    // we don't know what is the type of `m` so we force it to be a `number` or `bigint`.
-    "b": a[+m]
-}
-```
-
-In `a[i]`, `i` has to be a `number` or known `string`, which is not equal to prohibited words, see [property-accessor](./2351-property-accessor.md). If we don't know what is `i`, `+` requires before `i`.
-
-It means that the byte code for the expression inside the `[]` should be either the unary `+`, a number literal, or a string literal (excluding some strings). If it references an object, FS gives up. In the future, FS may try deeper analyses and type inference can help a lot.
-
-Depends on [property-accessor](./2351-property-accessor.md).

package/issues/test-debug.md

@@ -1,12 +0,0 @@
-# Allow Debugging During Test Run
-
-Currently, we read files as strings and then parse them as functions. See [dev/test.mjs](../dev/test.mjs). In this case, the
-debugger doesn't know about the source code and can't debug the functions. The main reason for loading modules as functions was
-that Deno v1 didn't support `.cjs` files. However, Deno v2 supports them.
-
-We can fix the issue by changing our test runner. The test runner will scan all directories, find all `test.f.cjs` files, and
-then load them using `require`.
-
-Limitations: we will not able to check test module dependencies to have module coverage but, anyway, without a parser, we are not able to get full coverage. So, we can drop support for it right now.
-
-**Note:** In this case, we may drop support for Deno v1. At least until we switch to [ESM](./esm.md).