functionalscript 0.0.477 → 0.0.479

package/com/cpp/module.f.cjs

@@ -52,13 +52,13 @@ const joinComma = join(', ')
 /** @type {(name: string) => (lib: types.Library) => text.Block} */
 const cpp = name => lib => {
 
-    /** @type {(t: types.Type) => string|undefined} */
+    /** @type {(t: types.Type) => string|null} */
     const interface_ = t => {
         if (!(t instanceof Array) || t.length !== 1) {
-            return undefined
+            return null
         }
         const [name] = t
-        return lib[name].interface !== undefined ? name : undefined
+        return 'interface' in lib[name] ? name : null
     }
 
     /** @type {(i: (t: string) => string) => (t: types.Type) => string} */
@@ -66,8 +66,8 @@ const cpp = name => lib => {
         if (typeof (t) === 'string') { return baseType(t) }
         if (t.length === 2) { return `${type(t[1])} const*` }
         const [id] = t
-        if (lib[id].interface === undefined) { return id }
-        return i(id)
+        if ('interface' in lib[id]) { return i(id) }
+        return id
     }
 
     const type = objectType(comRef)
@@ -101,7 +101,7 @@ const cpp = name => lib => {
         const paramArrayStr = `(${joinComma(mapParam(paramL))})`
         const m = methodHeader(result)(paramArrayStr)
         const resultName = interface_(paramArray._)
-        if (resultName === undefined) {
+        if (resultName === null) {
             return [m(name)]
         }
         return [
@@ -127,15 +127,15 @@ const cpp = name => lib => {
     }
 
     /** @type {(kv: obj.Entry<types.Definition>) => text.Block} */
-    const def = ([name, d]) => d.interface === undefined
-        ? struct(name)(defStruct(d))
-        : [
+    const def = ([name, d]) => 'interface' in d
+        ? [
             `class ${name} : public ::nanocom::IUnknown`,
             '{',
             'public:',
             defInterface(d),
             '};'
         ]
+        : struct(name)(defStruct(d))
 
     /** @type {(kv: obj.Entry<types.Definition>) => text.Block} */
     const forward = ([name]) => [`struct ${name};`]

package/com/cs/module.f.cjs

@@ -96,14 +96,13 @@ const flatMapMethod = flatMap(method)
 
 /** @type {(e: obj.Entry<types.Definition>) => list.List<text.Item>} */
 const def = ([n, d]) => {
-    const i = d.interface
-    return i === undefined ?
+    return !('interface' in d) ?
         struct(n)(mapField(entries(d.struct))) :
         typeDef
             ([`Guid("${d.guid}")`, 'InterfaceType(ComInterfaceType.InterfaceIsIUnknown)'])
             ('interface')
             (n)
-            (flatMapMethod(entries(i)))
+            (flatMapMethod(entries(d.interface)))
 }
 
 const flatMapDef = flatMap(def)

package/com/rust/module.f.cjs

@@ -84,7 +84,7 @@ const whereContent = h => ({ where, content }) => {
 
 /** @type {(impl: Impl) => text.Block} */
 const rustImpl = i => {
-    const p = i.param === undefined ? '' : `<${i.param}>`
+    const p = 'param' in i ? `<${i.param}>` : ''
     const header = `impl${p} ${i.trait} for ${i.type}`
     return whereContent(header)(i)
 }
@@ -135,7 +135,7 @@ const rust = library => {
             if (t.length === 2) { return `*const ${f(ref)(t[1])}` }
             const [id] = t
             const fullId = `${p}${id}`
-            return library[id].interface === undefined ? fullId : o(fullId)
+            return 'interface' in library[id] ? o(fullId) : fullId
         }
         return f
     }
@@ -157,8 +157,7 @@ const rust = library => {
 
     /** @type {(first: readonly string[]) => (p: types.FieldArray) => string} */
     const func = first => p => {
-        const result = p._
-        const resultStr = result === undefined ? '' : ` -> ${type(super_)(ref)(result)}`
+        const resultStr = '_' in p ? ` -> ${type(super_)(ref)(p._)}` : ''
         const params = commaJoin(flat([first, mapParam(paramList(p))]))
         return `(${params})${resultStr}`
     }
@@ -248,7 +247,7 @@ const rust = library => {
     }
 
     /** @type {(type: object.Entry<types.Definition>) => text.Block} */
-    const def = ([name, type]) => (type.interface === undefined ? struct(type.struct) : interface_(type))(name)
+    const def = ([name, type]) => ('interface' in type ? interface_(type) : struct(type.struct))(name)
 
     return flat([['#![allow(non_snake_case)]'], flatMap(def)(entries(library))])
 }

package/com/types/module.f.cjs

@@ -10,7 +10,6 @@ const { entries } = Object
 
 /**
  * @typedef {{
- *  readonly interface?: undefined
  *  readonly struct: FieldArray
  * }} Struct
  */

package/commonjs/README.md

@@ -17,15 +17,15 @@
 // - `localPackageId` examples:
 //   - `functionalscript`
 
-type PackageGet = (packageId: string) => Package | undefined
+type PackageGet = (packageId: string) => Package | null
 
 // A local file id is
 
 type Package = {
     // returns a global package id.
-    readonly dependency: (localPackageId: string) => string | undefined
+    readonly dependency: (localPackageId: string) => string | null
     // returns source of the file.
-    readonly file: (localFileId: string) => string | undefined
+    readonly file: (localFileId: string) => string | null
 }
 ```
 
@@ -38,7 +38,7 @@ type Package = {
 //
 // A module is a compiled and initialized source file.
 
-type ModuleGet = (moduleId: string) => ModuleState | undefined
+type ModuleGet = (moduleId: string) => ModuleState | null
 
 type ModuleMapInterface<M> = {
     readonly get: (moduleMap: M) => ModuleGet

package/commonjs/build/module.f.cjs

@@ -55,8 +55,8 @@ const getOrBuild = compile => packageGet => moduleMapInterface =>  {
         /** @type {function_.Require<readonly[map.Map<string>, M]>} */
         const require_ = p => ([requireMap, m]) => {
             /** @type {(e: unknown) => function_.Result<readonly[map.Map<string>, M]>} */
-            const error = e => [['error', 'file not found'], [requireMap, m]]
-            if (moduleDir === undefined) { return error('file not found') }
+            const error = e => [['error', e], [requireMap, m]]
+            if (moduleDir === null) { return error('file not found') }
             const r = parseAndFind(packageGet)(moduleDir)(p)
             if (r === undefined) { return error('file not found') }
             const rIdStr = idToString(r.id)

package/commonjs/module/module.f.cjs

@@ -38,10 +38,10 @@ const object = require('../../types/object/module.f.cjs')
  * }} Id
  */
 
-/** @type {(id: Id) => Id | undefined} */
+/** @type {(id: Id) => Id | null} */
 const dir = id => {
     const len = id.path.length
-    if (len < 1) { return undefined }
+    if (len < 1) { return null }
     return {
         package: id.package,
         path: id.path.slice(0, len - 1)

package/commonjs/test.cjs

@@ -6,7 +6,7 @@ module.exports = {
         const source = 'module.exports = "Hello world!"'
         const m = _.compile(source)
         if (m[0] !== 'ok') { throw m }
-        const [result] = m[1](() => { throw 0 })(undefined)
+        const [result] = m[1](() => { throw 0 })(null)
         if (result[0] !== 'ok') { throw result }
         if (result[1] !== 'Hello world!') { throw result }
     },
@@ -24,7 +24,7 @@ module.exports = {
         const source = 'a = 5'
         const m = _.compile(source)
         if (m[0] !== 'ok') { throw m }
-        const [result] = m[1](() => { throw 0 })(undefined)
+        const [result] = m[1](() => { throw 0 })(null)
         if (result[0] !== 'error') { throw result }
     },
     test: () => {

package/fsc/README.md

@@ -0,0 +1,113 @@
+# FunctionalScript Compiler
+
+## Tokenizer
+
+- `!` - logicalNot
+  - `!=` - nonStrictNotEqual
+  - `!==` - notEqual
+- `"` - doubleStringBegin
+- `$` - idBegin
+- `%` - remainder
+  - `%=` - remainder assignment
+- `&` - bitwiseAnd
+  - `&&` - logicalAnd
+  - `&&=` - logicalAndAssignment
+  - `&=` - bitwiseAndAssignment
+- `'` - singleStringBegin
+- `(` - groupingBegin
+- `)` - groupingEnd
+- `*` - multiplication
+  - `**` - exponential
+  - `**=` - exponentialAssignment
+  - `*/` - commentEnd
+  - `*=` - multiplicationAssignment
+- `+` - addition
+  - `++` - increment
+  - `+=` - additionAssignment
+- `,` - comma
+- `-` - subtraction
+  - `--` - decrement
+  - `-=` - subtractionAssignment
+- `.` - dot
+  - `...` - spread
+- `/` - division
+  - `/*` - commentBegin
+  - `/=` - divisionAssignment
+- `0..9` - numberBegin
+- `:` - colon
+- `;` - semicolon
+- `<` - less
+  - `<<` - leftShift
+  - `<<=` - leftShiftAssignment
+  - `<=` - lessEqual
+- `=` - assignment
+  - `==` - nonStrictEqual ?
+  - `===` - equal
+  - `=>` - arrow
+- `>` - greater
+  - `<=` - greaterEqual
+  - `>>` - rightShift
+  - `>>>` - unsignedRightShift
+  - `>>>=` unsignedRightShiftAssignment
+- `?` - question
+  - `?.` - optional chaining
+  - `??` - nullish coalescing
+- `A..Z` - idBegin
+  - `Infinity` - infinity
+  - `NaN` - nan
+- `[` - propertyBegin
+- `]` - propertyEnd`
+- `^` - bitwiseXor
+  - `^=` - bitwiseXorAssignment
+- `_` - idBegin
+- '`' - templateBegin
+- `a..z` - idBegin
+  - `async` ?
+  - `await` ?
+  - `break`
+  - `case`
+  - `catch`
+  - `class`
+  - `const`
+  - `continue`
+  - `debugger`
+  - `delete` ?
+  - `do` ?
+  - `else`
+  - `export`
+  - `exports` <= non-standard
+  - `false`
+  - `function` ?
+  - `globalThis` ?
+  - `for`
+  - `if`
+  - `import`
+  - `in`
+  - `instanceof`
+  - `let`
+  - `module` <= non-standard
+  - `new` ?
+  - `null`
+  - `of`
+  - `require`  <= non-standard
+  - `return`
+  - `super`
+  - `switch`
+  - `this` ?
+  - `throw`
+  - `true`
+  - `try`
+  - `typeof`
+  - `undefined`
+  - `var`
+  - `void`
+  - `while`
+  - `yield`
+- `{` - objectBegin
+- `|` - bitwiseOr
+  - `|=` - bitwiseOrAssignment
+  - `||` - logicalOr
+  - `||=` - logicalOrAssignment
+- `}` - objectEnd
+- `~` - bitwiseNot
+  - `~=` - bitwiseNotAssignment

package/fsc/module.f.cjs

@@ -1,4 +1,118 @@
-const ascii = require('../text/ascii/module.f.cjs')
+const operator = require('../types/function/operator/module.f.cjs')
+const range_map = require('../types/range_map/module.f.cjs')
+const { merge: rangeMapMerge, fromRange, get } = range_map
+const { reduce: listReduce } = require('../types/list/module.f.cjs')
+const { range: asciiRange } = require('../text/ascii/module.f.cjs')
+const { fromCharCode } = String
+const { fn } = require('../types/function/module.f.cjs')
+const list = require('../types/list/module.f.cjs')
+const _range = require('../types/range/module.f.cjs')
+const { one } = _range
+const { toArray, map } = list
+
+/** @typedef {readonly[readonly string[], ToResult]} Result */
+
+/** @typedef {(a: number) => Result} ToResult */
+
+/**
+ * @template T
+ * @typedef {(state: T) => ToResult} CreateToResult
+ */
+
+/**
+ * @template T
+ * @typedef {range_map.RangeMapArray<CreateToResult<T>>} State
+ */
+
+/** @type {ToResult} */
+const unknownSymbol = a => [[`unknown symbol ${a}`], unknownSymbol]
+
+/** @type {<T>(a: T) => ToResult} */
+const def = () => unknownSymbol
+
+/** @type {<T>(a: CreateToResult<T>) => (b: CreateToResult<T>) => CreateToResult<T>} */
+const union = a => b => {
+    if (a === def || a === b) { return b }
+    if (b === def) { return a }
+    throw [a, b]
+}
+
+/** @type {readonly never[]} */
+const empty = []
+
+/** @type {<T>(a: list.List<State<T>>) => State<T>} */
+const reduce = a => {
+    /** @typedef {typeof a extends list.List<State<infer T>> ? T : never} T */
+    /** @type {range_map.RangeMerge<CreateToResult<T>>} */
+    const merge = rangeMapMerge({
+        union,
+        equal: operator.strictEqual,
+    })
+    return toArray(listReduce(merge)(empty)(a))
+}
+
+
+const codePointRange = fromRange(def)
+
+const range = fn(asciiRange).then(codePointRange).result
+
+/** @type {(l: readonly string[]) => <T>(f: CreateToResult<T>) => State<T>} */
+const rangeSet = l => f => {
+    /** @typedef {typeof f extends CreateToResult<infer T> ? T : never} T */
+    /** @type {(a: _range.Range) => (f: CreateToResult<T>) => State<T>} */
+    const codePointRange = fromRange(def)
+    /** @type {(r: string) => State<T>} */
+    const g = r => codePointRange(asciiRange(r))(f)
+    return reduce(map(g)(l))
+}
+
+/** @type {<T>(a: list.List<State<T>>) => CreateToResult<T>} */
+const create = a => {
+    /** @typedef {typeof a extends list.List<State<infer T>> ? T : never} T */
+    const i = reduce(a)
+    /** @type {(v: number) => (i: State<T>) => (v: T) => ToResult} */
+    const x = get(def)
+    return v => c => x(c)(i)(v)(c)
+}
+
+const terminal = -1
+
+const init = create([
+    codePointRange(one(terminal))(() => () => [[], unknownSymbol]),
+    rangeSet(['\t', ' '])(() => () => [[' '], unknownSymbol]),
+    rangeSet(['\n', '\r'])(() => () => [['\n'], unknownSymbol]),
+    range('!')(() => () => [['!'], unknownSymbol]),
+    range('"')(() => () => [['"'], unknownSymbol]),
+    rangeSet(['$', '_', 'AZ', 'az'])(() => c => [[fromCharCode(c)], unknownSymbol]),
+    range('%')(() => () => [['%'], unknownSymbol]),
+    range('&')(() => () => [['&'], unknownSymbol]),
+    range("'")(() => () => [["'"], unknownSymbol]),
+    range('(')(() => () => [['('], unknownSymbol]),
+    range(')')(() => () => [[')'], unknownSymbol]),
+    range('*')(() => () => [['*'], unknownSymbol]),
+    range('+')(() => () => [['+'], unknownSymbol]),
+    range(',')(() => () => [[','], unknownSymbol]),
+    range('-')(() => () => [['-'], unknownSymbol]),
+    range('.')(() => () => [['.'], unknownSymbol]),
+    range('/')(() => () => [['/'], unknownSymbol]),
+    range('09')(() => a => [[fromCharCode(a)], unknownSymbol]),
+    range(':')(() => () => [[':'], unknownSymbol]),
+    range(';')(() => () => [[';'], unknownSymbol]),
+    range('<')(() => () => [['<'], unknownSymbol]),
+    range('=')(() => () => [['='], unknownSymbol]),
+    range('>')(() => () => [['>'], unknownSymbol]),
+    range('?')(() => () => [['?'], unknownSymbol]),
+    range('[')(() => () => [['['], unknownSymbol]),
+    range(']')(() => () => [[']'], unknownSymbol]),
+    range('^')(() => () => [['^'], unknownSymbol]),
+    range('`')(() => () => [['`'], unknownSymbol]),
+    range('{')(() => () => [['{'], unknownSymbol]),
+    range('|')(() => () => [['|'], unknownSymbol]),
+    range('}')(() => () => [['}'], unknownSymbol]),
+    range('~')(() => () => [['~'], unknownSymbol]),
+])
 
 module.exports = {
+    /** @readonly */
+    init,
 }

package/fsc/test.f.cjs

@@ -1,6 +1,18 @@
 const _ = require('./module.f.cjs')
+const { one } = require('../text/ascii/module.f.cjs')
+const { get } = require('../types/range_map/module.f.cjs')
+const { stringify } = require('../json/module.f.cjs')
+const s = stringify(i => i)
+
+/** @type {(v: string) => string} */
+const f = v => {
+    const n = one(v)
+    return s(_.init(undefined)(n)[0])
+}
 
 module.exports = {
     a: () => {
+        const x = f('1')
+        if (x != '["1"]') { throw x }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.477",
+  "version": "0.0.479",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {

package/text/ascii/module.f.cjs

@@ -13,7 +13,9 @@ const one = s => at(s)(0)
 /** @type {(s: string) => _range.Range} */
 const range = s => {
     const f = at(s)
-    return [f(0), f(1)]
+    const f0 = f(0)
+    if (s.length === 1) { return [f0, f0] }
+    return [f0, f(1)]
 }
 
 module.exports = {

package/text/ascii/test.f.cjs

@@ -0,0 +1,12 @@
+const { range } = require('./module.f.cjs')
+const json = require('../../json/module.f.cjs')
+const { sort } = require('../../types/object/module.f.cjs')
+
+const stringify = json.stringify(sort)
+
+module.exports = {
+    range: () => {
+        const r = stringify(range("A"))
+        if (r !== '[65,65]') { throw r }
+    }
+}

package/text/utf8/test.f.cjs

@@ -3,8 +3,7 @@ const json = require('../../json/module.f.cjs')
 const { sort } = require('../../types/object/module.f.cjs')
 const { list } = require('../../types/module.f.cjs')
 
-/** @type {(a: readonly json.Unknown[]) => string} */
-const stringify = a => json.stringify(sort)(a)
+const stringify = json.stringify(sort)
 
 module.exports = {
     toCodePoint: [

package/types/range/module.f.cjs

@@ -3,7 +3,12 @@
 /** @type {(range: Range) => (i: number) => boolean} */
 const contains = ([b, e]) => i => b <= i && i <= e
 
+/** @type {(i: number) => Range} */
+const one = a => [a, a]
+
 module.exports = {
     /** @readonly */
     contains,
+    /** @readonly */
+    one,
 }

package/types/range_map/module.f.cjs

@@ -37,7 +37,7 @@ const _range = require('../range/module.f.cjs')
 
 /**
  * @template T
- * @typedef {(a: RangeMap<T>) => (b: RangeMap<T>) => RangeMap<T>} RangeMerge
+ * @typedef {operator.Reduce<RangeMap<T>>} RangeMerge
  */
 
 /** @type {<T>(union: operator.Reduce<T>) => (equal: operator.Equal<T>) => sortedList.ReduceOp<Entry<T>, RangeState<T>>} */

package/types/sorted_set/test.f.cjs

@@ -33,7 +33,7 @@ module.exports = {
     intersect: [
         () => {
             const result = stringify(toArray(_.intersect(unsafeCmp)([2, 3, 4])([1, 3, 5])))
-            console.log(result)
+            // console.log(result)
             if (result !== '[3]') { throw result }
         },
         () => {