functionalscript 0.0.362 → 0.0.363

package/com/cpp/main.f.js

@@ -1 +1,10 @@
-module.exports = {}
+const types = require('../types/main.f.js')
+const text = require('../../text/main.f.js')
+
+/** @type {(name: string) => (library: types.Library) => text.Block} */
+const cpp = name => lib => []
+
+module.exports = {
+    /** @readonly */
+    cpp,
+}

package/com/cpp/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.cpp', cs)
+try {
+    console.log(cp.execSync('clang main.cpp').toString())
+} catch (e) {
+    // @ts-ignore
+    console.error(e.output.toString())
+}

package/com/cpp/test/main.cpp

@@ -0,0 +1,5 @@
+#include "../com.hpp"
+
+int main()
+{
+}

package/com/cpp/test.f.js

@@ -0,0 +1,3 @@
+const _ = require('./main.f.js')
+
+module.exports = {}

package/com/cs/main.f.js

@@ -4,10 +4,7 @@ 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, '}']
+const using = v => `using ${v};`
 
 /**
  * @type {(attributes: list.List<string>) =>
@@ -16,14 +13,14 @@ const csBlock = type => name => body => [`${type} ${name}`, '{', body, '}']
  *  (body: text.Block) =>
  *  list.List<text.Item>}
  */
-const csTypeDef = attributes => type => name => body =>
+const typeDef = attributes => type => name => body =>
     list.flat([
         list.map(v => `[${v}]`)(attributes),
-        csBlock(`public ${type}`)(name)(body)
+        text.curly(`public ${type}`)(name)(body)
     ])
 
 /** @type {(t: types.BaseType) => string} */
