functionalscript 0.0.203 → 0.0.210

package/function/index.js

@@ -5,7 +5,7 @@
  */
 
 /** @type {<X, O>(f: Func<X, O>) => <I>(g: Func<I, X>) => Func<I, O>} */
-const combine = f => g => x => f(g(x))
+const compose = f => g => x => f(g(x))
 
 /** @type {<T>(value: T) => T} */
 const id = value => value
@@ -14,5 +14,5 @@ module.exports = {
     /** @readonly */
     id,
     /** @readonly */
-    combine,
+    compose,
 }

package/json/index.js

@@ -1,8 +1,8 @@
 const seq = require('../sequence')
-const map = require('../map')
 const op = require('../sequence/operator')
 const object = require('../object')
 const array = require('../sequence/array')
+const { compose: combine } = require('../function')
 
 /** 
  * @typedef {{
@@ -22,9 +22,9 @@ const addProperty = value => {
         if (result === undefined) { return value }
         const srcObject = (src === undefined || src === null || typeof src !== 'object' || src instanceof Array) ? {} : src
         const [name, tail] = result
-        return { ...srcObject, [name]: f(tail)(srcObject[name]) }
+        return { ...srcObject, [name]: f(tail)(object.at(name)(srcObject)) }
     }
-    return path => f(array.sequence(path))
+    return combine(f)(array.sequence)
 }
 
 /** @type {(_: string) => seq.Sequence<string>} */
@@ -42,12 +42,6 @@ const falseSerialize = seq.list('false')
 /** @type {(_: boolean) => seq.Sequence<string>} */
 const boolSerialize = value => value ? trueSerialize : falseSerialize
 
-/** @type {(kv: readonly[string, Json]) => seq.Sequence<string>} */
-const propertySerialize = ([k, v]) => seq.concat(
-    stringSerialize(k), 
-    colon, 
-    serialize(v))
-
 const colon = seq.list(':')
 const comma = seq.list(',')
 
@@ -74,33 +68,46 @@ const objectList = list('{')('}')
 
 const arrayList = list('[')(']')
 
