functionalscript 0.1.608 → 0.1.609

package/issues/lang/3240-export.md

@@ -0,0 +1,44 @@
+# Non-default Export
+
+In FunctionalScript we use `export default`:
+
+```js
+export default 17
+```
+
+The main reason is that it's compatible with other module types, such as JSON and CommonJS.
+
+ECMAScript supports `export` of other non-default objects. We wouldn't have much reasons to support but systems as JSR doesn't really like `default` exports.
+
+To implement `export` we should change our definition of a module from `unknown` to
+
+```ts
+type Module = {
+    readonly [k in string]?: unknonwn
+    readonly default?: unknown
+}
+```
+
+Or, more strict version, which allows either `export` or `export default` but not both:
+
+```ts
+type Module = ExportMap | ExportDefault
+type ExportMap = Omit<{
+    readonly[k in string]: unknown
+}, 'default'>
+type DefaultExport = {
+    readonly default: unknown
+}
+```
+
+We don't need to change `import` for now if we implement `import * as X from ...`. For example
+
+```js
+// types/list/module.d.mjs
+export const map = ... 
+```
+
+```js
+import * as List from 'types/list/module.f.mjs'
+const { map } = List
+```

package/issues/lang/README.md

@@ -1,5 +1,9 @@
 # FunctionalScript Language
 
+Two main FunctionsScript princples:
+1. if FS code pass validation/compilation, then it doesn't have side-effects,
+2. the code that passed validation/compilation should behave on FunctionalScript VM the same way as on any other modern JavaScript engine.
+
 When we implement features of FunctionalScript, the first priority is a simplification of the VM.
 
 File Types:
@@ -16,44 +20,67 @@ File Types:
 
 - [ ] [JSON](./1000-json.md).
 
+**VM**:
+
+We are introducing new commands in the order that every new command depends only on previous commands.
+
+|format|any           |Tag|          |
+|------|--------------|---|----------|
+|JSON  |null          | 00|          |
+|      |number        | 01|u64       |
+|      |false         | 02|          |
+|      |true          | 03|          |
+|      |string        | 04|String    |
+|      |array         | 05|Array<Any>|
+|      |object        | 06|Object    |
+
 ## 2. DJS
 
 The DJS form a graph of values. It can be serialized without additional run-time information.
 
 File extensions: `.d.js` and `.d.mjs`.
 
+|format|any                     |Tag|          |Notes                                           |
+|------|------------------------|---|----------|------------------------------------------------|
+|DJS   |const_ref               | 07|u32       |[const](./2120-const.md)                        |
+|      |bigint_plus             | 08|Array<u64>|[bigint](./2320-bigint.md)                      |
+|      |bigint_minus            | 09|Array<u64>|[bigint](./2320-bigint.md)                      |
+|      |undefined               | 0A|          |[undefined](./2310-undefined.md)                |
+|      |own_property            | 0B|          |[property-accessor](./2330-property-accessor.md)|
+|      |instance_property       | 0C|          |[property-accessor](./2330-property-accessor.md)|
+|      |instance_method_call    | 0D|          |[property-accessor](./2330-property-accessor.md)|
+|      |at                      | 0E|          |[property-accessor](./2330-property-accessor.md)|
+|      |operators               |   |          |[operators](./2340-operators.md)                |
+
 ### 2.1. Required
 
-1. [ ] [default-export](./2110-default-export.md)
-2. [ ] [const](./2120-const.md)
-3. [ ] [default-import](./2130-default-import.md)
+1. [ ] [default-export](./2110-default-export.md),
+2. [ ] [const](./2120-const.md),
+3. [ ] [default-import](./2130-default-import.md).
 
 ### 2.2. Priority 1
 
 We need it to use JSDoc and TypeScript.
 
-1. [ ] [block-comment](./2210-block-comment.md)
-2. [ ] [namespace-import](./2220-namespace-import.md)
+1. [ ] [block-comment](./2210-block-comment.md),
+2. [ ] [namespace-import](./2220-namespace-import.md).
 
 ### 2.3. Priority 2
 
-1. [ ] [undefined](./231-undefined.md)
-2. [ ] [bigint](./232-bigint.md)
-3. [ ] [grouping](./233-grouping.md)
-4. [ ] [operators](./234-operators.md)
-5. [ ] Property Accessors:
-   1. [ ] [property-accessor](./2351-property-accessor.md)
-   2. [ ] [property-call](./2352-property-call.md)
-   3. [ ] [at](./2353-at.md)
-6. [ ] [global](./2360-built-in.md)
+1. [ ] [undefined](./2310-undefined.md),
+2. [ ] [bigint](./2320-bigint.md),
+3. [ ] [property-accessor](./2330-property-accessor.md),
+4. [ ] [operators](./2340-operators.md),
+5. [ ] [grouping](./2350-grouping.md),
+6. [ ] [built-in](./2360-built-in.md).
 
 ### 2.4. Syntactic Sugar
 
