functionalscript 0.0.350 → 0.0.353

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,115 @@
+const text = require('../text/main.f.js')
+const list = require('../types/list/main.f')
+const obj = require('../types/object/main.f.js')
+
+/** @typedef {{readonly[k in string]: Definition}} Library */
+
+/** @typedef {Struct|Interface} Definition */
+
+/**
+ * @typedef {{
+ *  readonly interface?: undefined
+ *  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]} GetMethod */
+
+/** @typedef {readonly[string, FieldArray]} SetMethod */
+
+/** @typedef {GetMethod|SetMethod} 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 */
+
+/** @type {(v: string) => string} */
+const csUsing = v => `using ${v};`
+
+/** @type {(type: string) => (name: string) => (body: text.Block) => text.Block} */
+const csBlock = type => name => body => [`${type} ${name}`, '{', body, '}']
+
+/** @type {(attributes: list.List<string>) => (type: string) => (name: string) => (body: text.Block) => list.List<text.Item>} */
+const csTypeDef = attributes => type => name => body =>
+    list.flat([
+        list.map(v=>`[${v}]`)(attributes),
+        csBlock(`public ${type}`)(name)(body)
+    ])
+
+/** @type {(t: BaseType) => string} */
+const csBaseType = t => {
+    switch (t) {
+        case 'bool': return 'bool'
+        case 'f32': return 'float'
+        case 'f64': return 'double'
+        case 'i16': return 'short'
+        case 'i32': return 'int'
+        case 'i64': return 'long'
+        case 'i8': return 'sbyte'
+        case 'isize': return 'IntPtr'
+        case 'u16': return 'ushort'
+        case 'u32': return 'uint'
+        case 'u64': return 'ulong'
+        case 'u8': return 'byte'
+        case 'usize': return 'UIntPtr'
+    }
+}
+
+/** @type {(t: Type) => string} */
+const csType = t => {
+    if (typeof(t) === 'string') {
+        return csBaseType(t)
+    }
+    if (t instanceof Array) {
+        return t[0]
+    }
+    return `${csType(t['*'])}*`
+}
+
+/** @type {(f: Field) => string} */
+const csField = f => `public ${csType(f[1])} ${f[0]};`
+
+/** @type {(e: obj.Entry<Definition>) => list.List<text.Item>} */
+const csDef = ([n, d]) => {
+    const i = d.interface
+    return i === undefined ?
+        csTypeDef(['StructLayout(LayoutKind.Sequential)'])('struct')(n)(() => list.map(csField)(d.struct)) :
+        csTypeDef([`Guid("${d.guid}")`,'InterfaceType(ComInterfaceType.InterfaceIsUnknown)'])('interface')(n)([])
+}
+
+/** @type {(name: string) => (library: Library) => text.Block} */
+const cs = name => library => {
+    const v = list.flatMap(csDef)(Object.entries(library))
+
+    /** @type {text.Block} */
+    const h = [
+        csUsing('System'),
+        csUsing('System.Runtime.InteropServices'),
+        ''
+    ]
+
+    const ns = csBlock('namespace')(name)(() => v)
+    return () => list.flat([h, ns])
+}
+
+module.exports = {
+    /** @readonly */
+    cs,
+}

package/com/test.f.js

@@ -0,0 +1,45 @@
+const _ = require('./main.f.js')
+const list = require('../types/list/main.f.js')
+const text = require('../text/main.f.js')
+
+/** @type {_.Library} */
+const library = {
+    Slice: {
+        struct: [
+            ['Start', { '*': 'u8' }],
+            ['Size', 'usize'],
+        ]
+    },
+    IMy: {
+        guid: 'C66FB270-2D80-49AD-BB6E-88C1F90B805D',
+        interface: [
+            ['GetSlice', [], ['Slice']],
+            ['SetSlice', [['slice', ['Slice']]]],
+        ],
+    }
+}
+
+{
+    const cs = list.join('\n')(text.flat('    ')(_.cs('My')(library)))
+    const e =
+        'using System;\n' +
+        'using System.Runtime.InteropServices;\n' +
+        '\n' +
+        'namespace My\n' +
+        '{\n' +
+        '    [StructLayout(LayoutKind.Sequential)]\n' +
+        '    public struct Slice\n' +
+        '    {\n' +
+        '        public byte* Start;\n' +
+        '        public UIntPtr Size;\n' +
+        '    }\n' +
+        '    [Guid("C66FB270-2D80-49AD-BB6E-88C1F90B805D")]\n' +
+        '    [InterfaceType(ComInterfaceType.InterfaceIsUnknown)]\n' +
+        '    public interface IMy\n' +
+        '    {\n' +
+        '    }\n' +
+        '}'
+    if (cs !== e) { throw [cs,e] }
+}
+
+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.350",
+  "version": "0.0.353",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "main.f.js",
   "scripts": {

package/test.f.js

@@ -16,6 +16,8 @@ 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')
+require('./com/test.f.js')
 
 /** @type {() => never} */
 const assert = () => { throw 'assert' }

package/text/main.f.js

@@ -0,0 +1,27 @@
+const list = require('../types/list/main.f.js')
+
+/** @typedef {ItemThunk|ItemArray} Block */
+
+/** @typedef {readonly Item[]} ItemArray */
+
+/** @typedef {() => list.List<Item>} ItemThunk */
+
+/** @typedef {string|ItemArray|ItemThunk} Item */
+
+/** @type {(indent: string) => (text: Block) => list.List<string>} */
+const flat = indent => {
+
+    /** @type {(prefix: string) => (text: Block) => list.List<string>} */
+    const f = prefix => {
+        /** @type {(item: Item) => list.List<string>} */
+        const g = item => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item)
+        return list.flatMap(g)
+    }
+
+    return f('')
+}
+
+module.exports = {
+    /** @readonly */
+    flat,
+}

package/text/test.f.js

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

package/types/list/main.f.js

@@ -172,8 +172,7 @@ const drop = n => apply(dropStep(n))
 /** @type {<D>(def: D) => <T>(input: List<T>) => D|T} */
 const first = def => input => {
     const result = next(input)
-    if (result === undefined) { return def }
-    return result.first
+    return result === undefined ? def : result.first
 }
 
 /** @type {<D>(first: D) => <T>(tail: List<T>) => D|T} */
@@ -215,6 +214,9 @@ const countdown = count => () => {
     return { first, tail: countdown(first) }
 }
 
+/** @type {<T>(v: T) => (c: number) => List<T>} */
+const repeat = v => n => map(() => v)(countdown(n))
+
 /** @type {<T>(list: List<T>) => List<T>} */
 const cycle = list => () => {
     const i = next(list)
@@ -355,6 +357,8 @@ module.exports = {
     /** @readonly */
     countdown,
     /** @readonly */
+    repeat,
+    /** @readonly */
     cycle,
     /** @readonly */
     scan,

package/types/list/test.f.js

@@ -354,6 +354,16 @@ const stress = () => {
     }
 }
 
+{
+    const s = _.join('.')(_.repeat('x')(0))
+    if (s != '') { throw s }
+}
+
+{
+    const s = _.join('.')(_.repeat('x')(5))
+    if (s != 'x.x.x.x.x') { throw s }
+}
+
 // stress()
 
 module.exports = {