feat: spread operator

Adds a new spread operator, allowing you to merge objects/arrays using
`..$input` inside objects or arrays.

README.md

@@ -360,6 +360,50 @@ if you need more power you should use a full language.
 That said, they hopefully provide a way of quickly viewing/changing values
 without needing to trawl through the whole file.
 
+#### Merging
+
+Somtimes you want to re-use an object or array to compose a larger object/array. 
+It is possible to achieve this by merging two together using the `..$input` spread operator.
+This allows you to spread object inputs into other objects, and array inputs into other arrays.
+
+```corn
+let {
+    $base = { foo = "bar"}
+} in {
+    ..$base
+}
+```
+
+Evaluates to:
+
+```json
+{
+    "foo": "bar"
+}
+```
+
+And with arrays:
+
+```corn
+let {
+    $low = [ 1 2 ]
+    $high = [ 3 4 ]
+} in {
+    nums = [ ..$low ..$high ]
+}
+```
+
+Evaluates to:
+
+```json
+{
+     "nums": ["1", "2", "3", "4"]
+}
+```
+
+Object keys and spreads are evaulated in the order they are written, 
+which allows you to spread a base object and then manually overwrite specific keys.
+
 ### Comments
 
 At any point you can start a comment using `//`. A comment is terminated by a newline `\n` character.
@@ -510,4 +554,4 @@ Make sure to enable it when building:
 
 ```sh
 wasm-pack build -- --features wasm
-```
+```

assets/inputs/invalid_spread.corn

@@ -0,0 +1,5 @@
+let {
+  foo = 23
+} in {
+  ..$foo
+}

assets/inputs/spread.corn

@@ -0,0 +1,10 @@
+let {
+  $foo = { bar = "baz" }
+
+  $nums_low = [ 1 2 ]
+  $num_high = [ 3 4 ]
+} in {
+  hello = "world"
+  ..$foo
+  nums = [ ..$nums_low ..$num_high ]
+}

assets/outputs/json/spread.json

@@ -0,0 +1,10 @@
+{
+  "bar": "baz",
+  "hello": "world",
+  "nums": [
+    1,
+    2,
+    3,
+    4
+  ]
+}

assets/outputs/toml/spread.toml

@@ -0,0 +1,9 @@
+bar = 'baz'
+hello = 'world'
+nums = [
+    1,
+    2,
+    3,
+    4,
+]
+

assets/outputs/yaml/spread.yml

@@ -0,0 +1,8 @@
+bar: baz
+hello: world
+nums:
+- 1
+- 2
+- 3
+- 4
+

libcorn/src/grammar.pest

@@ -2,18 +2,34 @@ WHITESPACE = _{ " " | "\t" | "\r" | "\n" }
 COMMENT = _{ "//" ~ (!"\n" ~ ANY)* }
 
 object = {
- "{" ~ pair* ~ "}"
+ "{" 
+ ~ object_value* 
+ ~ "}"
+}
+
+object_value = _{
+  pair | spread
+}
+
+spread = {
+  ".." ~ input
 }
 
 array = {
-  "[" ~ value* ~ "]"
+  "[" 
+  ~ array_value* 
+  ~ "]"
+}
+
+array_value = _{
+  value | spread
 }
 
 pair = { path ~ "=" ~ value }
 
 path = ${
-    path_seg
-    ~ ( "." ~ path_seg )*
+  path_seg
+  ~ ( "." ~ path_seg )*
 }
 
 path_seg = ${ path_char + }
@@ -33,9 +49,9 @@ string_val = ${ char* }
 
 char = {
 //     input
-    !("\"" | "\\") ~ ANY
-    | "\\" ~ ("\"" | "\\" | "/" | "b" | "f" | "n" | "r" | "t")
-    | "\\" ~ ("u" ~ ASCII_HEX_DIGIT{4})
+  !("\"" | "\\") ~ ANY
+  | "\\" ~ ("\"" | "\\" | "/" | "b" | "f" | "n" | "r" | "t")
+  | "\\" ~ ("u" ~ ASCII_HEX_DIGIT{4})
 }
 
 integer = @{
@@ -56,4 +72,4 @@ assignment = { input ~ "=" ~ value }
 
 assign_block = { "let" ~ "{" ~ assignment* ~ "}" ~ "in" }
 
-config = _{ SOI ~ assign_block? ~ object ~ EOI }
+config = _{ SOI ~ assign_block? ~ object ~ EOI }

libcorn/src/parser.rs

@@ -89,10 +89,25 @@ impl<'a> CornParser<'a> {
     /// to form a vector of `Value`s.
     fn parse_array(&self, block: Pair<'a, Rule>) -> Result<Vec<Value<'a>>> {
         assert_eq!(block.as_rule(), Rule::array);
-        block
-            .into_inner()
-            .map(|pair| self.parse_value(pair))
-            .collect::<Result<Vec<_>>>()
+
+        let mut arr = vec![];
+
+        for pair in block.into_inner() {
+            match pair.as_rule() {
+                Rule::spread => {
+                    let input = pair.into_inner().next().unwrap();
+                    let value = self.parse_value(input)?;
+
+                    match value {
+                        Value::Array(other) => arr.extend(other),
+                        _ => unreachable!(),
+                    }
+                }
+                _ => arr.push(self.parse_value(pair)?),
+            };
+        }
+
+        Ok(arr)
     }
 
     /// Parses each key/value pair in a `Rule::object`
@@ -118,6 +133,15 @@ impl<'a> CornParser<'a> {
                         value,
                     );
                 }
+                Rule::spread => {
+                    let input = pair.into_inner().next().unwrap();
+                    let value = self.parse_value(input)?;
+
+                    match value {
+                        Value::Object(other) => obj.extend(other),
+                        _ => unreachable!(),
+                    }
+                }
                 _ => unreachable!(),
             }
         }

libcorn/tests/parser_tests.rs

@@ -92,9 +92,10 @@ generate_eq_tests!(
     object,
     object_in_array,
     readme_example,
+    spread,
     string,
     value_after_table,
     very_compact
 );
 
-generate_invalid_tests!(invalid, invalid_input);
+generate_invalid_tests!(invalid, invalid_input, invalid_spread);