functionalscript 0.3.4 → 0.3.6

package/fsm/module.f.ts

@@ -1,107 +0,0 @@
-import * as list from '../types/list/module.f.ts'
-const { equal, isEmpty, fold, toArray, scan, foldScan, empty: emptyList } = list
-import * as byteSet from '../types/byte_set/module.f.ts'
-const { toRangeMap, union: byteSetUnion, one, empty } = byteSet
-import * as sortedSet from '../types/sorted_set/module.f.ts'
-const { intersect, union: sortedSetUnion } = sortedSet
-import * as rangeMap from '../types/range_map/module.f.ts'
-const { merge } = rangeMap
-import * as cmp from '../types/function/compare/module.f.ts'
-const { unsafeCmp } = cmp
-import * as operator from '../types/function/operator/module.f.ts'
-const { strictEqual } = operator
-import * as j from '../json/module.f.ts'
-const { stringify } = j
-import * as f from '../types/function/module.f.ts'
-const { identity } = f
-import * as utf16 from '../text/utf16/module.f.ts'
-const { stringToList } = utf16
-
-type Rule = readonly[string, byteSet.ByteSet, string]
-
-export type Grammar = list.List<Rule>
-
-type Dfa = {
-   readonly[state in string]: rangeMap.RangeMapArray<string>
-}
-
-const stringifyIdentity = stringify(identity)
-
-export const toRange
-    : (s: string) => byteSet.ByteSet
-    = s => {
-    const [b, e] = toArray(stringToList(s))
-    return byteSet.range([b, e])
-}
-
-const toUnionOp
-    : operator.Fold<number, byteSet.ByteSet>
-    = i => bs => byteSetUnion(bs)(one(i))
-
-export const toUnion
-    : (s: string) => byteSet.ByteSet
-    = s => {
-    const codePoints = stringToList(s)
-    return fold(toUnionOp)(empty)(codePoints)
-}
-
-const mergeOp
-    : rangeMap.Operators<sortedSet.SortedSet<string>>
-    = { union: sortedSetUnion(unsafeCmp), equal: equal(strictEqual) }
-
-const hasState
-    : (s: string) => (set: sortedSet.SortedSet<string>) => boolean
-    = s => set => !isEmpty(intersect(unsafeCmp)([s])(set))
-
-const foldOp
-    : (set: sortedSet.SortedSet<string>) => operator.Fold<Rule, rangeMap.RangeMap<sortedSet.SortedSet<string>>>
-    = set => ([ruleIn, bs, ruleOut]) => rm => {
-    if (hasState(ruleIn)(set)) { return merge(mergeOp)(rm)(toRangeMap(bs)(ruleOut)) }
-    return rm
-}
-
-const stringifyOp
-    : operator.Scan<rangeMap.Entry<sortedSet.SortedSet<string>>, rangeMap.Entry<string>>
-    = ([sortedSet, max]) => [[stringifyIdentity(sortedSet), max], stringifyOp]
-
-const scanStringify = scan(stringifyOp)
-
-const fetchOp
-    : operator.Scan<rangeMap.Entry<sortedSet.SortedSet<string>>, sortedSet.SortedSet<string>>
-    = ([item, _]) => [item, fetchOp]
-
-const scanFetch = scan(fetchOp)
-
-const addEntry
-    : (grammar: Grammar) => operator.Fold<sortedSet.SortedSet<string>, Dfa>
-    = grammar => set => dfa => {
-    const s = stringifyIdentity(set)
-    if (s in dfa) { return dfa }
-    const setMap = fold(foldOp(set))(emptyList)(grammar)
-    const stringMap = toArray(scanStringify(setMap))
-    const newDfa = { ...dfa, [s]: stringMap }
-    const newStates = scanFetch(setMap)
-    return fold(addEntry(grammar))(newDfa)(newStates)
-}
-
-const emptyState: string[] = []
-
-const emptyStateStringify = stringifyIdentity(emptyState)
-
-const initialState = ['']
-
-const initialStateStringify = stringifyIdentity(initialState)
-
-export const dfa
-    : (grammar: Grammar) => Dfa
-    = grammar => addEntry(grammar)(initialState)({})
-
-const get = rangeMap.get(emptyStateStringify)
-
-const runOp
-    : (dfa: Dfa) => operator.Fold<number, string>
-    = dfa => input => s => get(input)(dfa[s])
-
-export const run
-    : (dfa: Dfa) => (input: list.List<number>) => list.List<string>
-    = dfa => input => foldScan(runOp(dfa))(initialStateStringify)(input)

