functionalscript 0.0.254 → 0.0.258

package/README.md

@@ -3,158 +3,126 @@
 FunctionalScript is a pure functional programming language and a strict subset of 
 [ECMAScript](https://en.wikipedia.org/wiki/ECMAScript)/[JavaScript](https://en.wikipedia.org/wiki/JavaScript). It's inspired by 
 
-- [JSON](https://en.wikipedia.org/wiki/JSON), as a subset of JavaScript; FunctionalScript is a superset of JSON.
-- [asm.JS](https://en.wikipedia.org/wiki/Asm.js)/[WebAssembly](https://en.wikipedia.org/wiki/WebAssembly), as a subset of JavaScript;
+- [JSON](https://en.wikipedia.org/wiki/JSON), as a subset of JavaScript. JSON is also a subset of FunctionalScript.
+- [asm.JS](https://en.wikipedia.org/wiki/Asm.js)/[WebAssembly](https://en.wikipedia.org/wiki/WebAssembly), as a subset of JavaScript.
 - [TypeScript](https://en.wikipedia.org/wiki/TypeScript), as a superset of JavaScript.
 
 Try FunctionalScript [here](https://functionalscript.com/).
 
 Create a new FunctionalScript repository on GitHub [here](https://github.com/functionalscript/template/generate).
 
-One of the main challenges is how to make a pure functional language when ES6 TCO is not supported by Chrome and Firefox.
-A workaround for this problem is to use `let` for renaming objects.
-
-
-## Install FunctionalScript As A Library
+To install this repository as a library use:
 
 ```
 npm install -S github:functionalscript/functionalscript
 ```
 
-##  JSON
+## 1. Design Principles
 
-```js
-jsonFile = expression
-expression = primitive | array | objects
-primitive = 'true' | 'false' | 'null' | number | string
-array = '[' (() | items) ']'
-items = expression (() | ',' items)
-object = '{' (() | properties) '}'
-properties = propertyId ':' expression (() | ',' properties)
-propertyId = string
-```
+In FunctionalScript:
 
-## Stage 0
+- Any module is a valid JavaScript module
+- A module can't depend on non FunctionalScript module. 
+- A module can contain only pure functional statements. There are no exceptions to this rule, such as `unsafe` code in Rust or C#.
+- It also has no standard library, only a safe subset of standard JavaScript API is allowed.
 
-This stage can be used as an intermediate-code for VMs.
+## 2. Outlines
 
-```js
-fjsFile = expression
-expression = primitive | array | object | func | id | propertyAccessor
-func = ('()' | id) '=>' body
-body = '{' statements 'return' expression ';' '}'
-statements = () | (statement statements)
-statement = decl | ifStatement
-decl = `const` id `=` expression `;`
-ifStatement = `if` `(` expression `)` body
-propertyAccessor = expression `[` expression `]`
-call = expression `(` ( expression | ()) `)`
-```
+### 2.1. Module Ecosystem
 
-### Stage 0.1. Node.js
+FunctionalScript uses Common.JS conventions as a module ecosystem. For example,
 
 ```js
-nodeFile = statements 'module.exports' '=' expression ';'
+const thirdPartyModule = require('third-party-package/module')
+
+const result = thirdPartyModule.someFunction('hello')
 ```
 
-### Stage 0.2. 
+### 2.2. Packages
 
-#### Operators
+FunctionalScript uses a `package.json` file to define a package. This file is compatible with Node.js `package.json`. 
+The prefered way to refence dependencies is to use a GitHub URL. An example of dependencies in a `package.json` file:
 
-```js
-expression = ... | 'undefined' | groupingOperator | binaryOperatorExpression | unaryOperator | conditionalOperator
-groupingOperator = '(' expression ')'
-binaryOperatorExpression = expression binaryOperator expression
-binaryOperator = comparisonOperator | arithmeticOperator | bitwiseOperator | logicalOperators | '??'
-comparisonBinaryOperator = '===' | '!==' | '>' | '<' | '>=' | '<='
-arithmeticBinaryOperator = '+' | '-' | '*' | '/' | '%' | '**'
-bitwiseBinaryOperator = '&' | '|' | '^' | '<<' | '>>' | '>>>'
-logicalBinaryOperator = '&&' | '||'
-unaryOperator = '-' | '~' | '!'
+```json
+{
+   ...
+   "dependencies": {
+      "third-party-package": "github:exampleorg/thirdpartypackage"
+   }
+   ...
+}
 ```
 
-Note: the syntax should be fixed to reflect operator precedents.
+### 2.2. Module Structure
 
-No `==`, `!=`, `=...` operators.
-
-#### Function Expression
+A module is a file with the `.js` extention. It contains three parts: references to other modules, definitions, and exports. For example
 
+`./first.js`
 ```js
-func = ('()' | id) '=>' (('{' statements 'return' expression ';' '}') | expression)
+// 1. references
+const math = require('math')
+
+// 2. definitions
+const myConst = 42
+const addition = a => b => a + b
+const add42 = addition(42)
+const _10digitsOfPi = math.calculatePi(10)
+
+// 3. exports
+module.exports = {
+   addition,
+   add42,
+   _10digitsOfPi,
+}
 ```
 
-#### PropertyAccessor
-
+`./second.js`
 ```js
-propertyAccessor = expression (('[' expression ']') | ('.' id))
+// 1. references
+const first = require('./first.js')
+
+const _42plus7 = first.add42(7)
 ```
 
+### 2.3. References To Other Modules
+
+The format of references is `const ANYNAME = require('PATH_TO_A_MODULE')`. For example
+
 ```js
-propertyId = string | id
+const math = require('math')
+const algebra = require('math/algebra')
+const localFile = require('../some-directory/some-file.js')
 ```
 
-#### BigInt
-
-For example `42n`.
+### 2.4. Definitions
 
-#### Additional Operators
+The format of defintions is `const NAME = EXPRESSION`, where the `EXPRESSION` is a subset of [JavaScript expressions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators).
 
 ```js
-typeOfOperator = 'typeof' expression
-inOperator = expression 'in' expression
+const myConst = 42
+const functionDouble = a => a * 2
+const structure = { name: "John", surname: "Smith" }
+const array = [1, 2, 3]
+const nestedStructure = { 
+   address: undefined, 
+   serialNumber: "123-45-78", 
+   sum: 14 + myConst + functionDouble(4),
+   moreInfo: { 
+      name: "Ivan",
+      surname: "Terrible",
+   } 
+}
 ```
 
-### Stage 0.3. Syntax sugar
-
-Hex, binary and octal literals
-Functions with multiple parameters.
-Spread syntax. For example `...object`.
-Destructing assignments. For example `const {a,b} = exp;`, `const [a, b] = exp`.
-Property Id expression `{ [exp]: exp }`.
-Allow no semicolons.
-Optional comma in arrays and objects.
-Template literals ``const r= `onst r = ${exp}`;``.
-An `if` statement `if (exp) { ... return exp }`
-Multiline strings 
+### 2.5. Exports
+
+The format of exports is `module.exports = { A_LIST_OF_EXPORTED_DEFINITIONS }`. There should be only one `module.exports` at
+the end of a FunctionalScript file. For example
+
 ```js
-'sss\
-   wwww'
+module.exports = {
+   nestedStructure,
+   array,
+   structure,
+}
 ```
-Regular expressions.
-
-## Stage 1
-
-Typing using [JSDoc](https://jsdoc.app/) and TypeScript types.
-
-## Stage 2
-
-Mutable types with exclusive ownership (similar to Rust mutability).
-
-- `let`, `for`, `while` etc.
-  Note: `let` can work as an object name reuse. 
-  In this case, `let` objects can't be used in nested functions. It means we can't reference `let` object.
-  ```js
-  let x = 5 // ok
-  f(x)
-  x = 'hello!' // ok
-  f(x)
-  const r = () => {
-     return x // compilation error
-  }
-  ```
-  Translated into
-  ```js
-  const x0 = 5
-  f(x0)
-  const x1 = 'hello!'  
-  f(x1)
-  ```
-- Generators `function*(){  ... yield ... }`.
-- Async `async () => f(await exp())`.
-- hopefully, we will have [ES pipe operator](https://tc39.es/proposal-pipeline-operator/) at this time.
-- [pattern matching](https://github.com/tc39/proposal-pattern-matching)
-
-Controversial ideas: 
-
-- Import and export `import x from "..."`, `export const x = ...`, `export default = ` e.t.c. This may break `new Function` runners. 
-- Functional-TypeScript as a subset of TypeScript. Note: FunctionalScript doesn't require an additional build step in contrast to TypeScript.

package/package.json

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