-1. [ ] [identifier-property](./2410-identifier-property.md)
-2. [ ] [line-comment](./2420-line-comment.md)
-3. [ ] [trailing-comma](./2430-trailing-comma.md)
-4. [ ] [shorthand](./2440-shorthand.md)
-5. [ ] [destructuring](./2450-destructuring.md)
+1. [ ] [identifier-property](./2410-identifier-property.md),
+2. [ ] [line-comment](./2420-line-comment.md),
+3. [ ] [trailing-comma](./2430-trailing-comma.md),
+4. [ ] [shorthand](./2440-shorthand.md),
+5. [ ] [destructuring](./2450-destructuring.md).
 
 ## 3. FJS
 
@@ -61,6 +88,10 @@ The FJS can have functions. The format requires additional run-time information
 
 File extensions: `.f.js` and `.f.mjs`.
 
+|format|any     |Tag|    |Notes                           |
+|------|--------|---|----|--------------------------------|
+|FJS   |function|   |Func|[function](./3110-function.md)  |
+
 ### 3.1. Required
 
 1. [ ] [function](./3110-function.md)
@@ -69,12 +100,23 @@ File extensions: `.f.js` and `.f.mjs`.
 
 ### 3.2. Priority 1
 
-1. [ ] `if`
+1. [ ] `if`. See https://developer.mozilla.org/en-US/docs/Glossary/Falsy
 2. [ ] [let](./3220-let.md)
 3. [ ] `while`
+4. [ ] [export](./3240-export.md)
 
 ### 3.3. Syntactic Sugar
 
-1. [ ] [expression](./321-expression.md)
-2. [ ] [one-parameter](./322-one-parameter.md)
+1. [ ] [expression](./3210-expression.md)
+2. [ ] [one-parameter](./3220-one-parameter.md)
 3. [ ] [assignments](./3330-assignments.md)