-/** @type {(object: Object) => seq.Sequence<string>} */
-const objectSerialize = input => {
-    const _0 = object.entries(input)
-    const _1 = map.fromEntries(_0).entries
-    const _2 = seq.map(propertySerialize)(_1)
-    return objectList(_2)
-}
-
-/** @type {(input: Array) => seq.Sequence<string>} */
-const arraySerialize = input => {
-    const _0 = array.sequence(input)
-    const _1 = seq.map(serialize)(_0)
-    return arrayList(_1)
-}
-
-/** @type {(value: Json) => seq.Sequence<string>} */
-const serialize = value => {
-    switch (typeof value) {
-        case 'boolean': { return boolSerialize(value) }
-        case 'number': { return numberSerialize(value) }
-        case 'string': { return stringSerialize(value) }
-        default: {
-            if (value === null) { return nullSerialize }
-            if (value instanceof Array) { return arraySerialize(value) }
-            return objectSerialize(value)
+/** @typedef {object.Entry<Json>} Entry*/
+
+/** @typedef {(seq.Sequence<Entry>)} Entries */
+
+/** @typedef {(entries: Entries) => Entries} MapEntries */
+
+/** @type {(mapEntries: MapEntries) => (value: Json) => seq.Sequence<string>} */
+const serialize = sort => {
+    /** @type {(kv: readonly[string, Json]) => seq.Sequence<string>} */
+    const propertySerialize = ([k, v]) => seq.concat(
+        stringSerialize(k),
+        colon,
+        f(v))
+    /** @type {(object: Object) => seq.Sequence<string>} */
+    const objectSerialize = input => {
+        const entries = object.entries(input)
+        const sortedEntries = sort(entries)
+        const serializedEntries = seq.map(propertySerialize)(sortedEntries)
+        return objectList(serializedEntries)
+    }
+    /** @type {(input: Array) => seq.Sequence<string>} */
+    const arraySerialize = input => {
+        const sequence = array.sequence(input)
+        const serializedEntries = seq.map(f)(sequence)
+        return arrayList(serializedEntries)
+    }
+    /** @type {(value: Json) => seq.Sequence < string >} */
+    const f = value => {
+        switch (typeof value) {
+            case 'boolean': { return boolSerialize(value) }
+            case 'number': { return numberSerialize(value) }
+            case 'string': { return stringSerialize(value) }
+            default: {
+                if (value === null) { return nullSerialize }
+                if (value instanceof Array) { return arraySerialize(value) }
+                return objectSerialize(value)
+            }
         }
     }
+    return f
 }
 
 /**
@@ -109,9 +116,9 @@ const serialize = value => {
  * The standard `JSON.stringify` rules determines by 
  * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
  *  
- * @type {(value: Json) => string} 
+ * @type {(mapEntries: MapEntries) => (value: Json) => string}
  */
-const stringify = value => seq.join('')(serialize(value))
+const stringify = sort => value => seq.join('')(serialize(sort)(value))
 
 /** @type {(value: string) => Json} */
 const parse = value => JSON.parse(value)

package/json/test.js

@@ -1,20 +1,39 @@
 const json = require('.')
+const { sort } = require('../object')
+const { id } = require('../function')
 
 if (json.addProperty("Hello")([])({}) !== "Hello") { throw 'error' }
 
 {
-    const x = json.stringify(json.addProperty("Hello")(['a'])({}))
+    const x = json.stringify(sort)(json.addProperty("Hello")(['a'])({}))
     if (x !== '{"a":"Hello"}') { throw x }
 }
 
 {
-    const x = json.stringify(json.addProperty("Hello")(['a'])({c:[],b:12}))
+    const x = json.stringify(id)(json.addProperty("Hello")(['a'])({}))
+    if (x !== '{"a":"Hello"}') { throw x }
+}
+
+{
+    const x = json.stringify(sort)(json.addProperty("Hello")(['a'])({c:[],b:12}))
     if (x !== '{"a":"Hello","b":12,"c":[]}') { throw x }
 }
 
+{
+    const x = json.stringify(id)(json.addProperty("Hello")(['a'])({ c: [], b: 12 }))
+    if (x !== '{"c":[],"b":12,"a":"Hello"}') { throw x }
+}
+
 {
     const _0 = { a: { y: [24] }, c: [], b: 12 }
     const _1 = json.addProperty("Hello")(['a', 'x'])(_0)
-    const _2 = json.stringify(_1)
+    const _2 = json.stringify(sort)(_1)
     if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') { throw _2 }
 }
+
+{
+    const _0 = { a: { y: [24] }, c: [], b: 12 }
+    const _1 = json.addProperty("Hello")(['a', 'x'])(_0)
+    const _2 = json.stringify(id)(_1)
+    if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') { throw _2 }
+}

package/module-manager/README.md

@@ -5,26 +5,31 @@
 ```js
 /** @typedef {(packageName: string) => PackageMap|Package|undefined} PackageMap */
 
-/**
- * @typedef {{
- *  readonly id: string,
- *  readonly packages: PackageMap,
- *  readonly files: (fileName: string) => string|undefined,
- * }} Package
+/** 
+ * @typedef {readonly[
+ *  string, 
+ *  PackageMap, 
+ *  (fileName: string) => string|undefined
+ * ]} Package 
  */
 ```
 
 ## Runner IO
 
+The main target of this design is to simplify `RunnerIo` as much as possible.
+
 ```js
-/** 
- * @typedef {(require: Require<T>) => (info: T) => (source: string) => readonly[Result<unknown, Error>, T]} RunnerIo
+/**
+ * @template T 
+ * @typedef {readonly[Result<unknown, Error>, Require<T>]} RunnerResult
  */
-```
 
-```js
+/** @typedef {<T>(require: Require<T>) => (source: string) => RunnerResult<T>} RunnerIo */
+
 /**
  * @template T
- * @typedef {(info: T) => (module: string) => readonly[Result<unknown, Error>, T]} Require<T>
+ * @typedef {readonly[(path: string) => RunnerResult<T>, T]} Require<T>
  */
 ```
+
+`Require` is using a `Package` and it contains also `RunnerIo` to provide sources also it contains

package/module-manager/index.js

@@ -1,5 +1,5 @@
 const array = require('../sequence/array')
-const { combine } = require('../function')
+const { compose: combine } = require('../function')
 const option = require('../option')
 const { head, last, splitLast, splitFirst } = array
 const iter = require('../sequence/iterable')

package/object/index.js

@@ -1,17 +1,33 @@
 const array = require('../sequence/array')
 const seq = require('../sequence')
+const map = require('../map')
 
 /**
  * @template T
  * @typedef {{
  *  readonly [k in string]: T
- * }} Object_
+ * }} Map
  */
 
-/** @type {<T>(object: Object_<T>) => seq.Sequence<readonly[string, T]>} */
+/**
+ * @template T
+ * @typedef {readonly[string, T]} Entry
+ */
+
+/** @type {<T>(object: Map<T>) => seq.Sequence<Entry<T>>} */
 const entries = object => array.sequence(Object.entries(object))
 
+/** @type {(name: string) => <T>(object: Map<T>) => T|undefined} */
+const at = name => object => Object.getOwnPropertyDescriptor(object, name)?.value
+
+/** @type {<T>(entries: seq.Sequence<Entry<T>>) => seq.Sequence<Entry<T>>} */
+const sort = entries => map.fromEntries(entries).entries
+
 module.exports = {
     /** @readonly */
     entries,
+    /** @readonly */
+    at,
+    /** @readonly */
+    sort,
 }

package/object/test.js

@@ -0,0 +1,13 @@
+const _ = require('.')
+
+{
+    const a = {}
+    const value = _.at('constructor')(a)
+    if (value !== undefined) { throw value }
+}
+
+{
+    const a = { constructor: 42}
+    const value = _.at('constructor')(a)
+    if (value !== 42) { throw value }
+}

package/package.json

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

package/result/index.js

@@ -0,0 +1,17 @@
+/**
+ * @template T
+ * @typedef {readonly['ok', T]} Ok
+ */
+
+/**
+ * @template E
+ * @typedef {readonly['error', E]} Error
+ */
+
+/**
+ * @template T
+ * @template E
+ * @typedef {Ok<T>|Error<E>} Result
+ */
+
+module.exports = {}

package/sequence/asyncIterable/index.js

@@ -1,4 +1,4 @@
-const { combine } = require('../../function')
+const { compose: combine } = require('../../function')
 const seq = require('../operator')
 
 /**

package/sequence/index.js

@@ -1,5 +1,5 @@
 const seqOp = require('./operator')
-const { combine } = require('../function')
+const { compose: combine } = require('../function')
 const op = require('../function/operator')
 const { logicalNot, strictEqual } = require('../function/operator')
 

package/sequence/iterable/index.js

@@ -1,5 +1,5 @@
 const { iterable } = require('..')
-const { combine } = require('../../function')
+const { compose: combine } = require('../../function')
 const seq = require('../operator')
 
 /** @type {<T>(a: Iterable<T>) => (b: Iterable<T>) => Iterable<T>} */

package/sequence/iterable/test.js

@@ -1,5 +1,5 @@
 const i = require('.')
-const { combine } = require('../../function')
+const { compose: combine } = require('../../function')
 
 {
     const r = i.sum([120, 300, 42])

package/test.js

@@ -6,6 +6,7 @@ require('./sequence/iterable/test')
 require('./sequence/asyncIterable/test')
 require('./module-manager/test')
 require('./json/test')
+require('./object/test')
 
 /** @type {() => never} */
 const assert = () => { throw 'assert' }
@@ -104,6 +105,12 @@ const assert_if = c => { if (c) { throw 'assert_if' } }
     //const c = o['isPrototypeOf']
     //const c = o['propertyIsEnumerable']
     //const c = o['toString']
-    const c = o['valueOf']
+    const c = o['valueOf']    
     console.log(c)
+}
+
+{
+    const x = { 'a': 12 }
+    const c = Object.getOwnPropertyDescriptor(x, 'constructor')
+    const a = Object.getOwnPropertyDescriptor(x, 'a')
 }