functionalscript 0.0.353 → 0.0.356

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/{test.f.js → cs/test.f.js}

@@ -1,8 +1,9 @@
+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')
+const list = require('../../types/list/main.f.js')
+const text = require('../../text/main.f.js')
 
-/** @type {_.Library} */
+/** @type {types.Library} */
 const library = {
     Slice: {
         struct: [
@@ -15,10 +16,13 @@ const library = {
         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 =
@@ -30,16 +34,30 @@ const library = {
         '    [StructLayout(LayoutKind.Sequential)]\n' +
         '    public struct Slice\n' +
         '    {\n' +
-        '        public byte* Start;\n' +
+        '        public unsafe byte* Start;\n' +
         '        public UIntPtr Size;\n' +
         '    }\n' +
         '    [Guid("C66FB270-2D80-49AD-BB6E-88C1F90B805D")]\n' +
-        '    [InterfaceType(ComInterfaceType.InterfaceIsUnknown)]\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
 }
 
-module.exports = {}
+const result = f()
+
+module.exports = {
+    /** @readonly */
+    result,
+}

package/com/main.f.js

@@ -1,115 +1,6 @@
-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])
-}
+const types = require('./types/main.f.js');
 
 module.exports = {
     /** @readonly */
-    cs,
+    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/commonjs/path/README.md

@@ -0,0 +1,17 @@
+# Path
+
+## Simplified Common.js
+
+A path should be disambiguous.
+
+Path limitations:
+
+- Accepted file extensions: `.f.js`, `.json`.
+- A file path should be fully specified.  For example `../package/dependencies/test.f.js`.
+- A package name can't contain `/`. For example 
+  - `functionalscript/main.f.js` is allowed.
+  - `functionalscript/functionalscript/main.f.js` is not allowed.
+
+`package.json` limitations:
+
+- Only GitHub packages can be referenced. In the future, we may add generic Git repositories.

package/commonjs/path/main.f.js

@@ -98,11 +98,15 @@ const mapDependency = d => ([external, internal]) => {
  *  (items: list.List<string>) =>
  *  Path|undefined}
  */
-const parseGlobal = d => dir => items => {
-    const v = variants([undefined, items])
-    const r = list.first(undefined)(list.filterMap(mapDependency(d))(v))
-    if (r === undefined) { return undefined }
-    return { package: r[0], items: list.toArray(r[1]), dir }
+const parseGlobal = dependencies => 
+{
+    const filterMap = list.filterMap(mapDependency(dependencies))
+    return dir => items => {
+        const v = variants([undefined, items])
+        const r = list.first(undefined)(filterMap(v))
+        if (r === undefined) { return undefined }
+        return { package: r[0], items: list.toArray(r[1]), dir }
+    }
 }
 
 /**
@@ -112,12 +116,15 @@ const parseGlobal = d => dir => items => {
  *  (path: string) =>
  *  Path|undefined }
  */
-const parse = packageId => dependencies => local => path => {
-    const parsed = parseLocal(local)(path)
-    if (parsed === undefined) { return undefined }
-    const {external, dir, items } = parsed
-    if (!external) { return { package: packageId, items, dir } }
-    return parseGlobal(dependencies)(dir)(items)
+const parse = packageId => dependencies => {
+    const pg = parseGlobal(dependencies)
+    return local => path => {
+        const parsed = parseLocal(local)(path)
+        if (parsed === undefined) { return undefined }
+        const {external, dir, items } = parsed
+        if (!external) { return { package: packageId, items, dir } }
+        return pg(dir)(items)
+    }
 }
 
 /**

package/package.json

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

package/test.f.js

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