package/fsm/test.f.ts

@@ -1,139 +0,0 @@
-import * as _ from './module.f.ts'
-import * as byteSet from '../types/byte_set/module.f.ts'
-import * as o from '../types/object/module.f.ts'
-const { sort, fromEntries } = o
-import * as json from '../json/module.f.ts'
-import * as f from '../types/function/module.f.ts'
-const { identity } = f
-import * as list from '../types/list/module.f.ts'
-const { toArray } = list
-import * as utf16 from '../text/utf16/module.f.ts'
-const { stringToList } = utf16
-
-const stringifyIdentity = json.stringify(identity)
-
-const buildDfa = () => {
-    const lowercaseAlpha = _.toRange('az')
-    const uppercaseAlpha = _.toRange('AZ')
-    const alpha = byteSet.union(lowercaseAlpha)(uppercaseAlpha)
-    const idSymbol = _.toUnion('_$')
-    const idBegin = byteSet.union(alpha)(idSymbol)
-    const digit = _.toRange('09')
-    const idNext = byteSet.union(idBegin)(digit)
-    const dot = _.toUnion('.')
-
-    const grammar
-        : _.Grammar
-        = [
-        ['', digit, 'int'],
-        ['int', digit, 'int'],
-        ['', digit, 'floatBegin'],
-        ['floatBegin', digit, 'floatBegin'],
-        ['floatBegin', dot, 'floatDot'],
-        ['floatDot', digit, 'float'],
-        ['float', digit, 'float'],
-        ['', idBegin, 'id'],
-        ['id', idNext, 'id']
-    ]
-    return _.dfa(grammar)
-}
-
-export default {
-    dfa: () => {
-        const dfa = buildDfa()
-        const entries = Object.entries(dfa)
-        const sortedEntries = sort(entries)
-        const obj = fromEntries(sortedEntries)
-        const result = stringifyIdentity(obj)
-
-        const expectedObj = {
-            '[""]': [
-                [ '[]', 35 ],
-                [ '["id"]', 36 ],
-                [ '[]', 47 ],
-                [ '["floatBegin","int"]', 57 ],
-                [ '[]', 64 ],
-                [ '["id"]', 90 ],
-                [ '[]', 94 ],
-                [ '["id"]', 95 ],
-                [ '[]', 96 ],
-                [ '["id"]', 122 ]
-            ],
-            '["float"]': [ [ '[]', 47 ], [ '["float"]', 57 ] ],
-            '["floatBegin","int"]': [
-                [ '[]', 45 ],
-                [ '["floatDot"]', 46 ],
-                [ '[]', 47 ],
-                [ '["floatBegin","int"]', 57 ]
-            ],
-            '["floatDot"]': [ [ '[]', 47 ], [ '["float"]', 57 ] ],
-            '["id"]': [
-                [ '[]', 35 ],
-                [ '["id"]', 36 ],
-                [ '[]', 47 ],
-                [ '["id"]', 57 ],
-                [ '[]', 64 ],
-                [ '["id"]', 90 ],
-                [ '[]', 94 ],
-                [ '["id"]', 95 ],
-                [ '[]', 96 ],
-                [ '["id"]', 122 ]
-            ],
-            '[]': []
-        };
-        const expectedResult = stringifyIdentity(expectedObj)
-
-        if (result !== expectedResult) {throw result }
-    },
-    run: [
-        () => {
-            const dfa = buildDfa()
-            const input = stringToList('a1')
-            const result = stringifyIdentity(toArray(_.run(dfa)(input)))
-
-            const expectedOutput = [
-                '["id"]',
-                '["id"]'
-            ]
-            const expectedResult = stringifyIdentity(expectedOutput)
-            if (result !== expectedResult) { throw result }
-        },
-        () => {
-            const dfa = buildDfa()
-            const input = stringToList('0.1')
-            const result = stringifyIdentity(toArray(_.run(dfa)(input)))
-
-            const expectedOutput = [
-                '["floatBegin","int"]',
-                '["floatDot"]',
-                '["float"]'
-            ]
-            const expectedResult = stringifyIdentity(expectedOutput)
-            if (result !== expectedResult) { throw result }
-        },
-        () => {
-            const dfa = buildDfa()
-            const input = stringToList('//')
-            const result = stringifyIdentity(toArray(_.run(dfa)(input)))
-
-            const expectedOutput = [
-                '[]',
-                '[]'
-            ]
-            const expectedResult = stringifyIdentity(expectedOutput)
-            if (result !== expectedResult) { throw result }
-        },
-        () => {
-            const dfa = buildDfa()
-            const input = stringToList('::')
-            const result = stringifyIdentity(toArray(_.run(dfa)(input)))
-
-            const expectedOutput = [
-                '[]',
-                '[]'
-            ]
-            const expectedResult = stringifyIdentity(expectedOutput)
-            if (result !== expectedResult) { throw result }
-        }
-    ]
-}

