@danielx/civet 0.4.19-pre.1 → 0.4.19-pre.10

package/README.md

@@ -69,7 +69,7 @@ Things Kept from CoffeeScript
 - Indentation based block syntax
 - OptionalChain shorthand for index and function application `a?[b]` -> `a?.[b]`, `a?(b)` -> `a?.(b)`
 - `?=` null-coalescing assignment shorthand
-- `@` `this` shorthand `@` -> `this`, `@id` -> `this.id`
+- `@` `this` shorthand `@` -> `this`, `@id` -> `this.id`, `{@id} -> {id: this.id}`
 - Prototype shorthand `X::` -> `X.prototype`, `X::a` -> `X.prototype.a`
 - Class static shorthand `@`
 - Chained comparisons `a < b < c` -> `a < b && b < c`
@@ -79,50 +79,53 @@ Things Kept from CoffeeScript
 - `when` inside `switch` automatically breaks
 - Multiple `,` separated `case`/`when` expressions
 - `else` -> `default` in `switch`
+- Range literals `[0...10]`, `[a..b]`, `[x - 2 .. x + 2]`
 - Array slices `list[0...2]` -> `list.slice(0, 2)`
 - Slice assignment `numbers[3..6] = [-3, -4, -5, -6]` -> `numbers.splice(3, 4, ...[-3, -4, -5, -6])`
 - Implicit returns
+- Late assignment `x + y = z` -> `x + (y = z)`
+- Braceless inline objects `x = coolStory: true`
 - Simplified number method calls `1.toFixed()` -> `1..toFixed()`
-- `if`/`switch` expressions
+- `if`/`switch`/`for`/`loop`/`while`/`throw` expressions
 - Destructuring object assignment doesn't require being wrapped in parens at the statement level `{a, b} = c` -> `({a, b} = c)`
 - JSX 😿
 
 Things Removed from CoffeeScript
 ---
 
+Most of these can be enabled by adding a [`"civet coffeeCompat"` directive prologue](#coffeescript-compatibility) to the top of your file.
+The goal is to provide a very high level of compatibility with existing CoffeeScript code while offering a fine grained migration path to modern
+Civet.
+
 - Implicit `var` declarations (use `civet coffeeCompat` or `"civet autoVar"`)
 - `on/yes/off/no` (use `true/false`, `"civet coffeeCompat"`, or `"civet coffeeBooleans"` to add them back)
 - `isnt` (use `!==`, `"civet coffeeCompat"`, or `"civet coffeeIsnt"`)
 - `not` (use `!`, `"civet coffeeCompat"`, or `"civet coffeeNot"`)
   - `not instanceof` (use `!(a instanceof b)`)
-  - `not in`
   - `not of`
   - NOTE: CoffeeScript `not` precedence is dubious. `not a < b` should be equivalent to `!(a < b)` but it is in fact `!a < b`
-- `do` keyword (replaced with JS `do`, invoke using existing `(-> ...)()` syntax)
+- `do` keyword (replaced with JS `do`, invoke using existing `(-> ...)()` syntax, `"civet coffeeCompat"`, or `"civet coffeeDo"`)
 - `for from` (use JS `for of`, `"civet coffeeCompat"`, or `"civet coffeeForLoops"`)
 - `for own of` (use JS `for in` and check manually, switch to `Map#keys/values/entries`, or use `Object.create(null)`, or `"civet coffeeCompat"`, or `"civet coffeeForLoops"`)
 - `for ... when <condition>` (use `continue if exp` inside loop, `"civet coffeeCompat"`, or `"civet coffeeForLoops"`)
 - `and=`, `or=` (don't mix and match words and symbols)
-- `a ? b` (use `a ?? b`, though it doesn't check for undeclared variables)
+- `a ? b` (use `a ?? b`, though it doesn't check for undeclared variables, `"civet coffeeCompat"`, or `"civet coffeeBinaryExistential"` enables this at the cost of losing JS ternary operator)
 - `a of b` (use `a in b` matching JS, or `"civet coffeeCompat"`, or `"civet coffeeOf"`)
 - Iteration expression results
 - Backtick embedded JS (replaced by template literals)
 - Will likely add later
   - Optional assignment `x?.y = 3` -> `x != null ? x.y = 3 : undefined`
-  - Loop expressions (at least in compatibility mode)
   - Conditional assignment `a?[x] = 3` -> `a ? a[x] = 3 : undefined`
 - Might add later
-  - Braceless inline objects `x = coolStory: true`
   - `///` Heregexp
-  - Ranges `[0...10]`
   - Rest parameter in any assignment position
   - Multiple slice assignment `otherNumbers[0...] = numbers[3..6] = [-3, -4, -5, -6]`
 
 Things Changed from CoffeeScript
 ---
 
-- `==` -> `==` rather than `===` (can be kept with `"civet coffeeCompat"`)
-- `!=` -> `!=` rather than `!==` (can be kept with `"civet coffeeCompat"`)
+- `==` -> `==` rather than `===` (can be kept with `"civet coffeeCompat"` or `"civet coffeeEq"`)
+- `!=` -> `!=` rather than `!==` (can be kept with `"civet coffeeCompat"` or `"civet coffeeEq"`)
 - `for in` and `for of` are no longer swapped and become their JS equivalents.
 - `a...` is now `...a` just like JS
 - `a in b` is now `a in b` rather than `b.indexOf(a) >= 0`
@@ -193,7 +196,9 @@ Things Added that CoffeeScript didn't
   - function call `x.map &.callback a, b` -> `x.map($ => $.callback(a, b))`
   - unary operators `x.map !!&`, -> `x.map($ => !!$)`
   - binary operators `x.map &+1` -> `x.map($ => $+1)`
-- Postfix loop `run() loop` -> `while(true) run()`
+- CoffeeScript improvements
+  - Postfix loop `run() loop` -> `while(true) run()`
+  - Character range literals `["a".."z"]`, `['f'..'a']`, `['0'..'9']`
 - Shebang line is kept unmodified in output
   ```civet
   #!./node_modules/.bin/ts-node
@@ -224,11 +229,16 @@ CoffeeScript Compatibility
 Civet provides a compatability prologue directive that aims to be 97+% compatible with existing CoffeeScript2 code (still a work in progress).
 
 ```
+autoVar        (declare implicit vars based on assignment to undeclared identifiers)
 coffeeBooleans (yes/no/on/off)
 coffeeComment  (# single line comments)
+coffeeDo       ( `do ->`, disables ES6 do/while)
 coffeeEq       (`==` -> `===`, `!=` -> `!==`)
-coffeeInterpolation (`"a string with {myVar}"`)
+coffeeForLoops (for in, of, from loops behave like they do in CoffeeScript)
+coffeeInterpolation (`"a string with #{myVar}"`)
 coffeeIsnt     (`isnt` -> `!==`)
+coffeeNot      (`not` -> "!") (currently doesn't support `not instanceof`, `not of`)
+coffeeOf       (`a of b` -> `a in b`, `a in b` -> `b.indexOf(a) >= 0`, `a not in b` -> `b.indexOf(a) < 0`)
 ```
 
 You can use these with `"civet coffeeCompat"` to opt in to all or use them bit by bit with `"civet coffeeComment coffeeEq coffeeInterpolation"`.