functionalscript 0.0.349 → 0.0.352

package/LANGUAGE.md

@@ -206,3 +206,43 @@ const f = () => x // < invalid
 ### 9.7. Block
 
 [Block](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/block)
+
+## 10. Generators
+
+For compatibility reason, FunctionalScript allows to create generators as implementation of `[Symbol.iterator]` function. However, it doesn't allow to read the `[Symbol.iterator]` property. For example
+
+This code is allowed
+
+```js
+/** @type {<T>(list: List<T>) => Iterable<T>} */
+const iterable = list => ({
+    *[Symbol.iterator]() {
+        let i = list
+        while (true) {
+            const r = next(i)
+            if (r === undefined) { return }
+            yield r.first
+            i = r.tail
+        }
+    }
+})
+```
+
+The following code is not allowed, because `iterator` is a mutated object by design in JavaScript.
+
+```js
+const it = [0, 1, 2][Symbol.iterator] //< compilation error.
+```
+
+Use `Iterable` instead of `Iterator`.
+
+```js
+const x = () => {
+    const a = [0, 1, 2] // iterable
+    let sum = 0;
+    for (let i in a) {
+        sum = sum + i
+    }
+    return sum;
+}
+```

package/com/README.md

@@ -0,0 +1,3 @@
+# COM (Component Object Model)
+
+Basic Types: `f32`, `f64`, `u8`, `i8`, `u16`, `i16`, `u32`, `i32`, `u64`, `i64`, `usize`, `isize`, `bool`, ``.

package/com/main.f.js

@@ -0,0 +1,30 @@
+/** @typedef {{readonly[k in string]: Definition}} Library */
+
+/** @typedef {Struct|Interface} Definition */
+
+/** @typedef {{readonly struct: FieldArray}} Struct */
+
+/** @typedef {readonly Field[]} FieldArray */
+
+/** @typedef {[string, Type]} Field */
+
+/**
+ * @typedef {{
+ *  readonly interface: MethodArray
+ *  readonly guid: string
+ * }} Interface
+ */
+
+/** @typedef {readonly Method[]} MethodArray */
+
+/** @typedef {readonly[string, FieldArray, Type]} Method */
+
+/** @typedef {BaseType|Id|Pointer} Type */
+
+/** @typedef {readonly[string]} Id */
+
+/** @typedef {'u8'|'i8'|'u16'|'i16'|'u32'|'i32'|'u64'|'i64'|'usize'|'isize'|'f32'|'f64'|'bool'|''}  BaseType */
+
+/** @typedef {{readonly '*': Type}} Pointer */
+
+module.exports = {}

package/com/test.f.js

@@ -0,0 +1,23 @@
+const _ = require('./main.f.js')
+
+/** @type {_.Library} */
+const library = {
+    Slice: {
+        struct: [
+            ['Start', { '*': 'u8' }],
+            ['End', 'usize'],
+        ]
+    },
+    IMy: {
+        guid: 'C66FB270-2D80-49AD-BB6E-88C1F90B805D',
+        interface: [
+            ['GetSlice', [], ['Slice']],
+            ['SetSlice',
+                [['slice', ['Slice']]],
+                ''
+            ],
+        ],
+    }
+}
+
+module.exports = {}

package/commonjs/README.md

@@ -2,7 +2,7 @@
 
 ## Package
 
-[package/index.js](package/index.js)
+[package/main.f.js](package/main.f.js)
 
 ```ts
 // A dictionary of packages.
@@ -31,7 +31,7 @@ type Package = {
 
 ## Module
 
-[module/index.js](module/index.js)
+[module/main.f.js](module/main.f.js)
 
 ```ts
 // A module map is a dictionary of modules.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.349",
+  "version": "0.0.352",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "main.f.js",
   "scripts": {

package/test.f.js

@@ -16,6 +16,7 @@ require('./types/stringset/test.f.js')
 require('./commonjs/build/test.f.js')
 require('./types/range/test.f.js')
 require('./html/test.f.js')
+require('./text/test.f.js')
 
 /** @type {() => never} */
 const assert = () => { throw 'assert' }

package/text/main.f.js

@@ -0,0 +1,21 @@
+const list = require('../types/list/main.f.js')
+
+/** @typedef {readonly Item[]} Text */
+
+/** @typedef {string|Text} Item */
+
+/** @type {(indent: string) => (text: Text) => list.List<string>} */
+const flat = indent => {
+    /** @type {(v: string) => string} */
+    const indentFn = v => `${indent}${v}`
+    const map = list.map(indentFn)
+    /** @type {(item: Item) => list.List<string>} */
+    const flatItem = item => typeof(item) === 'string' ? [item] : map(flatText(item))
+    const flatText = list.flatMap(flatItem)
+    return flatText
+}
+
+module.exports = {
+    /** @readonly */
+    flat,
+}

package/text/test.f.js

@@ -0,0 +1,18 @@
+const _ = require('./main.f.js')
+const list = require('../types/list/main.f.js')
+
+{
+    /** @type {_.Text} */
+    const text = [
+        'a',
+        'b',
+        [
+            'c',
+            ['d'],
+        ]
+    ]
+    const result = list.join('\n')(_.flat('_')(text))
+    if (result !== 'a\nb\n_c\n__d') { throw result }
+}
+
+module.exports = {}