package/funding.json

@@ -1,61 +0,0 @@
-{
-    "version": "v1.0.0",
-    "entity": {
-        "type": "individual",
-        "role": "owner",
-        "name": "Sergey Shandar",
-        "email": "sergey.oss@proton.me",
-        "description": "Sergey is the main author of FunctionalScript, and other OSS projects related to content-addressable infrastructure",
-        "webpageUrl": {
-            "url": "https://github.com/functionalscript/functionalscript"
-        }
-    },
-    "projects": [
-        {
-            "guid": "functionalscript",
-            "name": "FunctionalScript",
-            "description": "FunctionalScript is a purely functional safe subset of JavaScript",
-            "webpageUrl": {
-                "url": "https://github.com/functionalscript/functionalscript"
-            },
-            "repositoryUrl": {
-                "url": "https://github.com/functionalscript/functionalscript"
-            },
-            "licenses": [
-                "spdx:AGPL-3.0-only"
-            ],
-            "tags": [
-                "programming",
-                "web-development",
-                "software-engineering",
-                "developer-tools",
-                "programming-language",
-                "cryptography",
-                "smart-contract"
-            ]
-        }
-    ],
-    "funding": {
-        "channels": [
-            {
-                "guid": "github",
-                "type": "other",
-                "address": "https://github.com/sponsors/sergey-shandar"
-            }
-        ],
-        "plans": [
-            {
-                "guid": "nanvm",
-                "status": "active",
-                "name": "NaNVM",
-                "description": "NaNVM is a virtual machine for the FunctionalScript",
-                "amount": 0,
-                "currency": "USD",
-                "frequency": "one-time",
-                "channels": [
-                    "github"
-                ]
-            }
-        ]
-    }
-}

package/html/README.md

@@ -1,32 +0,0 @@
-# HTML
-
-|HTML                                        |FunctionalScript DSL                             |
-|--------------------------------------------|-------------------------------------------------|
-|`<br>`                                      |`['br']`                                         |
-|`<img src="https://example.com/image.jpg">` |`['img',{src:'https://example.com/image.jpg'}]`  |
-|`<a href="https://example.com/">Example</a>`|`['a',{href:'https://example.com/'}, 'Example']` |
-|`<ul><li>Apple</li><li>Tomato</li></ul>`    |`['ul',['li','Apple'],['li','Tomato']]`          |
-
-## Example
-
-```html
-<html>
-    <head>
-        <title>Page</title>
-    </head>
-    <body>
-        <a href="https://example.com/">Example</a>
-    </body>
-</html>
-```
-
-```js
-['html',
-    ['head',
-        ['title', 'Page']
-    ]
-    ['body',
-        ['a', { href: 'https://example.com/' }, 'Example']
-    ]
-]
-```

package/html/module.f.ts

