goldstein 2.1.0 → 2.4.0

package/ChangeLog

@@ -1,3 +1,22 @@
+2022.06.30, v2.4.0
+
+feature:
+- goldstein: freeze: simplify: MemberExpression -> Identifier
+- goldstein: add freeze keyword (#6)
+
+
+2022.06.27, v2.3.0
+
+feature:
+- goldstein: add curry
+
+
+2022.06.27, v2.2.0
+
+feature:
+- goldstein: add support of throw expressions
+
+
 2022.06.25, v2.1.0
 
 feature:

package/README.md

@@ -166,6 +166,24 @@ try hello();
 
 > ☝️ *Warning: this feature can be helpful but also dangerous especially if you're debugging your application. In fact, this is made to be used as an optional function call (ex. should load content, but not necessary and knowing this feature is optional), if you call a function in this way while debugging, no error will be printed and the application will continue run as nothing happened.*
 
+### `freeze`
+
+You can use `freeze` instead of `Object.freeze()` like that:
+
+```gs
+freeze {
+    'example': true
+}
+```
+
+Is the same as:
+
+```js
+Object.freeze({
+    example: true,
+});
+```
+
 ### `if`
 
 You can omit parens. But you must use braces in this case.
@@ -176,6 +194,27 @@ if a > 3 {
 }
 ```
 
+### `throw expression`
+
+You can use [throw as expression](https://github.com/tc39/proposal-throw-expressions), just like that:
+
+```js
+const a = () => throw 'hello';
+```
+
+### `Curry`
+
+Similar to [partial application](https://github.com/tc39/proposal-partial-application):
+
+```gs
+const sum = (a, b) => a + b;
+const inc = sum~(1);
+
+inc(5);
+// returns
+6
+```
+
 ## How to contribute?
 
 Clone the registry, create a new keyword with a prefix `keyword-`, then create directory `fixture` and put there two files with extensions `.js` and `.gs`. Half way done 🥳!

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goldstein",
-  "version": "2.1.0",
+  "version": "2.4.0",
   "type": "module",
   "commitType": "colon",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",

package/packages/goldstein/index.js

@@ -6,7 +6,10 @@ import keywordFn from '../keyword-fn/index.js';
 import keywordGuard from '../keyword-guard/index.js';
 import keywordTry from '../keyword-try/index.js';
 import keywordShould from '../keyword-should/index.js';
+import keywordThrow from '../keyword-throw/index.js';
 import stringInterpolation from '../string-interpolation/index.js';
+import keywordCurry from '../keyword-curry/index.js';
+import keywordFreeze from '../keyword-freeze/index.js';
 
 export const compile = (source) => {
     const {parse} = extendParser([
@@ -14,6 +17,9 @@ export const compile = (source) => {
         keywordGuard,
         keywordTry,
         keywordShould,
+        keywordThrow,
+        keywordCurry,
+        keywordFreeze,
         stringInterpolation,
     ]);
     
@@ -23,6 +29,7 @@ export const compile = (source) => {
     const {code} = putout(jsCode, {
         plugins: [
             'try-catch',
+            'declare-undefined-variables',
         ],
     });
     

package/packages/keyword-curry/index.js

@@ -0,0 +1,32 @@
+import {types} from 'putout';
+import {tokTypes as tt} from '../operator/index.js';
+
+const {Identifier} = types;
+
+export default function keywordCurry(Parser) {
+    return class extends Parser {
+        parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit) {
+            const isTRA = this.eat(tt.prefix);
+            
+            if (isTRA)
+                return this.parseCurry(base, startPos, startLoc);
+            
+            return super.parseSubscript(base, startPos, startLoc, noCalls, maybeAsyncArrow, optionalChained, forInit);
+        }
+        parseCurry(base, startPos, startLoc) {
+            const node = this.startNodeAt(startPos, startLoc);
+            const isParenL = this.eat(tt.parenL);
+            
+            if (!isParenL)
+                this.raise(this.start, `After '~' should always go '(' when you use curry`);
+            
+            node.callee = Identifier('currify');
+            node.arguments = [base, this.parseExpression()];
+            
+            this.expect(tt.parenR);
+            
+            return this.finishNode(node, 'CallExpression');
+        }
+    };
+}
+

package/packages/keyword-freeze/index.js

@@ -0,0 +1,59 @@
+import {types} from 'putout';
+import {
+    addKeyword,
+    TokenType,
+} from '../operator/index.js';
+
+const {
+    isObjectExpression,
+    isArrayExpression,
+} = types;
+
+export default function keywordFreeze(Parser) {
+    const {keywordTypes} = Parser.acorn;
+    keywordTypes.freeze = new TokenType('freeze', {
+        keyword: 'freeze',
+    });
+    
+    return class extends Parser {
+        parse() {
+            this.keywords = addKeyword('freeze', this.keywords);
+            return super.parse();
+        }
+        parseStatement(context, topLevel, exports) {
+            if (this.type === keywordTypes.freeze) {
+                return this.parseFreeze();
+            }
+            
+            return super.parseStatement(context, topLevel, exports);
+        }
+        
+        parseFreeze() {
+            this.next();
+            
+            const node = super.startNode();
+            const expression = this.parseExpression();
+            
+            if (isObjectExpression(expression) || isArrayExpression(expression))
+                node.expression = {
+                    type: 'ExpressionStatement',
+                    expression: {
+                        type: 'CallExpression',
+                        callee: {
+                            type: 'Identifier',
+                            name: 'freeze',
+                        },
+                        arguments: [
+                            expression,
+                        ],
+                    },
+                };
+            
+            else
+                this.raise(this.start, `After 'freeze' only objects and arrays can come`);
+            
+            return super.finishNode(node, 'ExpressionStatement');
+        }
+    };
+}
+

package/packages/keyword-throw/index.js

@@ -0,0 +1,30 @@
+const {assign} = Object;
+
+export default function keywordThrow(Parser) {
+    const {keywordTypes} = Parser.acorn;
+    
+    return class extends Parser {
+        parseExprAtom(refDestructuringErrors, forInit) {
+            if (this.type === keywordTypes.throw) {
+                return this.parseThrowExpression();
+            }
+            
+            return super.parseExprAtom(refDestructuringErrors, forInit);
+        }
+        
+        parseThrowExpression() {
+            this.next();
+            
+            const node = super.startNode();
+            const expression = this.parseExpression();
+            
+            assign(node, {
+                operator: 'throw',
+                argument: expression,
+            });
+            
+            return super.finishNode(node, 'UnaryExpression');
+        }
+    };
+}
+

package/packages/string-interpolation/index.js

@@ -1,9 +1,13 @@
 import {template} from 'putout';
+const isString = (a) => typeof a === 'string';
 const {assign} = Object;
 
 export default function stringInterpolation(Parser) {
     return class extends Parser {
         parseLiteral(value) {
+            if (!isString(value))
+                return super.parseLiteral(value);
+            
             const chars = value.split('');
             
             let literalOpened = false;