Add generalized keyword expression syntax sugar

Author: mkantor

README.md

@@ -9,7 +9,7 @@ git clone [email protected]:mkantor/please-lang-prototype.git
 cd please-lang-prototype
 npm install
 npm run build
-echo '{"@runtime", { context => :context.program.start_time }}' | ./please --output-format=json
+echo '@runtime { context => :context.program.start_time }' | ./please --output-format=json
 ```
 
 There are more example programs in [`./examples`](./examples).
@@ -178,14 +178,18 @@ expressions_. Most of the interesting stuff that Please does involves evaluating
 keyword expressions.
 
 Under the hood, keyword expressions are modeled as objects. For example, `:foo`
-desugars to `{ "@lookup", { key: foo } }`. All such expressions have a property
-named `0` referring to a value that is an `@`-prefixed atom (the keyword). Most
-keyword expressions also require a property named `1` to pass an argument to the
-expression. Keywords include `@apply`, `@check`, `@function`, `@if`, `@index`,
-`@lookup`, `@panic`, and `@runtime`.
+desugars to `{ 0: "@lookup", 1: { key: foo } }`. All such expressions have a
+property named `0` referring to a value that is an `@`-prefixed atom (the
+keyword). Most keyword expressions also require a property named `1` to pass an
+argument to the expression. Keywords include `@apply`, `@check`, `@function`,
+`@if`, `@index`, `@lookup`, `@panic`, and `@runtime`.
 
-Currently only `@function`, `@lookup`, `@index`, and `@apply` have syntax
-sugars.
+In addition to the specific syntax sugars shown above, any keyword expression
+can be written using a generalized sugar:
+
+```
+@keyword { … } // desugars to `{ 0: "@keyword", 1: { … } }`
+```
 
 ### Semantics
 
@@ -211,7 +215,7 @@ function from other programming languages, except there can be any number of
 `@runtime` expressions in a given program. Here's an example:
 
 ```
-{"@runtime", { context => :context.program.start_time }}
+@runtime { context => :context.program.start_time }
 ```
 
 Unsurprisingly, this program outputs the current time when run.
@@ -250,7 +254,7 @@ Take this example `plz` program:
 {
   language: Please
   message: :atom.prepend("Welcome to ")(:language)
-  now: {"@runtime", { context => :context.program.start_time }}
+  now: @runtime { context => :context.program.start_time }
 }
 ```
 

examples/fibonacci.plz

