functionalscript 0.3.3 → 0.3.5

package/json/serializer/test.f.ts

@@ -1,64 +0,0 @@
-import * as _ from './module.f.ts'
-import * as list from '../../types/list/module.f.ts'
-const { toArray } = list
-
-export default {
-    arrayWrap: [
-        () => {
-            const result = JSON.stringify(toArray(_.arrayWrap(null)))
-            if (result !== '["[","]"]') { throw result }
-        },
-        () => {
-            const result = JSON.stringify(toArray(_.arrayWrap([['a','b']])))
-            if (result !== '["[","a","b","]"]') { throw result }
-        },
-        () => {
-            const result = JSON.stringify(toArray(_.arrayWrap([['a'],['b']])))
-            if (result !== '["[","a",",","b","]"]') { throw result }
-        }
-    ],
-    objectWrap: [
-        () => {
-            const result = JSON.stringify(toArray(_.objectWrap(null)))
-            if (result !== '["{","}"]') { throw result }
-        },
-        () => {
-            const result = JSON.stringify(toArray(_.objectWrap([['a','b']])))
-            if (result !== '["{","a","b","}"]') { throw result }
-        },
-        () => {
-            const result = JSON.stringify(toArray(_.objectWrap([['a'],['b']])))
-            if (result !== '["{","a",",","b","}"]') { throw result }
-        }
-    ],
-    stringSerialize: [
-        () => {
-            const result = JSON.stringify(toArray(_.stringSerialize('abc')))
-            if (result !== '["\\"abc\\""]') { throw result }
-        },
-        () => {
-            const result = JSON.stringify(toArray(_.stringSerialize('123')))
-            if (result !== '["\\"123\\""]') { throw result }
-        }
-    ],
-    numberSerialize: [
-        () => {
-            const result = JSON.stringify(toArray(_.numberSerialize(123)))
-            if (result !== '["123"]') { throw result }
-        },
-        () => {
-            const result = JSON.stringify(toArray(_.numberSerialize(10e20)))
-            if (result !== '["1e+21"]') { throw result }
-        }
-    ],
-    boolSerialize: [
-        () => {
-            const result = JSON.stringify(toArray(_.boolSerialize(false)))
-            if (result !== '["false"]') { throw result }
-        },
-        () => {
-            const result = JSON.stringify(toArray(_.boolSerialize(true)))
-            if (result !== '["true"]') { throw result }
-        }
-    ]
-}

package/json/test.f.ts

@@ -1,48 +0,0 @@
-import * as json from './module.f.ts'
-import * as o from '../types/object/module.f.ts'
-const { sort } = o
-import * as f from '../types/function/module.f.ts'
-const { identity } = f
-
-export default {
-    setProperty: () => {
-        if (json.setProperty("Hello")([])({}) !== "Hello") { throw 'error' }
-    },
-    stringify: [
-        {
-            sort: () => {
-                const r = json.setProperty("Hello")(['a'])({})
-                const x = json.stringify(sort)(r)
-                if (x !== '{"a":"Hello"}') { throw x }
-            },
-            identity: () => {
-                const x = json.stringify(identity)(json.setProperty("Hello")(['a'])({}))
-                if (x !== '{"a":"Hello"}') { throw x }
-            },
-        },
-        {
-            sort: () => {
-                const x = json.stringify(sort)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }))
-                if (x !== '{"a":"Hello","b":12,"c":[]}') { throw x }
-            },
-            identity: () => {
-                const x = json.stringify(identity)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }))
-                if (x !== '{"c":[],"b":12,"a":"Hello"}') { throw x }
-            },
-        },
-        {
-            sort: () => {
-                const _0 = { a: { y: [24] }, c: [], b: 12 }
-                const _1 = json.setProperty("Hello")(['a', 'x'])(_0)
-                const _2 = json.stringify(sort)(_1)
-                if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') { throw _2 }
-            },
-            identity: () => {
-                const _0 = { a: { y: [24] }, c: [], b: 12 }
-                const _1 = json.setProperty("Hello")(['a', 'x'])(_0)
-                const _2 = json.stringify(identity)(_1)
-                if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') { throw _2 }
-            }
-        }
-    ]
-}

package/json/tokenizer/module.f.ts

