functionalscript 0.0.351 → 0.0.354

package/com/main.f.js

@@ -1,8 +1,17 @@
+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 struct: FieldArray}} Struct */
+/**
+ * @typedef {{
+ *  readonly interface?: undefined
+ *  readonly struct: FieldArray
+ * }} Struct
+ */
 
 /** @typedef {readonly Field[]} FieldArray */
 
@@ -17,14 +26,111 @@
 
 /** @typedef {readonly Method[]} MethodArray */
 
-/** @typedef {readonly[string, FieldArray, Type]} Method */
+/** @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 {'u8'|'i8'|'u16'|'i16'|'u32'|'i32'|'u64'|'i64'|'usize'|'isize'|'f32'|'f64'|'bool'}  BaseType */
 
 /** @typedef {{readonly '*': Type}} Pointer */
 
-module.exports = {}
+/** @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 =>
+    typeof(t) === 'string' ? csBaseType(t) :
+    t instanceof Array ? t[0] :
+    `${csType(t['*'])}*`
+
+/** @type {(f: Field) => string} */
+const csParam = ([name, type]) => `${csType(type)} ${name}`
+
+/** @type {(f: Field) => string} */
+const csField = f => `public ${csParam(f)};`
+
+/** @type {(m: Method) => string} */
+const csResult = m => m.length === 2 ? 'void' : csType(m[2])
+
+/** @type {(m: Method) => readonly string[]} */
+const csMethod = m => [
+    '[PreserveSig]',
+    `${csResult(m)} ${m[0]}(${list.join(',')(list.map(csParam)(m[1]))});`
+]
+
+/** @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)
+            (() => list.flatMap(csMethod)(d.interface))
+}
+
+/** @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

@@ -1,23 +1,49 @@
 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' }],
-            ['End', 'usize'],
+            ['Size', 'usize'],
         ]
     },
     IMy: {
         guid: 'C66FB270-2D80-49AD-BB6E-88C1F90B805D',
         interface: [
             ['GetSlice', [], ['Slice']],
-            ['SetSlice',
-                [['slice', ['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' +
+        '        [PreserveSig]\n' +
+        '        Slice GetSlice();\n' +
+        '        [PreserveSig]\n' +
+        '        void SetSlice(Slice slice);\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.351",
+  "version": "0.0.354",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "main.f.js",
   "scripts": {

package/test.f.js

@@ -17,6 +17,7 @@ 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

@@ -1,21 +1,27 @@
 const list = require('../types/list/main.f.js')
 
-/** @typedef {readonly Item[]} Text */
+/** @typedef {ItemThunk|ItemArray} Block */
 
-/** @typedef {string|Text} Item */
+/** @typedef {readonly Item[]} ItemArray */
 
-/** @type {(indent: string) => (text: Text) => list.List<string>} */
+/** @typedef {() => list.List<Item>} ItemThunk */
+
+/** @typedef {string|ItemArray|ItemThunk} Item */
+
+/** @type {(indent: string) => (text: Block) => 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
+
+    /** @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

@@ -2,17 +2,18 @@ const _ = require('./main.f.js')
 const list = require('../types/list/main.f.js')
 
 {
-    /** @type {_.Text} */
+    /** @type {_.Block} */
     const text = [
         'a',
         'b',
-        [
+        () => [
             'c',
-            ['d'],
-        ]
+            () => ['d'],
+        ],
+        'e',
     ]
-    const result = list.join('\n')(_.flat('_')(text))
-    if (result !== 'a\nb\n_c\n__d') { throw result }
+    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 = {