@@ -1,27 +1,21 @@
 {
-  fibonacci: n => {
-    "@if"
-    {
+  fibonacci: n =>
+    @if {
       condition: :n < 2
       then: :n
       else: :fibonacci(:n - 1) + :fibonacci(:n - 2)
     }
-  }
 
-  input: {
-    "@runtime"
-    { context => :context.arguments.lookup(input) }
+  input: @runtime { context =>
+    :context.arguments.lookup(input)
   }
 
   output: :input match {
     none: _ => "missing input argument"
-    some: input => {
-      "@if"
-      {
-        condition: :natural_number.is(:input)
-        then: :fibonacci(:input)
-        else: "input must be a natural number"
-      }
+    some: input => @if {
+      condition: :natural_number.is(:input)
+      then: :fibonacci(:input)
+      else: "input must be a natural number"
     }
   }
 }.output

examples/kitchen-sink.plz

@@ -8,6 +8,6 @@
   add_one: :integer.add(1)
   three: :add_one(:two)
   function: x => { value: :x }
-  conditional_value: :function({ "@if", { :sky_is_blue, :two, :three } })
+  conditional_value: :function(@if { :sky_is_blue, :two, :three })
   side_effect: { "@runtime", { context => :context.log("this goes to stderr") } }
 }

examples/lookup-environment-variable.plz

@@ -2,16 +2,12 @@
   * Given CLI arguments like `--variable=FOO`, looks up the environment
   * variable named `FOO`.
   */
-{
-  "@runtime"
-  {
-    context =>
-      :context.arguments.lookup(variable) match {
-        none: {}
-        some: :context.environment.lookup >> :match({
-          none: {}
-          some: :identity
-        })
-      }
+@runtime { context =>
+  :context.arguments.lookup(variable) match {
+    none: {}
+    some: :context.environment.lookup >> :match({
+      none: {}
+      some: :identity
+    })
   }
 }

src/end-to-end.test.ts

@@ -28,9 +28,9 @@ testCases(endToEnd, code => code)('end-to-end tests', [
   ['{,a,b,c,}', either.makeRight({ 0: 'a', 1: 'b', 2: 'c' })],
   ['{a,1:overwritten,c}', either.makeRight({ 0: 'a', 1: 'c' })],
   ['{overwritten,0:a,c}', either.makeRight({ 0: 'a', 1: 'c' })],
-  ['{"@check", {type:true, value:true}}', either.makeRight('true')],
+  ['@check {type:true, value:true}', either.makeRight('true')],
   [
-    '{"@panic"}',
+    '@panic',
     result => {
       assert(either.isLeft(result))
       assert('kind' in result.value)
@@ -42,7 +42,7 @@ testCases(endToEnd, code => code)('end-to-end tests', [
   ['{a:A, b: :a}', either.makeRight({ a: 'A', b: 'A' })],
   ['{a:A, :a}', either.makeRight({ a: 'A', 0: 'A' })],
   [
-    '{"@runtime", {_ => {"@panic"}}}',
+    '@runtime {_ => @panic}',
     result => {
       assert(either.isLeft(result))
       assert('kind' in result.value)
@@ -153,9 +153,9 @@ testCases(endToEnd, code => code)('end-to-end tests', [
   ],
   [':match({ a: A })({ tag: a, value: {} })', either.makeRight('A')],
   [
-    `{"@runtime", { context =>
+    `@runtime { context =>
       :identity(:context).program.start_time
-    }}`,
+    }`,
     output => {
       if (either.isLeft(output)) {
         assert.fail(output.value.message)
@@ -181,9 +181,7 @@ testCases(endToEnd, code => code)('end-to-end tests', [
   [`(1 - 2) - 3`, either.makeRight('-4')],
   [':flow(:atom.append(b))(:atom.append(a))(z)', either.makeRight('zab')],
   [
-    `{"@runtime"
-      { :object.lookup("key which does not exist in runtime context") }
-    }`,
+    `@runtime { :object.lookup("key which does not exist in runtime context") }`,
     either.makeRight({ tag: 'none', value: {} }),
   ],
   [
@@ -213,7 +211,7 @@ testCases(endToEnd, code => code)('end-to-end tests', [
     either.makeRight({ true: 'true', false: 'false' }),
   ],
   [
-    `{"@runtime", {
+    `@runtime {
       :flow(
         :match({
           none: "environment does not exist"
@@ -228,7 +226,7 @@ testCases(endToEnd, code => code)('end-to-end tests', [
         })
       )(
         :object.lookup(environment)
-      )}
+      )
     }`,
     output => {
       if (either.isLeft(output)) {
@@ -260,9 +258,9 @@ testCases(endToEnd, code => code)('end-to-end tests', [
     either.makeRight({ 0: 'a', 1: 'b', 2: 'c', 3: 'd' }),
   ],
   [
-    `{"@runtime", { context =>
+    `@runtime { context =>
       :context.environment.lookup(PATH)
-    }}`,
+    }`,
     output => {
       if (either.isLeft(output)) {
         assert.fail(output.value.message)
@@ -273,11 +271,11 @@ testCases(endToEnd, code => code)('end-to-end tests', [
     },
   ],
   [
-    `{"@if", {
+    `@if {
       true
       "it works!"
-      {"@panic"}
-    }}`,
+      @panic
+    }`,
     either.makeRight('it works!'),
   ],
   [
@@ -289,24 +287,23 @@ testCases(endToEnd, code => code)('end-to-end tests', [
     either.makeRight({ 0: 'a', 1: 'b', 2: 'c' }),
   ],
   [
-    `{"@runtime", { context =>
-      {"@if", {
+    `@runtime { context =>
+      @if {
         :boolean.not(:boolean.is(:context))
         "it works!"
-        {"@panic"}
-      }}
-    }}`,
+        @panic
+      }
+    }`,
     either.makeRight('it works!'),
   ],
   [
     `{
-      fibonacci: n => {
-        "@if", {
+      fibonacci: n =>
+        @if {
           :integer.less_than(2)(:n)
           then: :n
           else: :fibonacci(:n - 1) + :fibonacci(:n - 2)
         }
-      }
       result: :fibonacci(10)
     }.result`,
     either.makeRight('55'),
@@ -362,7 +359,7 @@ testCases(endToEnd, code => code)('end-to-end tests', [
     either.makeRight('2'),
   ],
   [
-    `{"@runtime", { context =>
+    `@runtime { context =>
       (
         PATH
           |> :context.environment.lookup
@@ -371,7 +368,7 @@ testCases(endToEnd, code => code)('end-to-end tests', [
             some: :atom.prepend("PATH=")
           })
       )
-    }}`,
+    }`,
     result => {
       if (either.isLeft(result)) {
         assert.fail(result.value.message)

src/language/parsing/expression.ts

@@ -13,10 +13,12 @@ import { keyPathToMolecule, type KeyPath } from '../semantics.js'
 import {
   atom,
   atomWithAdditionalQuotationRequirements,
+  unquotedAtomParser,
   type Atom,
 } from './atom.js'
 import {
   arrow,
+  atSign,
   closingBrace,
   colon,
   comma,
@@ -371,6 +373,22 @@ const precededByAtomThenArrow = map(
   },
 )
 
+// @runtime { context => … }
+// @panic
+// @todo blah
+const precededByAtSign = map(
+  sequence([
+    atSign,
+    unquotedAtomParser,
+    optionalTrivia,
+    optional(lazy(() => expression)),
+  ]),
+  ([_atSign, keyword, _trivia, argument]) => ({
+    0: `@${keyword}`,
+    1: argument === undefined ? {} : argument,
+  }),
+)
+
 // :a
 // :a.b
 // :a.b(1).c
@@ -421,6 +439,7 @@ export const expression: Parser<Atom | Molecule> = map(
     oneOf([
       precededByOpeningParenthesis,
       precededByOpeningBrace,
+      precededByAtSign,
       precededByColonThenAtom,
       precededByAtomThenArrow,
       atom,