functionalscript 0.0.268 → 0.0.272

package/README.md

@@ -15,7 +15,7 @@ Try FunctionalScript [here](https://functionalscript.com/).
 
 In FunctionalScript:
 
-- Any module is a valid JavaScript module
+- Any module is a valid JavaScript module. No additional build steps are required.
 - Code should not have [side-effects](https://en.wikipedia.org/wiki/Side_effect_(computer_science)). Any JavaScript statement, expression, or function which has a side effect is not allowed in FunctionalScript. There are no exceptions to this rule, such as `unsafe` code which can be found in Rust, C#, and other languages.
 - A module can't depend on non FunctionalScript module. 
 - It also has no standard library, only a safe subset of standard JavaScript API can be used without referencing other modules.
@@ -172,6 +172,7 @@ The format of an arrow function is `ARGUMENT_NAME => FUNCTION_BODY`. An arrow fu
 x => x * 2
 a => a + 4
 s => `template literal ${s}`
+a => b => a + b // an arrow functions that returns another arrow functions.
 () => 'hello' // an arrow function with no arguments
 ```
 

package/commonjs/path/index.js

@@ -1,9 +1,9 @@
-const seq = require("../../types/list")
+const list = require("../../types/list")
 const option = require("../../types/option")
 const { compose } = require("../../types/function")
-const dep = require("../package/dependencies")
-const { at } = require("../../types/object")
-// const pack = require("../package")
+const { todo } = require("../../dev")
+const package_ = require("../package")
+const module_ = require("../module")
 
 /** @typedef {readonly string[]} Items */
 
@@ -18,32 +18,39 @@ const { at } = require("../../types/object")
 /** @type {(path: string) => readonly string[]} */
 const split = path => path.split('/')
 
-/** @type {(s: undefined|seq.List<string>) => (items: string) => undefined|seq.List<string>} */
+/** @typedef {readonly[list.List<string>] | undefined} OptionList */
+
+/** @type {(s: OptionList) => (items: string) => OptionList} */
 const normItemsOp = prior => item => {
     if (prior === undefined) { return undefined }
+    const priorList = prior[0]
     switch (item) {
         case '': case '.': { return prior }
         case '..': {
-            const result = seq.next(prior)
+            const result = list.next(priorList)
             if (result === undefined) { return undefined }
-            return result.tail
+            return [result.tail]
         }
         default: {
-            return seq.nonEmpty(item)(prior)
+            return [list.nonEmpty(item)(priorList)]
         }
     }
 }
 
-/** @type {(items: seq.List<string>) => seq.List<string>|undefined} */
-const normItems = compose(seq.reduce(normItemsOp)([]))(option.map(seq.reverse))
+/** @type {(items: list.List<string>) => OptionList} */
+const normItems = items => {
+    const result = list.reduce(normItemsOp)([undefined])(items)
+    if (result === undefined) { return result }
+    return [list.reverse(result[0])]
+}
 
 /** @type {(local: string) => (path: string) => LocalPath|undefined} */
 const parseLocal = local => {
-    /** @type {(path: string) => readonly[boolean, seq.List<string>]} */
+    /** @type {(path: string) => readonly[boolean, list.List<string>]} */
     const fSeq = path => {
         const pathSeq = split(path)
-        switch (seq.first(undefined)(pathSeq)) {
-            case '.': case '..': { return [false, seq.flat([split(local), pathSeq])] }
+        switch (list.first(undefined)(pathSeq)) {
+            case '.': case '..': { return [false, list.flat([split(local), pathSeq])] }
             default: { return [true, pathSeq] }
         }
     }
@@ -55,18 +62,18 @@ const parseLocal = local => {
         return {
             external,
             dir: path[path.length - 1] === '/',
-            items: seq.toArray(n)
+            items: list.toArray(n[0])
         }
     }
     return f
 }
 
-/** @typedef {readonly[string, seq.List<string>]} IdPath */
+/** @typedef {readonly[string, list.List<string>]} IdPath */
 
-/** @type {(prior: readonly[string|undefined, seq.List<string>]) => seq.Thunk<IdPath>} */
+/** @type {(prior: readonly[string|undefined, list.List<string>]) => list.Thunk<IdPath>} */
 const variants = prior => () => {
     const [a, b] = prior
-    const r = seq.next(b)
+    const r = list.next(b)
     if (r === undefined) { return undefined }
     const { first, tail } = r
     /** @type {IdPath} */
@@ -82,35 +89,74 @@ const mapDependency = d => ([external, internal]) => {
 
 /**
  * @typedef {{
- *  readonly name: string,
+ *  readonly packageId: string,
  *  readonly items: Items,
  *  readonly dir: boolean,
  * }} Path
  */
 
-/** @type {(d: (local: string) => string|undefined) => (dir: boolean) => (items: seq.List<string>) => Path|undefined} */
+/**
+ * @type {(d: (local: string) => string|undefined) =>
+ *  (dir: boolean) =>
+ *  (items: list.List<string>) =>
+ *  Path|undefined}
+ */
 const parseGlobal = d => dir => items => {
     const v = variants([undefined, items])
-    const r = seq.first(undefined)(seq.filterMap(mapDependency(d))(v))
+    const r = list.first(undefined)(list.filterMap(mapDependency(d))(v))
     if (r === undefined) { return undefined }
-    return { name: r[0], items: seq.toArray(r[1]), dir }
+    return { packageId: r[0], items: list.toArray(r[1]), dir }
 }
 
 /**
- * @type {(name: string) =>
+ * @type {(packageId: string) =>
  *  (dependencies: (local: string) => string|undefined) =>
  *  (local: string) =>
  *  (path: string) =>
  *  Path|undefined }
  */
-const parse = name => dependencies => local => path => {
+const parse = packageId => dependencies => local => path => {
     const parsed = parseLocal(local)(path)
     if (parsed === undefined) { return undefined }
-    const {external, dir, items} = parsed
-    if (!external) { return { name, items, dir } }
+    const {external, dir, items } = parsed
+    if (!external) { return { packageId, items, dir } }
     return parseGlobal(dependencies)(dir)(items)
 }
 
+/**
+ * @typedef {{
+ *  readonly package: string
+ *  readonly file: string
+ *  readonly source: string
+ * }| undefined} Result
+ */
+
+/**
+ * @type {(packageGet: package_.Get) =>
+ *  (packageId: string) =>
+ *  (local: string) =>
+ *  (path: string) =>
+ *  Result
+ * }
+ */
+const parseAndFind = packageGet => packageId => local => path => {
+    const currentPack = packageGet(packageId)
+    if (currentPack === undefined) { return undefined }
+    const p = parse(packageId)(currentPack.dependency)(local)(path)
+    if (p === undefined) { return undefined }
+    const pack = packageGet(p.packageId)
+    if (pack === undefined) { return undefined }
+    /** @type {(file: string) => Result } */
+    const tryFile = file => {
+        const source = pack.file(file)
+        return source === undefined ? undefined : { package: p.packageId, file, source }
+    }
+    const file = p.items.join('/')
+    const indexJs = list.join('/')(list.concat(p.items)(['index.js']))
+    const fileList = p.dir || list.isEmpty(p.items) ? [indexJs] : [file, `${file}.js`, indexJs]
+    return list.first(undefined)(list.filterMap(tryFile)(fileList))
+}
+
 module.exports = {
     /** @readonly */
     parseLocal,
@@ -118,4 +164,6 @@ module.exports = {
     parseGlobal,
     /** @readonly */
     parse,
+    /** @readonly */
+    parseAndFind,
 }

package/commonjs/path/test.js

@@ -1,7 +1,10 @@
 const _ = require('.')
+const { todo } = require('../../dev')
 const json = require('../../json')
 const { identity } = require('../../types/function')
+const object = require('../../types/object')
 const { at } = require('../../types/object')
+const package_ = require('../package')
 
 /** @type {(g: json.Unknown|undefined) => string} */
 const stringify = g => {
@@ -51,15 +54,101 @@ const stringify = g => {
     if (_.parseGlobal(d => at(d)({ b: 'x' }))(false)(['d']) !== undefined) { throw 'error' }
     {
         const result = stringify(_.parseGlobal(d => at(d)({ b: 'x' }))(false)(['b']))
-        if (result !== '["x",""]') { throw result }
+        if (result !== '{"packageId":"x","items":[],"dir":false}') { throw result }
     }
     if (_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(false)(['b']) !== undefined) { throw 'error' }
     {
         const result = stringify(_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(false)(['b', 'r']))
-        if (result !== '["x",""]') { throw result }
+        if (result !== '{"packageId":"x","items":[],"dir":false}') { throw result }
     }
     {
         const result = stringify(_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(false)(['b', 'r', 'd', 't']))
-        if (result !== '["x","d/t"]') { throw result }
+        if (result !== '{"packageId":"x","items":["d","t"],"dir":false}') { throw result }
     }
+    {
+        const result = stringify(_.parseGlobal(d => at(d)({ 'b/r': 'x' }))(true)(['b', 'r', 'd', 't']))
+        if (result !== '{"packageId":"x","items":["d","t"],"dir":true}') { throw result }
+    }
+}
+
+{
+    /** @type {object.Map<package_.Package>} */
+    const packages = {
+        '': {
+            dependency: () => todo(),
+            file: path => at(path)({ 'a/c': 'return "a/c"' }),
+        }
+    }
+    const result = stringify(_.parseAndFind(p => at(p)(packages))('')('a/b')('../c'))
+    if (result !== '{"package":"","file":"a/c","source":"return \\"a/c\\""}') { throw result }
 }
+
+{
+    /** @type {object.Map<package_.Package>} */
+    const packages = {
+        '': {
+            dependency: x => {
+                const path = `node_modules/${x}`
+                return at(path)(packages) !== undefined ? path : undefined
+            },
+            file: todo
+        },
+        'node_modules/z': {
+            dependency: () => todo(),
+            file: path => at(path)({ 'a/c/index.js': 'return "a/c"' }),
+        }
+    }
+    const result = stringify(_.parseAndFind(p => at(p)(packages))('')('a/b')('z/a/c'))
+    if (result !== '{"package":"node_modules/z","file":"a/c/index.js","source":"return \\"a/c\\""}') { throw result }
+}
+
+{
+    /** @type {object.Map<package_.Package>} */
+    const packages = {
+        '': {
+            dependency: x => {
+                const path = `node_modules/${x}`
+                return at(path)(packages) !== undefined ? path : undefined
+            },
+            file: todo
+        },
+        'node_modules/z/a': {
+            dependency: () => todo(),
+            file: path => at(path)({
+                'c/index.js': 'return "c/index.js"',
+                'c.js': 'return "c.js"'
+            }),
+        }
+    }
+    {
+        const result = stringify(_.parseAndFind(p => at(p)(packages))('')('a/b')('z/a/c'))
+        if (result !== '{"package":"node_modules/z/a","file":"c.js","source":"return \\"c.js\\""}') { throw result }
+    }
+    {
+        const result = stringify(_.parseAndFind(p => at(p)(packages))('')('a/b')('z/a/c/'))
+        if (result !== '{"package":"node_modules/z/a","file":"c/index.js","source":"return \\"c/index.js\\""}') { throw result }
+    }
+}
+
+{
+    /** @type {object.Map<package_.Package>} */
+    const packages = {
+        '': {
+            dependency: x => {
+                const path = `node_modules/${x}`
+                return at(path)(packages) !== undefined ? path : undefined
+            },
+            file: todo
+        },
+        'node_modules/z/a/c': {
+            dependency: () => todo(),
+            file: path => at(path)({
+                '': 'throw',
+                '.js': 'throw',
+                'index.js': 'return "a/c"'
+            }),
+        }
+    }
+    const result = stringify(_.parseAndFind(p => at(p)(packages))('')('a/b')('z/a/c'))
+    if (result !== '{"package":"node_modules/z/a/c","file":"index.js","source":"return \\"a/c\\""}') { throw result }
+}

package/package.json

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

package/test.js

@@ -7,6 +7,7 @@ require('./types/object/test')
 require('./io/commonjs/test')
 require('./commonjs/package/dependencies/test')
 require('./commonjs/package/test')
+require('./commonjs/path/test')
 
 /** @type {() => never} */
 const assert = () => { throw 'assert' }
@@ -100,12 +101,12 @@ const assert_if = c => { if (c) { throw 'assert_if' } }
     //const c = o['__defineGetter__']
     //const c = o['__defineSetter__']
     //const c = o['__lookupGetter__']
-    //const c = o['__lookupSetter__'] 
-    //const c = o['hasOwnProperty']   
+    //const c = o['__lookupSetter__']
+    //const c = o['hasOwnProperty']
     //const c = o['isPrototypeOf']
     //const c = o['propertyIsEnumerable']
     //const c = o['toString']
-    const c = o['valueOf']    
+    const c = o['valueOf']
     //console.log(c)
 }
 

package/types/list/index.js

@@ -199,6 +199,9 @@ const some = input => find
     (/** @type {(_: boolean) => boolean} */(identity))
     (input)
 
+/** @type {<T>(input: List<T>) => boolean} */
+const isEmpty = input => !some(map(() => true)(input))
+
 /** @type {(input: List<boolean>) => boolean} */
 const every = input => !some(map(logicalNot)(input))
 
@@ -336,6 +339,8 @@ module.exports = {
     /** @readonly */
     every,
     /** @readonly */
+    isEmpty,
+    /** @readonly */
     includes,
     /** @readonly */
     countdown,

package/types/list/test.js

@@ -214,6 +214,16 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
     if (result !== 12) { throw result }
 }
 
+{
+    const result = _.isEmpty(() => [])
+    if (result !== true) { throw result }
+}
+
+{
+    const result = _.isEmpty(() => [2])
+    if (result !== false) { throw result }
+}
+
 // stress tests
 
 const stress = () => {
@@ -319,7 +329,7 @@ const stress = () => {
     }
 }
 
-stress()
+// stress()
 
 module.exports = {