-const csBaseType = t => {
+const baseType = t => {
     switch (t) {
         case 'bool': return 'bool'
         case 'f32': return 'float'
@@ -45,69 +42,72 @@ const csBaseType = t => {
 const unsafe = isUnsafe => isUnsafe ? 'unsafe ' : ''
 
 /** @type {(t: types.Type) => readonly[boolean, string]} */
-const csType = t =>
-    typeof (t) === 'string' ? [false, csBaseType(t)] :
+const type = t =>
+    typeof (t) === 'string' ? [false, baseType(t)] :
         t.length === 1 ? [false, t[0]] :
-            [true, `${csType(t[1])[1]}*`]
+            [true, `${type(t[1])[1]}*`]
 
 /** @type {(f: types.Field) => string} */
-const csParam = ([name, type]) => `${csType(type)[1]} ${name}`
+const param = ([name, t]) => `${type(t)[1]} ${name}`
 
 /** @type {(f: types.Field) => string} */
-const csField = ([name, type]) => {
-    const [isUnsafe, t] = csType(type)
+const field = ([name, comType]) => {
+    const [isUnsafe, t] = type(comType)
     return `public ${unsafe(isUnsafe)}${t} ${name};`
 }
 
-/** @type {(m: types.FieldArray) => readonly[boolean, string]} */
-const csResult = m => m._ === undefined ? [false, 'void'] : csType(m._)
+/** @type {(m: types.FieldArray) => string} */
+const result = m => {
+    const result = m._
+    return result === undefined ? 'void' : type(result)[1]
+}
 
 /** @type {(field: types.Field) => boolean} */
-const isUnsafeField = field => csType(field[1])[0]
+const isUnsafeField = field => type(field[1])[0]
 
 /** @type {(kv: obj.Entry<types.Type>) => boolean} */
 const isParam = kv => kv[0] !== '_'
 
 /** @type {(e: obj.Entry<types.FieldArray>) => readonly string[]} */
-const csMethod = ([name, m]) => {
-    const result = csResult(m)
-    const paramArray = list.filter(isParam)(Object.entries(m))
-    const isUnsafe = result[0] || list.some(list.map(isUnsafeField)(paramArray))
+const method = ([name, m]) => {
+    const paramAndResultList = Object.entries(m)
+    const paramList = list.filter(isParam)(paramAndResultList)
+    const isUnsafe = list.some(list.map(isUnsafeField)(paramAndResultList))
     return [
         '[PreserveSig]',
-        `${unsafe(isUnsafe)}${result[1]} ${name}(${list.join(', ')(list.map(csParam)(paramArray))});`
+        `${unsafe(isUnsafe)}${result(m)} ${name}(${list.join(', ')(list.map(param)(paramList))});`
     ]
 }
 
 /** @type {(e: obj.Entry<types.Definition>) => list.List<text.Item>} */
-const csDef = ([n, d]) => {
+const def = ([n, d]) => {
     const i = d.interface
     return i === undefined ?
-        csTypeDef
+        typeDef
             (['StructLayout(LayoutKind.Sequential)'])
             ('struct')
             (n)
-            (() => list.map(csField)(Object.entries(d.struct))) :
-        csTypeDef
+            (list.map(field)(Object.entries(d.struct))) :
+        typeDef
             ([`Guid("${d.guid}")`, 'InterfaceType(ComInterfaceType.InterfaceIsIUnknown)'])
             ('interface')
             (n)
-            (() => list.flatMap(csMethod)(Object.entries(d.interface)))
+            (list.flatMap(method)(Object.entries(d.interface)))
 }
 
 /** @type {(name: string) => (library: types.Library) => text.Block} */
 const cs = name => library => {
-    const v = list.flatMap(csDef)(Object.entries(library))
+    const v = list.flatMap(def)(Object.entries(library))
 
     /** @type {text.Block} */
     const h = [
-        csUsing('System'),
-        csUsing('System.Runtime.InteropServices'),
+        using('System'),
+        using('System.Runtime.InteropServices'),
         ''
     ]
 
-    const ns = csBlock('namespace')(name)(() => v)
-    return () => list.flat([h, ns])
+    const ns = text.curly('namespace')(name)(() => v)
+    return list.flat([h, ns])
 }
 
 module.exports = {

package/com/cs/test.f.js

@@ -14,15 +14,9 @@ const library = {
     IMy: {
         guid: 'C66FB270-2D80-49AD-BB6E-88C1F90B805D',
         interface: {
-            GetSlice: {
-                _: ['Slice']
-            },
-            SetSlice: {
-                slice: ['Slice']
-            },
-            GetUnsafe: {
-                _: ['*', 'bool']
-            },
+            GetSlice: { _: ['Slice'] },
+            SetSlice: { slice: ['Slice'] },
+            GetUnsafe: { _: ['*', 'bool'] },
             SetUnsafe: {
                 p: ['*', ['Slice']],
                 size: 'u32'

package/html/main.f.js

@@ -73,7 +73,7 @@ const escapeCharCode = code => {
     }
 }
 
-const escape = compose(list.toCharCodes)(list.map(escapeCharCode))
+const escape = compose(list.toCharCodeList)(list.map(escapeCharCode))
 
 /** @type {(n: Node) => list.List<string>} */
 const node = n => typeof n === 'string' ? escape(n) : element(n)

package/json/tokenizer/test.f.js

@@ -4,7 +4,7 @@ const json = require('../main.f.js')
 const { sort } = require('../../types/object/main.f.js')
 
 /** @type {(s: string) => readonly tokenizer.JsonToken[]} */
-const tokenizeString = s => list.toArray(tokenizer.tokenize(list.toCharCodes(s)))
+const tokenizeString = s => list.toArray(tokenizer.tokenize(list.toCharCodeList(s)))
 
 const stringify = json.stringify(sort)
 

package/package.json

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

package/text/main.f.js

@@ -21,7 +21,12 @@ const flat = indent => {
     return f('')
 }
 
+/** @type {(type: string) => (name: string) => (body: Block) => Block} */
+const curly = type => name => body => [`${type} ${name}`, '{', body, '}']
+
 module.exports = {
     /** @readonly */
     flat,
+    /** @readonly */
+    curly,
 }

package/types/list/main.f.js

@@ -105,7 +105,7 @@ const toArray = list => {
     return u instanceof Array ? u : Array.from(iterable(u))
 }
 
-/** @type {<I, O>(step: (n: NonEmpty<I>) => List<O>) => (input: List<I>) => List<O>} */
+/** @type {<I, O>(step: (n: NonEmpty<I>) => List<O>) => (input: List<I>) => Thunk<O>} */
 const apply = f => input => () => {
     const n = next(input)
     if (n === undefined) { return undefined }
@@ -115,16 +115,16 @@ const apply = f => input => () => {
 /** @type {<T>(n: NonEmpty<List<T>>) => List<T>} */
 const flatStep = n => concat(n.first)(flat(n.tail))
 
-/** @type {<T>(list: List<List<T>>) => List<T>} */
+/** @type {<T>(list: List<List<T>>) => Thunk<T>} */
 const flat = apply(flatStep)
 
 /** @type {<I, O>(f: (value: I) => O) => (n: NonEmpty<I>) => List<O>} */
 const mapStep = f => n => ({ first: f(n.first), tail: map(f)(n.tail) })
 
-/** @type {<I, O>(f: (value: I) => O) => (input: List<I>) => List<O>} */
+/** @type {<I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>} */
 const map = f => apply(mapStep(f))
 
-/** @type {<I, O>(f: (value: I) => List<O>) => (input: List<I>) => List<O>} */
+/** @type {<I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>} */
 const flatMap = f => compose(map(f))(flat)
 
 /** @type {<T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>} */
@@ -133,7 +133,7 @@ const filterStep = f => n => {
     return f(n.first) ? { first: n.first, tail } : tail
 }
 
-/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => List<T>} */
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
 const filter = f => apply(filterStep(f))
 
 /** @type {<I, O>(f: (value: I) => O|undefined) => (n: NonEmpty<I>) => List<O>} */
@@ -142,31 +142,31 @@ const filterMapStep = f => n => {
     return first === undefined ? tail : { first, tail }
 }
 
-/** @type {<I, O>(f: (value: I) => O|undefined) => (input: List<I>) => List<O>} */
+/** @type {<I, O>(f: (value: I) => O|undefined) => (input: List<I>) => Thunk<O>} */
 const filterMap = f => apply(filterMapStep(f))
 
 /** @type {<T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>} */
 const takeWhileStep = f => n => f(n.first) ? { first: n.first, tail: takeWhile(f)(n.tail) } : undefined
 
-/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => List<T>} */
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
 const takeWhile = f => apply(takeWhileStep(f))
 
 /** @type {(n: number) => <T>(result: NonEmpty<T>) => List<T>} */
 const takeStep = n => ne => 0 < n ? { first: ne.first, tail: take(n - 1)(ne.tail) } : undefined
 
-/** @type {(n: number) => <T>(input: List<T>) => List<T>} */
+/** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
 const take = n => apply(takeStep(n))
 
 /** @type {<T>(f: (value: T) => boolean) => (ne: NonEmpty<T>) => List<T>} */
 const dropWhileStep = f => ne => f(ne.first) ? dropWhile(f)(ne.tail) : ne
 
-/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => List<T>} */
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
 const dropWhile = f => apply(dropWhileStep(f))
 
 /** @type {(n: number) => <T>(ne: NonEmpty<T>) => List<T>} */
 const dropStep = n => ne => 0 < n ? drop(n - 1)(ne.tail) : ne
 
-/** @type {(n: number) => <T>(input: List<T>) => List<T>} */
+/** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
 const drop = n => apply(dropStep(n))
 
 /** @type {<D>(def: D) => <T>(input: List<T>) => D|T} */
@@ -214,7 +214,7 @@ const countdown = count => () => {
     return { first, tail: countdown(first) }
 }
 
-/** @type {<T>(v: T) => (c: number) => List<T>} */
+/** @type {<T>(v: T) => (c: number) => Thunk<T>} */
 const repeat = v => n => map(() => v)(countdown(n))
 
 /** @type {<T>(list: List<T>) => List<T>} */
@@ -229,13 +229,13 @@ const scanStep = op => ne => {
     return { first, tail: scan(newOp)(ne.tail) }
 }
 
-/** @type {<I, O>(op: operator.Scan<I, O>) => (input: List<I>) => List<O>} */
+/** @type {<I, O>(op: operator.Scan<I, O>) => (input: List<I>) => Thunk<O>} */
 const scan = op => apply(scanStep(op))
 
-/** @type {<I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => List<O>} */
+/** @type {<I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
 const stateScan = op => init => scan(stateScanToScan(op)(init))
 
-/** @type {<I,O>(op: operator.Reduce<I, O>) => (init: O) => (input: List<I>) => List<O>} */
+/** @type {<I,O>(op: operator.Reduce<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
 const reduceScan = op => init => scan(reduceToScan(op)(init))
 
 /** @type {<I,O>(op: operator.Reduce<I, O>) => (init: O) => (input: List<I>) => O} */
@@ -264,7 +264,7 @@ const length = reduce(operator.counter)(0)
 /** @type {(index: number) => <T>(value: T) => readonly[Entry<T>, number]} */
 const entryOperator = index => value => [[index, value], index + 1]
 
-/** @type {<T>(input: List<T>) => List<Entry<T>>} */
+/** @type {<T>(input: List<T>) => Thunk<Entry<T>>} */
 const entries = input => {
     /** @typedef {typeof input extends List<infer T> ? T : never} T */
     return stateScan(/** @type {operator.StateScan<T, Number, Entry<T>>} */(entryOperator))(0)(input)
@@ -276,16 +276,13 @@ const reverseOperator = first => tail => ({ first, tail })
 /** @type {<T>(input: List<T>) => List<T>} */
 const reverse = reduce(reverseOperator)(undefined)
 
-/** @type {<A>(a: A) => <B>(b: B) => readonly[A, B]} */
-const tuple2 = a => b => [a, b]
-
 /** @type {<A>(a: List<A>) => <B>(b: List<B>) => List<readonly[A, B]>} */
 const zip = a => b => () => {
     const aResult = next(a)
     if (aResult === undefined) { return undefined }
     const bResult = next(b)
     if (bResult === undefined) { return undefined }
-    return { first: tuple2(aResult.first)(bResult.first), tail: zip(aResult.tail)(bResult.tail) }
+    return { first: [aResult.first, bResult.first], tail: zip(aResult.tail)(bResult.tail) }
 }
 
 /** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => List<boolean>} */
@@ -300,7 +297,7 @@ const equalZip = e => a => b => () => {
 const equal = e => a => b => every(equalZip(e)(a)(b))
 
 /** @type {(s: string) => List<number>} */
-const toCharCodes = s => {
+const toCharCodeList = s => {
     /** @type {(i: number) => Result<number>} */
     const at = i => {
         const first = s.charCodeAt(i)
@@ -309,7 +306,7 @@ const toCharCodes = s => {
     return at(0)
 }
 
-const fromCharCodes = compose(map(String.fromCharCode))(fold(operator.concat)(''))
+const fromCharCodeList = compose(map(String.fromCharCode))(fold(operator.concat)(''))
 
 module.exports = {
     /** @readonly */
@@ -389,7 +386,7 @@ module.exports = {
     /** @readonly */
     equal,
     /** @readonly */
-    toCharCodes,
+    toCharCodeList,
     /** @readonly */
-    fromCharCodes,
+    fromCharCodeList,
 }

package/types/list/test.f.js

@@ -235,8 +235,8 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 }
 
 {
-    const r = _.toCharCodes("Hello world!")
-    const x = _.fromCharCodes(r)
+    const r = _.toCharCodeList("Hello world!")
+    const x = _.fromCharCodeList(r)
     if (x !== "Hello world!") { throw x }
 }