@danielx/civet 0.5.73 → 0.5.75

package/README.md

@@ -10,6 +10,7 @@ Civet
 The modern way to write TypeScript.
 
 - [Documentation](https://civet.dev/)
+- [Design Philosophy](https://civet.dev/philosophy)
 - [Civet Playground](https://civet.dev/playground)
 - [Civet VSCode Extension](https://marketplace.visualstudio.com/items?itemName=DanielX.civet)
 - [Discord Server](https://discord.gg/xkrW9GebBc)
@@ -74,6 +75,11 @@ Civet is essentially a tasteful superset of TypeScript.
 
 ### Implementations of New and Proposed ES Features
 
+See the [documentation](https://civet.dev/) for examples of these
+and other features.
+
+- Pattern matching (based on [TC39 proposal](https://github.com/tc39/proposal-pattern-matching))
+  - `switch` can match patterns like `[{type: "text", name}, ...rest]`
 - Pipe operator (based on [F# pipes](https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/symbol-and-operator-reference/#function-symbols-and-operators), [Hack pipes](https://docs.hhvm.com/hack/expressions-and-operators/pipe) and the [TC39 proposal](https://github.com/tc39/proposal-pipeline-operator))
   - `data |> Object.keys |> console.log` equivalent to
     `console.log(Object.keys(data))`
@@ -82,14 +88,19 @@ Civet is essentially a tasteful superset of TypeScript.
   - `|> await`, `|> yield`, and `|> return` (at end)
     for wrapping left-hand side with that operation
 - Short function block syntax like [Ruby symbol to proc](https://ruby-doc.org/core-3.1.2/Symbol.html#method-i-to_proc), [Crystal](https://crystal-lang.org/reference/1.6/syntax_and_semantics/blocks_and_procs.html#short-one-parameter-syntax), [Elm record access](https://elm-lang.org/docs/records#access)
-  - Access: `x.map &.name` → `x.map(a => a.name)`
+  - Access: `x.map &.name` or `x.map .name` → `x.map(a => a.name)`
   - Nested access + slices: `x.map &.profile?.name[0...3]` → `x.map(a => a.profile?.name.slice(0, 3))`
   - 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)`
-- Flagging shorthand based on [from LiveScript](https://livescript.net/#literals-objects):
-  `{+debug, -live, !verbose}` → `{debug: true, live: false, verbose: false}`
-
+- Object literal shorthand
+  - `{foo()}` → `{foo: foo()}`, `{props.foo}` → `{foo: props.foo}`
+  - ``{`${x}${y}`: z}`` → ``{[`${x}${y}`]: z}``
+  - `data.{x,y}` or `data{x,y}` → `{x: data.x, y: data.y}`
+  - Flagging shorthand based on [from LiveScript](https://livescript.net/#literals-objects):
+    `{+debug, -live, !verbose}` → `{debug: true, live: false, verbose: false}`
+- Custom infix operators from any two-argument function
+- `do` expressions, `if` expressions, `for` expressions
 
 ### Convenience for ES6+ Features
 
@@ -194,7 +205,7 @@ could be a valid property `1.e10` → `1..e10`. The workaround is to add a trail
 - `when` inside switch automatically breaks and adds block scope.
 - `else` inside switch adds block scope.
 - No whitespace between unary operators and operands. Mandatory whitespace between condition and ternary `?` ex. `x ? a : b` since `x?` is the unary existential operator.
-- No labels (yet...)
+- Labels written `:label` (except for special case `$:` for Svelte)
 
 ### Scripting Improvements
 
@@ -361,42 +372,6 @@ esbuild.build({
 
 It's super fast and works great!
 
-Philosophy
----
-
-Civet is a **large language that feels small**. Civet is large because it is mostly a **superset of TypeScript**,
-an already large language. Civet feels small because of the coherent design aesthetic: related
-features look and behave similarly, so when seeing a new feature you can have a good idea what it does,
-and your existing knowledge of JavaScript and other languages leads you in the right direction.
-
-Civet works with **existing tools**. We're not trying to replace the TypeScript type checker; we want to
-amplify its power. We're not trying to change ES semantics; we want to present them in a coherent and expressive
-way.
-
-**Less syntax** is preferred.
-
-**Context matters**. The same tokens can mean different things in different contexts. This shouldn't be arbitrary
-but based on pragmatic concerns. Things should be consistent where possible, especially conceptually.
-
-Civet builds on top of **history**. We've taken inspiration from languages like CoffeeScript, Elm, LiveScript, Flow,
-Haskell, Perl, Python, Ruby, Crystal, Bash, and others.
-
-Civet is **pragmatic**. Civet design is informed by 25+ years of JavaScript development. Frontend frameworks
-have come and gone but they all addressed issues that were important for their time. We focus heavily on
-addressing concerns that real developers feel every day. A key criteria for evaluating features is "how does it
-work in practice?".
-
-Civet **evolves**. As the official JS and TS specifications evolve into the future, Civet also evolves favoring **compatibility**.
-This may lead us to difficult choices where the future spec has evolved differently than we anticipated (pipe operators,
-do expressions, pattern matching). In those cases, Civet will adapt to match the latest spec while providing configuration
-options to allow migration bit by bit while keeping existing code working.
-
-Civet is **configurable**. There is no single "right way" for everyone at all times. Some of us have older CoffeeScript
-codebases that would benefit from added types. Others have massive TypeScript applications that could benefit from
-new language features and shorthand syntax. Civet provides a way to get the benefits bit by bit without a complete
-rewrite. This same configurability lets us experiment with language features to gain experience and improve them before
-locking them in. It also allows us to adapt to a changing future.
-
 Sponsorship
 ---
 If you are so inclined, you can sponsor Civet on [Open Collective](https://opencollective.com/civet).