functionalscript 0.0.352 → 0.0.355

package/com/cs/main.f.js

@@ -0,0 +1,112 @@
+const types = require('../types/main.f.js')
+const text = require('../../text/main.f.js')
+const list = require('../../types/list/main.f.js')
+const obj = require('../../types/object/main.f.js')
+
+/** @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: types.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 {(isUnsafe: boolean) => string} */
+const unsafe = isUnsafe => isUnsafe ? 'unsafe ' : ''
+
+/** @type {(t: types.Type) => readonly[boolean, string]} */
+const csType = t =>
+    typeof (t) === 'string' ? [false, csBaseType(t)] :
+        t instanceof Array ? [false, t[0]] :
+            [true, `${csType(t['*'])[1]}*`]
+
+/** @type {(f: types.Field) => string} */
+const csParam = ([name, type]) => `${csType(type)[1]} ${name}`
+
+/** @type {(f: types.Field) => string} */
+const csField = ([name, type]) => {
+    const [isUnsafe, t] = csType(type)
+    return `public ${unsafe(isUnsafe)}${t} ${name};`
+}
+
+/** @type {(m: types.Method) => readonly[boolean, string]} */
+const csResult = m => m.length === 2 ? [false, 'void'] : csType(m[2])
+
+/** @type {(field: types.Field) => boolean} */
+const isUnsafeField = field => csType(field[1])[0]
+
+/** @type {(m: types.Method) => readonly string[]} */
+const csMethod = m => {
+    const result = csResult(m)
+    const isUnsafe = result[0] || list.some(list.map(isUnsafeField)(m[1]))
+    return [
+        '[PreserveSig]',
+        `${unsafe(isUnsafe)}${result[1]} ${m[0]}(${list.join(', ')(list.map(csParam)(m[1]))});`
+    ]
+}
+
+/** @type {(e: obj.Entry<types.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.InterfaceIsIUnknown)'])
+            ('interface')
+            (n)
+            (() => list.flatMap(csMethod)(d.interface))
+}
+
+/** @type {(name: string) => (library: types.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/cs/test/Program.cs

@@ -0,0 +1,2 @@
+// See https://aka.ms/new-console-template for more information
+Console.WriteLine("Hello, World!");

package/com/cs/test/build.js

@@ -0,0 +1,11 @@
+const fs = require('node:fs')
+const cp = require('node:child_process')
+const cs = require('../test.f.js').result
+
+fs.writeFileSync('_result.cs', cs)
+try {
+    console.log(cp.execSync('dotnet build').toString())
+} catch (e) {
+    // @ts-ignore
+    console.log(e.output.toString())
+}

package/com/cs/test/test.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+</Project>

package/com/cs/test.f.js

@@ -0,0 +1,63 @@
+const types = require('../types/main.f.js')
+const _ = require('./main.f.js')
+const list = require('../../types/list/main.f.js')
+const text = require('../../text/main.f.js')
+
+/** @type {types.Library} */
+const library = {
+    Slice: {
+        struct: [
+            ['Start', { '*': 'u8' }],
+            ['Size', 'usize'],
+        ]
+    },
+    IMy: {
+        guid: 'C66FB270-2D80-49AD-BB6E-88C1F90B805D',
+        interface: [
+            ['GetSlice', [], ['Slice']],
+            ['SetSlice', [['slice', ['Slice']]]],
+            ['GetUnsafe', [], {'*': 'bool'}],
+            ['SetUnsafe', [['p', {'*': ['Slice']}], ['size', 'u32']]],
+        ],
+    }
+}
+
+const f = () =>
+{
+    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 unsafe byte* Start;\n' +
+        '        public UIntPtr Size;\n' +
+        '    }\n' +
+        '    [Guid("C66FB270-2D80-49AD-BB6E-88C1F90B805D")]\n' +
+        '    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]\n' +
+        '    public interface IMy\n' +
+        '    {\n' +
+        '        [PreserveSig]\n' +
+        '        Slice GetSlice();\n' +
+        '        [PreserveSig]\n' +
+        '        void SetSlice(Slice slice);\n' +
+        '        [PreserveSig]\n' +
+        '        unsafe bool* GetUnsafe();\n' +
+        '        [PreserveSig]\n' +
+        '        unsafe void SetUnsafe(Slice* p, uint size);\n' +
+        '    }\n' +
+        '}'
+    if (cs !== e) { throw [cs,e] }
+    return cs
+}
+
+const result = f()
+
+module.exports = {
+    /** @readonly */
+    result,
+}

package/com/main.f.js

@@ -1,30 +1,6 @@
-/** @typedef {{readonly[k in string]: Definition}} Library */
+const types = require('./types/main.f.js');
 
-/** @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 = {}
+module.exports = {
+    /** @readonly */
+    types,
+}

package/com/types/main.f.js

@@ -0,0 +1,55 @@
+/** @typedef {{readonly[k in string]: Definition}} Library */
+
+/** @typedef {Struct|Interface} Definition */
+
+/**
+ * @typedef {{
+ *  readonly interface?: undefined
+ *  readonly struct: FieldArray
+ * }} Struct
+ */
+
+/** @typedef {readonly Field[]} FieldArray */
+
+/** @typedef {readonly[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 */
+
+module.exports = {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.352",
+  "version": "0.0.355",
   "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/cs/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 = {

package/com/test.f.js

@@ -1,23 +0,0 @@
-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 = {}