@@ -1,85 +0,0 @@
-import * as Operator from '../../types/function/operator/module.f.ts'
-import * as list from '../../types/list/module.f.ts'
-const { empty, flat, stateScan } = list
-import * as bf from '../../types/bigfloat/module.f.ts'
-const { multiply } = bf
-import * as jsTokenizer from '../../js/tokenizer/module.f.ts'
-
-export type JsonToken = |
- {readonly kind: 'true' | 'false' | 'null' } |
- {readonly kind: '{' | '}' | ':' | ',' | '[' | ']' } |
- jsTokenizer.StringToken |
- jsTokenizer.NumberToken |
- jsTokenizer.ErrorToken
-
-type ScanState = {readonly kind: 'def' | '-' }
-
-type ScanInput = jsTokenizer.JsToken | null
-
-const mapToken
-    : (input: jsTokenizer.JsToken) => list.List<JsonToken>
-    = input =>
-{
-    switch(input.kind)
-    {
-        case '{':
-        case '}':
-        case ':':
-        case ',':
-        case '[':
-        case ']':
-        case 'true':
-        case 'false':
-        case 'null':
-        case 'string':
-        case 'number':
-        case 'error': return [input]
-        case 'ws':
-        case 'nl': return empty
-        default: return [{ kind: 'error', message: 'invalid token' }]
-    }
-}
-
-const parseDefaultState
-    : (input: ScanInput) => readonly [list.List<JsonToken>, ScanState]
-    = input =>
-{
-    if (input === null) return [empty, { kind: 'def'}]
-    switch(input.kind)
-    {
-        case '-': return [empty, { kind: '-'}]
-        default: return [mapToken(input),  { kind: 'def'}]
-    }
-}
-
-const parseMinusState
-    : (input: ScanInput) => readonly [list.List<JsonToken>, ScanState]
-    = input =>
-{
-    if (input === null) return [[{ kind: 'error', message: 'invalid token' }], { kind: 'def'}]
-    switch(input.kind)
-    {
-        case '-': return [[{ kind: 'error', message: 'invalid token' }], { kind: '-'}]
-        case 'number': return [[{ kind: 'number', bf: multiply(input.bf)(-1n), value: `-${input.value}` }], { kind: 'def'}]
-        default: return [{ first: { kind: 'error', message: 'invalid token' }, tail: mapToken(input)},  { kind: 'def'}]
-    }
-}
-
-const scanToken
-    : Operator.StateScan<ScanInput, ScanState, list.List<JsonToken>>
-    = state => input => {
-    switch(state.kind)
-    {
-        case '-': return parseMinusState(input)
-        default: return parseDefaultState(input)
-    }
-}
-
-export const tokenize
-    = (input: list.List<number>): list.List<JsonToken> =>
-{
-    const jsTokens
-        : list.List<ScanInput>
-        = jsTokenizer.tokenize(input)
-    return flat(stateScan(scanToken)({ kind: 'def' })(list.concat(jsTokens)([null])))
-}

package/json/tokenizer/test.f.ts