@@ -1,109 +0,0 @@
-import { map, flatMap, flat, concat as listConcat, type List } from '../types/list/module.f.ts'
-import { concat as stringConcat } from '../types/string/module.f.ts'
-import * as O from '../types/object/module.f.ts'
-import { compose } from '../types/function/module.f.ts'
-import * as utf16 from '../text/utf16/module.f.ts'
-const { stringToList } = utf16
-const { fromCharCode } = String
-const { entries } = Object
-
-type Tag = string
-
-/**
- * Void Elements
- *
- * https://developer.mozilla.org/en-US/docs/Glossary/Void_element
- */
-const voidTagList = [
-    'area',
-    'base',
-    'br',
-    'col',
-    'embed',
-    'hr',
-    'img',
-    'input',
-    'link',
-    'meta',
-    'param',
-    'source',
-    'track',
-    'wbr',
-] as const
-
-type VoidTagList = typeof voidTagList
-
-type VoidTag = keyof VoidTagList
-
-const isVoid
-    : (tag: string) => boolean
-    = tag => (voidTagList as readonly string[]).includes(tag)
-
-type Element1 = readonly[Tag, ...Node[]]
-
-type Element2 = readonly[Tag, Attributes, ...Node[]]
-
-export type Element = Element1 | Element2
-
-type Attributes = {
-    readonly[k in string]: string
-}
-
-type Node = Element | string
-
-/**
- * https://stackoverflow.com/questions/7381974/which-characters-need-to-be-escaped-in-html
- */
-const escapeCharCode
-    : (code: number) => string
-    = code => {
-    switch (code) {
-        case 0x22: return '"'
-        case 0x26: return '&'
-        case 0x3C: return '<'
-        case 0x3E: return '>'
-        default: return fromCharCode(code)
-    }
-}
-
-const escape = compose(stringToList)(map(escapeCharCode))
-
-const node
-: (n: Node) => List<string>
-= n => typeof n === 'string' ? escape(n) : element(n)
-
-const nodes = flatMap(node)
-
-const attribute
-: (a: O.Entry<string>) => List<string>
-= ([name, value]) => flat([[' ', name, '="'], escape(value), ['"']])
-
-const attributes
-: (a: Attributes) => List<string>
-= compose(entries)(flatMap(attribute))
-
-const open
-: (t: string) => (a: Attributes) => List<string>
-= t => a => flat([[`<`, t], attributes(a), [`>`]])
-
-const element3
-: (t: string) => (an: readonly[Attributes, readonly Node[]]) => List<string>
-= t => ([a, n]) => {
-    const o = flat([[`<`, t], attributes(a), [`>`]])
-    return isVoid(t) ? o : flat([o, nodes(n), ['</', t, '>']])
-}
-
-export const element
-: (element: Element) => List<string>
-= e => {
-    const [t, a, ...n] = e
-    return element3(t)(a === undefined ? [{}, []]: typeof a === 'object' && !(a instanceof Array) ? [a, n] : [{}, [a, ...n]])
-}
-
-export const html
-: (_: Element) => List<string>
-= compose(element)(listConcat(['<!DOCTYPE html>']))
-
-export const htmlToString
-: (_: Element) => string
-= compose(html)(stringConcat)

package/html/test.f.ts

@@ -1,37 +0,0 @@
-import * as _ from './module.f.ts'
-
-export default {
-    empty: () => {
-        const r = _.htmlToString(['html'])
-        if (r !== '<!DOCTYPE html><html></html>') { throw `empty: ${r}` }
-    },
-    empty2: () => {
-        const r = _.htmlToString(['html'])
-        if (r !== '<!DOCTYPE html><html></html>') { throw r }
-    },
-    void: () => {
-        const r = _.htmlToString(['area'])
-        if (r !== '<!DOCTYPE html><area>') { throw r }
-    },
-    some: () => {
-        const x
-            : _.Element
-            = ['div', {}, '<div>&amp;</div>', ['a', { href: 'hello"' }]]
-        const s = _.htmlToString(x)
-        if (s !== '<!DOCTYPE html><div>&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') { throw s }
-    },
-    some2: () => {
-        const x
-            : _.Element
-            = ['div', '<div>&amp;</div>', ['a', { href: 'hello"' }]]
-        const s = _.htmlToString(x)
-        if (s !== '<!DOCTYPE html><div>&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') { throw s }
-    },
-    someVoid: () => {
-        const x
-            : _.Element
-            = ['div', ['br', {id: '5'}], '<div>&amp;</div>', ['a', { href: 'hello"' }]]
-        const s = _.htmlToString(x)
-        if (s !== '<!DOCTYPE html><div><br id="5">&lt;div&gt;&amp;amp;&lt;/div&gt;<a href="hello&quot;"></a></div>') { throw s }
-    }
-}

