functionalscript 0.2.5 → 0.3.0

package/json/tokenizer/{module.f.mjs → module.f.ts}

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

package/json/tokenizer/{test.f.mjs → test.f.ts}

@@ -1,13 +1,14 @@
-import * as tokenizer from './module.f.mjs'
-import * as list from '../../types/list/module.f.mjs'
+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.mjs'
-import * as o from '../../types/object/module.f.mjs'
+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.mjs'
+import * as encoding from '../../text/utf16/module.f.ts'
 
-/** @type {(s: string) => readonly tokenizer.JsonToken[]} */
-const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
+const tokenizeString
+    : (s: string) => readonly tokenizer.JsonToken[]
+    = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = djs.stringify(sort)
 
@@ -286,4 +287,4 @@ export default {
             if (result !== '[{"kind":"["},{"kind":"null"},{"kind":"]"}]') { throw result }
         },
     ]
-}
+}

package/nanvm-lib/src/extension.rs

@@ -1,8 +1,12 @@
-use crate::{interface::{Any, Extension, Unpacked}, nullish::Nullish::*, simple::Simple};
+use crate::{
+    interface::{Any, Extension, Unpacked},
+    nullish::Nullish::*,
+    simple::Simple,
+};
 
 pub trait AnyExtension: Any {
     fn string(c: &str) -> Self::String16 {
-        c.encode_utf16().into_iter().to_complex()
+        c.encode_utf16().to_complex()
     }
     fn to_string(self) -> Self::String16 {
         match self.unpack() {
@@ -51,7 +55,11 @@ impl<T: Any> AnyExtension for T {}
 mod test {
     mod to_string {
         use crate::{
-            extension::AnyExtension, interface::{Complex, Extension}, naive::{Any, Array, Object}, nullish::Nullish::*, simple::Simple
+            extension::AnyExtension,
+            interface::{Complex, Extension},
+            naive::{Any, Array, Object},
+            nullish::Nullish::*,
+            simple::Simple,
         };
 
         #[test]
@@ -100,7 +108,10 @@ mod test {
     }
 
     mod own_property {
-        use crate::{extension::AnyExtension, interface::Complex, naive::Any, nullish::Nullish::*, simple::Simple};
+        use crate::{
+            extension::AnyExtension, interface::Complex, naive::Any, nullish::Nullish::*,
+            simple::Simple,
+        };
 
         #[test]
         #[should_panic]

package/nanvm-lib/src/interface.rs

@@ -22,10 +22,7 @@ pub trait String16<U: Any<String16 = Self>>:
 {
 }
 
-pub trait BigInt<U: Any<BigInt = Self>>:
-    Complex<U> + Container<Header = Sign, Item = u64>
-{
-}
+pub trait BigInt<U: Any<BigInt = Self>>: Complex<U> + Container<Header = Sign, Item = u64> {}
 
 pub trait Array<U: Any<Array = Self>>: Complex<U> + Container<Header = (), Item = U> {}
 
@@ -58,16 +55,16 @@ pub trait Any: PartialEq + Sized + Clone + fmt::Debug {
 
     fn to_string(self) -> Self::String16 {
         if let Some(simple) = self.try_to_simple() {
-            return simple.to_string::<Self>()
+            return simple.to_string::<Self>();
         }
         if let Ok(v) = self.clone().try_to::<Self::String16>() {
             return v;
         }
         if self.clone().try_to::<Self::Array>().is_ok() {
-            return "".to_string16::<Self>()
+            return "".to_string16::<Self>();
         }
         if self.clone().try_to::<Self::Object>().is_ok() {
-            return "[object Object]".to_string16::<Self>()
+            return "[object Object]".to_string16::<Self>();
         }
         // bigint and function
         todo!()
@@ -105,12 +102,12 @@ pub trait Extension: Sized {
     where
         Self: IntoIterator<Item: Any>,
     {
-        self.to_complex::<<Self::Item as Any>::Array>()
-            .to_unknown()
+        self.to_complex::<<Self::Item as Any>::Array>().to_unknown()
     }
 
     fn to_object_unknown<U: Any>(self) -> U
-    where Self: IntoIterator<Item = (U::String16, U)>
+    where
+        Self: IntoIterator<Item = (U::String16, U)>,
     {
         self.to_complex::<U::Object>().to_unknown()
     }

package/nanvm-lib/src/lib.rs

@@ -1,7 +1,7 @@
-pub mod interface;
 pub mod extension;
+pub mod interface;
+pub mod naive;
+pub mod nanenum;
 pub mod nullish;
 pub mod sign;
-pub mod naive;
 pub mod simple;
-pub mod nanenum;

package/nanvm-lib/src/naive.rs

@@ -1,7 +1,11 @@
 use core::{fmt, marker::PhantomData};
 use std::rc;
 
-use crate::{interface::{self, Utf8}, nullish::Nullish, sign::Sign, simple::Simple};
+use crate::{
+    interface::{self},
+    sign::Sign,
+    simple::Simple,
+};
 
 pub trait Policy {
     type Header: PartialEq + fmt::Debug + Clone;
@@ -38,7 +42,10 @@ pub struct Complex<P: Policy> {
 
 impl<P: Policy> Clone for Complex<P> {
     fn clone(&self) -> Self {
-        Self { header: self.header.clone(), items: self.items.clone() }
+        Self {
+            header: self.header.clone(),
+            items: self.items.clone(),
+        }
     }
 }
 
@@ -61,7 +68,7 @@ impl<P: Policy> interface::Container for Complex<P> {
     type Header = P::Header;
     type Item = P::Item;
     fn items(&self) -> &[Self::Item] {
-        &*self.items
+        &self.items
     }
     fn header(&self) -> &Self::Header {
         &self.header

package/nanvm-lib/src/nanenum.rs

@@ -99,7 +99,11 @@ impl<T: Raw64> Drop for NaNEnumPack<T> {
 
 #[cfg(test)]
 mod test {
-    use core::{mem::forget, ptr::null, sync::atomic::{AtomicUsize, Ordering}};
+    use core::{
+        mem::forget,
+        ptr::null,
+        sync::atomic::{AtomicUsize, Ordering},
+    };
     use std::rc::Rc;
 
     use crate::nanenum::{Raw64, NEGATIVE, NOT_FINITE};

package/nanvm-lib/tests/{test.f.mjs → test.f.ts}

@@ -1,10 +1,12 @@
-/** @type {(a: unknown) => (b: unknown) => void} */
-const e = a => b => {
+const e
+    : (a: unknown) => (b: unknown) => void
+    = a => b => {
     if (a === b) { } else { throw [a, '===', b] }
 }
 
-/** @type {(a: unknown) => (b: unknown) => void} */
-const n = a => b => {
+const n
+    : (a: unknown) => (b: unknown) => void
+    = a => b => {
     if (a !== b) { } else { throw [a, '!==', b] }
 }
 
@@ -60,8 +62,7 @@ export default {
         },
         array: {
             array: () => {
-                /** @type {any} */
-                const a = []
+                const a: any = []
                 e(a)(a)
                 n([])([])
                 const a0 = ['0']

package/nodejs/version/{main.mjs → main.ts}

@@ -1,4 +1,4 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 import fs from 'node:fs'
 
 _.updateVersion({ fs })

package/nodejs/version/module.f.ts

@@ -0,0 +1,42 @@
+export type Buffer = {}
+
+type Fs<T> = {
+   readonly readFileSync: (name: string) => Buffer
+   readonly writeFileSync: (name: string, content: string) => T
+}
+
+export type Node<T> = {
+   readonly fs: Fs<T>
+}
+
+const { stringify, parse } = JSON
+
+export const getVersion
+    : <T>(fs: Fs<T>) => string
+    = fs => readJson(fs)('package').version
+
+const jsonFile = (jsonFile: string) => `${jsonFile}.json`
+
+const readJson
+    : <T>(node: Fs<T>) => (name: string) => any
+    = fs => name => parse(fs.readFileSync(jsonFile(name)).toString())
+
+export const updateVersion
+    : <T>(node: Node<T>) => readonly[T, T]
+    = ({ fs }) => {
+    const f = (name: string) => {
+        return fs.writeFileSync(
+            jsonFile(name),
+            stringify(
+                {
+                    ...readJson(fs)(name),
+                    version: getVersion(fs)
+                },
+                null,
+                2))
+    }
+    return [
+        f('package'),
+        f('deno')
+    ]
+}

package/nodejs/version/{test.f.mjs → test.f.ts}

@@ -1,13 +1,10 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 
 const version = '0.3.0'
 
-/**
- * @type {{
- *  readonly[k in string]: unknown
- * }}
- */
-const x = {
+const x
+    : { readonly[k in string]: unknown }
+    = {
     'package.json': {
         "name": "functionalscript",
         version,
@@ -43,7 +40,7 @@ const x = {
             "typescript": "^4.7.4"
         }
     },
-    "jsr.json": {}
+    "deno.json": {}
 }
 
 const e = '{\n' +
@@ -82,14 +79,16 @@ const e = '{\n' +
     '  }\n' +
     '}'
 
-/** @type {(s: string) => _.Buffer} */
-const buffer = s => ({
+const buffer
+    : (s: string) => _.Buffer
+    = s => ({
     toString: () => s
 })
 
 export default () => {
-    /** @type {_.Node<string>} */
-    const node = {
+    const node
+        : _.Node<string>
+        = {
         fs: {
             readFileSync: n => buffer(JSON.stringify(x[n])),
             writeFileSync: (_, content) => content

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "functionalscript",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "type": "module",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "scripts": {
-    "tscp": "rm -rf out/ && tsc --NoEmit false",
-    "tsc": "tsc",
-    "test": "tsc && npm run test-only",
-    "index": "node ./dev/index.mjs",
-    "version": "node ./nodejs/version/main.mjs",
-    "test-only": "node --trace-uncaught ./dev/test.mjs",
-    "comtest": "node ./com/test/build.mjs",
-    "doc": "rm -rf docs/ && npm run tscp && deno doc --html out/**/module.f.mjs"
+    "tscp": "tsc --NoEmit false --emitDeclarationOnly true",
+    "tsct": "tsc --NoEmit false --checkJs false",
+    "prepack": "npm run tscp && npm run tsct",
+    "test20": "npm run prepack && node --trace-uncaught ./dev/test.js",
+    "test": "tsc && node --experimental-strip-types --trace-uncaught ./dev/test.ts",
+    "comtest": "node --experimental-strip-types ./com/test/build.ts",
+    "index": "node --experimental-strip-types ./dev/index.ts",
+    "version": "node --experimental-strip-types ./nodejs/version/main.ts"
   },
   "repository": {
     "type": "git",

package/text/ascii/{module.f.mjs → module.f.ts}

@@ -1,18 +1,20 @@
-// @ts-self-types="./module.f.d.mts"
-import * as _range from '../../types/range/module.f.mjs'
+import * as _range from '../../types/range/module.f.ts'
 
-/** @type {(s: string) => (i: number) => number} */
-const at = s => i => {
+const at
+    : (s: string) => (i: number) => number
+    = s => i => {
     const r = s.codePointAt(i)
     if (r === void 0) { throw s }
     return r
 }
 
-/** @type {(s: string) => number} */
-export const one = s => at(s)(0)
+export const one
+    : (s: string) => number
+    = s => at(s)(0)
 
-/** @type {(s: string) => _range.Range} */
-export const range = s => {
+export const range
+    : (s: string) => _range.Range
+    = s => {
     const f = at(s)
     const f0 = f(0)
     if (s.length === 1) { return [f0, f0] }

package/text/ascii/{test.f.mjs → test.f.ts}

@@ -1,7 +1,7 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 const { range } = _
-import * as json from '../../json/module.f.mjs'
-import * as o from '../../types/object/module.f.mjs'
+import * as json from '../../json/module.f.ts'
+import * as o from '../../types/object/module.f.ts'
 const { sort } = o
 
 const stringify = json.stringify(sort)
@@ -11,4 +11,4 @@ export default {
         const r = stringify(range("A"))
         if (r !== '[65,65]') { throw r }
     }
-}
+}

package/text/module.f.ts

@@ -0,0 +1,30 @@
+import * as list from '../types/list/module.f.ts'
+const { flatMap } = list
+
+export type Block = ItemThunk|ItemArray
+
+type ItemArray = readonly Item[]
+
+type ItemThunk = () => list.List<Item>
+
+export type Item = string|ItemArray|ItemThunk
+
+export const flat
+    : (indent: string) => (text: Block) => list.List<string>
+    = indent => {
+
+    const f
+        : (prefix: string) => (text: Block) => list.List<string>
+        = prefix => {
+        const g
+            : (item: Item) => list.List<string>
+            = item => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item)
+        return flatMap(g)
+    }
+
+    return f('')
+}
+
+export const curly
+    : (type: string) => (name: string) => (body: Block) => Block
+    = type => name => body => [`${type} ${name}`, '{', body, '}']

package/text/sgr/{module.f.mjs → module.f.ts}

@@ -1,11 +1,9 @@
-// @ts-self-types="./module.f.d.mts"
-
 /**
  * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
- *
- * @type {(c: number) => string}
  */
-export const sgr = c => `\x1b[${c.toString()}m`
+export const sgr
+    : (c: number) => string
+    = c => `\x1b[${c.toString()}m`
 
 export const codes = {
     /** @readonly */

package/text/{test.f.mjs → test.f.ts}

@@ -1,10 +1,11 @@
-import * as _ from './module.f.mjs'
-import * as string from '../types/string/module.f.mjs'
+import * as _ from './module.f.ts'
+import * as string from '../types/string/module.f.ts'
 const { join } = string
 
 export default () => {
-    /** @type {_.Block} */
-    const text = [
+    const text
+        : _.Block
+        = [
         'a',
         'b',
         () => [

package/text/utf16/module.f.ts

@@ -0,0 +1,108 @@
+import * as list from '../../types/list/module.f.ts'
+import * as operator from '../../types/function/operator/module.f.ts'
+import * as range from '../../types/range/module.f.ts'
+const { contains } = range
+import * as f from '../../types/function/module.f.ts'
+const { fn } = f
+const { map, flat, stateScan, reduce, flatMap, empty } = list
+
+type WordOrEof = u16|null
+
+type Utf16State = number|null
+
+type u16 = number
+
+type i32 = number
+
+const lowBmp = contains([0x0000, 0xd7ff])
+const highBmp = contains([0xe000, 0xffff])
+
+const isBmpCodePoint
+    : (codePoint: i32) => boolean
+    = codePoint => lowBmp(codePoint) || highBmp(codePoint)
+
+const isHighSurrogate
+    : (codePoint: i32) => boolean
+    = contains([0xd800, 0xdbff])
+
+const isLowSurrogate
+    : (codePoint: i32) => boolean
+    = contains([0xdc00, 0xdfff])
+
+const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000
+
+const isSupplementaryPlane
+    : (a: i32) => boolean
+    = contains([0x01_0000, 0x10_ffff])
+
+const codePointToUtf16
+    : (input: i32) => list.List<u16>
+    = codePoint => {
+    if (isBmpCodePoint(codePoint)) { return [codePoint] }
+    if (isSupplementaryPlane(codePoint)) {
+        const n = codePoint - 0x1_0000
+        const high = (n >> 10) + 0xd800
+        const low = (n & 0b0011_1111_1111) + 0xdc00
+        return [high, low]
+    }
+    return [codePoint & 0xffff]
+}
+
+export const fromCodePointList = flatMap(codePointToUtf16)
+
+const u16 = contains([0x0000, 0xFFFF])
+
+const utf16ByteToCodePointOp
+    : operator.StateScan<u16, Utf16State, list.List<i32>>
+    = state => word => {
+    if (!u16(word)) {
+        return [[0xffffffff], state]
+    }
+    if (state === null) {
+        if (isBmpCodePoint(word)) { return [[word], null] }
+        if (isHighSurrogate(word)) { return [[], word] }
+        return [[word | errorMask], null]
+    }
+    if (isLowSurrogate(word)) {
+        const high = state - 0xd800
+        const low = word - 0xdc00
+        return [[(high << 10) + low + 0x10000], null]
+    }
+    if (isBmpCodePoint(word)) { return [[state | errorMask, word], null] }
+    if (isHighSurrogate(word)) { return [[state | errorMask], word] }
+    return [[state | errorMask, word | errorMask], null]
+}
+
+const utf16EofToCodePointOp
+    : (state: Utf16State) => readonly[list.List<i32>, Utf16State]
+    = state => [state === null ? empty : [state | errorMask],  null]
+
+const utf16ByteOrEofToCodePointOp
+    : operator.StateScan<WordOrEof, Utf16State, list.List<i32>>
+    = state => input => input === null ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input)
+
+const eofList
+    : list.List<WordOrEof>
+    = [null]
+
+export const toCodePointList
+    : (input: list.List<u16>) => list.List<i32>
+    = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])))
+
+export const stringToList
+    : (s: string) => list.List<u16>
+    = s => {
+    const at
+        : (i: number) => list.Result<number>
+        = i => {
+        const first = s.charCodeAt(i)
+        return isNaN(first) ? empty : { first, tail: () => at(i + 1) }
+    }
+    return at(0)
+}
+
+export const listToString
+    : (input: list.List<u16>) => string
+    = fn(map(String.fromCharCode))
+    .then(reduce(operator.concat)(''))
+    .result