@@ -1,290 +0,0 @@
-import * as tokenizer from './module.f.ts'
-import * as list from '../../types/list/module.f.ts'
-const { toArray } = list
-import * as djs from '../../djs/module.f.ts'
-import * as o from '../../types/object/module.f.ts'
-const { sort } = o
-import * as encoding from '../../text/utf16/module.f.ts'
-
-const tokenizeString
-    : (s: string) => readonly tokenizer.JsonToken[]
-    = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
-
-const stringify = djs.stringify(sort)
-
-export default {
-    json: [
-        () => {
-            const result = tokenizeString('')
-            if (result.length !== 0) { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('{'))
-            if (result !== '[{"kind":"{"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('}'))
-            if (result !== '[{"kind":"}"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString(':'))
-            if (result !== '[{"kind":":"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString(','))
-            if (result !== '[{"kind":","}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('['))
-            if (result !== '[{"kind":"["}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString(']'))
-            if (result !== '[{"kind":"]"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('ᄑ'))
-            if (result !== '[{"kind":"error","message":"unexpected character"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('{ \t\n\r}'))
-            if (result !== '[{"kind":"{"},{"kind":"}"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('""'))
-            if (result !== '[{"kind":"string","value":""}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('"value"'))
-            if (result !== '[{"kind":"string","value":"value"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('"value'))
-            if (result !== '[{"kind":"error","message":"\\" are missing"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('"value1" "value2"'))
-            if (result !== '[{"kind":"string","value":"value1"},{"kind":"string","value":"value2"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('"'))
-            if (result !== '[{"kind":"error","message":"\\" are missing"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\\\"'))
-            if (result !== '[{"kind":"string","value":"\\\\"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\""'))
-            if (result !== '[{"kind":"string","value":"\\""}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\/"'))
-            if (result !== '[{"kind":"string","value":"/"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\x"'))
-            if (result !== '[{"kind":"error","message":"unescaped character"},{"kind":"string","value":"x"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\'))
-            if (result !== '[{"kind":"error","message":"\\" are missing"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\b\\f\\n\\r\\t"'))
-            if (result !== '[{"kind":"string","value":"\\b\\f\\n\\r\\t"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\u1234"'))
-            if (result !== '[{"kind":"string","value":"ሴ"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\uaBcDEeFf"'))
-            if (result !== '[{"kind":"string","value":"ꯍEeFf"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('"\\uEeFg"'))
-            if (result !== '[{"kind":"error","message":"invalid hex value"},{"kind":"string","value":"g"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('0'))
-            if (result !== '[{"bf":[0n,0],"kind":"number","value":"0"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('[0]'))
-            if (result !== '[{"kind":"["},{"bf":[0n,0],"kind":"number","value":"0"},{"kind":"]"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('00'))
-            if (result !== '[{"kind":"error","message":"invalid number"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('0abc,'))
-            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"error","message":"invalid token"},{"kind":","}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('123456789012345678901234567890'))
-            if (result !== '[{"bf":[123456789012345678901234567890n,0],"kind":"number","value":"123456789012345678901234567890"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('{90}'))
-            if (result !== '[{"kind":"{"},{"bf":[90n,0],"kind":"number","value":"90"},{"kind":"}"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('1 2'))
-            if (result !== '[{"bf":[1n,0],"kind":"number","value":"1"},{"bf":[2n,0],"kind":"number","value":"2"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('0. 2'))
-            if (result !== '[{"kind":"error","message":"invalid number"},{"bf":[2n,0],"kind":"number","value":"2"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('10-0'))
-            if (result !== '[{"bf":[10n,0],"kind":"number","value":"10"},{"bf":[0n,0],"kind":"number","value":"-0"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('9a:'))
-            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"error","message":"invalid token"},{"kind":":"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('-10'))
-            if (result !== '[{"bf":[-10n,0],"kind":"number","value":"-10"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('-'))
-            if (result !== '[{"kind":"error","message":"invalid token"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('--'))
-            if (result !== '[{"kind":"error","message":"invalid token"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('---'))
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid token"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('-0'))
-            if (result !== '[{"bf":[0n,0],"kind":"number","value":"-0"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('-00'))
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid number"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('-.123'))
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid token"},{"bf":[123n,0],"kind":"number","value":"123"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('0.01'))
-            if (result !== '[{"bf":[1n,-2],"kind":"number","value":"0.01"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('-0.9'))
-            if (result !== '[{"bf":[-9n,-1],"kind":"number","value":"-0.9"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('-0.'))
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid number"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('-0.]'))
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid number"},{"kind":"]"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('12.34'))
-            if (result !== '[{"bf":[1234n,-2],"kind":"number","value":"12.34"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('-12.00'))
-            if (result !== '[{"bf":[-1200n,-2],"kind":"number","value":"-12.00"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('-12.'))
-            if (result !== '[{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid number"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('12.]'))
-            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"]"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('0e1'))
-            if (result !== '[{"bf":[0n,1],"kind":"number","value":"0e1"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('0e+2'))
-            if (result !== '[{"bf":[0n,2],"kind":"number","value":"0e+2"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('0e-0'))
-            if (result !== '[{"bf":[0n,0],"kind":"number","value":"0e-0"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('12e0000'))
-            if (result !== '[{"bf":[12n,0],"kind":"number","value":"12e0000"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('-12e-0001'))
-            if (result !== '[{"bf":[-12n,-1],"kind":"number","value":"-12e-0001"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('-12.34e1234'))
-            if (result !== '[{"bf":[-1234n,1232],"kind":"number","value":"-12.34e1234"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('0e'))
-            if (result !== '[{"kind":"error","message":"invalid number"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('0e-'))
-            if (result !== '[{"kind":"error","message":"invalid number"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('1234567890n'))
-            if (result !== '[{"kind":"error","message":"invalid token"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('0n'))
-            if (result !== '[{"kind":"error","message":"invalid token"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('[-1234567890n]'))
-            if (result !== '[{"kind":"["},{"kind":"error","message":"invalid token"},{"kind":"error","message":"invalid token"},{"kind":"]"}]') { throw result }
-        },
-    ],
-    id: [
-        () => {
-            const result = stringify(tokenizeString('err'))
-            if (result !== '[{"kind":"error","message":"invalid token"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('{e}'))
-            if (result !== '[{"kind":"{"},{"kind":"error","message":"invalid token"},{"kind":"}"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('tru'))
-            if (result !== '[{"kind":"error","message":"invalid token"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('break'))
-            if (result !== '[{"kind":"error","message":"invalid token"}]') { throw result }
-        },
-    ],
-    keywords: [
-        () => {
-            const result = stringify(tokenizeString('true'))
-            if (result !== '[{"kind":"true"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('false'))
-            if (result !== '[{"kind":"false"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('null'))
-            if (result !== '[{"kind":"null"}]') { throw result }
-        },
-        () => {
-            const result = stringify(tokenizeString('[null]'))
-            if (result !== '[{"kind":"["},{"kind":"null"},{"kind":"]"}]') { throw result }
-        },
-    ]
-}

package/nanvm-lib/Cargo.toml

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

package/nanvm-lib/src/extension.rs

@@ -1,130 +0,0 @@
-use crate::{
-    interface::{Any, Extension, Unpacked},
-    nullish::Nullish::*,
-    simple::Simple,
-};
-
-pub trait AnyExtension: Any {
-    fn string(c: &str) -> Self::String16 {
-        c.encode_utf16().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()));
-        }
-    }
-}