package/issues/01-test-debug.md

@@ -1,3 +0,0 @@
-# Allow Debugging During Test Run
-
-Limitations: without a parser, we are not able to get full coverage.

package/issues/02-esm.md

@@ -1,8 +0,0 @@
-# Switching to ESM
-
-We need ESM for such systems like Deno, JSR and browsers.
-
-Currently, the biggest obstacle to using ESM is that we cannot make bundles on ESM modules without an FS parser.
-The solution is to deploy ESM modules to HTTPS.
-
-This task depends on [test-debug](./test-debug.md).

package/issues/03-djs.md

@@ -1,57 +0,0 @@
-# DJS
-
-Parse this code
-
-```js
-import a from 'c.d.mjs'
-const c = [12, 'x']
-export default { a: a, b: a, c: c}
-```
-
-Into this structure:
-
-```ts
-type Module = {
-  modules: string[]
-  func: Func
-}
-
-// the last constant from the array is a return
-type Func = Const[]
-
-type Const = Primitive | CObject | CArray |CRef | ARef 
-
-type Primitive = number|string|boolean|null|bigint
-
-type CRef = ['cref', number]
-
-type ARef = ['aref', number]
-
-type CObject = ['object', {
-  [k in string]: Const
-}]
-
-type CArray = ['array', [Const]]
-```
-
-Where `func` is a description of the function:
-
-```js
-(...args) => {
-  const const0 = [12, 'x']
-  return { a: args[0], b: args[0], c: const0}
-}
-```
-
-## Parsed Example
-
-```js
-export default
-// array of constants
-[
-  // const const0
-  ['array', [12, 'x']],
-  // return
-  ['object', { 'a': ['aref', 0], 'b': ['aref', 0], c: ['cref', 0] }]
-]
-```

package/issues/05-publish.md

