functionalscript 0.1.608 → 0.2.0

package/doc/LANGUAGE.md

@@ -1,15 +1,16 @@
 # FunctionalScript Programming Language
 
-Principals:
-- FunctionalScript VM should behaves the same way as a JavaScript VM
+Principles:
+
+- FunctionalScript VM should behaves the same way as a JavaScript VM,
 - Any unsupported feature should be reported at compile-time.
 
 ## 1. Module Ecosystem
 
-FunctionalScript uses [CommonJS](https://en.wikipedia.org/wiki/CommonJS) conventions as a module ecosystem. For example,
+FunctionalScript uses ESM conventions as a module ecosystem. For example,
 
 ```js
-const thirdPartyModule = require('third-party-package/module')
+import thirdPartyModule from 'third-party-package/module'
 
 const result = thirdPartyModule.someFunction('hello')
 ```
@@ -39,10 +40,10 @@ npm install -S github:functionalscript/functionalscript
 
 A module is a file with the `.js` extension. It contains three parts: references to other modules, definitions, and exports. For example
 
-`./first.js`
+`./first.f.mjs`
 ```js
 // 1. references
-const math = require('math')
+import math from 'math'
 
 // 2. definitions
 const myConst = 42
@@ -52,35 +53,35 @@ const add42 = addition(42)
 const _10digitsOfPi = math.calculatePi(10)
 
 // 3. exports
-module.exports = {
+export default {
    addition,
    add42,
    _10digitsOfPi,
 }
 ```
 
-`./second.js`
+`./second.f.mjs`
 ```js
 // 1. references
-const first = require('./first.js')
+import first from './first.f.mjs'
 
 // 2. definitions
 const _42plus7 = first.add42(7)
 
 // 3. exports
-module.exports = {
+export default {
    _42plus7,
 }
 ```
 
 ## 4. References To Other Modules
 
-The format of references is `const ANYNAME = require('PATH_TO_A_MODULE')`. For example,
+The format of references is `import ANYNAME from 'PATH_TO_A_MODULE'`. For example,
 
 ```js
-const math = require('math')
-const algebra = require('math/algebra')
-const localFile = require('../some-directory/some-file.js')
+import math from 'math'
+import algebra from 'math/algebra'
+import localFile from '../some-directory/some-file.f.mjs'
 ```
 
 ## 5. Definitions
@@ -107,11 +108,11 @@ See [Expressions](#7-Expressions).
 
 ### 6. Exports
 
-The format of exports is `module.exports = { A_LIST_OF_EXPORTED_DEFINITIONS }`. There should be only one `module.exports` at
+The format of exports is `export default { A_LIST_OF_EXPORTED_DEFINITIONS }`. There should be only one `export default` at
 the end of a FunctionalScript file. For example,
 
 ```js
-module.exports = {
+export default {
    nestedStructure,
    array,
    structure,

package/doc/README.md

@@ -1,76 +1,40 @@
 # Documentation
 
-FunctionalScript files have `.f.cjs` file extensions because it's using a `Common.JS` module system. We plan to add 
-ESM support when we have the first parser working. See
-[ESM. Resolver Algorithm Specification](https://nodejs.org/api/esm.html#resolver-algorithm-specification)
-and [ESM. Enabling](https://nodejs.org/docs/latest-v13.x/api/esm.html#esm_enabling).
+FunctionalScript files have `.f.mjs` file extensions because it's using the ES module system.
 
-## 1. Creating a New Repository
+## 1. Language
 
-Creating from a template https://github.com/functionalscript/template/generate
-
-## 1.1. Creating From Scratch
-
-Prerequisites:
-
-- [Git](https://git-scm.com/).
-- [Node.js](https://nodejs.org/en/).
-- GitHub account.
-
-Creating a new GitHub repository
-
-1. Create a public git repository on GitHub using Node template.
-2. Clone the repository.
-3. Go to the root directory of the cloned repository.
-4. Run `npm init`. It should create `package.json` file.
-5. Create a `main.f.cjs` file in the repository root directory.
-6. Edit the `main.f.cjs` file. For example
-    ```js
-    module.exports = "Hello world!"
-    ```
-11. Go to [functionalscript.com](https://functionalscript.com) and enter `github:YOUR_GITHUB_NAME/YOUR_REPOSITORY_NAME`. Press `Build`.
-
-### 1.1. Optional
-
-1. Install [Visual Studio Code](https://code.visualstudio.com/).
-2. Add [TypeScript](https://www.typescriptlang.org/) to your repository for static type checking.
-   1. Run `npm install -D typescript`.
-   2. Run `npx tsc --init`. It should create `tsconfig.json` file.
-   3. Uncomment `"allowJs": true,` and `"checkJs": true` in the `tsconfig.json` file.
-
-## 2. Language
-
-### 2.1. Exports
+### 1.1. Exports
 
 ```js
-module.exports = 'Hello world!'
+export default 'Hello world!'
 ```
 
 ```js
-module.exports = { a: 'hello', b: 42 }
+export default { a: 'hello', b: 42 }
 ```
 
 ```js
-module.exports = x => x * x
+export default x => x * x
 ```
 
-### 2.2. Reference Another Module
+### 1.2. Reference Another Module
 
-#### 2.2.1. Local File
+#### 1.2.1. Local File
 
 ```js
-const x = require('./folder/main.f.cjs')
+import x from './folder/main.f.mjs'
 ```
 
-### 2.2.2. External Module
+### 1.2.2. External Module
 
 Run `npm install -D github:USER/REPO`
 
 ```js
-const x = require(`REPO/DIR/FILE.f.cjs`)
+import x from `REPO/DIR/FILE.f.mjs`
 ```
 
-### 2.3. Functions
+### 1.3. Functions
 
 ```js
 const f = x => x * x
@@ -83,9 +47,9 @@ const sum = ar => ar.reduce((a, i) => a + i, 0)
 const sumResult = sum([1, 2, 3])
 ```
 
-## 3. Advanced
+## 2. Advanced
 
-### 3.1. Generators
+### 2.1. Generators
 
 ```js
 const range5 = {*[System.iterator]() {

package/fsc/README.md

@@ -76,7 +76,6 @@
   - `do` ?
   - `else`
   - `export`
-  - `exports` <= non-standard
   - `false`
   - `function` ?
   - `globalThis` ?
@@ -86,11 +85,9 @@
   - `in`
   - `instanceof`
   - `let`
-  - `module` <= non-standard
   - `new` ?
   - `null`
   - `of`
-  - `require`  <= non-standard
   - `return`
   - `super`
   - `switch`

package/fsc/module.f.d.mts

@@ -1,12 +1,7 @@
-declare namespace _default {
-    export { terminal };
-    export { init };
-}
-export default _default;
+export const terminal: -1;
+export const init: ToResult;
 export type Result = readonly [readonly string[], ToResult];
 export type ToResult = (codePoint: number) => Result;
 export type CreateToResult<T> = (state: T) => ToResult;
-export type State<T> = RM.RangeMapArray<CreateToResult<T>>;
-declare const terminal: -1;
-declare const init: ToResult;
-import * as RM from '../types/range_map/module.f.mjs';
+export type State<T> = rangeMap.RangeMapArray<CreateToResult<T>>;
+import * as rangeMap from '../types/range_map/module.f.mjs';

package/fsc/module.f.mjs

@@ -1,15 +1,15 @@
 // @ts-self-types="./module.f.d.mts"
-import operator from '../types/function/operator/module.f.mjs'
-import range_map, * as RM from '../types/range_map/module.f.mjs'
-const { merge: rangeMapMerge, fromRange, get } = range_map
-import list, * as List from '../types/list/module.f.mjs'
+import * as operator from '../types/function/operator/module.f.mjs'
+import * as rangeMap from '../types/range_map/module.f.mjs'
+const { merge: rangeMapMerge, fromRange, get } = rangeMap
+import * as list from '../types/list/module.f.mjs'
 const { reduce: listReduce } = list
-import ascii from '../text/ascii/module.f.mjs'
+import * as ascii from '../text/ascii/module.f.mjs'
 const { range: asciiRange } = ascii
 const { fromCharCode } = String
-import f from '../types/function/module.f.mjs'
+import * as f from '../types/function/module.f.mjs'
 const { fn } = f
-import _range, * as Range from '../types/range/module.f.mjs'
+import * as _range from '../types/range/module.f.mjs'
 const { one } = _range
 const { toArray, map } = list
 
@@ -24,7 +24,7 @@ const { toArray, map } = list
 
 /**
  * @template T
- * @typedef {RM.RangeMapArray<CreateToResult<T>>} State
+ * @typedef {rangeMap.RangeMapArray<CreateToResult<T>>} State
  */
 
 /** @type {ToResult} */
@@ -43,10 +43,10 @@ const union = a => b => {
 /** @type {readonly never[]} */
 const empty = []
 
-/** @type {<T>(a: List.List<State<T>>) => State<T>} */
+/** @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 {RM.RangeMerge<CreateToResult<T>>} */
+    /** @typedef {typeof a extends list.List<State<infer T>> ? T : never} T */
+    /** @type {rangeMap.RangeMerge<CreateToResult<T>>} */
     const merge = rangeMapMerge({
         union,
         equal: operator.strictEqual,
@@ -61,28 +61,28 @@ 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>} */
+    /** @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>} */
+/** @type {<T>(a: list.List<State<T>>) => CreateToResult<T>} */
 const create = a => {
-    /** @typedef {typeof a extends List.List<State<infer T>> ? T : never} T */
+    /** @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
+export const terminal = -1
 
 /** @type {() => ToResult} */
 const toInit = () => () => [[], init]
 
-const init = create([
+export const init = create([
     codePointRange(one(terminal))(toInit),
     rangeSet(['\t', ' ', '\n', '\r'])(toInit),
     range('!')(() => () => [['!'], unexpectedSymbol]),
@@ -114,11 +114,4 @@ const init = create([
     range('|')(() => () => [['|'], unexpectedSymbol]),
     range('}')(() => () => [['}'], unexpectedSymbol]),
     range('~')(() => () => [['~'], unexpectedSymbol]),
-])(void 0)
-
-export default {
-    /** @readonly */
-    terminal,
-    /** @readonly */
-    init,
-}
+])(undefined)

package/fsc/test.f.mjs

@@ -1,7 +1,7 @@
-import _ from './module.f.mjs'
-import ascii from '../text/ascii/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as ascii from '../text/ascii/module.f.mjs'
 const { one } = ascii
-import j from '../json/module.f.mjs'
+import * as j from '../json/module.f.mjs'
 const { stringify } = j
 const s = stringify(i => i)
 

package/fsm/README.md

@@ -107,7 +107,7 @@ const b = { ...a, z: 7 }
 ## How to Add a Property # 2
 
 ```js
-const map = require('./types/map/module.f.js')
+import map from './types/map/module.f.mjs'
 const a = map.fromEntries(Object.entries({ x: 5, y: 6 }))
 const b = map.setReplace('z')(7)(a)
 ```

package/fsm/module.f.d.mts

@@ -1,21 +1,14 @@
-declare namespace _default {
-    export { dfa };
-    export { run };
-    export { toRange };
-    export { toUnion };
-}
-export default _default;
-export type Rule = readonly [string, byteSetT.ByteSet, string];
-export type Grammar = List.List<Rule>;
-export type Dfa = { readonly [state in string]: RM.RangeMapArray<string>; };
+/** @type {(s: string) => byteSet.ByteSet} */
+export const toRange: (s: string) => byteSet.ByteSet;
+/** @type {(s: string) => byteSet.ByteSet} */
+export const toUnion: (s: string) => byteSet.ByteSet;
 /** @type {(grammar: Grammar) => Dfa} */
-declare const dfa: (grammar: Grammar) => Dfa;
-/** @type {(dfa: Dfa) => (input: List.List<number>) => List.List<string>} */
-declare const run: (dfa: Dfa) => (input: List.List<number>) => List.List<string>;
-/** @type {(s: string) => byteSetT.ByteSet} */
-declare const toRange: (s: string) => byteSetT.ByteSet;
-/** @type {(s: string) => byteSetT.ByteSet} */
-declare const toUnion: (s: string) => byteSetT.ByteSet;
-import * as byteSetT from '../types/byte_set/module.f.mjs';
-import * as List from '../types/list/module.f.mjs';
-import * as RM from '../types/range_map/module.f.mjs';
+export const dfa: (grammar: Grammar) => Dfa;
+/** @type {(dfa: Dfa) => (input: list.List<number>) => list.List<string>} */
+export const run: (dfa: Dfa) => (input: list.List<number>) => list.List<string>;
+export type Rule = readonly [string, byteSet.ByteSet, string];
+export type Grammar = list.List<Rule>;
+export type Dfa = { readonly [state in string]: rangeMap.RangeMapArray<string>; };
+import * as byteSet from '../types/byte_set/module.f.mjs';
+import * as list from '../types/list/module.f.mjs';
+import * as rangeMap from '../types/range_map/module.f.mjs';

package/fsm/module.f.mjs

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

package/fsm/test.f.mjs

@@ -1,13 +1,13 @@
-import _, * as T from './module.f.mjs'
-import byteSet from '../types/byte_set/module.f.mjs'
-import o from '../types/object/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as byteSet from '../types/byte_set/module.f.mjs'
+import * as o from '../types/object/module.f.mjs'
 const { sort, fromEntries } = o
-import json from '../json/module.f.mjs'
-import f from '../types/function/module.f.mjs'
+import * as json from '../json/module.f.mjs'
+import * as f from '../types/function/module.f.mjs'
 const { identity } = f
-import list from '../types/list/module.f.mjs'
+import * as list from '../types/list/module.f.mjs'
 const { toArray } = list
-import utf16 from '../text/utf16/module.f.mjs'
+import * as utf16 from '../text/utf16/module.f.mjs'
 const { stringToList } = utf16
 
 const stringifyIdentity = json.stringify(identity)
@@ -22,7 +22,7 @@ const buildDfa = () => {
     const idNext = byteSet.union(idBegin)(digit)
     const dot = _.toUnion('.')
 
-    /** @type {T.Grammar} */
+    /** @type {_.Grammar} */
     const grammar = [
         ['', digit, 'int'],
         ['int', digit, 'int'],

package/html/README.md

@@ -5,3 +5,27 @@
 |`<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']]`|
+
+## 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.d.mts

@@ -1,9 +1,7 @@
-declare namespace _default {
-    export { element };
-    export { html };
-    export { htmlToString };
-}
-export default _default;
+/** @type {(element: Element) => list.List<string>} */
+export const element: (element: Element) => list.List<string>;
+export const html: f.Func<Element, list.List<string>>;
+export const htmlToString: f.Func<Element, string>;
 export type Tag = string;
 export type Element1 = readonly [Tag];
 export type Element2A = readonly [Tag, Attributes];
@@ -11,10 +9,7 @@ export type Element2N = readonly [Tag, readonly Node[]];
 export type Element3 = readonly [Tag, Attributes, Nodes];
 export type Element = Element1 | Element2A | Element2N | Element3;
 export type Attributes = { readonly [k in string]: string; };
-export type Nodes = List.List<Node>;
+export type Nodes = list.List<Node>;
 export type Node = Element | string;
-/** @type {(element: Element) => List.List<string>} */
-declare const element: (element: Element) => List.List<string>;
-declare const html: import("../types/function/module.f.mjs").Func<Element, List.List<string>>;
-declare const htmlToString: import("../types/function/module.f.mjs").Func<Element, string>;
-import * as List from '../types/list/module.f.mjs';
+import * as list from '../types/list/module.f.mjs';
+import * as f from '../types/function/module.f.mjs';