functionalscript 0.1.608 → 0.2.0

package/types/string_set/module.f.mjs

@@ -1,51 +1,36 @@
 // @ts-self-types="./module.f.d.mts"
 import * as BtreeTypes from '../btree/types/module.f.mjs'
-import btree from '../btree/module.f.mjs'
-import btf from '../btree/find/module.f.mjs'
+import * as btree from '../btree/module.f.mjs'
+import * as btf from '../btree/find/module.f.mjs'
 const { find, isFound } = btf
-import btr from '../btree/remove/module.f.mjs'
+import * as btr from '../btree/remove/module.f.mjs'
 const { remove: btreeRemove } = btr
-import bts from '../btree/set/module.f.mjs'
+import * as bts from '../btree/set/module.f.mjs'
 const { set: btreeSet } = bts
-const {
+export const {
     /** @type {(s: StringSet) => list.List<string>} */
     values,
     empty,
 } = btree
-import string from "../string/module.f.mjs"
+import * as string from "../string/module.f.mjs"
 const { cmp } = string
-import list from '../list/module.f.mjs'
+import * as list from '../list/module.f.mjs'
 const { fold } = list
-import f from '../function/module.f.mjs'
+import * as f from '../function/module.f.mjs'
 const { compose } = f
 
 /** @typedef {BtreeTypes.Tree<string>} StringSet */
 
 /** @type {(value: string) => (set: StringSet) => boolean} */
-const contains = value => {
+export const contains = value => {
     const f = find(cmp(value))
     return s => s !== null && isFound(f(s).first)
 }
 
 /** @type {(value: string) => (s: StringSet) => StringSet} */
-const set = value => btreeSet(cmp(value))(() => value)
+export const set = value => btreeSet(cmp(value))(() => value)
 
-const fromValues = fold(set)(null)
+export const fromValues = fold(set)(null)
 
 /** @type {(value: string) => (s: StringSet) => StringSet} */
-const remove = compose(cmp)(btreeRemove)
-
-export default {
-    /** @readonly */
-    empty,
-    /** @readonly */
-    contains,
-    /** @readonly */
-    set,
-    /** @readonly */
-    values,
-    /** @readonly */
-    fromValues,
-    /** @readonly */
-    remove,
-}
+export const remove = compose(cmp)(btreeRemove)

package/types/string_set/test.f.mjs

@@ -1,4 +1,4 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 
 export default {
     contains: () => {

package/issues/lang/2351-property-accessor.md

@@ -1,44 +0,0 @@
-# Property Accessor
-
-- `.`
-- `?.`
-
-FunctionalScript is a strict subset of JavaScript and should behave the same way as JavaScript or reject JS code during compilation as non-valid FS code. However, every object in JavaScript has inherited properties, such as [`constructor`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor) and [`__proto__`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto). These properties can cause side effects. For example:
-
-```js
-const f = (() => {}).constructor
-const g = f(`console.log('hello')`)
-g() // we received direct access to I/O
-```
-
-According to FunctionScript principles, an FS compiler should reject such code during compilation. So, the compiler will prohibit the use of `construct` and `__proto__` after `.` and `?.`.
-
-If an object has its own properties with such names (e.g. `constructor`) then we can access it using the [Object.getOwnPropertyDescriptor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor) function instead. The function doesn't return inherited properties.
-
-```js
-const f = (() => {}).constructor
-const g = Object.getOwnPropertyDescriptor(f, 'constructor') // g === undefined
-
-const myObject = { constructor: 42 }
-const c = Object.getOwnPropertyDescriptor(myObject, 'constructor').value // c === 42
-```
-
-Here's the reason why we prohibit `__proto__`:
-
-```js
-const p = (() => {}).__proto__
-const f = Object.getOwnPropertyDescriptor(p, 'constructor').value
-const g = f(`console.log('hello')`)
-g() // side-effect
-```
-
-## Example
-
-```js
-const a = { x: 3}
-export default a.x
-```
-
-Depends on [const](./2120-const.md), [default-import](./2130-default-import.md) and [undefined](./2310-undefined.md).
-
-See <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_accessors>.

package/issues/lang/2352-property-call.md

@@ -1,43 +0,0 @@
-# Function Call With Property Accessor
-
-Operators `a.b()`, `a?.b()`.
-
-```js
-const x = a.b(5)
-```
-
-For `null?.b(x())`. We follow the same behavior as JS, so the `x` function will not be called.
-
-Not allowed (additional to `constructor` and `__proto__`, see [property-accessor](./2351-property-accessor.md)):
-
-- `__defineGetter__`
-- `__defineSetter__`
-- `__lookupGetter__`
-- `__lookupSetter__`
-- `isPrototypeOf` FS has no prototype concept because it has no inheritance.
-- `toLocaleString` because it depends on the locale, which is a side-effect.
-
-Also, from a function:
-
-- `apply`
-- `bind`
-- `call`
-
-Also, from an array:
-
-- `copyWithin`
-- `entries` - returns an iterator.
-- `values` - returns an iterator.
-- `keys` - returns an iterator.
-- `pop`
-- `push`
-- `shift`
-- `unshift`
-- `sort`
-- `reverse`
-
-FunctionalScript doesn't allow direct access to iterators. An iterator can be mutated by `.next()` or `for()`. Indirect access to iterators is allowed through the `Iterable` interface. For example 
-```js
-for (const i of [1, 2]) { }
-```
-In this example, the loop gets a temporary iterator from the iterable interface of `[1, 2]` then use it and discard it. A user can't have direct access to the iterator and can't make a copy of it. 

package/issues/lang/2353-property-at.md

@@ -1,19 +0,0 @@
-# At
-
-`a[42]`, `a['str']`, `a[+i]`.
-
-```js
-import m from './m.f.mjs'
-const a = [2, 3]
-export default {
-    "a": a[0],
-    // we don't know what is the type of `m` so we force it to be a `number` or `bigint`.
-    "b": a[+m]
-}
-```
-
-In `a[i]`, `i` has to be a `number` or known `string`, which is not equal to prohibited words, see [property-accessor](./2351-property-accessor.md). If we don't know what is `i`, `+` requires before `i`.
-
-It means that the byte code for the expression inside the `[]` should be either the unary `+`, a number literal, or a string literal (excluding some strings). If it references an object, FS gives up. In the future, FS may try deeper analyses and type inference can help a lot.
-
-Depends on [property-accessor](./2351-property-accessor.md).

package/issues/test-debug.md

@@ -1,12 +0,0 @@
-# Allow Debugging During Test Run
-
-Currently, we read files as strings and then parse them as functions. See [dev/test.mjs](../dev/test.mjs). In this case, the
-debugger doesn't know about the source code and can't debug the functions. The main reason for loading modules as functions was
-that Deno v1 didn't support `.cjs` files. However, Deno v2 supports them.
-
-We can fix the issue by changing our test runner. The test runner will scan all directories, find all `test.f.cjs` files, and
-then load them using `require`.
-
-Limitations: we will not able to check test module dependencies to have module coverage but, anyway, without a parser, we are not able to get full coverage. So, we can drop support for it right now.
-
-**Note:** In this case, we may drop support for Deno v1. At least until we switch to [ESM](./esm.md).