@@ -1,40 +0,0 @@
-# Publishing Packages
-
-We are targeting the following systems:
-
-- JS:
-  - [X] NPM
-  - [X] JSR
-  - [ ] https://esm.sh/ optional
-- Rust:
-  - [ ] https://crates.io/
-
-The main principle is that we should be able to install FunctionalScript from Git/GitHub. Currently,
-
-- `NPM` works with Git links and `.mjs` files.
-- `JSR`. Unfortunately, JSR doesn't support JSDoc type information, see [jsr-io/jsr/issues/494](https://github.com/jsr-io/jsr/issues/494).
-- Browsers. `import * from 'https://...'`.
-
-We have two options:
-
-- Continue to use JavaScript source files and generate JSR package before publishing,
-- Switch to TypeScript source files and write [prepack](https://docs.npmjs.com/cli/v7/using-npm/scripts) script. TS files could be a problem for our parser because it doesn't strip type annotations yet.
-
-This problem will go away as soon as ECMAScript supports for [Type Annotations](https://github.com/tc39/proposal-type-annotations).
-
-## Updating Packages
-
-Currently, we regenerate `exports` in [./jsr.json](./index.f.mjs) using `npm run index` during CD (publishing) and `version` using `npm run version`. We should combine it into `update` script.
-
-We don't check in CI if it was regenerated. The idea is that CI should check if all generated files in Git are updated:
-
-- [package.json](./package.json) `version` property
-- [jsr.json](./jsr.json), `version` and `exports` property.
-
-`version` property should be the same in `package.json` and `jsr.json`.
-
-We abandoned the idea to publish on every commit on `main`. Instead, we publish only when there is an new version in the `main`. This strategy can also work for Rust packages.
-
-## CI Publishing (merge to `main`)
-
-Check if the version is new, then publish.

package/issues/11-fs-load.md

@@ -1,13 +0,0 @@
-# FS VM load/save
-
-sketch / mention future documentation on errors / exceptions and execution scheme in general, for example:
-
-The host environment has well defined operations like 'Load' (takes a "root" module path, optional extra parameters), 'Execute' (takes the successful result of 'Load', optional extra parameters), 'Save' (takes the successful result of 'Load', optional extra parameters).
-
-'Load' time errors are communicated to the host environment (e.g. to output error diagnostics on the console). In presence of load time errors there is no successful result of 'Load', so there is nothing to pass to Execute, Save. However, it makes sense to have results of a partially successful 'Load' even though they cannot be used in 'Execute', 'Save' - for example, in language server protocol scenarios.
-
-'Save' corresponds to code / data transformations other than 'Execute', e.g. bundling. 'Save' time errors are communicated to the host environment. It might make sense to have results of a partially successful 'Save' (similarly to abovementioned scenarios for partially successful 'Load' results).
-
-'Execute' corresponds to calling the function that is the default export of the "root" module and that takes produces side effects on the environment. Execution ends with a halt caused either by the inner logic of the code (e.g. the root function successfully completes, or an unhandled error happens), or by external causes (e.g. the user stops the execution).
-
-Now, does a proper FS system provide user code means to handle errors, e.g. an exception handling mechanism similar to JS's exception handling?

package/issues/17-djs-extension.md

@@ -1,6 +0,0 @@
-# `.d.js` extension conflict
-
- We use an extension `.d.js` for data JS files, but if we can't use it for TypeScript files, like `.d.ts` because it means declaration TypeScript files. There are several solutions to the problem:
-
-1. Use only `.f.js` extension but make sure that `export default` has no functions at the end. In this case we can reference `.f.js` files as well to use functions to transform data (preferred).
-2. Don't use it for TypeScript until we have type annotations in JavaScript.

package/issues/README.md

@@ -1,42 +0,0 @@
-# Issues
-
-1. [X] [test-debug](./01-test-debug.md).
-2. [X] [esm](./02-esm.md)
-3. [ ] [djs](./03-djs.md)
-4. [ ] VM Rust project
-5. [ ] [publish](./05-publish.md)
-6. [ ] fix index generation by including sub modules `{ ...m, add: mAdd, remove: mRemove}`.
-7. [ ] Conventions:
-
-    ```js
-    import list, * as List from 'list.mjs'
-    // list is for objects.
-    // List is for types and should be ignored by FJS or errored if used in code.
-    ```
-
-8. Move logic from `.mjs` files to `.f.mjs` files.
-9. [ ] Generating a Website.
-10. [ ] Short URL table.
-11. [ ] [fs-load](./11-fs-load.md)
-12. [ ] Replace file extensions from `.mjs` to `.js`. Make sure `package.json/type` is equal to `module`. May be later: https://v8.dev/features/modules#mjs
-13. [ ] Docs for JSR. See https://jsr.io/@functionalscript/functionalscript/score
-14. [ ] Combine `npm run index` and `npm run version`
-15. [ ] Generate `package.json/exports` instead of `index.f.mjs`.
-16. [ ] License in JSR file?
-17. [ ] [djs-extension](./17-djs-extension.md).
-18. [ ] Formatter for `.f.js` and `.f.ts` files.
-19. [ ] Convert FunctionalScript code using non-default `export`.
-20. [ ] Test framework should be able to run a subset of tests.
-21. [ ] Test Framework silent mode. Show progress and failed tests only.
-22. [x] bit sequences based on bigint
-23. [ ] a console program similar to one that we have in the NaNVM repo.
-24. [ ] create `./module.mjs` that supports the same behavior like current NaNVM Rust implementation:
-    - [ ] run `node ./module.mjs input.f.mjs output.f.mjs`
-    - [ ] run `deno ./module.mjs input.f.mjs output.f.mjs`
-25. [ ] Switch to Deno an `.ts`?
-    1. Deno TypeScript and Microsoft TypeScript are different https://bsky.app/profile/macwright.com/post/3lbrwioa5zs27
-    2. One day we may switch back to `.js` extension if [Type Annotation Proposal](https://github.com/tc39/proposal-type-annotations) is included into ECMAScript. BTW, we should only use JS with type annotations instead of full TypeScript.
-
-## Language Specification
-
-See [lang/README.md](./lang/README.md).