KS 3.0: ES6-related KEP's

[AuthorOfTheSurf]

KobraScript 3.0

Add some nice new ES6 features to KobraScript. Target language becomes ES6 JS, users will be responsible for ES5 transpilation.

Kobra Extension Proposals

1. $ becomes const
2. let becomes let
3. var no longer becomes part of transpilations.
4. fn continues to be function.
5. anon continues to be (function(){...}());.
6. Lambda proposal @ comment 3
7. Consider implementing template literals. $ fullName = ${firstName} ${lastName}``
8. Default parameter values.
9. Rest parameter @ comment 4
10. Property shorthand @ comment 5
11. Method properties @ comment 6
12. New Ways to Assign @ comment 7
13. ...

I think the first couple are not bad at all to implement, and frequently used in ES6 JS. We would notably be leaving classes out as KS aint about that. Lambdas and constants will help though!

[AuthorOfTheSurf]

ES6 related updates will be apart of "KS 3.0" !

[AuthorOfTheSurf]

3.0 Lambda proposal:

fn double(x):
  return 2 * x
end

$ values = [1, 3, 5, 8]

// Without lambda
say values.map(double);
// Or
say valus.map(fn(x): return x*2 ..)

// lambda-entering-expression
// lambdas always have blocks
// single expressions are always returned
// Style: no need to have spaces for single-expression-returns
say values.map(fn(x)::x*2..)

Comments:

• :: to enter a lambda block is elegant. Functions, and lambda functions will begin similarly: the blocks will define what they are. This matches the intent of the difference between these two kinds of functions: that they have different scoping contexts on their blocks.
• Similar to method pointers in Java, a feature that I would strongly consider for a more type-oriented KS.
• Super-set of current syntax, keeping it simple for the functionality it adds
• Reads well for one-liners, simple expressions
• Much better than lmb, KS prefers expressive and beautiful symbols in its syntax

[AuthorOfTheSurf]

3.0 Rest parameter proposal:

ES6 Rest Parameter

Comments:

• Elegant
• Direct pass-through to ES6 node
• useful, much better than relying on arguments parameter... let people name that.

[AuthorOfTheSurf]

3.0 Property Shorthand proposal

ES6 Property Shorthand

Comments:

• Elegant
• Frequently used in practice
• Direct pass-through to ES6 node
• 🔥

[AuthorOfTheSurf]

3.0 Method Properties proposal:

ES6 Method Properties

$ obj = {
    foo(a, b):
        //
    ..,
    bar(x, y):
        //
    ..,
    *quux(x, y):
        //
    ..
}

Comments:

• Elegant
• Supports generator functions
• Supports simple objects with simple functionalities
• Direct pass-through to ES6 node
• Looks more elegant in KS
• Looks like lambdas not allowed for this syntax, these are always JS functions
• Easy to read as an object with three method properties

[AuthorOfTheSurf]

3.0 New Ways to Assign:

• Array Matching assignment
• Object Matching shorthand assignment
• NO to deep object matching for now. Those types of assignments can be more confusing than normal assignments to read. Declarations should be clear, and one level of matching keys/indexes is sufficient for simple cases.
• Parameter Context matching, this matches array and object matching notation and allows the two to be used with each other, e.g.:

fn createPoint({ x, y }):
  return new Point(x, y)
end

$  x = find.x.somehow
.. y = find.y.somehow
.. Point = createPoint({ x, y })

• Fail-soft Destructuring, this matches array and object matching, along with default parameters.