+
+## 4. ECMAScript Proposals
+
+1. [ ] [Type Annotations](https://github.com/tc39/proposal-type-annotations), Stage 1:
+   - [Node.js](https://nodejs.org/en/learn/typescript/run-natively),
+   - `Deno` supports TypeScript,
+   - `Bun` supports TypeScript,
+   - most browsers don't support the feature.
+2. [ ] [Pipe Operator `|>`](https://github.com/tc39/proposal-pipeline-operator), Stage 2.
+3. [ ] [Records and Tuples](https://github.com/tc39/proposal-record-tuple), Stage 2.

package/issues/test.f.d.mts

@@ -0,0 +1,16 @@
+declare namespace _default {
+    namespace ownProperty {
+        function nullish(): void;
+        function bool(): void;
+        function array(): void;
+        namespace object {
+            export function _null(): void;
+            export { _null as null };
+            export function undefined(): void;
+        }
+        namespace string {
+            function number(): void;
+        }
+    }
+}
+export default _default;

package/issues/test.f.mjs

@@ -0,0 +1,57 @@
+/** @type {(a: unknown) => (i: any) =>unknown} */
+const at = a => i => Object.getOwnPropertyDescriptor(a, i)?.value
+
+export default {
+    ownProperty: {
+        nullish: () => {
+            /* // panic
+            const v = Object.getOwnPropertyDescriptor(null, 0)
+            if (v !== undefined) {
+                throw v
+            }
+            */
+            /* // panic
+            const v = Object.getOwnPropertyDescriptor(undefined, 0)
+            if (v !== undefined) {
+                throw v
+            }
+            */
+        },
+        bool: () => {
+            const v = at(true)('x')
+            if (v !== undefined) {
+                throw v
+            }
+        },
+        array: () => {
+            const a = ['42']
+            {
+                const v = at(a)('0')
+                if (v !== '42') { throw v }
+            }
+            {
+                const v = at(a)(0)
+                if (v !== '42') { throw v }
+            }
+        },
+        object: {
+            null: () => {
+                const o = { null: 'hello' }
+                const v = at(o)(null)
+                if (v !== 'hello') { throw v }
+            },
+            undefined: () => {
+                const o = { undefined: 'hello' }
+                const v = at(o)(undefined)
+                if (v !== 'hello') { throw v }
+            }
+        },
+        string: {
+            number: () => {
+                const o = 'hello'
+                const v = at(o)(1)
+                if (v !== 'e') { throw v }
+            }
+        }
+    }
+}

package/js/tokenizer/module.f.d.mts

@@ -23,6 +23,9 @@ export type ErrorToken = {
 export type WhitespaceToken = {
     readonly kind: "ws";
 };
+export type NewLineToken = {
+    readonly kind: "nl";
+};
 export type TrueToken = {
     readonly kind: "true";
 };
@@ -72,8 +75,8 @@ export type OperatorToken = {
 } | {
     readonly kind: "?" | "?." | "=>";
 };
-export type JsToken = KeywordToken | TrueToken | FalseToken | NullToken | WhitespaceToken | StringToken | NumberToken | ErrorToken | IdToken | BigIntToken | OperatorToken;
-export type TokenizerState = InitialState | ParseIdState | ParseStringState | ParseEscapeCharState | ParseUnicodeCharState | ParseNumberState | InvalidNumberState | ParseOperatorState | ParseMinusState | ParseWhitespaceState | EofState;
+export type JsToken = KeywordToken | TrueToken | FalseToken | NullToken | WhitespaceToken | NewLineToken | StringToken | NumberToken | ErrorToken | IdToken | BigIntToken | OperatorToken;
+export type TokenizerState = InitialState | ParseIdState | ParseStringState | ParseEscapeCharState | ParseUnicodeCharState | ParseNumberState | InvalidNumberState | ParseOperatorState | ParseMinusState | ParseWhitespaceState | ParseNewLineState | EofState;
 export type ErrorMessage = "\" are missing" | "unescaped character" | "invalid hex value" | "unexpected character" | "invalid number" | "invalid token" | "eof";
 export type InitialState = {
     readonly kind: "initial";
@@ -85,6 +88,9 @@ export type ParseIdState = {
 export type ParseWhitespaceState = {
     readonly kind: "ws";
 };
+export type ParseNewLineState = {
+    readonly kind: "nl";
+};
 export type ParseStringState = {
     readonly kind: "string";
     readonly value: string;

package/js/tokenizer/module.f.mjs

@@ -96,6 +96,8 @@ const {
 
 /** @typedef {{readonly kind: 'ws'}} WhitespaceToken */
 
+/** @typedef {{readonly kind: 'nl'}} NewLineToken */
+
 /** @typedef {{readonly kind: 'true'}} TrueToken */
 
 /** @typedef {{readonly kind: 'false'}} FalseToken */
@@ -143,6 +145,7 @@ const {
 * FalseToken |
 * NullToken |
 * WhitespaceToken |
+* NewLineToken |
 * StringToken |
 * NumberToken |
 * ErrorToken |
@@ -154,15 +157,19 @@ const {
 
 const rangeOneNine = range('19')
 
+const rangeSetNewLine = [    
+    one(lf),
+    one(cr)    
+]
+
 const rangeSetWhiteSpace = [
     one(ht),
-    one(lf),
-    one(cr),
     one(space)
 ]
 
 const rangeSetTerminalForNumber = [
     ...rangeSetWhiteSpace,
+    ...rangeSetNewLine,
     one(exclamationMark),
     one(percentSign),
     one(ampersand),
@@ -235,6 +242,7 @@ const rangeId = [digitRange, ...rangeIdStart]
  * ParseOperatorState |
  * ParseMinusState |
  * ParseWhitespaceState |
+ * ParseNewLineState |
  * EofState
  * } TokenizerState
  */
@@ -257,6 +265,8 @@ const rangeId = [digitRange, ...rangeIdStart]
 
 /** @typedef {{ readonly kind: 'ws'}} ParseWhitespaceState */
 
+/** @typedef {{ readonly kind: 'nl'}} ParseNewLineState */
+
 /** @typedef {{ readonly kind: 'string', readonly value: string}} ParseStringState */
 
 /** @typedef {{ readonly kind: 'escapeChar', readonly value: string}} ParseEscapeCharState */
@@ -525,6 +535,7 @@ const initialStateOp = create(state => () => [[{ kind: 'error', message: 'unexpe
     rangeFunc(rangeOneNine)(() => input => [empty, { kind: 'number', value: fromCharCode(input), b: startNumber(input), numberKind: 'int' }]),
     rangeSetFunc(rangeIdStart)(() => input => [empty, { kind: 'id', value: fromCharCode(input) }]),
     rangeSetFunc(rangeSetWhiteSpace)(state => () => [empty, { kind: 'ws' }]),
+    rangeSetFunc(rangeSetNewLine)(state => () => [empty, { kind: 'nl' }]),
     rangeFunc(one(quotationMark))(() => () => [empty, { kind: 'string', value: '' }]),
     rangeFunc(one(digit0))(() => input => [empty, { kind: 'number', value: fromCharCode(input), b: startNumber(input), numberKind: '0' }]),
     rangeSetFunc(rangeOpStart)(() => input => [empty, { kind: 'op', value: fromCharCode(input) }])
@@ -739,7 +750,20 @@ const parseWhitespaceDefault = state => input => {
 
 /** @type {(state: ParseWhitespaceState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
 const parseWhitespaceStateOp = create(parseWhitespaceDefault)([
-    rangeSetFunc(rangeSetWhiteSpace)(state => () => [empty, state])
+    rangeSetFunc(rangeSetWhiteSpace)(state => () => [empty, state]),
+    rangeSetFunc(rangeSetNewLine)(state => () => [empty, { kind: 'nl' }])
+])
+
+/** @type {(state: ParseNewLineState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+const parseNewLineDefault = state => input => {
+    const next = tokenizeOp({ kind: 'initial' })(input)
+    return [{ first: { kind: 'nl' }, tail: next[0] }, next[1]]
+}
+
+/** @type {(state: ParseNewLineState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+const parseNewLineStateOp = create(parseNewLineDefault)([
+    rangeSetFunc(rangeSetWhiteSpace)(state => () => [empty, state]),
+    rangeSetFunc(rangeSetNewLine)(state => () => [empty, state])
 ])
 
 /** @type {(state: EofState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
@@ -758,6 +782,7 @@ const tokenizeCharCodeOp = state => {
         case 'op': return parseOperatorStateOp(state)
         case '-': return parseMinusStateOp(state)
         case 'ws': return parseWhitespaceStateOp(state)
+        case 'nl': return parseNewLineStateOp(state)
         case 'eof': return eofStateOp(state)
     }
 }
@@ -782,6 +807,7 @@ const tokenizeEofOp = state => {
         case 'op': return [[getOperatorToken(state.value)], { kind: 'eof' }]
         case '-': return [[{kind: '-'}], { kind: 'eof' }]
         case 'ws': return [[{kind: 'ws'}], { kind: 'eof' }]
+        case 'nl': return [[{kind: 'nl'}], { kind: 'eof' }]
         case 'eof': return [[{ kind: 'error', message: 'eof' }], state]
     }
 }

package/js/tokenizer/test.f.mjs

@@ -47,9 +47,8 @@ export default {
         },
         () => {
             const result = stringify(tokenizeString('{ \t\n\r}'))
-            if (result !== '[{"kind":"{"},{"kind":"ws"},{"kind":"}"}]') { throw result }
+            if (result !== '[{"kind":"{"},{"kind":"nl"},{"kind":"}"}]') { throw result }
         },
-
         () => {
             const result = stringify(tokenizeString('""'))
             if (result !== '[{"kind":"string","value":""}]') { throw result }
@@ -344,16 +343,20 @@ export default {
             if (result !== '[{"kind":"ws"}]') { throw result }
         },
         () => {
-            const result = stringify(tokenizeString('\n'))
+            const result = stringify(tokenizeString(' \t'))
             if (result !== '[{"kind":"ws"}]') { throw result }
         },
+        () => {
+            const result = stringify(tokenizeString('\n'))
+            if (result !== '[{"kind":"nl"}]') { throw result }
+        },
         () => {
             const result = stringify(tokenizeString('\r'))
-            if (result !== '[{"kind":"ws"}]') { throw result }
+            if (result !== '[{"kind":"nl"}]') { throw result }
         },
         () => {
-            const result = stringify(tokenizeString(' \t\n\r'))
-            if (result !== '[{"kind":"ws"}]') { throw result }
+            const result = stringify(tokenizeString(' \t\n\r '))
+            if (result !== '[{"kind":"nl"}]') { throw result }
         },
     ],
     id: [

package/json/tokenizer/module.f.mjs

@@ -45,7 +45,8 @@ const mapToken = input =>
         case 'string':
         case 'number':
         case 'error': return [input]
-        case 'ws': return empty
+        case 'ws':
+        case 'nl': return empty
         default: return [{ kind: 'error', message: 'invalid token' }]
     }
 }

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@functionalscript/functionalscript",
-  "version": "0.1.608",
+  "version": "0.1.609",
   "exports": {
     "./com/cpp": "./com/cpp/module.f.mjs",
     "./com/cs": "./com/cs/module.f.mjs",

package/nanvm-lib/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "nanvm-lib"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

package/nanvm-lib/src/extension.rs

@@ -0,0 +1,119 @@
+use crate::{interface::{Any, Container, Extension, Unpacked}, nullish::Nullish::*, simple::Simple};
+
+pub trait AnyExtension: Any {
+    fn string(c: &str) -> Self::String16 {
+        c.encode_utf16().into_iter().to_complex()
+    }
+    fn to_string(self) -> Self::String16 {
+        match self.unpack() {
+            Unpacked::Nullish(v) => Self::string(match v {
+                Null => "null",
+                Undefined => "undefined",
+            }),
+            Unpacked::Bool(v) => Self::string(match v {
+                true => "true",
+                false => "false",
+            }),
+            Unpacked::Number(_) => todo!(),
+            Unpacked::String16(v) => v,
+            Unpacked::BigInt(_) => todo!(),
+            Unpacked::Array(_) => [].to_complex(),
+            Unpacked::Object(_) => Self::string("[object Object"),
+            Unpacked::Function(_) => todo!(),
+        }
+    }
+    fn own_property(self, i: Self) -> Self {
+        match self.unpack() {
+            Unpacked::Nullish(_) => panic!("own_property(\"nullish\")"),
+            Unpacked::Bool(_) => Simple::Nullish(Undefined).to_unknown(),
+            Unpacked::Number(_) => todo!(),
+            Unpacked::String16(_) => todo!(),
+            Unpacked::BigInt(_) => todo!(),
+            Unpacked::Array(_) => match i.unpack() {
+                Unpacked::Nullish(_) => todo!(),
+                Unpacked::Bool(_) => todo!(),
+                Unpacked::Number(_) => todo!(),
+                Unpacked::String16(_) => todo!(),
+                Unpacked::BigInt(_) => todo!(),
+                Unpacked::Array(_) => todo!(),
+                Unpacked::Object(_) => todo!(),
+                Unpacked::Function(_) => todo!(),
+            },
+            Unpacked::Object(_) => todo!(),
+            Unpacked::Function(_) => todo!(),
+        }
+    }
+}
+
+impl<T: Any> AnyExtension for T {}
+
+#[cfg(test)]
+mod test {
+    mod to_string {
+        use crate::{
+            extension::AnyExtension, interface::{Complex, Extension}, naive::{Any, Array, Object}, nullish::Nullish::*, simple::Simple
+        };
+
+        #[test]
+        fn test_string() {
+            let s = Any::string("Hello world!");
+            let xs: Any = s.clone().to_unknown();
+            let sxs = xs.to_string();
+            assert_eq!(s, sxs);
+        }
+
+        #[test]
+        fn test_nullish() {
+            {
+                let x: Any = Simple::Nullish(Null).to_unknown();
+                assert_eq!(Any::string("null"), x.to_string());
+            }
+            {
+                let x: Any = Simple::Nullish(Undefined).to_unknown();
+                assert_eq!(Any::string("undefined"), x.to_string());
+            }
+        }
+
+        #[test]
+        fn test_boolean() {
+            {
+                let x: Any = Simple::Boolean(true).to_unknown();
+                assert_eq!(Any::string("true"), x.to_string());
+            }
+            {
+                let x: Any = Simple::Boolean(false).to_unknown();
+                assert_eq!(Any::string("false"), x.to_string());
+            }
+        }
+
+        #[test]
+        fn test_object() {
+            let x: Any = [].to_object_unknown();
+            assert_eq!(Any::string("[object Object"), x.to_string());
+        }
+
+        #[test]
+        fn test_array() {
+            let x: Any = [].to_array_unknown();
+            assert_eq!(Any::string(""), x.to_string());
+        }
+    }
+
+    mod own_property {
+        use crate::{extension::AnyExtension, interface::Complex, naive::Any, nullish::Nullish::*, simple::Simple};
+
+        #[test]
+        #[should_panic]
+        fn test_own_property_null() {
+            let x: Any = Simple::Nullish(Null).to_unknown();
+            x.own_property(Any::string("hello").to_unknown());
+        }
+
+        #[test]
+        fn test_own_property_bool() {
+            let x: Any = Simple::Boolean(true).to_unknown();
+            let undefined: Any = Simple::Nullish(Undefined).to_unknown();
+            assert_eq!(undefined, x.own_property(Any::string("hello").to_unknown()));
+        }
+    }
+}