Bump version

Improved lexer performance!
Increment version
2025-01-18 04:53:17 -08:00 · 2021-02-25 16:52:49 +11:00 · 2021-02-25 16:47:55 +11:00 · 2021-02-18 11:19:16 +11:00 · 2021-02-18 11:16:54 +11:00 · 2021-02-15 18:23:50 +11:00
43 changed files with 964 additions and 223 deletions
--- a/cmd/evaluate_all_command.go
+++ b/cmd/evaluate_all_command.go
@@ -42,14 +42,21 @@ func evaluateAll(cmd *cobra.Command, args []string) error {
 		colorsEnabled = true
 	}

-	if writeInplace && len(args) < 2 {
+	firstFileIndex := -1
+	if !nullInput && len(args) == 1 {
+		firstFileIndex = 0
+	} else if len(args) > 1 {
+		firstFileIndex = 1
+	}
+
+	if writeInplace && (firstFileIndex == -1) {
 		return fmt.Errorf("Write inplace flag only applicable when giving an expression and at least one file")
 	}

 	if writeInplace {
 		// only use colors if its forced
 		colorsEnabled = forceColor
-		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[1])
+		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[firstFileIndex])
 		out, err = writeInPlaceHandler.CreateTempFile()
 		if err != nil {
 			return err
--- a/cmd/evalute_sequence_command.go
+++ b/cmd/evalute_sequence_command.go
@@ -62,14 +62,21 @@ func evaluateSequence(cmd *cobra.Command, args []string) error {
 		colorsEnabled = true
 	}

-	if writeInplace && len(args) < 2 {
+	firstFileIndex := -1
+	if !nullInput && len(args) == 1 {
+		firstFileIndex = 0
+	} else if len(args) > 1 {
+		firstFileIndex = 1
+	}
+
+	if writeInplace && (firstFileIndex == -1) {
 		return fmt.Errorf("Write inplace flag only applicable when giving an expression and at least one file")
 	}

 	if writeInplace {
 		// only use colors if its forced
 		colorsEnabled = forceColor
-		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[1])
+		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[firstFileIndex])
 		out, err = writeInPlaceHandler.CreateTempFile()
 		if err != nil {
 			return err
@@ -102,7 +109,7 @@ func evaluateSequence(cmd *cobra.Command, args []string) error {
 			err = streamEvaluator.EvaluateFiles(processExpression(""), []string{args[0]}, printer)
 		}
 	default:
-		err = streamEvaluator.EvaluateFiles(args[0], args[1:], printer)
+		err = streamEvaluator.EvaluateFiles(processExpression(args[0]), args[1:], printer)
 	}
 	completedSuccessfully = err == nil

--- a/cmd/version.go
+++ b/cmd/version.go
@@ -11,7 +11,7 @@ var (
 	GitDescribe string

 	// Version is main version number that is being run at the moment.
-	Version = "4.4.1"
+	Version = "4.6.1"

 	// VersionPrerelease is a pre-release marker for the version. If this is "" (empty string)
 	// then it means that it is a final release. Otherwise, this is a pre-release
--- a/github-action/Dockerfile
+++ b/github-action/Dockerfile
@@ -1,4 +1,4 @@
-FROM mikefarah/yq:4.4.1
+FROM mikefarah/yq:4.6.1

 COPY entrypoint.sh /entrypoint.sh

--- a/go.mod
+++ b/go.mod
@@ -1,14 +1,14 @@
 module github.com/mikefarah/yq/v4

 require (
-	github.com/elliotchance/orderedmap v1.3.0
+	github.com/elliotchance/orderedmap v1.4.0
 	github.com/fatih/color v1.10.0
-	github.com/goccy/go-yaml v1.8.4
-	github.com/jinzhu/copier v0.1.0
+	github.com/goccy/go-yaml v1.8.8
+	github.com/jinzhu/copier v0.2.3
 	github.com/spf13/cobra v1.1.1
 	github.com/timtadh/data-structures v0.5.3 // indirect
 	github.com/timtadh/lexmachine v0.2.2
-	golang.org/x/sys v0.0.0-20210105210732-16f7687f5001 // indirect
+	golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c // indirect
 	gopkg.in/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473
 	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
 )
--- a/go.sum
+++ b/go.sum
@@ -36,8 +36,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
-github.com/elliotchance/orderedmap v1.3.0 h1:k6m77/d0zCXTjsk12nX40TkEBkSICq8T4s6R6bpCqU0=
-github.com/elliotchance/orderedmap v1.3.0/go.mod h1:8hdSl6jmveQw8ScByd3AaNHNk51RhbTazdqtTty+NFw=
+github.com/elliotchance/orderedmap v1.4.0 h1:wZtfeEONCbx6in1CZyE6bELEt/vFayMvsxqI5SgsR+A=
+github.com/elliotchance/orderedmap v1.4.0/go.mod h1:wsDwEaX5jEoyhbs7x93zk2H/qv0zwuhg4inXhDkYqys=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fatih/color v1.10.0 h1:s36xzo75JdqLaaWoiEHk767eHiwo0598uUxyfiPkDsg=
 github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
@@ -52,8 +52,8 @@ github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTM
 github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
 github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/goccy/go-yaml v1.8.4 h1:AOEdR7aQgbgwHznGe3BLkDQVujxCPUpHOZZcQcp8Y3M=
-github.com/goccy/go-yaml v1.8.4/go.mod h1:U/jl18uSupI5rdI2jmuCswEA2htH9eXfferR3KfscvA=
+github.com/goccy/go-yaml v1.8.8 h1:MGfRB1GeSn/hWXYWS2Pt67iC2GJNnebdIro01ddyucA=
+github.com/goccy/go-yaml v1.8.8/go.mod h1:U/jl18uSupI5rdI2jmuCswEA2htH9eXfferR3KfscvA=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
@@ -101,8 +101,8 @@ github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2p
 github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
-github.com/jinzhu/copier v0.1.0 h1:Vh8xALtH3rrKGB/XIRe5d0yCTHPZFauWPLvdpDAbi88=
-github.com/jinzhu/copier v0.1.0/go.mod h1:24xnZezI2Yqac9J61UC6/dG/k76ttpq0DdJI3QmUvro=
+github.com/jinzhu/copier v0.2.3 h1:Oe09ju+9qft7TffZ7l/04AB2f8u1+V4ZMxmp/nnqeOs=
+github.com/jinzhu/copier v0.2.3/go.mod h1:24xnZezI2Yqac9J61UC6/dG/k76ttpq0DdJI3QmUvro=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
@@ -182,6 +182,8 @@ github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXf
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
 github.com/timtadh/data-structures v0.5.3 h1:F2tEjoG9qWIyUjbvXVgJqEOGJPMIiYn7U5W5mE+i/vQ=
 github.com/timtadh/data-structures v0.5.3/go.mod h1:9R4XODhJ8JdWFEI8P/HJKqxuJctfBQw6fDibMQny2oU=
@@ -257,8 +259,8 @@ golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae h1:/WDfKMnPU+m5M4xB+6x4kaepxRw6jWvR5iDRdvjHgy8=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210105210732-16f7687f5001 h1:/dSxr6gT0FNI1MO5WLJo8mTmItROeOKTkDn+7OwWBos=
-golang.org/x/sys v0.0.0-20210105210732-16f7687f5001/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c h1:VwygUrnw9jn88c4u8GD3rZQbqrP/tgas88tPUbBxQrk=
+golang.org/x/sys v0.0.0-20210124154548-22da62e12c0c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
@@ -324,6 +326,7 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
 gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
 gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
--- a/pkg/yqlib/candidate_node.go
+++ b/pkg/yqlib/candidate_node.go
@@ -2,8 +2,6 @@ package yqlib

 import (
 	"fmt"
-	"strconv"
-	"strings"

 	"github.com/jinzhu/copier"
 	yaml "gopkg.in/yaml.v3"
@@ -18,10 +16,15 @@ type CandidateNode struct {
 	// when performing op against all nodes given, this will treat all the nodes as one
 	// (e.g. top level cross document merge). This property does not propegate to child nodes.
 	EvaluateTogether bool
+	IsMapKey         bool
 }

 func (n *CandidateNode) GetKey() string {
-	return fmt.Sprintf("%v - %v", n.Document, n.Path)
+	keyPrefix := ""
+	if n.IsMapKey {
+		keyPrefix = "key-"
+	}
+	return fmt.Sprintf("%v%v - %v", keyPrefix, n.Document, n.Path)
 }

 func (n *CandidateNode) CreateChild(path interface{}, node *yaml.Node) *CandidateNode {
@@ -63,11 +66,10 @@ func (n *CandidateNode) UpdateFrom(other *CandidateNode) {
 	n.UpdateAttributesFrom(other)
 	n.Node.Content = other.Node.Content
 	n.Node.Value = other.Node.Value
-	n.Node.Alias = other.Node.Alias
-	n.Node.Anchor = other.Node.Anchor
 }

 func (n *CandidateNode) UpdateAttributesFrom(other *CandidateNode) {
+	log.Debug("UpdateAttributesFrom: n: %v other: %v", n.GetKey(), other.GetKey())
 	if n.Node.Kind != other.Node.Kind {
 		// clear out the contents when switching to a different type
 		// e.g. map to array
@@ -76,6 +78,8 @@ func (n *CandidateNode) UpdateAttributesFrom(other *CandidateNode) {
 	}
 	n.Node.Kind = other.Node.Kind
 	n.Node.Tag = other.Node.Tag
+	n.Node.Alias = other.Node.Alias
+	n.Node.Anchor = other.Node.Anchor

 	// merge will pickup the style of the new thing
 	// when autocreating nodes
@@ -86,46 +90,3 @@ func (n *CandidateNode) UpdateAttributesFrom(other *CandidateNode) {
 	n.Node.HeadComment = n.Node.HeadComment + other.Node.HeadComment
 	n.Node.LineComment = n.Node.LineComment + other.Node.LineComment
 }
-
-func (n *CandidateNode) PathStackToString() string {
-	return mergePathStackToString(n.Path)
-}
-
-func mergePathStackToString(pathStack []interface{}) string {
-	var sb strings.Builder
-	for index, path := range pathStack {
-		switch path.(type) {
-		case int, int64:
-			// if arrayMergeStrategy == AppendArrayMergeStrategy {
-			// sb.WriteString("[+]")
-			// } else {
-			sb.WriteString(fmt.Sprintf("[%v]", path))
-			// }
-
-		default:
-			s := fmt.Sprintf("%v", path)
-			var _, errParsingInt = strconv.ParseInt(s, 10, 64) // nolint
-
-			hasSpecial := strings.Contains(s, ".") || strings.Contains(s, "[") || strings.Contains(s, "]") || strings.Contains(s, "\"")
-			hasDoubleQuotes := strings.Contains(s, "\"")
-			wrappingCharacterStart := "\""
-			wrappingCharacterEnd := "\""
-			if hasDoubleQuotes {
-				wrappingCharacterStart = "("
-				wrappingCharacterEnd = ")"
-			}
-			if hasSpecial || errParsingInt == nil {
-				sb.WriteString(wrappingCharacterStart)
-			}
-			sb.WriteString(s)
-			if hasSpecial || errParsingInt == nil {
-				sb.WriteString(wrappingCharacterEnd)
-			}
-		}
-
-		if index < len(pathStack)-1 {
-			sb.WriteString(".")
-		}
-	}
-	return sb.String()
-}
--- a/pkg/yqlib/context.go
+++ b/pkg/yqlib/context.go
@@ -18,6 +18,20 @@ func (n *Context) SingleChildContext(candidate *CandidateNode) Context {
 	return n.ChildContext(list)
 }

+func (n *Context) GetVariable(name string) *list.List {
+	if n.Variables == nil {
+		return nil
+	}
+	return n.Variables[name]
+}
+
+func (n *Context) SetVariable(name string, value *list.List) {
+	if n.Variables == nil {
+		n.Variables = make(map[string]*list.List)
+	}
+	n.Variables[name] = value
+}
+
 func (n *Context) ChildContext(results *list.List) Context {
 	clone := Context{}
 	err := copier.Copy(&clone, n)
@@ -28,3 +42,13 @@ func (n *Context) ChildContext(results *list.List) Context {
 	clone.MatchingNodes = results
 	return clone
 }
+
+func (n *Context) Clone() Context {
+	clone := Context{}
+	err := copier.Copy(&clone, n)
+	if err != nil {
+		log.Error("Error cloning context :(")
+		panic(err)
+	}
+	return clone
+}
--- a/pkg/yqlib/doc/Equals.md
+++ b/pkg/yqlib/doc/Equals.md
@@ -29,6 +29,24 @@ true
 false
 ```

+## Don't match string
+Given a sample.yml file of:
+```yaml
+- cat
+- goat
+- dog
+```
+then
+```bash
+yq eval '.[] | (. != "*at")' sample.yml
+```
+will output
+```yaml
+false
+false
+true
+```
+
 ## Match number
 Given a sample.yml file of:
 ```yaml
@@ -47,6 +65,24 @@ true
 false
 ```

+## Dont match number
+Given a sample.yml file of:
+```yaml
+- 3
+- 4
+- 5
+```
+then
+```bash
+yq eval '.[] | (. != 4)' sample.yml
+```
+will output
+```yaml
+true
+false
+true
+```
+
 ## Match nulls
 Running
 ```bash
--- a/pkg/yqlib/doc/File
+++ b/pkg/yqlib/doc/File
@@ -35,6 +35,26 @@ will output
 0
 ```

+## Get file indices of multiple documents
+Given a sample.yml file of:
+```yaml
+a: cat
+```
+And another sample another.yml file of:
+```yaml
+a: cat
+```
+then
+```bash
+yq eval-all 'fileIndex' sample.yml another.yml
+```
+will output
+```yaml
+0
+---
+1
+```
+
 ## Get file index alias
 Given a sample.yml file of:
 ```yaml
--- a/pkg/yqlib/doc/Multiply.md
+++ b/pkg/yqlib/doc/Multiply.md
@@ -1,19 +1,34 @@
-Like the multiple operator in jq, depending on the operands, this multiply operator will do different things. Currently only objects are supported, which have the effect of merging the RHS into the LHS.
+Like the multiple operator in jq, depending on the operands, this multiply operator will do different things. Currently numbers, arrays and objects are supported.

-To concatenate arrays when merging objects, use the *+ form (see examples below). This will recursively merge objects, appending arrays when it encounters them.
+## Objects and arrays - merging
+Objects are merged deeply matching on matching keys. By default, array values override and are not deeply merged.

-To merge only existing fields, use the *? form. Note that this can be used with the concatenate arrays too *+?.
 Note that when merging objects, this operator returns the merged object (not the parent). This will be clearer in the examples below.

-Multiplication of strings and numbers are not yet supported.
+### Merge Flags
+You can control how objects are merged by using one or more of the following flags. Multiple flags can be used together, e.g. `.a *+? .b`.  See examples below

-## Merging files
+- `+` to append arrays
+- `?` to only merge existing fields
+- `d` to deeply merge arrays
+
+### Merging files
 Note the use of `eval-all` to ensure all documents are loaded into memory.

 ```bash
 yq eval-all 'select(fileIndex == 0) * select(fileIndex == 1)' file1.yaml file2.yaml
 ```

+## Multiply integers
+Running
+```bash
+yq eval --null-input '3 * 4'
+```
+will output
+```yaml
+12
+```
+
 ## Merge objects together, returning merged result only
 Given a sample.yml file of:
 ```yaml
@@ -71,7 +86,6 @@ Given a sample.yml file of:
 a: {things: great}
 b:
  also: "me"
-
 ```
 then
 ```bash
@@ -191,6 +205,32 @@ thing:
  - 4
 ```

+## Merge, deeply merging arrays
+Merging arrays deeply means arrays are merge like objects, with indexes as their key. In this case, we merge the first item in the array, and do nothing with the second.
+
+Given a sample.yml file of:
+```yaml
+a:
+  - name: fred
+    age: 12
+  - name: bob
+    age: 32
+b:
+  - name: fred
+    age: 34
+```
+then
+```bash
+yq eval '.a *d .b' sample.yml
+```
+will output
+```yaml
+- name: fred
+  age: 34
+- name: bob
+  age: 32
+```
+
 ## Merge to prefix an element
 Given a sample.yml file of:
 ```yaml
--- a/pkg/yqlib/doc/Reduce.md
+++ b/pkg/yqlib/doc/Reduce.md
@@ -0,0 +1,76 @@
+Reduce is a powerful way to process a collection of data into a new form.
+
+```
+<exp> as $<name> ireduce (<init>; <block>)
+```
+
+e.g.
+
+```
+.[] as $item ireduce (0; . + $item)
+```
+
+On the LHS we are configuring the collection of items that will be reduced `<exp>` as well as what each element will be called `$<name>`. Note that the array has been splatted into its individual elements.
+
+On the RHS there is `<init>`, the starting value of the accumulator and `<block>`, the expression that will update the accumulator for each element in the collection. Note that within the block expression, `.` will evaluate to the current value of the accumulator. 
+
+## yq vs jq syntax
+Reduce syntax in `yq` is a little different from `jq` - as `yq` (currently) isn't as sophisticated as `jq` and its only supports infix notation (e.g. a + b, where the operator is in the middle of the two parameters) - where as `jq` uses a mix of infix notation with _prefix_ notation (e.g. `reduce a b` is like writing `+ a b`).
+
+To that end, the reduce operator is called `ireduce` for backwards compatability if a `jq` like prefix version of `reduce` is ever added.
+
+
+## Sum numbers
+Given a sample.yml file of:
+```yaml
+- 10
+- 2
+- 5
+- 3
+```
+then
+```bash
+yq eval '.[] as $item ireduce (0; . + $item)' sample.yml
+```
+will output
+```yaml
+20
+```
+
+## Merge all yaml files together
+Given a sample.yml file of:
+```yaml
+a: cat
+```
+And another sample another.yml file of:
+```yaml
+b: dog
+```
+then
+```bash
+yq eval-all '. as $item ireduce ({}; . * $item )' sample.yml another.yml
+```
+will output
+```yaml
+a: cat
+b: dog
+```
+
+## Convert an array to an object
+Given a sample.yml file of:
+```yaml
+- name: Cathy
+  has: apples
+- name: Bob
+  has: bananas
+```
+then
+```bash
+yq eval '.[] as $item ireduce ({}; .[$item | .name] = ($item | .has) )' sample.yml
+```
+will output
+```yaml
+Cathy: apples
+Bob: bananas
+```
+
--- a/pkg/yqlib/doc/Traverse.md
+++ b/pkg/yqlib/doc/Traverse.md
@@ -33,7 +33,7 @@ c: banana
 ```

 ## Special characters
-Use quotes around path elements with special characters
+Use quotes with brackets around path elements with special characters

 Given a sample.yml file of:
 ```yaml
@@ -41,7 +41,23 @@ Given a sample.yml file of:
 ```
 then
 ```bash
-yq eval '."{}"' sample.yml
+yq eval '.["{}"]' sample.yml
+```
+will output
+```yaml
+frog
+```
+
+## Keys with spaces
+Use quotes with brackets around path elements with special characters
+
+Given a sample.yml file of:
+```yaml
+"red rabbit": frog
+```
+then
+```bash
+yq eval '.["red rabbit"]' sample.yml
 ```
 will output
 ```yaml
--- a/pkg/yqlib/doc/Variable
+++ b/pkg/yqlib/doc/Variable
@@ -0,0 +1,58 @@
+For more complex scenarios, variables can be used to hold values of expression to be used in other expressions.
+
+## Single value variable
+Given a sample.yml file of:
+```yaml
+a: cat
+```
+then
+```bash
+yq eval '.a as $foo | $foo' sample.yml
+```
+will output
+```yaml
+cat
+```
+
+## Multi value variable
+Given a sample.yml file of:
+```yaml
+- cat
+- dog
+```
+then
+```bash
+yq eval '.[] as $foo | $foo' sample.yml
+```
+will output
+```yaml
+cat
+dog
+```
+
+## Using variables as a lookup
+Example taken from [jq](https://stedolan.github.io/jq/manual/#Variable/SymbolicBindingOperator:...as$identifier|...)
+
+Given a sample.yml file of:
+```yaml
+"posts":
+  - "title": Frist psot
+    "author": anon
+  - "title": A well-written article
+    "author": person1
+"realnames":
+  "anon": Anonymous Coward
+  "person1": Person McPherson
+```
+then
+```bash
+yq eval '.realnames as $names | .posts[] | {"title":.title, "author": $names[.author]}' sample.yml
+```
+will output
+```yaml
+title: Frist psot
+author: Anonymous Coward
+title: A well-written article
+author: Person McPherson
+```
+
--- a/pkg/yqlib/doc/headers/Multiply.md
+++ b/pkg/yqlib/doc/headers/Multiply.md
@@ -1,13 +1,18 @@
-Like the multiple operator in jq, depending on the operands, this multiply operator will do different things. Currently only objects are supported, which have the effect of merging the RHS into the LHS.
+Like the multiple operator in jq, depending on the operands, this multiply operator will do different things. Currently numbers, arrays and objects are supported.

-To concatenate arrays when merging objects, use the *+ form (see examples below). This will recursively merge objects, appending arrays when it encounters them.
+## Objects and arrays - merging
+Objects are merged deeply matching on matching keys. By default, array values override and are not deeply merged.

-To merge only existing fields, use the *? form. Note that this can be used with the concatenate arrays too *+?.
 Note that when merging objects, this operator returns the merged object (not the parent). This will be clearer in the examples below.

-Multiplication of strings and numbers are not yet supported.
+### Merge Flags
+You can control how objects are merged by using one or more of the following flags. Multiple flags can be used together, e.g. `.a *+? .b`.  See examples below

-## Merging files
+- `+` to append arrays
+- `?` to only merge existing fields
+- `d` to deeply merge arrays
+
+### Merging files
 Note the use of `eval-all` to ensure all documents are loaded into memory.

 ```bash
--- a/pkg/yqlib/doc/headers/Reduce.md
+++ b/pkg/yqlib/doc/headers/Reduce.md
@@ -0,0 +1,21 @@
+Reduce is a powerful way to process a collection of data into a new form.
+
+```
+<exp> as $<name> ireduce (<init>; <block>)
+```
+
+e.g.
+
+```
+.[] as $item ireduce (0; . + $item)
+```
+
+On the LHS we are configuring the collection of items that will be reduced `<exp>` as well as what each element will be called `$<name>`. Note that the array has been splatted into its individual elements.
+
+On the RHS there is `<init>`, the starting value of the accumulator and `<block>`, the expression that will update the accumulator for each element in the collection. Note that within the block expression, `.` will evaluate to the current value of the accumulator. 
+
+## yq vs jq syntax
+Reduce syntax in `yq` is a little different from `jq` - as `yq` (currently) isn't as sophisticated as `jq` and its only supports infix notation (e.g. a + b, where the operator is in the middle of the two parameters) - where as `jq` uses a mix of infix notation with _prefix_ notation (e.g. `reduce a b` is like writing `+ a b`).
+
+To that end, the reduce operator is called `ireduce` for backwards compatability if a `jq` like prefix version of `reduce` is ever added.
+
--- a/pkg/yqlib/doc/headers/Traverse.md
+++ b/pkg/yqlib/doc/headers/Traverse.md
--- a/pkg/yqlib/doc/headers/Variable
+++ b/pkg/yqlib/doc/headers/Variable
@@ -0,0 +1 @@
+For more complex scenarios, variables can be used to hold values of expression to be used in other expressions.
--- a/pkg/yqlib/expression_parser.go
+++ b/pkg/yqlib/expression_parser.go
@@ -5,9 +5,6 @@ import (
 	"strings"
 )

-var myPathTokeniser = newExpressionTokeniser()
-var myPathPostfixer = newExpressionPostFixer()
-
 type ExpressionNode struct {
 	Operation *Operation
 	Lhs       *ExpressionNode
@@ -19,19 +16,21 @@ type ExpressionParser interface {
 }

 type expressionParserImpl struct {
+	pathTokeniser expressionTokeniser
+	pathPostFixer expressionPostFixer
 }

 func NewExpressionParser() ExpressionParser {
-	return &expressionParserImpl{}
+	return &expressionParserImpl{newExpressionTokeniser(), newExpressionPostFixer()}
 }

 func (p *expressionParserImpl) ParseExpression(expression string) (*ExpressionNode, error) {
-	tokens, err := myPathTokeniser.Tokenise(expression)
+	tokens, err := p.pathTokeniser.Tokenise(expression)
 	if err != nil {
 		return nil, err
 	}
 	var Operations []*Operation
-	Operations, err = myPathPostfixer.ConvertToPostfix(tokens)
+	Operations, err = p.pathPostFixer.ConvertToPostfix(tokens)
 	if err != nil {
 		return nil, err
 	}
@@ -70,7 +69,7 @@ func (p *expressionParserImpl) createExpressionTree(postFixPath []*Operation) (*
 		stack = append(stack, &newNode)
 	}
 	if len(stack) != 1 {
-		return nil, fmt.Errorf("expected end of expression but found '%v', please check expression syntax", strings.TrimSpace(stack[1].Operation.StringValue))
+		return nil, fmt.Errorf("Bad expression, please check expression syntax")
 	}
 	return stack[0], nil
 }
--- a/pkg/yqlib/expression_parser_test.go
+++ b/pkg/yqlib/expression_parser_test.go
@@ -38,5 +38,5 @@ func TestPathTreeOneArgForOneArgOp(t *testing.T) {

 func TestPathTreeExtraArgs(t *testing.T) {
 	_, err := NewExpressionParser().ParseExpression("sortKeys(.) explode(.)")
-	test.AssertResultComplex(t, "expected end of expression but found 'explode', please check expression syntax", err.Error())
+	test.AssertResultComplex(t, "Bad expression, please check expression syntax", err.Error())
 }
--- a/pkg/yqlib/expression_postfix.go
+++ b/pkg/yqlib/expression_postfix.go
@@ -20,20 +20,22 @@ func newExpressionPostFixer() expressionPostFixer {
 func popOpToResult(opStack []*token, result []*Operation) ([]*token, []*Operation) {
 	var newOp *token
 	opStack, newOp = opStack[0:len(opStack)-1], opStack[len(opStack)-1]
+	log.Debugf("popped %v from opstack to results", newOp.toString(true))
 	return opStack, append(result, newOp.Operation)
 }

 func (p *expressionPostFixerImpl) ConvertToPostfix(infixTokens []*token) ([]*Operation, error) {
 	var result []*Operation
-	// surround the whole thing with quotes
-	var opStack = []*token{&token{TokenType: openBracket}}
+	// surround the whole thing with brackets
+	var opStack = []*token{{TokenType: openBracket}}
 	var tokens = append(infixTokens, &token{TokenType: closeBracket})

 	for _, currentToken := range tokens {
-		log.Debugf("postfix processing currentToken %v, %v", currentToken.toString(), currentToken.Operation)
+		log.Debugf("postfix processing currentToken %v", currentToken.toString(true))
 		switch currentToken.TokenType {
 		case openBracket, openCollect, openCollectObject:
 			opStack = append(opStack, currentToken)
+			log.Debugf("put %v onto the opstack", currentToken.toString(true))
 		case closeCollect, closeCollectObject:
 			var opener tokenType = openCollect
 			var collectOperator *operationType = collectOpType
@@ -41,23 +43,23 @@ func (p *expressionPostFixerImpl) ConvertToPostfix(infixTokens []*token) ([]*Ope
 				opener = openCollectObject
 				collectOperator = collectObjectOpType
 			}
-			itemsInMiddle := false
+
 			for len(opStack) > 0 && opStack[len(opStack)-1].TokenType != opener {
 				opStack, result = popOpToResult(opStack, result)
-				itemsInMiddle = true
-			}
-			if !itemsInMiddle {
-				// must be an empty collection, add the empty object as a LHS parameter
-				result = append(result, &Operation{OperationType: emptyOpType})
 			}
 			if len(opStack) == 0 {
 				return nil, errors.New("Bad path expression, got close collect brackets without matching opening bracket")
 			}
-			// now we should have [] as the last element on the opStack, get rid of it
+			// now we should have [ as the last element on the opStack, get rid of it
 			opStack = opStack[0 : len(opStack)-1]
+			log.Debugf("deleteing open bracket from opstack")
+
 			//and append a collect to the opStack
-			opStack = append(opStack, &token{TokenType: operationToken, Operation: &Operation{OperationType: shortPipeOpType}})
-			opStack = append(opStack, &token{TokenType: operationToken, Operation: &Operation{OperationType: collectOperator}})
+			result = append(result, &Operation{OperationType: collectOperator})
+			log.Debugf("put collect onto the result")
+			result = append(result, &Operation{OperationType: shortPipeOpType})
+			log.Debugf("put shortpipe onto the result")
+
 		case closeBracket:
 			for len(opStack) > 0 && opStack[len(opStack)-1].TokenType != openBracket {
 				opStack, result = popOpToResult(opStack, result)
@@ -73,11 +75,12 @@ func (p *expressionPostFixerImpl) ConvertToPostfix(infixTokens []*token) ([]*Ope
 			// pop off higher precedent operators onto the result
 			for len(opStack) > 0 &&
 				opStack[len(opStack)-1].TokenType == operationToken &&
-				opStack[len(opStack)-1].Operation.OperationType.Precedence >= currentPrecedence {
+				opStack[len(opStack)-1].Operation.OperationType.Precedence > currentPrecedence {
 				opStack, result = popOpToResult(opStack, result)
 			}
 			// add this operator to the opStack
 			opStack = append(opStack, currentToken)
+			log.Debugf("put %v onto the opstack", currentToken.toString(true))
 		}
 	}

--- a/pkg/yqlib/expression_processing_test.go
+++ b/pkg/yqlib/expression_processing_test.go
@@ -12,40 +12,70 @@ var pathTests = []struct {
 	expectedTokens  []interface{}
 	expectedPostFix []interface{}
 }{
+	{
+		`.a as $item ireduce (0; . + $item)`, // note - add code to shuffle reduce to this position for postfix
+		append(make([]interface{}, 0), "a", "ASSIGN_VARIABLE", "GET_VARIABLE", "REDUCE", "(", "0 (int64)", "BLOCK", "SELF", "ADD", "GET_VARIABLE", ")"),
+		append(make([]interface{}, 0), "a", "GET_VARIABLE", "ASSIGN_VARIABLE", "0 (int64)", "SELF", "GET_VARIABLE", "ADD", "BLOCK", "REDUCE"),
+	},
+	{
+		`.a | .b | .c`,
+		append(make([]interface{}, 0), "a", "PIPE", "b", "PIPE", "c"),
+		append(make([]interface{}, 0), "a", "b", "c", "PIPE", "PIPE"),
+	},
 	{
 		`[]`,
-		append(make([]interface{}, 0), "[", "]"),
+		append(make([]interface{}, 0), "[", "EMPTY", "]"),
 		append(make([]interface{}, 0), "EMPTY", "COLLECT", "SHORT_PIPE"),
 	},
+	{
+		`{}`,
+		append(make([]interface{}, 0), "{", "EMPTY", "}"),
+		append(make([]interface{}, 0), "EMPTY", "COLLECT_OBJECT", "SHORT_PIPE"),
+	},
+	{
+		`[{}]`,
+		append(make([]interface{}, 0), "[", "{", "EMPTY", "}", "]"),
+		append(make([]interface{}, 0), "EMPTY", "COLLECT_OBJECT", "SHORT_PIPE", "COLLECT", "SHORT_PIPE"),
+	},
+	{
+		`.realnames as $names | $names["anon"]`,
+		append(make([]interface{}, 0), "realnames", "ASSIGN_VARIABLE", "GET_VARIABLE", "PIPE", "GET_VARIABLE", "TRAVERSE_ARRAY", "[", "anon (string)", "]"),
+		append(make([]interface{}, 0), "realnames", "GET_VARIABLE", "ASSIGN_VARIABLE", "GET_VARIABLE", "anon (string)", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "PIPE"),
+	},
+	{
+		`.b[.a]`,
+		append(make([]interface{}, 0), "b", "TRAVERSE_ARRAY", "[", "a", "]"),
+		append(make([]interface{}, 0), "b", "a", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
+	},
 	{
 		`.[]`,
-		append(make([]interface{}, 0), "TRAVERSE_ARRAY", "[", "]"),
-		append(make([]interface{}, 0), "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
+		append(make([]interface{}, 0), "SELF", "TRAVERSE_ARRAY", "[", "EMPTY", "]"),
+		append(make([]interface{}, 0), "SELF", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
 	},
 	{
 		`.a[]`,
-		append(make([]interface{}, 0), "a", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "]"),
-		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE"),
+		append(make([]interface{}, 0), "a", "TRAVERSE_ARRAY", "[", "EMPTY", "]"),
+		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
 	},
 	{
 		`.a.[]`,
-		append(make([]interface{}, 0), "a", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "]"),
-		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE"),
+		append(make([]interface{}, 0), "a", "TRAVERSE_ARRAY", "[", "EMPTY", "]"),
+		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
 	},
 	{
 		`.a[0]`,
-		append(make([]interface{}, 0), "a", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "0 (int64)", "]"),
-		append(make([]interface{}, 0), "a", "0 (int64)", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE"),
+		append(make([]interface{}, 0), "a", "TRAVERSE_ARRAY", "[", "0 (int64)", "]"),
+		append(make([]interface{}, 0), "a", "0 (int64)", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
 	},
 	{
 		`.a.[0]`,
-		append(make([]interface{}, 0), "a", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "0 (int64)", "]"),
-		append(make([]interface{}, 0), "a", "0 (int64)", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE"),
+		append(make([]interface{}, 0), "a", "TRAVERSE_ARRAY", "[", "0 (int64)", "]"),
+		append(make([]interface{}, 0), "a", "0 (int64)", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY"),
 	},
 	{
 		`.a[].c`,
-		append(make([]interface{}, 0), "a", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "]", "SHORT_PIPE", "c"),
-		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE", "c", "SHORT_PIPE"),
+		append(make([]interface{}, 0), "a", "TRAVERSE_ARRAY", "[", "EMPTY", "]", "SHORT_PIPE", "c"),
+		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "c", "SHORT_PIPE"),
 	},
 	{
 		`[3]`,
@@ -69,18 +99,18 @@ var pathTests = []struct {
 	},
 	{
 		`.a | .[].b == "apple"`,
-		append(make([]interface{}, 0), "a", "PIPE", "TRAVERSE_ARRAY", "[", "]", "SHORT_PIPE", "b", "EQUALS", "apple (string)"),
-		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "b", "SHORT_PIPE", "apple (string)", "EQUALS", "PIPE"),
+		append(make([]interface{}, 0), "a", "PIPE", "SELF", "TRAVERSE_ARRAY", "[", "EMPTY", "]", "SHORT_PIPE", "b", "EQUALS", "apple (string)"),
+		append(make([]interface{}, 0), "a", "SELF", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "b", "SHORT_PIPE", "apple (string)", "EQUALS", "PIPE"),
 	},
 	{
 		`(.a | .[].b) == "apple"`,
-		append(make([]interface{}, 0), "(", "a", "PIPE", "TRAVERSE_ARRAY", "[", "]", "SHORT_PIPE", "b", ")", "EQUALS", "apple (string)"),
-		append(make([]interface{}, 0), "a", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "b", "SHORT_PIPE", "PIPE", "apple (string)", "EQUALS"),
+		append(make([]interface{}, 0), "(", "a", "PIPE", "SELF", "TRAVERSE_ARRAY", "[", "EMPTY", "]", "SHORT_PIPE", "b", ")", "EQUALS", "apple (string)"),
+		append(make([]interface{}, 0), "a", "SELF", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "b", "SHORT_PIPE", "PIPE", "apple (string)", "EQUALS"),
 	},
 	{
 		`.[] | select(. == "*at")`,
-		append(make([]interface{}, 0), "TRAVERSE_ARRAY", "[", "]", "PIPE", "SELECT", "(", "SELF", "EQUALS", "*at (string)", ")"),
-		append(make([]interface{}, 0), "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SELF", "*at (string)", "EQUALS", "SELECT", "PIPE"),
+		append(make([]interface{}, 0), "SELF", "TRAVERSE_ARRAY", "[", "EMPTY", "]", "PIPE", "SELECT", "(", "SELF", "EQUALS", "*at (string)", ")"),
+		append(make([]interface{}, 0), "SELF", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SELF", "*at (string)", "EQUALS", "SELECT", "PIPE"),
 	},
 	{
 		`[true]`,
@@ -113,9 +143,9 @@ var pathTests = []struct {
 		append(make([]interface{}, 0), "a", "mike (string)", "CREATE_MAP", "COLLECT_OBJECT", "SHORT_PIPE"),
 	},
 	{
-		`{.a: .c, .b.[]: .f.g.[]}`,
-		append(make([]interface{}, 0), "{", "a", "CREATE_MAP", "c", "UNION", "b", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "]", "CREATE_MAP", "f", "SHORT_PIPE", "g", "SHORT_PIPE", "TRAVERSE_ARRAY", "[", "]", "}"),
-		append(make([]interface{}, 0), "a", "c", "CREATE_MAP", "b", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE", "f", "g", "SHORT_PIPE", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE", "CREATE_MAP", "UNION", "COLLECT_OBJECT", "SHORT_PIPE"),
+		`{.a: .c, .b.[]: .f.g[]}`,
+		append(make([]interface{}, 0), "{", "a", "CREATE_MAP", "c", "UNION", "b", "TRAVERSE_ARRAY", "[", "EMPTY", "]", "CREATE_MAP", "f", "SHORT_PIPE", "g", "TRAVERSE_ARRAY", "[", "EMPTY", "]", "}"),
+		append(make([]interface{}, 0), "a", "c", "CREATE_MAP", "b", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "f", "g", "EMPTY", "COLLECT", "SHORT_PIPE", "TRAVERSE_ARRAY", "SHORT_PIPE", "CREATE_MAP", "UNION", "COLLECT_OBJECT", "SHORT_PIPE"),
 	},
 	{
 		`explode(.a.b)`,
@@ -167,11 +197,6 @@ var pathTests = []struct {
 		append(make([]interface{}, 0), "foo*", "PIPE", "(", "SELF", "ASSIGN_STYLE", "flow (string)", ")"),
 		append(make([]interface{}, 0), "foo*", "SELF", "flow (string)", "ASSIGN_STYLE", "PIPE"),
 	},
-	{
-		`{}`,
-		append(make([]interface{}, 0), "{", "}"),
-		append(make([]interface{}, 0), "EMPTY", "COLLECT_OBJECT", "SHORT_PIPE"),
-	},
 }

 var tokeniser = newExpressionTokeniser()
@@ -185,7 +210,7 @@ func TestPathParsing(t *testing.T) {
 		}
 		var tokenValues []interface{}
 		for _, token := range tokens {
-			tokenValues = append(tokenValues, token.toString())
+			tokenValues = append(tokenValues, token.toString(false))
 		}
 		test.AssertResultComplexWithContext(t, tt.expectedTokens, tokenValues, fmt.Sprintf("tokenise: %v", tt.path))

--- a/pkg/yqlib/expression_tokeniser.go
+++ b/pkg/yqlib/expression_tokeniser.go
@@ -34,9 +34,11 @@ type token struct {

 }

-func (t *token) toString() string {
+func (t *token) toString(detail bool) string {
 	if t.TokenType == operationToken {
-		log.Debug("toString, its an op")
+		if detail {
+			return fmt.Sprintf("%v (%v)", t.Operation.toString(), t.Operation.OperationType.Precedence)
+		}
 		return t.Operation.toString()
 	} else if t.TokenType == openBracket {
 		return "("
@@ -98,6 +100,9 @@ func multiplyWithPrefs() lex.Action {
 		if strings.Contains(options, "?") {
 			prefs.TraversePrefs = traversePreferences{DontAutoCreate: true}
 		}
+		if strings.Contains(options, "d") {
+			prefs.DeepMergeArrays = true
+		}
 		op := &Operation{OperationType: multiplyOpType, Value: multiplyOpType.Type, StringValue: options, Preferences: prefs}
 		return &token{TokenType: operationToken, Operation: op}, nil
 	}
@@ -180,6 +185,19 @@ func stringValue(wrapped bool) lex.Action {
 	}
 }

+func getVariableOpToken() lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		value := string(m.Bytes)
+
+		value = value[1:]
+
+		getVarOperation := createValueOperation(value, value)
+		getVarOperation.OperationType = getVariableOpType
+
+		return &token{TokenType: operationToken, Operation: getVarOperation, CheckForPostTraverse: true}, nil
+	}
+}
+
 func envOp(strenv bool) lex.Action {
 	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
 		value := string(m.Bytes)
@@ -237,6 +255,8 @@ func initLexer() (*lex.Lexer, error) {
 	lexer.Add([]byte(`or`), opToken(orOpType))
 	lexer.Add([]byte(`and`), opToken(andOpType))
 	lexer.Add([]byte(`not`), opToken(notOpType))
+	lexer.Add([]byte(`ireduce`), opToken(reduceOpType))
+	lexer.Add([]byte(`;`), opToken(blockOpType))
 	lexer.Add([]byte(`\/\/`), opToken(alternativeOpType))

 	lexer.Add([]byte(`documentIndex`), opToken(getDocumentIndexOpType))
@@ -269,6 +289,7 @@ func initLexer() (*lex.Lexer, error) {
 	lexer.Add([]byte(`collect`), opToken(collectOpType))

 	lexer.Add([]byte(`\s*==\s*`), opToken(equalsOpType))
+	lexer.Add([]byte(`\s*!=\s*`), opToken(notEqualsOpType))
 	lexer.Add([]byte(`\s*=\s*`), assignOpToken(false))

 	lexer.Add([]byte(`del`), opToken(deleteChildOpType))
@@ -301,11 +322,13 @@ func initLexer() (*lex.Lexer, error) {
 	lexer.Add([]byte(`\]`), literalToken(closeCollect, true))
 	lexer.Add([]byte(`\{`), literalToken(openCollectObject, false))
 	lexer.Add([]byte(`\}`), literalToken(closeCollectObject, true))
-	lexer.Add([]byte(`\*[\+|\?]*`), multiplyWithPrefs())
+	lexer.Add([]byte(`\*[\+|\?d]*`), multiplyWithPrefs())
 	lexer.Add([]byte(`\+`), opToken(addOpType))
 	lexer.Add([]byte(`\+=`), opToken(addAssignOpType))
+	lexer.Add([]byte(`\$[a-zA-Z_-0-9]+`), getVariableOpToken())
+	lexer.Add([]byte(`as`), opToken(assignVariableOpType))

-	err := lexer.Compile()
+	err := lexer.CompileNFA()
 	if err != nil {
 		return nil, err
 	}
@@ -339,7 +362,7 @@ func (p *expressionTokeniserImpl) Tokenise(expression string) ([]*token, error)

 		if tok != nil {
 			currentToken := tok.(*token)
-			log.Debugf("Tokenising %v", currentToken.toString())
+			log.Debugf("Tokenising %v", currentToken.toString(true))
 			tokens = append(tokens, currentToken)
 		}
 		if err != nil {
@@ -369,6 +392,12 @@ func (p *expressionTokeniserImpl) handleToken(tokens []*token, index int, postPr
 		//need to put a traverse array then a collect currentToken
 		// do this by adding traverse then converting currentToken to collect

+		if index == 0 || tokens[index-1].TokenType != operationToken ||
+			tokens[index-1].Operation.OperationType != traversePathOpType {
+			op := &Operation{OperationType: selfReferenceOpType, StringValue: "SELF"}
+			postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
+		}
+
 		op := &Operation{OperationType: traverseArrayOpType, StringValue: "TRAVERSE_ARRAY"}
 		postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})

@@ -386,6 +415,14 @@ func (p *expressionTokeniserImpl) handleToken(tokens []*token, index int, postPr

 	postProcessedTokens = append(postProcessedTokens, currentToken)

+	if index != len(tokens)-1 &&
+		((currentToken.TokenType == openCollect && tokens[index+1].TokenType == closeCollect) ||
+			(currentToken.TokenType == openCollectObject && tokens[index+1].TokenType == closeCollectObject)) {
+
+		op := &Operation{OperationType: emptyOpType, StringValue: "EMPTY"}
+		postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
+	}
+
 	if index != len(tokens)-1 && currentToken.CheckForPostTraverse &&
 		tokens[index+1].TokenType == operationToken &&
 		tokens[index+1].Operation.OperationType == traversePathOpType {
@@ -395,18 +432,8 @@ func (p *expressionTokeniserImpl) handleToken(tokens []*token, index int, postPr
 	if index != len(tokens)-1 && currentToken.CheckForPostTraverse &&
 		tokens[index+1].TokenType == openCollect {

-		op := &Operation{OperationType: shortPipeOpType, Value: "PIPE"}
+		op := &Operation{OperationType: traverseArrayOpType}
 		postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
-
-		op = &Operation{OperationType: traverseArrayOpType}
-		postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
-	}
-	if index != len(tokens)-1 && currentToken.CheckForPostTraverse &&
-		tokens[index+1].TokenType == traverseArrayCollect {
-
-		op := &Operation{OperationType: shortPipeOpType, Value: "PIPE"}
-		postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
-
 	}
 	return postProcessedTokens, skipNextToken
 }
--- a/pkg/yqlib/lib.go
+++ b/pkg/yqlib/lib.go
@@ -25,6 +25,9 @@ type operationType struct {

 var orOpType = &operationType{Type: "OR", NumArgs: 2, Precedence: 20, Handler: orOperator}
 var andOpType = &operationType{Type: "AND", NumArgs: 2, Precedence: 20, Handler: andOperator}
+var reduceOpType = &operationType{Type: "REDUCE", NumArgs: 2, Precedence: 35, Handler: reduceOperator}
+
+var blockOpType = &operationType{Type: "BLOCK", Precedence: 10, NumArgs: 2, Handler: emptyOperator}

 var unionOpType = &operationType{Type: "UNION", NumArgs: 2, Precedence: 10, Handler: unionOperator}

@@ -35,6 +38,7 @@ var addAssignOpType = &operationType{Type: "ADD_ASSIGN", NumArgs: 2, Precedence:

 var assignAttributesOpType = &operationType{Type: "ASSIGN_ATTRIBUTES", NumArgs: 2, Precedence: 40, Handler: assignAttributesOperator}
 var assignStyleOpType = &operationType{Type: "ASSIGN_STYLE", NumArgs: 2, Precedence: 40, Handler: assignStyleOperator}
+var assignVariableOpType = &operationType{Type: "ASSIGN_VARIABLE", NumArgs: 2, Precedence: 40, Handler: assignVariableOperator}
 var assignTagOpType = &operationType{Type: "ASSIGN_TAG", NumArgs: 2, Precedence: 40, Handler: assignTagOperator}
 var assignCommentOpType = &operationType{Type: "ASSIGN_COMMENT", NumArgs: 2, Precedence: 40, Handler: assignCommentsOperator}
 var assignAnchorOpType = &operationType{Type: "ASSIGN_ANCHOR", NumArgs: 2, Precedence: 40, Handler: assignAnchorOperator}
@@ -45,6 +49,7 @@ var addOpType = &operationType{Type: "ADD", NumArgs: 2, Precedence: 42, Handler:
 var alternativeOpType = &operationType{Type: "ALTERNATIVE", NumArgs: 2, Precedence: 42, Handler: alternativeOperator}

 var equalsOpType = &operationType{Type: "EQUALS", NumArgs: 2, Precedence: 40, Handler: equalsOperator}
+var notEqualsOpType = &operationType{Type: "EQUALS", NumArgs: 2, Precedence: 40, Handler: notEqualsOperator}
 var createMapOpType = &operationType{Type: "CREATE_MAP", NumArgs: 2, Precedence: 40, Handler: createMapOperator}

 var shortPipeOpType = &operationType{Type: "SHORT_PIPE", NumArgs: 2, Precedence: 45, Handler: pipeOperator}
@@ -52,6 +57,7 @@ var shortPipeOpType = &operationType{Type: "SHORT_PIPE", NumArgs: 2, Precedence:
 var lengthOpType = &operationType{Type: "LENGTH", NumArgs: 0, Precedence: 50, Handler: lengthOperator}
 var collectOpType = &operationType{Type: "COLLECT", NumArgs: 0, Precedence: 50, Handler: collectOperator}
 var splitDocumentOpType = &operationType{Type: "SPLIT_DOC", NumArgs: 0, Precedence: 50, Handler: splitDocumentOperator}
+var getVariableOpType = &operationType{Type: "GET_VARIABLE", NumArgs: 0, Precedence: 55, Handler: getVariableOperator}
 var getStyleOpType = &operationType{Type: "GET_STYLE", NumArgs: 0, Precedence: 50, Handler: getStyleOperator}
 var getTagOpType = &operationType{Type: "GET_TAG", NumArgs: 0, Precedence: 50, Handler: getTagOperator}
 var getCommentOpType = &operationType{Type: "GET_COMMENT", NumArgs: 0, Precedence: 50, Handler: getCommentsOperator}
@@ -70,14 +76,14 @@ var splitStringOpType = &operationType{Type: "SPLIT", NumArgs: 1, Precedence: 50
 var keysOpType = &operationType{Type: "KEYS", NumArgs: 0, Precedence: 50, Handler: keysOperator}

 var collectObjectOpType = &operationType{Type: "COLLECT_OBJECT", NumArgs: 0, Precedence: 50, Handler: collectObjectOperator}
-var traversePathOpType = &operationType{Type: "TRAVERSE_PATH", NumArgs: 0, Precedence: 50, Handler: traversePathOperator}
-var traverseArrayOpType = &operationType{Type: "TRAVERSE_ARRAY", NumArgs: 1, Precedence: 50, Handler: traverseArrayOperator}
+var traversePathOpType = &operationType{Type: "TRAVERSE_PATH", NumArgs: 0, Precedence: 55, Handler: traversePathOperator}
+var traverseArrayOpType = &operationType{Type: "TRAVERSE_ARRAY", NumArgs: 2, Precedence: 50, Handler: traverseArrayOperator}

-var selfReferenceOpType = &operationType{Type: "SELF", NumArgs: 0, Precedence: 50, Handler: selfOperator}
+var selfReferenceOpType = &operationType{Type: "SELF", NumArgs: 0, Precedence: 55, Handler: selfOperator}
 var valueOpType = &operationType{Type: "VALUE", NumArgs: 0, Precedence: 50, Handler: valueOperator}
 var envOpType = &operationType{Type: "ENV", NumArgs: 0, Precedence: 50, Handler: envOperator}
 var notOpType = &operationType{Type: "NOT", NumArgs: 0, Precedence: 50, Handler: notOperator}
-var emptyOpType = &operationType{Type: "EMPTY", NumArgs: 50, Handler: emptyOperator}
+var emptyOpType = &operationType{Type: "EMPTY", Precedence: 50, Handler: emptyOperator}

 var recursiveDescentOpType = &operationType{Type: "RECURSIVE_DESCENT", NumArgs: 0, Precedence: 50, Handler: recursiveDescentOperator}

--- a/pkg/yqlib/operator_assign.go
+++ b/pkg/yqlib/operator_assign.go
@@ -36,6 +36,7 @@ func assignUpdateOperator(d *dataTreeNavigator, context Context, expressionNode

 // does not update content or values
 func assignAttributesOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+	log.Debug("getting lhs matching nodes for update")
 	lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs)
 	if err != nil {
 		return Context{}, err
--- a/pkg/yqlib/operator_delete.go
+++ b/pkg/yqlib/operator_delete.go
@@ -7,29 +7,32 @@ import (
 )

 func deleteChildOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-
-	nodesToDelete, err := d.GetMatchingNodes(context, expressionNode.Rhs)
+	contextToUse := context.Clone()
+	contextToUse.DontAutoCreate = true
+	nodesToDelete, err := d.GetMatchingNodes(contextToUse, expressionNode.Rhs)

 	if err != nil {
 		return Context{}, err
 	}
-
-	for el := nodesToDelete.MatchingNodes.Front(); el != nil; el = el.Next() {
+	//need to iterate backwards to ensure correct indices when deleting multiple
+	for el := nodesToDelete.MatchingNodes.Back(); el != nil; el = el.Prev() {
 		candidate := el.Value.(*CandidateNode)

-		deleteImmediateChildOp := &Operation{
-			OperationType: deleteImmediateChildOpType,
-			Value:         candidate.Path[len(candidate.Path)-1],
-		}
+		if len(candidate.Path) > 0 {
+			deleteImmediateChildOp := &Operation{
+				OperationType: deleteImmediateChildOpType,
+				Value:         candidate.Path[len(candidate.Path)-1],
+			}

-		deleteImmediateChildOpNode := &ExpressionNode{
-			Operation: deleteImmediateChildOp,
-			Rhs:       createTraversalTree(candidate.Path[0:len(candidate.Path)-1], traversePreferences{}),
-		}
+			deleteImmediateChildOpNode := &ExpressionNode{
+				Operation: deleteImmediateChildOp,
+				Rhs:       createTraversalTree(candidate.Path[0:len(candidate.Path)-1], traversePreferences{}, false),
+			}

-		_, err := d.GetMatchingNodes(context, deleteImmediateChildOpNode)
-		if err != nil {
-			return Context{}, err
+			_, err := d.GetMatchingNodes(contextToUse, deleteImmediateChildOpNode)
+			if err != nil {
+				return Context{}, err
+			}
 		}
 	}
 	return context, nil
--- a/pkg/yqlib/operator_delete_test.go
+++ b/pkg/yqlib/operator_delete_test.go
@@ -37,6 +37,38 @@ var deleteOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::[1, 3]\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   `a: [1,2,3]`,
+		expression: `del(.a[])`,
+		expected: []string{
+			"D0, P[], (doc)::a: []\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `a: [10,x,10, 10, x, 10]`,
+		expression: `del(.a[] | select(. == 10))`,
+		expected: []string{
+			"D0, P[], (doc)::a: [x, x]\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `a: {thing1: yep, thing2: cool, thing3: hi, b: {thing1: cool, great: huh}}`,
+		expression: `del(..)`,
+		expected: []string{
+			"D0, P[], (!!map)::{}\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `a: {thing1: yep, thing2: cool, thing3: hi, b: {thing1: cool, great: huh}}`,
+		expression: `del(.. | select(tag == "!!map") | (.b.thing1,.thing2))`,
+		expected: []string{
+			"D0, P[], (!!map)::a: {thing1: yep, thing3: hi, b: {great: huh}}\n",
+		},
+	},
 	{
 		description: "Delete nested entry in array",
 		document:    `[{a: cat, b: dog}]`,
--- a/pkg/yqlib/operator_equals.go
+++ b/pkg/yqlib/operator_equals.go
@@ -1,21 +1,33 @@
 package yqlib

+import "gopkg.in/yaml.v3"
+
 func equalsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
 	log.Debugf("-- equalsOperation")
-	return crossFunction(d, context, expressionNode, isEquals)
+	return crossFunction(d, context, expressionNode, isEquals(false))
 }

-func isEquals(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
-	value := false
+func isEquals(flip bool) func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+	return func(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+		value := false

-	lhsNode := unwrapDoc(lhs.Node)
-	rhsNode := unwrapDoc(rhs.Node)
+		lhsNode := unwrapDoc(lhs.Node)
+		rhsNode := unwrapDoc(rhs.Node)

-	if lhsNode.Tag == "!!null" {
-		value = (rhsNode.Tag == "!!null")
-	} else {
-		value = matchKey(lhsNode.Value, rhsNode.Value)
+		if lhsNode.Tag == "!!null" {
+			value = (rhsNode.Tag == "!!null")
+		} else if lhsNode.Kind == yaml.ScalarNode && rhsNode.Kind == yaml.ScalarNode {
+			value = matchKey(lhsNode.Value, rhsNode.Value)
+		}
+		log.Debugf("%v == %v ? %v", NodeToString(lhs), NodeToString(rhs), value)
+		if flip {
+			value = !value
+		}
+		return createBooleanCandidate(lhs, value), nil
 	}
-	log.Debugf("%v == %v ? %v", NodeToString(lhs), NodeToString(rhs), value)
-	return createBooleanCandidate(lhs, value), nil
+}
+
+func notEqualsOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+	log.Debugf("-- equalsOperation")
+	return crossFunction(d, context, expressionNode, isEquals(true))
 }
--- a/pkg/yqlib/operator_equals_test.go
+++ b/pkg/yqlib/operator_equals_test.go
@@ -14,6 +14,14 @@ var equalsOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!bool)::false\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   "{a: { b: {things: \"\"}, f: [1], g: [] }}",
+		expression: ".. | select(. == \"\")",
+		expected: []string{
+			"D0, P[a b things], (!!str)::\"\"\n",
+		},
+	},
 	{
 		description: "Match string",
 		document:    `[cat,goat,dog]`,
@@ -23,7 +31,18 @@ var equalsOperatorScenarios = []expressionScenario{
 			"D0, P[1], (!!bool)::true\n",
 			"D0, P[2], (!!bool)::false\n",
 		},
-	}, {
+	},
+	{
+		description: "Don't match string",
+		document:    `[cat,goat,dog]`,
+		expression:  `.[] | (. != "*at")`,
+		expected: []string{
+			"D0, P[0], (!!bool)::false\n",
+			"D0, P[1], (!!bool)::false\n",
+			"D0, P[2], (!!bool)::true\n",
+		},
+	},
+	{
 		description: "Match number",
 		document:    `[3, 4, 5]`,
 		expression:  `.[] | (. == 4)`,
@@ -32,7 +51,18 @@ var equalsOperatorScenarios = []expressionScenario{
 			"D0, P[1], (!!bool)::true\n",
 			"D0, P[2], (!!bool)::false\n",
 		},
-	}, {
+	},
+	{
+		description: "Dont match number",
+		document:    `[3, 4, 5]`,
+		expression:  `.[] | (. != 4)`,
+		expected: []string{
+			"D0, P[0], (!!bool)::true\n",
+			"D0, P[1], (!!bool)::false\n",
+			"D0, P[2], (!!bool)::true\n",
+		},
+	},
+	{
 		skipDoc:    true,
 		document:   `a: { cat: {b: apple, c: whatever}, pat: {b: banana} }`,
 		expression: `.a | (.[].b == "apple")`,
--- a/pkg/yqlib/operator_file_test.go
+++ b/pkg/yqlib/operator_file_test.go
@@ -21,6 +21,16 @@ var fileOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!int)::0\n",
 		},
 	},
+	{
+		description: "Get file indices of multiple documents",
+		document:    `{a: cat}`,
+		document2:   `{a: cat}`,
+		expression:  `fileIndex`,
+		expected: []string{
+			"D0, P[], (!!int)::0\n",
+			"D0, P[], (!!int)::1\n",
+		},
+	},
 	{
 		description: "Get file index alias",
 		document:    `{a: cat}`,
--- a/pkg/yqlib/operator_multiply.go
+++ b/pkg/yqlib/operator_multiply.go
@@ -10,8 +10,9 @@ import (
 )

 type multiplyPreferences struct {
-	AppendArrays  bool
-	TraversePrefs traversePreferences
+	AppendArrays    bool
+	DeepMergeArrays bool
+	TraversePrefs   traversePreferences
 }

 func multiplyOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
@@ -37,11 +38,31 @@ func multiply(preferences multiplyPreferences) func(d *dataTreeNavigator, contex
 			return mergeObjects(d, context, newThing, rhs, preferences)
 		} else if lhs.Node.Tag == "!!int" && rhs.Node.Tag == "!!int" {
 			return multiplyIntegers(lhs, rhs)
+		} else if (lhs.Node.Tag == "!!int" || lhs.Node.Tag == "!!float") && (rhs.Node.Tag == "!!int" || rhs.Node.Tag == "!!float") {
+			return multiplyFloats(lhs, rhs)
 		}
 		return nil, fmt.Errorf("Cannot multiply %v with %v", lhs.Node.Tag, rhs.Node.Tag)
 	}
 }

+func multiplyFloats(lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+	target := lhs.CreateChild(nil, &yaml.Node{})
+	target.Node.Kind = yaml.ScalarNode
+	target.Node.Style = lhs.Node.Style
+	target.Node.Tag = "!!float"
+
+	lhsNum, err := strconv.ParseFloat(lhs.Node.Value, 64)
+	if err != nil {
+		return nil, err
+	}
+	rhsNum, err := strconv.ParseFloat(rhs.Node.Value, 64)
+	if err != nil {
+		return nil, err
+	}
+	target.Node.Value = fmt.Sprintf("%v", lhsNum*rhsNum)
+	return target, nil
+}
+
 func multiplyIntegers(lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
 	target := lhs.CreateChild(nil, &yaml.Node{})
 	target.Node.Kind = yaml.ScalarNode
@@ -66,7 +87,7 @@ func mergeObjects(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs

 	// shouldn't recurse arrays if appending
 	prefs := recursiveDescentPreferences{RecurseArray: !shouldAppendArrays,
-		TraversePreferences: traversePreferences{DontFollowAlias: true}}
+		TraversePreferences: traversePreferences{DontFollowAlias: true, IncludeMapKeys: true}}
 	err := recursiveDecent(d, results, context.SingleChildContext(rhs), prefs)
 	if err != nil {
 		return nil, err
@@ -78,7 +99,12 @@ func mergeObjects(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs
 	}

 	for el := results.Front(); el != nil; el = el.Next() {
-		err := applyAssignment(d, context, pathIndexToStartFrom, lhs, el.Value.(*CandidateNode), preferences)
+		candidate := el.Value.(*CandidateNode)
+		if candidate.Node.Tag == "!!merge" {
+			continue
+		}
+
+		err := applyAssignment(d, context, pathIndexToStartFrom, lhs, candidate, preferences)
 		if err != nil {
 			return nil, err
 		}
@@ -88,20 +114,21 @@ func mergeObjects(d *dataTreeNavigator, context Context, lhs *CandidateNode, rhs

 func applyAssignment(d *dataTreeNavigator, context Context, pathIndexToStartFrom int, lhs *CandidateNode, rhs *CandidateNode, preferences multiplyPreferences) error {
 	shouldAppendArrays := preferences.AppendArrays
-	log.Debugf("merge - applyAssignment lhs %v, rhs: %v", NodeToString(lhs), NodeToString(rhs))
+	log.Debugf("merge - applyAssignment lhs %v, rhs: %v", lhs.GetKey(), rhs.GetKey())

 	lhsPath := rhs.Path[pathIndexToStartFrom:]

 	assignmentOp := &Operation{OperationType: assignAttributesOpType}
-	if rhs.Node.Kind == yaml.ScalarNode || rhs.Node.Kind == yaml.AliasNode {
+	if shouldAppendArrays && rhs.Node.Kind == yaml.SequenceNode {
+		assignmentOp.OperationType = addAssignOpType
+	} else if !preferences.DeepMergeArrays && rhs.Node.Kind == yaml.SequenceNode ||
+		(rhs.Node.Kind == yaml.ScalarNode || rhs.Node.Kind == yaml.AliasNode) {
 		assignmentOp.OperationType = assignOpType
 		assignmentOp.UpdateAssign = false
-	} else if shouldAppendArrays && rhs.Node.Kind == yaml.SequenceNode {
-		assignmentOp.OperationType = addAssignOpType
 	}
 	rhsOp := &Operation{OperationType: valueOpType, CandidateNode: rhs}

-	assignmentOpNode := &ExpressionNode{Operation: assignmentOp, Lhs: createTraversalTree(lhsPath, preferences.TraversePrefs), Rhs: &ExpressionNode{Operation: rhsOp}}
+	assignmentOpNode := &ExpressionNode{Operation: assignmentOp, Lhs: createTraversalTree(lhsPath, preferences.TraversePrefs, rhs.IsMapKey), Rhs: &ExpressionNode{Operation: rhsOp}}

 	_, err := d.GetMatchingNodes(context.SingleChildContext(lhs), assignmentOpNode)

--- a/pkg/yqlib/operator_multiply_test.go
+++ b/pkg/yqlib/operator_multiply_test.go
@@ -5,6 +5,27 @@ import (
 )

 var multiplyOperatorScenarios = []expressionScenario{
+	{
+		description: "Multiply integers",
+		expression:  `3 * 4`,
+		expected: []string{
+			"D0, P[], (!!int)::12\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		expression: `3 * 4.5`,
+		expected: []string{
+			"D0, P[], (!!float)::13.5\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		expression: `4.5 * 3`,
+		expected: []string{
+			"D0, P[], (!!float)::13.5\n",
+		},
+	},
 	{
 		skipDoc:    true,
 		document:   `{a: {also: [1]}, b: {also: me}}`,
@@ -13,6 +34,30 @@ var multiplyOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!map)::{a: {also: me}, b: {also: me}}\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   "# b\nb:\n  # a\n  a: cat",
+		expression: "{} * .",
+		expected: []string{
+			"D0, P[], (!!map)::# b\nb:\n    # a\n    a: cat\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   "# b\nb:\n  # a\n  a: cat",
+		expression: ". * {}",
+		expected: []string{
+			"D0, P[], (!!map)::# b\nb:\n    # a\n    a: cat\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{a: &a { b: &b { c: &c cat } } }`,
+		expression: `{} * .`,
+		expected: []string{
+			"D0, P[], (!!map)::{a: &a {b: &b {c: &c cat}}}\n",
+		},
+	},
 	{
 		skipDoc:    true,
 		document:   `{a: 2, b: 5}`,
@@ -92,7 +137,7 @@ var multiplyOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   `{a: {things: great}, b: {also: me}}`,
-		expression: `. * {"a":.b}`,
+		expression: `. * {"a": .b}`,
 		expected: []string{
 			"D0, P[], (!!map)::{a: {things: great, also: me}, b: {also: me}}\n",
 		},
@@ -100,16 +145,10 @@ var multiplyOperatorScenarios = []expressionScenario{
 	{
 		description:           "Merge keeps style of LHS",
 		dontFormatInputForDoc: true,
-		document: `a: {things: great}
-b:
-  also: "me"
-`,
-		expression: `. * {"a":.b}`,
+		document:              "a: {things: great}\nb:\n  also: \"me\"",
+		expression:            `. * {"a":.b}`,
 		expected: []string{
-			`D0, P[], (!!map)::a: {things: great, also: "me"}
-b:
-    also: "me"
-`,
+			"D0, P[], (!!map)::a: {things: great, also: \"me\"}\nb:\n    also: \"me\"\n",
 		},
 	},
 	{
@@ -139,7 +178,7 @@ b:
 	{
 		skipDoc:    true,
 		document:   `{a: [{thing: one}], b: [{missing: two, thing: two}]}`,
-		expression: `.a *? .b`,
+		expression: `.a *?d .b`,
 		expected: []string{
 			"D0, P[a], (!!seq)::[{thing: two}]\n",
 		},
@@ -168,6 +207,15 @@ b:
 			"D0, P[a], (!!map)::{thing: [1, 2, 3, 4]}\n",
 		},
 	},
+	{
+		description:    "Merge, deeply merging arrays",
+		subdescription: "Merging arrays deeply means arrays are merge like objects, with indexes as their key. In this case, we merge the first item in the array, and do nothing with the second.",
+		document:       `{a: [{name: fred, age: 12}, {name: bob, age: 32}], b: [{name: fred, age: 34}]}`,
+		expression:     `.a *d .b`,
+		expected: []string{
+			"D0, P[a], (!!seq)::[{name: fred, age: 34}, {name: bob, age: 32}]\n",
+		},
+	},
 	{
 		description: "Merge to prefix an element",
 		document:    `{a: cat, b: dog}`,
--- a/pkg/yqlib/operator_reduce.go
+++ b/pkg/yqlib/operator_reduce.go
@@ -0,0 +1,59 @@
+package yqlib
+
+import (
+	"container/list"
+	"fmt"
+)
+
+func reduceOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+	log.Debugf("-- reduceOp")
+	//.a as $var reduce (0; . + $var)
+	//lhs is the assignment operator
+	//rhs is the reduce block
+	// '.' refers to the current accumulator, initialised to 0
+	// $var references a single element from the .a
+
+	//ensure lhs is actually an assignment
+	//and rhs is a block (empty)
+	if expressionNode.Lhs.Operation.OperationType != assignVariableOpType {
+		return Context{}, fmt.Errorf("reduce must be given a variables assignment, got %v instead", expressionNode.Lhs.Operation.OperationType.Type)
+	} else if expressionNode.Rhs.Operation.OperationType != blockOpType {
+		return Context{}, fmt.Errorf("reduce must be given a block, got %v instead", expressionNode.Rhs.Operation.OperationType.Type)
+	}
+
+	arrayExpNode := expressionNode.Lhs.Lhs
+	array, err := d.GetMatchingNodes(context, arrayExpNode)
+
+	log.Debugf("array of %v things", array.MatchingNodes.Len())
+
+	if err != nil {
+		return Context{}, err
+	}
+
+	variableName := expressionNode.Lhs.Rhs.Operation.StringValue
+
+	initExp := expressionNode.Rhs.Lhs
+
+	accum, err := d.GetMatchingNodes(context, initExp)
+	if err != nil {
+		return Context{}, err
+	}
+
+	log.Debugf("with variable %v", variableName)
+
+	blockExp := expressionNode.Rhs.Rhs
+	for el := array.MatchingNodes.Front(); el != nil; el = el.Next() {
+		candidate := el.Value.(*CandidateNode)
+		log.Debugf("REDUCING WITH %v", NodeToString(candidate))
+		l := list.New()
+		l.PushBack(candidate)
+		accum.SetVariable(variableName, l)
+
+		accum, err = d.GetMatchingNodes(accum, blockExp)
+		if err != nil {
+			return Context{}, err
+		}
+	}
+
+	return accum, nil
+}
--- a/pkg/yqlib/operator_reduce_test.go
+++ b/pkg/yqlib/operator_reduce_test.go
@@ -0,0 +1,40 @@
+package yqlib
+
+import (
+	"testing"
+)
+
+var reduceOperatorScenarios = []expressionScenario{
+	{
+		description: "Sum numbers",
+		document:    `[10,2, 5, 3]`,
+		expression:  `.[] as $item ireduce (0; . + $item)`,
+		expected: []string{
+			"D0, P[], (!!int)::20\n",
+		},
+	},
+	{
+		description: "Merge all yaml files together",
+		document:    `a: cat`,
+		document2:   `b: dog`,
+		expression:  `. as $item ireduce ({}; . * $item )`,
+		expected: []string{
+			"D0, P[], (!!map)::a: cat\nb: dog\n",
+		},
+	},
+	{
+		description: "Convert an array to an object",
+		document:    `[{name: Cathy, has: apples},{name: Bob, has: bananas}]`,
+		expression:  `.[] as $item ireduce ({}; .[$item | .name] = ($item | .has) )`,
+		expected: []string{
+			"D0, P[], (!!map)::Cathy: apples\nBob: bananas\n",
+		},
+	},
+}
+
+func TestReduceOperatorScenarios(t *testing.T) {
+	for _, tt := range reduceOperatorScenarios {
+		testScenario(t, &tt)
+	}
+	documentScenarios(t, "Reduce", reduceOperatorScenarios)
+}
--- a/pkg/yqlib/operator_traverse_path.go
+++ b/pkg/yqlib/operator_traverse_path.go
@@ -10,9 +10,10 @@ import (
 )

 type traversePreferences struct {
-	DontFollowAlias bool
-	IncludeMapKeys  bool
-	DontAutoCreate  bool // by default, we automatically create entries on the fly.
+	DontFollowAlias      bool
+	IncludeMapKeys       bool
+	DontAutoCreate       bool // by default, we automatically create entries on the fly.
+	DontIncludeMapValues bool
 }

 func splat(d *dataTreeNavigator, context Context, prefs traversePreferences) (Context, error) {
@@ -20,7 +21,7 @@ func splat(d *dataTreeNavigator, context Context, prefs traversePreferences) (Co
 }

 func traversePathOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
-	log.Debugf("-- Traversing")
+	log.Debugf("-- traversePathOperator")
 	var matches = list.New()

 	for el := context.MatchingNodes.Front(); el != nil; el = el.Next() {
@@ -75,6 +76,16 @@ func traverse(d *dataTreeNavigator, context Context, matchingNode *CandidateNode
 }

 func traverseArrayOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+
+	//lhs may update the variable context, we should pass that into the RHS
+	// BUT we still return the original context back (see jq)
+	// https://stedolan.github.io/jq/manual/#Variable/SymbolicBindingOperator:...as$identifier|...
+
+	lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs)
+	if err != nil {
+		return Context{}, err
+	}
+
 	// rhs is a collect expression that will yield indexes to retreive of the arrays

 	rhs, err := d.GetMatchingNodes(context, expressionNode.Rhs)
@@ -83,7 +94,13 @@ func traverseArrayOperator(d *dataTreeNavigator, context Context, expressionNode
 	}

 	var indicesToTraverse = rhs.MatchingNodes.Front().Value.(*CandidateNode).Node.Content
-	return traverseNodesWithArrayIndices(context, indicesToTraverse, traversePreferences{})
+
+	//now we traverse the result of the lhs against the indices we found
+	result, err := traverseNodesWithArrayIndices(lhs, indicesToTraverse, traversePreferences{})
+	if err != nil {
+		return Context{}, err
+	}
+	return context.ChildContext(result.MatchingNodes), nil
 }

 func traverseNodesWithArrayIndices(context Context, indicesToTraverse []*yaml.Node, prefs traversePreferences) (Context, error) {
@@ -198,10 +215,21 @@ func traverseMap(context Context, matchingNode *CandidateNode, key string, prefs
 	if !prefs.DontAutoCreate && !context.DontAutoCreate && newMatches.Len() == 0 {
 		//no matches, create one automagically
 		valueNode := &yaml.Node{Tag: "!!null", Kind: yaml.ScalarNode, Value: "null"}
+		keyNode := &yaml.Node{Kind: yaml.ScalarNode, Value: key}
 		node := matchingNode.Node
-		node.Content = append(node.Content, &yaml.Node{Kind: yaml.ScalarNode, Value: key}, valueNode)
-		candidateNode := matchingNode.CreateChild(key, valueNode)
-		newMatches.Set(candidateNode.GetKey(), candidateNode)
+		node.Content = append(node.Content, keyNode, valueNode)
+
+		if prefs.IncludeMapKeys {
+			log.Debug("including key")
+			candidateNode := matchingNode.CreateChild(key, keyNode)
+			candidateNode.IsMapKey = true
+			newMatches.Set(fmt.Sprintf("keyOf-%v", candidateNode.GetKey()), candidateNode)
+		}
+		if !prefs.DontIncludeMapValues {
+			log.Debug("including value")
+			candidateNode := matchingNode.CreateChild(key, valueNode)
+			newMatches.Set(candidateNode.GetKey(), candidateNode)
+		}
 	}

 	results := list.New()
@@ -237,11 +265,16 @@ func doTraverseMap(newMatches *orderedmap.OrderedMap, candidate *CandidateNode,
 		} else if splat || keyMatches(key, wantedKey) {
 			log.Debug("MATCHED")
 			if prefs.IncludeMapKeys {
+				log.Debug("including key")
 				candidateNode := candidate.CreateChild(key.Value, key)
+				candidateNode.IsMapKey = true
 				newMatches.Set(fmt.Sprintf("keyOf-%v", candidateNode.GetKey()), candidateNode)
 			}
-			candidateNode := candidate.CreateChild(key.Value, value)
-			newMatches.Set(candidateNode.GetKey(), candidateNode)
+			if !prefs.DontIncludeMapValues {
+				log.Debug("including value")
+				candidateNode := candidate.CreateChild(key.Value, value)
+				newMatches.Set(candidateNode.GetKey(), candidateNode)
+			}
 		}
 	}

--- a/pkg/yqlib/operator_traverse_path_test.go
+++ b/pkg/yqlib/operator_traverse_path_test.go
@@ -47,13 +47,30 @@ var traversePathOperatorScenarios = []expressionScenario{
 	},
 	{
 		description:    "Special characters",
-		subdescription: "Use quotes around path elements with special characters",
+		subdescription: "Use quotes with brackets around path elements with special characters",
 		document:       `{"{}": frog}`,
-		expression:     `."{}"`,
+		expression:     `.["{}"]`,
 		expected: []string{
 			"D0, P[{}], (!!str)::frog\n",
 		},
 	},
+	{
+		description:    "Keys with spaces",
+		subdescription: "Use quotes with brackets around path elements with special characters",
+		document:       `{"red rabbit": frog}`,
+		expression:     `.["red rabbit"]`,
+		expected: []string{
+			"D0, P[red rabbit], (!!str)::frog\n",
+		},
+	},
+	{
+		skipDoc:    true,
+		document:   `{"flying fox": frog}`,
+		expression: `.["flying fox"]`,
+		expected: []string{
+			"D0, P[flying fox], (!!str)::frog\n",
+		},
+	},
 	{
 		description:    "Dynamic keys",
 		subdescription: `Expressions within [] can be used to dynamically lookup / calculate keys`,
@@ -63,6 +80,14 @@ var traversePathOperatorScenarios = []expressionScenario{
 			"D0, P[apple], (!!str)::crispy yum\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   `{b: apple, fruit: {apple: yum, banana: smooth}}`,
+		expression: `.fruit[.b]`,
+		expected: []string{
+			"D0, P[fruit apple], (!!str)::yum\n",
+		},
+	},
 	{
 		description:    "Children don't exist",
 		subdescription: "Nodes are added dynamically while traversing",
@@ -83,7 +108,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   `{}`,
-		expression: `.a.[1]`,
+		expression: `.a[1]`,
 		expected: []string{
 			"D0, P[a 1], (!!null)::null\n",
 		},
@@ -154,7 +179,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   `{a: &cat {c: frog}, b: *cat}`,
-		expression: `.b.[]`,
+		expression: `.b[]`,
 		expected: []string{
 			"D0, P[b c], (!!str)::frog\n",
 		},
@@ -236,7 +261,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   mergeDocSample,
-		expression: `.foobar.[]`,
+		expression: `.foobar[]`,
 		expected: []string{
 			"D0, P[foobar c], (!!str)::foo_c\n",
 			"D0, P[foobar a], (!!str)::foo_a\n",
@@ -298,7 +323,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   mergeDocSample,
-		expression: `.foobarList.[]`,
+		expression: `.foobarList[]`,
 		expected: []string{
 			"D0, P[foobarList b], (!!str)::bar_b\n",
 			"D0, P[foobarList a], (!!str)::foo_a\n",
@@ -344,7 +369,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   `{a: [a,b,c]}`,
-		expression: `.a.[0, 2]`,
+		expression: `.a[0, 2]`,
 		expected: []string{
 			"D0, P[a 0], (!!str)::a\n",
 			"D0, P[a 2], (!!str)::c\n",
@@ -361,7 +386,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   `{a: [a,b,c]}`,
-		expression: `.a.[-1]`,
+		expression: `.a[-1]`,
 		expected: []string{
 			"D0, P[a -1], (!!str)::c\n",
 		},
@@ -377,7 +402,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   `{a: [a,b,c]}`,
-		expression: `.a.[-2]`,
+		expression: `.a[-2]`,
 		expected: []string{
 			"D0, P[a -2], (!!str)::b\n",
 		},
@@ -395,7 +420,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		skipDoc:    true,
 		document:   `{a: [a,b,c]}`,
-		expression: `.a.[]`,
+		expression: `.a[]`,
 		expected: []string{
 			"D0, P[a 0], (!!str)::a\n",
 			"D0, P[a 1], (!!str)::b\n",
@@ -418,5 +443,5 @@ func TestTraversePathOperatorScenarios(t *testing.T) {
 	for _, tt := range traversePathOperatorScenarios {
 		testScenario(t, &tt)
 	}
-	documentScenarios(t, "Traverse", traversePathOperatorScenarios)
+	documentScenarios(t, "Traverse (Read)", traversePathOperatorScenarios)
 }
--- a/pkg/yqlib/operator_variables.go
+++ b/pkg/yqlib/operator_variables.go
@@ -0,0 +1,29 @@
+package yqlib
+
+import (
+	"container/list"
+	"fmt"
+)
+
+func getVariableOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+	variableName := expressionNode.Operation.StringValue
+	log.Debug("getVariableOperator %v", variableName)
+	result := context.GetVariable(variableName)
+	if result == nil {
+		result = list.New()
+	}
+	return context.ChildContext(result), nil
+}
+
+func assignVariableOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) {
+	lhs, err := d.GetMatchingNodes(context, expressionNode.Lhs)
+	if err != nil {
+		return Context{}, nil
+	}
+	if expressionNode.Rhs.Operation.OperationType.Type != "GET_VARIABLE" {
+		return Context{}, fmt.Errorf("RHS of 'as' operator must be a variable name e.g. $foo")
+	}
+	variableName := expressionNode.Rhs.Operation.StringValue
+	context.SetVariable(variableName, lhs.MatchingNodes)
+	return context, nil
+}
--- a/pkg/yqlib/operator_variables_test.go
+++ b/pkg/yqlib/operator_variables_test.go
@@ -0,0 +1,45 @@
+package yqlib
+
+import (
+	"testing"
+)
+
+var variableOperatorScenarios = []expressionScenario{
+	{
+		description: "Single value variable",
+		document:    `a: cat`,
+		expression:  `.a as $foo | $foo`,
+		expected: []string{
+			"D0, P[a], (!!str)::cat\n",
+		},
+	},
+	{
+		description: "Multi value variable",
+		document:    `[cat, dog]`,
+		expression:  `.[] as $foo | $foo`,
+		expected: []string{
+			"D0, P[0], (!!str)::cat\n",
+			"D0, P[1], (!!str)::dog\n",
+		},
+	},
+	{
+		description:    "Using variables as a lookup",
+		subdescription: "Example taken from [jq](https://stedolan.github.io/jq/manual/#Variable/SymbolicBindingOperator:...as$identifier|...)",
+		document: `{"posts": [{"title": "Frist psot", "author": "anon"},
+		{"title": "A well-written article", "author": "person1"}],
+"realnames": {"anon": "Anonymous Coward",
+				"person1": "Person McPherson"}}`,
+		expression: `.realnames as $names | .posts[] | {"title":.title, "author": $names[.author]}`,
+		expected: []string{
+			"D0, P[], (!!map)::title: \"Frist psot\"\nauthor: \"Anonymous Coward\"\n",
+			"D0, P[], (!!map)::title: \"A well-written article\"\nauthor: \"Person McPherson\"\n",
+		},
+	},
+}
+
+func TestVariableOperatorScenarios(t *testing.T) {
+	for _, tt := range variableOperatorScenarios {
+		testScenario(t, &tt)
+	}
+	documentScenarios(t, "Variable Operators", variableOperatorScenarios)
+}
--- a/pkg/yqlib/operators.go
+++ b/pkg/yqlib/operators.go
@@ -4,6 +4,7 @@ import (
 	"container/list"
 	"fmt"

+	"github.com/jinzhu/copier"
 	"gopkg.in/yaml.v3"
 )

@@ -88,16 +89,25 @@ func createBooleanCandidate(owner *CandidateNode, value bool) *CandidateNode {
 	return owner.CreateChild(nil, node)
 }

-func createTraversalTree(path []interface{}, traversePrefs traversePreferences) *ExpressionNode {
+func createTraversalTree(path []interface{}, traversePrefs traversePreferences, targetKey bool) *ExpressionNode {
 	if len(path) == 0 {
 		return &ExpressionNode{Operation: &Operation{OperationType: selfReferenceOpType}}
 	} else if len(path) == 1 {
-		return &ExpressionNode{Operation: &Operation{OperationType: traversePathOpType, Preferences: traversePrefs, Value: path[0], StringValue: fmt.Sprintf("%v", path[0])}}
+		lastPrefs := traversePrefs
+		if targetKey {
+			err := copier.Copy(&lastPrefs, traversePrefs)
+			if err != nil {
+				panic(err)
+			}
+			lastPrefs.IncludeMapKeys = true
+			lastPrefs.DontIncludeMapValues = true
+		}
+		return &ExpressionNode{Operation: &Operation{OperationType: traversePathOpType, Preferences: lastPrefs, Value: path[0], StringValue: fmt.Sprintf("%v", path[0])}}
 	}

 	return &ExpressionNode{
 		Operation: &Operation{OperationType: shortPipeOpType},
-		Lhs:       createTraversalTree(path[0:1], traversePrefs),
-		Rhs:       createTraversalTree(path[1:], traversePrefs),
+		Lhs:       createTraversalTree(path[0:1], traversePrefs, false),
+		Rhs:       createTraversalTree(path[1:], traversePrefs, targetKey),
 	}
 }
--- a/release_instructions.txt
+++ b/release_instructions.txt
@@ -2,11 +2,13 @@
 - increment version in snapcraft.yaml
 - increment version in github-action/Dockerfile
 - make sure local build passes
+- commit version update changes
 - tag git with same version number
 - commit vX tag - this will trigger github actions
 - use github actions to publish docker and make github release
 - check github updated yq action in marketplace

+
 - snapcraft
  - will auto create a candidate, test it works then promote
  
--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
@@ -1,5 +1,5 @@
 name: yq
-version: '4.4.1'
+version: '4.6.1'
 summary: A lightweight and portable command-line YAML processor
 description: |
  The aim of the project is to be the jq or sed of yaml files.
--- a/yq_linux_amd64.tar.gz
+++ b/yq_linux_amd64.tar.gz
--- a/BIN
+++ b/BIN
Author	SHA1	Message	Date
Mike Farah	5911ab2929	Bump version	2021-02-25 16:52:49 +11:00
Mike Farah	2ed5b2ff59	Improved lexer performance!	2021-02-25 16:47:55 +11:00
Mike Farah	111c6e0be1	Increment version	2021-02-18 11:19:16 +11:00
Mike Farah	81136ad57e	Arrays no longer deeply merge by defauly, like jq	2021-02-18 11:16:54 +11:00
Mike Farah	a6cd250987	nicer reduce example	2021-02-15 18:23:50 +11:00
Mike Farah	ee1f55630f	nicer reduce example	2021-02-15 17:33:41 +11:00
Mike Farah	9072e8d3b3	Added context variable for reduce	2021-02-15 17:31:12 +11:00
Mike Farah	99b08fd612	Added reduce examples and doc	2021-02-15 16:38:53 +11:00
Mike Farah	b2317a14ef	infix reduce	2021-02-15 16:06:37 +11:00
Mike Farah	3e5f7b147f	infix reduce	2021-02-15 15:31:55 +11:00
Mike Farah	c4faa70143	wip - reduce!	2021-02-15 14:27:00 +11:00
Mike Farah	4d6d07ec43	Force re-release	2021-02-11 10:58:40 +11:00
Mike Farah	bd0818c481	Fixed write-inplace with no expression	2021-02-11 10:58:40 +11:00
Ben Moss	26742b2597	Fix pretty-printing Fixes #716 #715	2021-02-11 10:58:40 +11:00
Mike Farah	64c618c041	Version increment	2021-02-11 10:58:40 +11:00
Mike Farah	c4c8e5e7b0	Preserve comments on map keys	2021-02-11 10:58:40 +11:00
Mike Farah	e02ad4d7e8	Added space example to docs	2021-02-11 10:58:40 +11:00
Mike Farah	dd17f072cf	update deps	2021-02-11 10:58:40 +11:00
Mike Farah	429c3ca65b	Fixed merge dropping anchors	2021-02-11 10:58:40 +11:00
Mike Farah	cfcac6d1dc	improving docs	2021-02-11 10:58:40 +11:00
Mike Farah	a5ddbca97f	Fixing special character example	2021-02-11 10:58:40 +11:00
Mike Farah	30027a8cf4	Added not equals operator	2021-02-11 10:58:40 +11:00
Mike Farah	f92a42e4f8	Equals now only compares scalars	2021-02-11 10:58:40 +11:00
Mike Farah	3c466dc66e	Fixed delete bug	2021-02-11 10:58:40 +11:00
Mike Farah	0816e16d30	fixed instructions	2021-02-11 10:58:40 +11:00
Mike Farah	802d54e14e	v4.5.0	2021-02-11 10:58:40 +11:00
Mike Farah	10600dd29a	Fixed delete bug	2021-02-11 10:58:40 +11:00
Mike Farah	3a464272d4	Added variable doc	2021-02-11 10:58:40 +11:00
Mike Farah	691efadfac	Fixed variable precedence	2021-02-11 10:58:40 +11:00
Mike Farah	6efe4c4797	Fixing op precedences	2021-02-11 10:58:40 +11:00
Mike Farah	9e56b364c2	Fixing op precedences	2021-02-11 10:58:40 +11:00
Mike Farah	85ec32e3db	Added variables	2021-02-11 10:58:40 +11:00
Mike Farah	5c73132c8e	Dont create entries when selecting	2021-02-11 10:58:40 +11:00
Mike Farah	c6efd5519b	Pass context through operators Allows more sophisticated functionality	2021-02-11 10:58:40 +11:00
Mike Farah	3bae44be68	Added funding button	2021-02-11 10:58:40 +11:00
zy	48a7c59c4b	change version from master to latest(v4)	2021-02-11 10:58:40 +11:00
zy	851fbd8cf5	fix: go install fails Installation by go will result in an error: module declares its path as: xxx, but was required as: xxx. Go install with master branch will fix it. fix: #676	2021-02-11 10:58:40 +11:00
Mike Farah	820a3320be	Fixed length of null to be zero	2021-02-11 10:58:40 +11:00
Mike Farah	61f569aebb	fixing docker pipeline for nextime	2021-02-11 10:58:40 +11:00
Mike Farah	9ff51cd066	attempt to fix dockre	2021-02-11 10:58:40 +11:00
Mike Farah	9dd6d11362	Fixed bad docker version	2021-02-11 10:58:40 +11:00
Mike Farah	83139e21d9	Bump version	2021-02-11 10:58:40 +11:00
Mike Farah	c77001f969	Can add and merge append to null	2021-02-11 10:58:40 +11:00
evnp	1be3b31bbc	Don't escape HTML chars when converting to json json.Encoder and json.Marshal implicitly use HTMLEscape to convert >, <, &, with \u003c, \u003e, \u0026. This behavior carries over to yq, where chars will be escaped when outputting json but not when outputting yaml. This changeset disables this behavior via encoder.SetEscapeHTML(false). Unfortunately there is no equivalent option for json.Marshal, so its single usage has been replaced with an encoder (with escaping disabled).	2021-02-11 10:58:40 +11:00
Mike Farah	6c14a80991	Fixed cross-function combinatorial bug	2021-02-11 10:58:40 +11:00
Mike Farah	76bd1896e9	wip	2021-02-11 10:58:40 +11:00
Mike Farah	c63801a8a5	thoughts	2021-02-11 10:58:40 +11:00
Mike Farah	f7cfdc29e1	cross function fix wip	2021-02-11 10:58:40 +11:00
Mike Farah	07c6549a58	Fixed doker instructions	2021-02-11 10:58:40 +11:00
Mike Farah	29f40dad59	Fixing multiply doc	2021-02-11 10:58:40 +11:00
Mike Farah	fe33e7fcfe	Incrementing version	2021-02-11 10:58:40 +11:00
Mike Farah	0707525b29	Added keys operator	2021-02-11 10:58:40 +11:00
Mike Farah	62acee54c3	Added split string operator	2021-02-11 10:58:40 +11:00
Mike Farah	d21c94cf4f	Added join strings operator	2021-02-11 10:58:40 +11:00
Mike Farah	626e9cacaf	Split doc operator	2021-02-11 10:58:40 +11:00
Mike Farah	02ef99560d	Fixing add,multiply,alternative operator precendences	2021-02-11 10:58:40 +11:00
Mike Farah	c59209f041	Fixed remove comments example	2021-02-11 10:58:40 +11:00
Mike Farah	947ffb6986	Dont use pointer for env prefs (avoid nil)	2021-02-11 10:58:40 +11:00
Mike Farah	1a03031297	Dont use pointer for recursive prefs (avoid nil)	2021-02-11 10:58:40 +11:00
Mike Farah	2c7db0071a	Dont use pointer for multiply prefs (avoid nil)	2021-02-11 10:58:40 +11:00
Mike Farah	0484d0232b	Dont use pointer for commment prefs (avoid nil)	2021-02-11 10:58:40 +11:00
Mike Farah	91c72d2d9e	Added merge if empty	2021-02-11 10:58:40 +11:00
Mike Farah	09ec740d45	Added operator level doc	2021-02-11 10:58:40 +11:00
Mike Farah	532dbd81a5	Incrementing version	2021-02-11 10:58:40 +11:00
Mike Farah	e86f83fb69	Renaming pathtree to expression	2021-02-11 10:58:40 +11:00
Mike Farah	7d5b6b5442	Removed global vars	2021-02-11 10:58:40 +11:00
Mike Farah	b749973fe0	UnwrapDoc now private	2021-02-11 10:58:40 +11:00
Mike Farah	ba223df4ac	Moved eval function to eval interface	2021-02-11 10:58:40 +11:00
Mikhail Katychev	e6336bcb85	added lib_test.go	2021-02-11 10:58:40 +11:00
Mikhail Katychev	9ae03e0a1c	added EvaluateNodes and EvaluateCandidateNodes to yqlib	2021-02-11 10:58:40 +11:00
Mike Farah	55712afea6	Merge now copies anchor names	2021-02-11 10:58:40 +11:00
Mike Farah	7518dac99c	Fixed creation of candidateNode in operators to include file metadata	2021-02-11 10:58:40 +11:00
Mike Farah	49ac2bac13	Cleaning up exposed public api	2021-02-11 10:58:40 +11:00
Mike Farah	e28df367eb	Fixed tag operator for top level node	2021-02-11 10:58:40 +11:00
Mike Farah	90ec05be54	Fixed equals operator for top level node	2021-02-11 10:58:40 +11:00
Mike Farah	8f5270cc63	Fixed has operator for top level node	2021-02-11 10:58:40 +11:00
Mike Farah	286590b01e	fixing exposed functions and interfaces	2021-02-11 10:58:40 +11:00
Mike Farah	c1cf8b4e34	fixing exposed functions and interfaces	2021-02-11 10:58:40 +11:00
Mike Farah	461661112c	Better add documentation	2021-02-11 10:58:40 +11:00
Mike Farah	578f2c27f9	Added scalar addition	2021-02-11 10:58:40 +11:00
Mike Farah	6ed037a9f6	Fixed collect at document level	2021-02-11 10:58:40 +11:00
Mike Farah	69386316f3	Better error handling will empty env	2021-02-11 10:58:40 +11:00
Mike Farah	a0e1f65b20	Better recursive decent docs	2021-02-11 10:58:40 +11:00
Mike Farah	8027f4c568	Better docIndex docs	2021-02-11 10:58:40 +11:00
Mike Farah	b13eb7083e	Better env docs	2021-02-11 10:58:40 +11:00
Mike Farah	b505240d09	Merged env commands in :eye-roll:	2021-02-11 10:58:40 +11:00
Mike Farah	7a184bef78	Env Ops!	2021-02-11 10:58:40 +11:00
Mike Farah	34bc33d5c5	strenv	2021-02-11 10:58:40 +11:00
Mike Farah	4d8b64d05c	wip	2021-02-11 10:58:40 +11:00
Mike Farah	2d9cc3c107	wip	2021-02-11 10:58:40 +11:00
Mike Farah	018a6e616d	Bump version	2021-02-11 10:58:40 +11:00
Mike Farah	7fa2b20b48	Error when passing files and using null-input flag	2021-02-11 10:58:40 +11:00
Mike Farah	316e0d4d5a	Bumped go yaml for comment hanlding fixes	2021-02-11 10:58:40 +11:00
Mike Farah	a0d4c51e27	Added webi	2021-02-11 10:58:40 +11:00
Mike Farah	ceff2cc18d	Added recurse examples	2021-02-11 10:58:40 +11:00
Mike Farah	db62a16007	Added another delete example	2021-02-11 10:58:40 +11:00
Mike Farah	2a6e423d2d	Can assign-update tag	2021-02-11 10:58:40 +11:00
Mike Farah	5a1b81cbfc	Can assign-update style	2021-02-11 10:58:40 +11:00
Mike Farah	8c1f7dfbd7	Can assign-update aliases and anchors	2021-02-11 10:58:40 +11:00
Mike Farah	2e81384eed	Can assign-update comments	2021-02-11 10:58:40 +11:00
Mike Farah	fbf36037c9	updating readme	2021-02-11 10:58:40 +11:00
Mike Farah	2957210e65	brew v3!	2021-02-11 10:58:40 +11:00
Mike Farah	bde419aaee	Updated collect objcet doc	2021-02-11 10:58:40 +11:00
Mike Farah	9b185a4409	Added shorthand document index selection	2021-02-11 10:58:40 +11:00
Mike Farah	0c777a4967	Unwrap node in get tag to return proper tag at root level	2021-02-11 10:58:40 +11:00
Mike Farah	e9591e0cd5	Added v3 snap instructions	2021-02-11 10:58:40 +11:00
Mike Farah	04491e13c3	Refactored doc generation, add fi fileIndex alias	2021-02-11 10:58:40 +11:00
Mike Farah	5aff50a345	Fixed updating yaml from other files	2021-02-11 10:58:40 +11:00
Mike Farah	90d55fb52a	update issue template, instruct questions to be raised in disussion	2021-02-11 10:58:40 +11:00
Mike Farah	e6f97518f3	fixed heading	2021-02-11 10:58:40 +11:00
Mike Farah	f4a44e7313	added tar.gz instructions	2021-02-11 10:58:37 +11:00
				`@@ -0,0 +1 @@`
				`For more complex scenarios, variables can be used to hold values of expression to be used in other expressions.`