functionalscript 0.1.608 → 0.2.0

package/json/parser/module.f.d.mts

@@ -1,18 +1,16 @@
-declare namespace _default {
-    export { parse };
-}
-export default _default;
+/** @type {(tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>} */
+export const parse: (tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>;
 export type JsonObject = {
     readonly kind: "object";
-    readonly values: Map.Map<Json.Unknown>;
+    readonly values: map.Map<Json.Unknown>;
     readonly key: string;
 };
 export type JsonArray = {
     readonly kind: "array";
-    readonly values: List.List<Json.Unknown>;
+    readonly values: list.List<Json.Unknown>;
 };
 export type JsonStackElement = JsonObject | JsonArray;
-export type JsonStack = List.List<JsonStackElement>;
+export type JsonStack = list.List<JsonStackElement>;
 export type StateParse = {
     readonly status: "" | "[" | "[v" | "[," | "{" | "{k" | "{:" | "{v" | "{,";
     readonly top: JsonStackElement | null;
@@ -27,10 +25,8 @@ export type StateError = {
     readonly message: string;
 };
 export type JsonState = StateParse | StateResult | StateError;
-/** @type {(tokenList: List.List<Tokenizer.JsonToken>) => Result.Result<Json.Unknown, string>} */
-declare const parse: (tokenList: List.List<Tokenizer.JsonToken>) => Result.Result<Json.Unknown, string>;
-import * as Map from '../../types/map/module.f.mjs';
-import * as Json from '../module.f.mjs';
-import * as List from '../../types/list/module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';
 import * as Tokenizer from '../tokenizer/module.f.mjs';
-import * as Result from '../../types/result/module.f.mjs';
+import * as result from '../../types/result/module.f.mjs';
+import * as Json from '../module.f.mjs';
+import * as map from '../../types/map/module.f.mjs';

package/json/parser/module.f.mjs

@@ -1,20 +1,20 @@
 // @ts-self-types="./module.f.d.mts"
-import result, * as Result from '../../types/result/module.f.mjs'
-import list, * as List from '../../types/list/module.f.mjs'
+import * as result from '../../types/result/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 const { fold, first, drop, toArray } = list
 import * as Operator from '../../types/function/operator/module.f.mjs'
 import * as Tokenizer from '../tokenizer/module.f.mjs'
-import map, * as Map from '../../types/map/module.f.mjs'
+import * as map from '../../types/map/module.f.mjs'
 const { setReplace } = map
 import * as Json from '../module.f.mjs'
-import o from '../../types/object/module.f.mjs'
+import * as o from '../../types/object/module.f.mjs'
 const { fromMap } = o
 
 
 /**
  * @typedef {{
 * readonly kind: 'object'
-* readonly values: Map.Map<Json.Unknown>
+* readonly values: map.Map<Json.Unknown>
 * readonly key: string
 * }} JsonObject
 * */
@@ -22,7 +22,7 @@ const { fromMap } = o
 /**
  * @typedef {{
 * readonly kind: 'array'
-* readonly values: List.List<Json.Unknown>
+* readonly values: list.List<Json.Unknown>
 * }} JsonArray
 * */
 
@@ -33,7 +33,7 @@ const { fromMap } = o
 * } JsonStackElement
 */
 
-/** @typedef {List.List<JsonStackElement>} JsonStack */
+/** @typedef {list.List<JsonStackElement>} JsonStack */
 
 /**
  * @typedef {{
@@ -206,8 +206,8 @@ const foldOp = token => state => {
     }
 }
 
-/** @type {(tokenList: List.List<Tokenizer.JsonToken>) => Result.Result<Json.Unknown, string>} */
-const parse = tokenList => {
+/** @type {(tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>} */
+export const parse = tokenList => {
     const state = fold(foldOp)({ status: '', top: null, stack: null })(tokenList)
     switch (state.status) {
         case 'result': return result.ok(state.value)
@@ -215,8 +215,3 @@ const parse = tokenList => {
         default: return result.error('unexpected end')
     }
 }
-
-export default {
-    /** @readonly */
-    parse
-}

package/json/parser/test.f.mjs

@@ -1,13 +1,13 @@
-import parser from './module.f.mjs'
-import tokenizer, * as Tokenizer from '../tokenizer/module.f.mjs'
-import list from '../../types/list/module.f.mjs'
+import * as parser from './module.f.mjs'
+import * as tokenizer from '../tokenizer/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 const { toArray } = list
-import json from '../module.f.mjs'
-import o from '../../types/object/module.f.mjs'
+import * as json from '../module.f.mjs'
+import * as o from '../../types/object/module.f.mjs'
 const { sort } = o
-import encoding from '../../text/utf16/module.f.mjs'
+import * as encoding from '../../text/utf16/module.f.mjs'
 
-/** @type {(s: string) => readonly Tokenizer.JsonToken[]} */
+/** @type {(s: string) => readonly tokenizer.JsonToken[]} */
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = json.stringify(sort)

package/json/serializer/module.f.d.mts

@@ -1,12 +1,12 @@
-declare namespace _default {
-    export { objectWrap };
-    export { arrayWrap };
-    export { stringSerialize };
-    export { numberSerialize };
-    export { nullSerialize };
-    export { boolSerialize };
-}
-export default _default;
+/** @type {(_: string) => list.List<string>} */
+export const stringSerialize: (_: string) => list.List<string>;
+/** @type {(_: number) => list.List<string>} */
+export const numberSerialize: (_: number) => list.List<string>;
+export const nullSerialize: string[];
+/** @type {(_: boolean) => list.List<string>} */
+export const boolSerialize: (_: boolean) => list.List<string>;
+export const objectWrap: (input: list.List<list.List<string>>) => list.List<string>;
+export const arrayWrap: (input: list.List<list.List<string>>) => list.List<string>;
 /**
  * <T>
  */
@@ -27,19 +27,10 @@ export type Entry<T> = O.Entry<Unknown<T>>;
 /**
  * <T>
  */
-export type Entries<T> = (List.List<Entry<T>>);
+export type Entries<T> = (list.List<Entry<T>>);
 /**
  * <T>
  */
 export type MapEntries<T> = (entries: Entries<T>) => Entries<T>;
-declare const objectWrap: (input: List.List<List.List<string>>) => List.List<string>;
-declare const arrayWrap: (input: List.List<List.List<string>>) => List.List<string>;
-/** @type {(_: string) => List.List<string>} */
-declare const stringSerialize: (_: string) => List.List<string>;
-/** @type {(_: number) => List.List<string>} */
-declare const numberSerialize: (_: number) => List.List<string>;
-declare const nullSerialize: string[];
-/** @type {(_: boolean) => List.List<string>} */
-declare const boolSerialize: (_: boolean) => List.List<string>;
+import * as list from '../../types/list/module.f.mjs';
 import * as O from '../../types/object/module.f.mjs';
-import * as List from '../../types/list/module.f.mjs';

package/json/serializer/module.f.mjs

@@ -1,5 +1,5 @@
 // @ts-self-types="./module.f.d.mts"
-import list, * as List from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 const { flat, reduce, empty } = list
 import * as O from '../../types/object/module.f.mjs'
 import * as Operator from '../../types/function/operator/module.f.mjs'
@@ -37,39 +37,39 @@ import * as Operator from '../../types/function/operator/module.f.mjs'
 
 const jsonStringify = JSON.stringify
 
-/** @type {(_: string) => List.List<string>} */
-const stringSerialize = input => [jsonStringify(input)]
+/** @type {(_: string) => list.List<string>} */
+export const stringSerialize = input => [jsonStringify(input)]
 
-/** @type {(_: number) => List.List<string>} */
-const numberSerialize = input => [jsonStringify(input)]
+/** @type {(_: number) => list.List<string>} */
+export const numberSerialize = input => [jsonStringify(input)]
 
-const nullSerialize = ['null']
+export const nullSerialize = ['null']
 
 const trueSerialize = ['true']
 
 const falseSerialize = ['false']
 
-/** @type {(_: boolean) => List.List<string>} */
-const boolSerialize = value => value ? trueSerialize : falseSerialize
+/** @type {(_: boolean) => list.List<string>} */
+export const boolSerialize = value => value ? trueSerialize : falseSerialize
 
 const comma = [',']
 
-/** @type {Operator.Reduce<List.List<string>>} */
+/** @type {Operator.Reduce<list.List<string>>} */
 const joinOp = b => prior => flat([prior, comma, b])
 
-/** @type {(input: List.List<List.List<string>>) => List.List<string>} */
+/** @type {(input: list.List<list.List<string>>) => list.List<string>} */
 const join = reduce(joinOp)(empty)
 
-/** @type {(open: string) => (close: string) => (input: List.List<List.List<string>>) => List.List<string>} */
+/** @type {(open: string) => (close: string) => (input: list.List<list.List<string>>) => list.List<string>} */
 const wrap = open => close => {
     const seqOpen = [open]
     const seqClose = [close]
     return input => flat([seqOpen, join(input), seqClose])
 }
 
-const objectWrap = wrap('{')('}')
+export const objectWrap = wrap('{')('}')
 
-const arrayWrap = wrap('[')(']')
+export const arrayWrap = wrap('[')(']')
 
 /**
  * @template T
@@ -78,25 +78,10 @@ const arrayWrap = wrap('[')(']')
 
 /**
  * @template T
- *  @typedef {(List.List<Entry<T>>)} Entries<T>
+ *  @typedef {(list.List<Entry<T>>)} Entries<T>
 */
 
 /**
  * @template T
  * @typedef {(entries: Entries<T>) => Entries<T>} MapEntries<T>
 */
-
-export default {
-    /** @readonly */
-    objectWrap,
-    /** @readonly */
-    arrayWrap,
-    /** @readonly */
-    stringSerialize,
-    /** @readonly */
-    numberSerialize,
-    /** @readonly */
-    nullSerialize,
-    /** @readonly */
-    boolSerialize,
-}

package/json/serializer/test.f.mjs

@@ -1,5 +1,5 @@
-import _, * as T from './module.f.mjs'
-import list from '../../types/list/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 const { toArray } = list
 
 export default {

package/json/test.f.mjs

@@ -1,7 +1,7 @@
-import json from './module.f.mjs'
-import o from '../types/object/module.f.mjs'
+import * as json from './module.f.mjs'
+import * as o from '../types/object/module.f.mjs'
 const { sort } = o
-import f from '../types/function/module.f.mjs'
+import * as f from '../types/function/module.f.mjs'
 const { identity } = f
 
 export default {

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

@@ -1,17 +1,13 @@
-declare namespace _default {
-    export { tokenize };
-}
-export default _default;
+/** @type {(input: list.List<number>) => list.List<JsonToken>} */
+export const tokenize: (input: list.List<number>) => list.List<JsonToken>;
 export type JsonToken = {
     readonly kind: "true" | "false" | "null";
 } | {
     readonly kind: "{" | "}" | ":" | "," | "[" | "]";
-} | JsTokenizer.StringToken | JsTokenizer.NumberToken | JsTokenizer.ErrorToken;
+} | jsTokenizer.StringToken | jsTokenizer.NumberToken | jsTokenizer.ErrorToken;
 export type ScanState = {
     readonly kind: "def" | "-";
 };
-export type ScanInput = JsTokenizer.JsToken | null;
-/** @type {(input: List.List<number>) => List.List<JsonToken>} */
-declare const tokenize: (input: List.List<number>) => List.List<JsonToken>;
-import * as JsTokenizer from '../../js/tokenizer/module.f.mjs';
-import * as List from '../../types/list/module.f.mjs';
+export type ScanInput = jsTokenizer.JsToken | null;
+import * as list from '../../types/list/module.f.mjs';
+import * as jsTokenizer from '../../js/tokenizer/module.f.mjs';

package/json/tokenizer/module.f.mjs

@@ -1,18 +1,18 @@
 // @ts-self-types="./module.f.d.mts"
 import * as Operator from '../../types/function/operator/module.f.mjs'
-import list, * as List from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 const { empty, flat, stateScan } = list
-import bf from '../../types/bigfloat/module.f.mjs'
+import * as bf from '../../types/bigfloat/module.f.mjs'
 const { multiply } = bf
-import jsTokenizer, * as JsTokenizer from '../../js/tokenizer/module.f.mjs'
+import * as jsTokenizer from '../../js/tokenizer/module.f.mjs'
 
 /**
  * @typedef {|
 * {readonly kind: 'true' | 'false' | 'null' } |
 * {readonly kind: '{' | '}' | ':' | ',' | '[' | ']' } |
-* JsTokenizer.StringToken |
-* JsTokenizer.NumberToken |
-* JsTokenizer.ErrorToken
+* jsTokenizer.StringToken |
+* jsTokenizer.NumberToken |
+* jsTokenizer.ErrorToken
 * } JsonToken
 */
 
@@ -24,11 +24,11 @@ import jsTokenizer, * as JsTokenizer from '../../js/tokenizer/module.f.mjs'
 
 /**
  * @typedef {|
-* JsTokenizer.JsToken | null
+* jsTokenizer.JsToken | null
 * } ScanInput
 */
 
-/** @type {(input: JsTokenizer.JsToken) => List.List<JsonToken>} */
+/** @type {(input: jsTokenizer.JsToken) => list.List<JsonToken>} */
 const mapToken = input =>
 {
     switch(input.kind)
@@ -45,12 +45,13 @@ 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' }]
     }
 }
 
-/** @type {(input: ScanInput) => readonly [List.List<JsonToken>, ScanState]} */
+/** @type {(input: ScanInput) => readonly [list.List<JsonToken>, ScanState]} */
 const parseDefaultState = input =>
 {
     if (input === null) return [empty, { kind: 'def'}]
@@ -61,7 +62,7 @@ const parseDefaultState = input =>
     }
 }
 
-/** @type {(input: ScanInput) => readonly [List.List<JsonToken>, ScanState]} */
+/** @type {(input: ScanInput) => readonly [list.List<JsonToken>, ScanState]} */
 const parseMinusState = input =>
 {
     if (input === null) return [[{ kind: 'error', message: 'invalid token' }], { kind: 'def'}]
@@ -73,7 +74,7 @@ const parseMinusState = input =>
     }
 }
 
-/** @type {Operator.StateScan<ScanInput, ScanState, List.List<JsonToken>>} */
+/** @type {Operator.StateScan<ScanInput, ScanState, list.List<JsonToken>>} */
 const scanToken = state => input => {
     switch(state.kind)
     {
@@ -82,15 +83,10 @@ const scanToken = state => input => {
     }
 }
 
-/** @type {(input: List.List<number>) => List.List<JsonToken>} */
-const tokenize = input =>
+/** @type {(input: list.List<number>) => list.List<JsonToken>} */
+export const tokenize = input =>
 {
-    /** @type {List.List<ScanInput>} */
+    /** @type {list.List<ScanInput>} */
     const jsTokens = jsTokenizer.tokenize(input)
     return flat(stateScan(scanToken)({ kind: 'def' })(list.concat(jsTokens)([null])))
 }
-
-export default {
-    /** @readonly */
-    tokenize
-}

package/json/tokenizer/test.f.mjs

@@ -1,12 +1,12 @@
-import tokenizer, * as Tokenizer from './module.f.mjs'
-import list from '../../types/list/module.f.mjs'
+import * as tokenizer from './module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 const { toArray } = list
-import djs from '../../djs/module.f.mjs'
-import o from '../../types/object/module.f.mjs'
+import * as djs from '../../djs/module.f.mjs'
+import * as o from '../../types/object/module.f.mjs'
 const { sort } = o
-import encoding from '../../text/utf16/module.f.mjs'
+import * as encoding from '../../text/utf16/module.f.mjs'
 
-/** @type {(s: string) => readonly Tokenizer.JsonToken[]} */
+/** @type {(s: string) => readonly tokenizer.JsonToken[]} */
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = djs.stringify(sort)

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@functionalscript/functionalscript",
-  "version": "0.1.608",
+  "version": "0.2.0",
   "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()));
+        }
+    }
+}