tests passsing!

wip
2025-01-18 04:53:17 -08:00 · 2020-12-27 22:47:19 +11:00 · 2020-12-27 22:29:00 +11:00 · 2020-12-27 22:14:26 +11:00 · 2020-12-27 09:55:21 +11:00 · 2020-12-27 09:55:21 +11:00
109 changed files with 1157 additions and 2419 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report_v3.md
+++ b/.github/ISSUE_TEMPLATE/bug_report_v3.md
@@ -10,8 +10,6 @@ assignees: ''
 **Describe the bug**
 A clear and concise description of what the bug is.

-Note that any how to questions should be posted in the discussion board and not raised as an issue.
-
 Version of yq: 3.X.X
 Operating system: mac/linux/windows/....
 Installed via: docker/binary release/homebrew/snap/...
--- a/.github/ISSUE_TEMPLATE/bug_report_v4.md
+++ b/.github/ISSUE_TEMPLATE/bug_report_v4.md
@@ -10,8 +10,6 @@ assignees: ''
 **Describe the bug**
 A clear and concise description of what the bug is.

-Note that any how to questions should be posted in the discussion board and not raised as an issue.
-
 Version of yq: 4.X.X
 Operating system: mac/linux/windows/....
 Installed via: docker/binary release/homebrew/snap/...
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -9,11 +9,9 @@ assignees: ''

 **Please describe your feature request.**
 A clear and concise description of what the request is and what it would solve. 
-Eg. I wish I could use yq to [...]
+Ex. I wish I could use yq to [...]

-Note:
- how to questions should be posted in the discussion board and not raised as an issue.
- V3 will no longer have any enhancements.
+Please note that V3 will no longer have any enhancements.

 **Describe the solution you'd like**
 If we have data1.yml like:
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -68,9 +68,7 @@ jobs:
 
      - name: Build and push image
        run: |
-          IMAGE_V_VERSION="$(git describe --tags --abbrev=0)"
-          IMAGE_VERSION=${IMAGE_V_VERSION:1}
-
+          IMAGE_VERSION="$(git describe --tags --abbrev=0)"
          SHORT_SHA1=$(git rev-parse --short HEAD)
          PLATFORMS="linux/amd64,linux/ppc64le,linux/arm64"
          echo "Building and pushing version ${IMAGE_VERSION} of image ${IMAGE_NAME}"
--- a/Dockerfile.dev
+++ b/Dockerfile.dev
@@ -4,7 +4,6 @@ COPY scripts/devtools.sh /opt/devtools.sh

 RUN set -e -x \
    && /opt/devtools.sh
-ENV PATH=/go/bin:$PATH

 # install mkdocs
 RUN set -ex \
--- a/README.md
+++ b/README.md
@@ -3,64 +3,30 @@
 ![Build](https://github.com/mikefarah/yq/workflows/Build/badge.svg)  ![Docker Pulls](https://img.shields.io/docker/pulls/mikefarah/yq.svg) ![Github Releases (by Release)](https://img.shields.io/github/downloads/mikefarah/yq/total.svg) ![Go Report](https://goreportcard.com/badge/github.com/mikefarah/yq)


-a lightweight and portable command-line YAML processor. `yq` uses [jq](https://github.com/stedolan/jq) like syntax but works with yaml files as well as json. It doesn't yet support everything `jq` does - but it does support the most common operations and functions, and more is being added continuously.
+a lightweight and portable command-line YAML processor

-yq is written in go - so you can download a dependency free binary for your platform and you are good to go! If you prefer there are a variety of package managers that can be used as well as docker, all listed below.
+The aim of the project is to be the [jq](https://github.com/stedolan/jq) or sed of yaml files.

 ## V4 released!
 V4 is now officially released, it's quite different from V3 (sorry for the migration), however it is much more similar to ```jq```, using a similar expression syntax and therefore support much more complex functionality! 

 If you've been using v3 and want/need to upgrade, checkout the [upgrade guide](https://mikefarah.gitbook.io/yq/v/v4.x/upgrading-from-v3).

-Support for v3 will cease August 2021, until then, critical bug and security fixes will still get applied if required.
-
 ## Install

 ### [Download the latest binary](https://github.com/mikefarah/yq/releases/latest)

-### wget
-Use wget to download the pre-compiled binaries:
-
-#### Compressed via tar.gz
-```bash
-wget https://github.com/mikefarah/yq/releases/download/${VERSION}/${BINARY}.tar.gz -O - |\
-  tar xz && mv ${BINARY} /usr/bin/yq
-```
-
-#### Plain binary
-
-```bash
-wget https://github.com/mikefarah/yq/releases/download/${VERSION}/${BINARY} -O /usr/bin/yq &&\
-    chmod +x /usr/bin/yq
-```
-
-For instance, VERSION=v4.2.0 and BINARY=yq_linux_amd64
-
-### MacOS / Linux via Homebrew:
+### MacOS:
 Using [Homebrew](https://brew.sh/)
 ```
 brew install yq
 ```

-or, for the (deprecated) v3 version:
-
-```
-brew install yq@3
-```
-
-Note that for v3, as it is a versioned brew it will not add the `yq` command to your path automatically. Please follow the instructions given by brew upon installation.
-
-### Linux via snap:
+### Ubuntu and other Linux distros supporting `snap` packages:
 ```
 snap install yq
 ```

-or, for the (deprecated) v3 version:
-
-```
-snap install yq --channel=v3/stable
-```
-
 #### Snap notes
 `yq` installs with [_strict confinement_](https://docs.snapcraft.io/snap-confinement/6233) in snap, this means it doesn't have direct access to root files. To read root files you can:

@@ -79,6 +45,17 @@ sudo mv /etc/myfile.tmp /etc/myfile
 rm /etc/myfile.tmp
 ```

+### wget
+
+Use wget to download the pre-compiled binaries:
+
+```bash
+wget https://github.com/mikefarah/yq/releases/download/${VERSION}/${BINARY} -O /usr/bin/yq &&\
+    chmod +x /usr/bin/yq
+```
+
+For instance, VERSION=4.0.0 and BINARY=yq_linux_amd64
+
 ### Run with Docker

 #### Oneshot use:
@@ -109,14 +86,6 @@ GO111MODULE=on go get github.com/mikefarah/yq
 ## Community Supported Installation methods
 As these are supported by the community :heart: - however, they may be out of date with the officially supported releases.

-# Webi
-
-```
-webi yq
-```
-
-See [webi](https://webinstall.dev/)
-Supported by @adithyasunil26 (https://github.com/webinstall/webi-installers/tree/master/yq)

 ### Windows:
 ```
@@ -189,7 +158,6 @@ Flags:
  -M, --no-colors     force print with no colors
  -N, --no-doc        Don't print document separators (---)
  -n, --null-input    Don't read input, simply evaluate the expression given. Useful for creating yaml docs from scratch.
-  -P, --prettyPrint    pretty print, shorthand for '... style = ""' 
  -j, --tojson        output as json. Set indent to 0 to print json in one line.
  -v, --verbose       verbose mode
  -V, --version       Print version information and quit
--- a/cmd/constant.go
+++ b/cmd/constant.go
@@ -14,6 +14,5 @@ var noDocSeparators = false
 var nullInput = false
 var verbose = false
 var version = false
-var prettyPrint = false

 var completedSuccessfully = false
--- a/cmd/evaluate_all_command.go
+++ b/cmd/evaluate_all_command.go
@@ -59,29 +59,25 @@ func evaluateAll(cmd *cobra.Command, args []string) error {
 		defer func() { writeInPlaceHandler.FinishWriteInPlace(completedSuccessfully) }()
 	}

-	if nullInput && len(args) > 1 {
-		return errors.New("Cannot pass files in when using null-input flag")
-	}
-
 	printer := yqlib.NewPrinter(out, outputToJSON, unwrapScalar, colorsEnabled, indent, !noDocSeparators)

 	allAtOnceEvaluator := yqlib.NewAllAtOnceEvaluator()
 	switch len(args) {
 	case 0:
 		if pipingStdIn {
-			err = allAtOnceEvaluator.EvaluateFiles(processExpression(""), []string{"-"}, printer)
+			err = allAtOnceEvaluator.EvaluateFiles("", []string{"-"}, printer)
 		} else {
 			cmd.Println(cmd.UsageString())
 			return nil
 		}
 	case 1:
 		if nullInput {
-			err = yqlib.NewStreamEvaluator().EvaluateNew(processExpression(args[0]), printer)
+			err = yqlib.NewStreamEvaluator().EvaluateNew(args[0], printer)
 		} else {
-			err = allAtOnceEvaluator.EvaluateFiles(processExpression(""), []string{args[0]}, printer)
+			err = allAtOnceEvaluator.EvaluateFiles("", []string{args[0]}, printer)
 		}
 	default:
-		err = allAtOnceEvaluator.EvaluateFiles(processExpression(args[0]), args[1:], printer)
+		err = allAtOnceEvaluator.EvaluateFiles(args[0], args[1:], printer)
 	}

 	completedSuccessfully = err == nil
--- a/cmd/evalute_sequence_command.go
+++ b/cmd/evalute_sequence_command.go
@@ -33,16 +33,6 @@ yq e '.a.b = "cool"' -i file.yaml
 	}
 	return cmdEvalSequence
 }
-
-func processExpression(expression string) string {
-	if prettyPrint && expression == "" {
-		return `... style=""`
-	} else if prettyPrint {
-		return fmt.Sprintf("%v | ... style= \"\"", expression)
-	}
-	return expression
-}
-
 func evaluateSequence(cmd *cobra.Command, args []string) error {
 	cmd.SilenceUsage = true
 	// 0 args, read std in
@@ -83,23 +73,19 @@ func evaluateSequence(cmd *cobra.Command, args []string) error {

 	streamEvaluator := yqlib.NewStreamEvaluator()

-	if nullInput && len(args) > 1 {
-		return errors.New("Cannot pass files in when using null-input flag")
-	}
-
 	switch len(args) {
 	case 0:
 		if pipingStdIn {
-			err = streamEvaluator.EvaluateFiles(processExpression(""), []string{"-"}, printer)
+			err = streamEvaluator.EvaluateFiles("", []string{"-"}, printer)
 		} else {
 			cmd.Println(cmd.UsageString())
 			return nil
 		}
 	case 1:
 		if nullInput {
-			err = streamEvaluator.EvaluateNew(processExpression(args[0]), printer)
+			err = streamEvaluator.EvaluateNew(args[0], printer)
 		} else {
-			err = streamEvaluator.EvaluateFiles(processExpression(""), []string{args[0]}, printer)
+			err = streamEvaluator.EvaluateFiles("", []string{args[0]}, printer)
 		}
 	default:
 		err = streamEvaluator.EvaluateFiles(args[0], args[1:], printer)
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -48,7 +48,6 @@ func New() *cobra.Command {
 	rootCmd.Flags().BoolVarP(&version, "version", "V", false, "Print version information and quit")
 	rootCmd.PersistentFlags().BoolVarP(&writeInplace, "inplace", "i", false, "update the yaml file inplace of first yaml file given.")
 	rootCmd.PersistentFlags().BoolVarP(&unwrapScalar, "unwrapScalar", "", true, "unwrap scalar, print the value with no quotes, colors or comments")
-	rootCmd.PersistentFlags().BoolVarP(&prettyPrint, "prettyPrint", "P", false, "pretty print, shorthand for '... style = \"\"'")
 	rootCmd.PersistentFlags().BoolVarP(&exitStatus, "exit-status", "e", false, "set exit status if there are no matches or null or false is returned")

 	rootCmd.PersistentFlags().BoolVarP(&forceColor, "colors", "C", false, "force print with colors")
--- 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.3.2"
+	Version = "4.1.0"

 	// 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.3.2
+FROM mikefarah/yq:3

 COPY entrypoint.sh /entrypoint.sh

--- a/go.mod
+++ b/go.mod
@@ -2,15 +2,17 @@ module github.com/mikefarah/yq/v4

 require (
 	github.com/elliotchance/orderedmap v1.3.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/fatih/color v1.9.0
+	github.com/goccy/go-yaml v1.8.1
+	github.com/jinzhu/copier v0.0.0-20190924061706-b57f9002281a
+	github.com/mattn/go-colorable v0.1.7 // indirect
 	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-20200930185726-fdedc70b468f // indirect
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
 	gopkg.in/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473
-	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b
+	gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776
 )

 go 1.15
--- a/go.sum
+++ b/go.sum
@@ -39,21 +39,19 @@ github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8
 github.com/elliotchance/orderedmap v1.3.0 h1:k6m77/d0zCXTjsk12nX40TkEBkSICq8T4s6R6bpCqU0=
 github.com/elliotchance/orderedmap v1.3.0/go.mod h1:8hdSl6jmveQw8ScByd3AaNHNk51RhbTazdqtTty+NFw=
 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=
+github.com/fatih/color v1.9.0 h1:8xPHl4/q1VyqGIPif1F+1V3Y3lSmrq01EabUW3CoW5s=
+github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
 github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
-github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
 github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
 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.1 h1:JuZRFlqLM5cWF6A+waL8AKVuCcqvKOuhJtUQI+L3ez0=
+github.com/goccy/go-yaml v1.8.1/go.mod h1:wS4gNoLalDSJxo/SpngzPQ2BN4uuZVLCmbM4S3vd4+Y=
 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 +99,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.0.0-20190924061706-b57f9002281a h1:zPPuIq2jAWWPTrGt70eK/BSch+gFAGrNzecsoENgu2o=
+github.com/jinzhu/copier v0.0.0-20190924061706-b57f9002281a/go.mod h1:yL958EeXv8Ylng6IfnvG4oflryUi3vgA3xPs9hmII1s=
 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=
@@ -120,9 +118,15 @@ github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
 github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
-github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
-github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-colorable v0.1.4 h1:snbPLB8fVfU9iwbbo30TPtbLRzwWu6aJS6Xh4eaaviA=
+github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-colorable v0.1.7 h1:bQGKb3vps/j0E9GfJQ03JyhRuxsvdAanXlT9BTw3mdw=
+github.com/mattn/go-colorable v0.1.7/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84=
+github.com/mattn/go-isatty v0.0.11 h1:FxPOTFNqGkuDUGi3H/qkUbQO4ZiBa2brKq5r0l8TGeM=
+github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
 github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
@@ -200,7 +204,6 @@ golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnf
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -248,17 +251,22 @@ golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191010194322-b09406accb47/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037 h1:YyJpGZS1sBuBCzLAR1VEpK193GlqGZbnPFnPV/5Rsb4=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 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-20200930185726-fdedc70b468f h1:+Nyd8tzPX9R7BWHguqsrbFdRx3WQ/1ib8I44HXV5yTA=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/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=
@@ -281,9 +289,10 @@ golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgw
 golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc h1:NCy3Ohtk6Iny5V/reW2Ktypo4zIpWBdRJ1uFMjBxdg8=
 golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
@@ -313,6 +322,8 @@ gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE=
+gopkg.in/go-playground/validator.v9 v9.30.0/go.mod h1:+c9/zcJMFNgbLvly1L1V+PpxWdVbfP1avr/N00E2vyQ=
 gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473 h1:6D+BvnJ/j6e222UW8s2qTSe3wGBtvo0MbVQG/c5k8RE=
 gopkg.in/op/go-logging.v1 v1.0.0-20160211212156-b2cb9fa56473/go.mod h1:N1eN2tsCx0Ydtgjl4cqmbRCsY4/+z4cYDeqwZTk6zog=
@@ -324,8 +335,8 @@ 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-20210107192922-496545a6307b h1:h8qDotaEPuJATrMmW04NCwg7v22aHH28wwpauUhK9Oo=
-gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776 h1:tQIYjPdBoyREyB9XMu+nnTclpTYkz2zFM+lzLJFO4gQ=
+gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
--- a/pkg/yqlib/all_at_once_evaluator.go
+++ b/pkg/yqlib/all_at_once_evaluator.go
@@ -1,50 +1,29 @@
 package yqlib

-import (
-	"container/list"
+import "container/list"

-	yaml "gopkg.in/yaml.v3"
-)
-
-// A yaml expression evaluator that runs the expression once against all files/nodes in memory.
+/**
+	Loads all yaml documents of all files given into memory, then runs the given expression once.
+**/
 type Evaluator interface {
 	EvaluateFiles(expression string, filenames []string, printer Printer) error
-
-	// EvaluateNodes takes an expression and one or more yaml nodes, returning a list of matching candidate nodes
-	EvaluateNodes(expression string, nodes ...*yaml.Node) (*list.List, error)
-
-	// EvaluateCandidateNodes takes an expression and list of candidate nodes, returning a list of matching candidate nodes
-	EvaluateCandidateNodes(expression string, inputCandidateNodes *list.List) (*list.List, error)
 }

 type allAtOnceEvaluator struct {
 	treeNavigator DataTreeNavigator
-	treeCreator   ExpressionParser
+	treeCreator   PathTreeCreator
 }

 func NewAllAtOnceEvaluator() Evaluator {
-	return &allAtOnceEvaluator{treeNavigator: NewDataTreeNavigator(), treeCreator: NewExpressionParser()}
-}
-
-func (e *allAtOnceEvaluator) EvaluateNodes(expression string, nodes ...*yaml.Node) (*list.List, error) {
-	inputCandidates := list.New()
-	for _, node := range nodes {
-		inputCandidates.PushBack(&CandidateNode{Node: node})
-	}
-	return e.EvaluateCandidateNodes(expression, inputCandidates)
-}
-
-func (e *allAtOnceEvaluator) EvaluateCandidateNodes(expression string, inputCandidates *list.List) (*list.List, error) {
-	node, err := e.treeCreator.ParseExpression(expression)
-	if err != nil {
-		return nil, err
-	}
-	return e.treeNavigator.GetMatchingNodes(inputCandidates, node)
+	return &allAtOnceEvaluator{treeNavigator: NewDataTreeNavigator(), treeCreator: NewPathTreeCreator()}
 }

 func (e *allAtOnceEvaluator) EvaluateFiles(expression string, filenames []string, printer Printer) error {
 	fileIndex := 0
-
+	node, err := treeCreator.ParsePath(expression)
+	if err != nil {
+		return err
+	}
 	var allDocuments *list.List = list.New()
 	for _, filename := range filenames {
 		reader, err := readStream(filename)
@@ -58,7 +37,7 @@ func (e *allAtOnceEvaluator) EvaluateFiles(expression string, filenames []string
 		allDocuments.PushBackList(fileDocuments)
 		fileIndex = fileIndex + 1
 	}
-	matches, err := e.EvaluateCandidateNodes(expression, allDocuments)
+	matches, err := treeNavigator.GetMatchingNodes(allDocuments, node)
 	if err != nil {
 		return err
 	}
--- a/pkg/yqlib/all_at_once_evaluator_test.go
+++ b/pkg/yqlib/all_at_once_evaluator_test.go
@@ -1,40 +0,0 @@
-package yqlib
-
-import (
-	"testing"
-
-	"github.com/mikefarah/yq/v4/test"
-)
-
-var evaluateNodesScenario = []expressionScenario{
-	{
-		document:   `a: hello`,
-		expression: `.a`,
-		expected: []string{
-			"D0, P[a], (!!str)::hello\n",
-		},
-	},
-	{
-		document:   `a: hello`,
-		expression: `.`,
-		expected: []string{
-			"D0, P[], (doc)::a: hello\n",
-		},
-	},
-	{
-		document:   `- a: "yes"`,
-		expression: `.[] | has("a")`,
-		expected: []string{
-			"D0, P[0], (!!bool)::true\n",
-		},
-	},
-}
-
-func TestAllAtOnceEvaluateNodes(t *testing.T) {
-	var evaluator = NewAllAtOnceEvaluator()
-	for _, tt := range evaluateNodesScenario {
-		node := test.ParseData(tt.document)
-		list, _ := evaluator.EvaluateNodes(tt.expression, &node)
-		test.AssertResultComplex(t, tt.expected, resultsToString(list))
-	}
-}
--- a/pkg/yqlib/candidate_node.go
+++ b/pkg/yqlib/candidate_node.go
@@ -21,23 +21,7 @@ func (n *CandidateNode) GetKey() string {
 	return fmt.Sprintf("%v - %v", n.Document, n.Path)
 }

-func (n *CandidateNode) CreateChild(path interface{}, node *yaml.Node) *CandidateNode {
-	return &CandidateNode{
-		Node:      node,
-		Path:      n.createChildPath(path),
-		Document:  n.Document,
-		Filename:  n.Filename,
-		FileIndex: n.FileIndex,
-	}
-}
-
-func (n *CandidateNode) createChildPath(path interface{}) []interface{} {
-	if path == nil {
-		newPath := make([]interface{}, len(n.Path))
-		copy(newPath, n.Path)
-		return newPath
-	}
-
+func (n *CandidateNode) CreateChildPath(path interface{}) []interface{} {
 	//don't use append as they may actually modify the path of the orignal node!
 	newPath := make([]interface{}, len(n.Path)+1)
 	copy(newPath, n.Path)
@@ -56,12 +40,10 @@ func (n *CandidateNode) Copy() (*CandidateNode, error) {

 // updates this candidate from the given candidate node
 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) {
--- a/pkg/yqlib/color_print.go
+++ b/pkg/yqlib/color_print.go
@@ -17,8 +17,8 @@ func format(attr color.Attribute) string {
 	return fmt.Sprintf("%s[%dm", escape, attr)
 }

-func colorizeAndPrint(yamlBytes []byte, writer io.Writer) error {
-	tokens := lexer.Tokenize(string(yamlBytes))
+func ColorizeAndPrint(bytes []byte, writer io.Writer) error {
+	tokens := lexer.Tokenize(string(bytes))
 	var p printer.Printer
 	p.Bool = func() *printer.Property {
 		return &printer.Property{
--- a/pkg/yqlib/data_tree_navigator.go
+++ b/pkg/yqlib/data_tree_navigator.go
@@ -9,10 +9,10 @@ import (
 )

 type DataTreeNavigator interface {
-	// given a list of CandidateEntities and a expressionNode,
-	// this will process the list against the given expressionNode and return
+	// given a list of CandidateEntities and a pathNode,
+	// this will process the list against the given pathNode and return
 	// a new list of matching candidates
-	GetMatchingNodes(matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error)
+	GetMatchingNodes(matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error)
 }

 type dataTreeNavigator struct {
@@ -22,22 +22,22 @@ func NewDataTreeNavigator() DataTreeNavigator {
 	return &dataTreeNavigator{}
 }

-func (d *dataTreeNavigator) GetMatchingNodes(matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
-	if expressionNode == nil {
+func (d *dataTreeNavigator) GetMatchingNodes(matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+	if pathNode == nil {
 		log.Debugf("getMatchingNodes - nothing to do")
 		return matchingNodes, nil
 	}
-	log.Debugf("Processing Op: %v", expressionNode.Operation.toString())
+	log.Debugf("Processing Op: %v", pathNode.Operation.toString())
 	if log.IsEnabledFor(logging.DEBUG) {
 		for el := matchingNodes.Front(); el != nil; el = el.Next() {
 			log.Debug(NodeToString(el.Value.(*CandidateNode)))
 		}
 	}
 	log.Debug(">>")
-	handler := expressionNode.Operation.OperationType.Handler
+	handler := pathNode.Operation.OperationType.Handler
 	if handler != nil {
-		return handler(d, matchingNodes, expressionNode)
+		return handler(d, matchingNodes, pathNode)
 	}
-	return nil, fmt.Errorf("Unknown operator %v", expressionNode.Operation.OperationType)
+	return nil, fmt.Errorf("Unknown operator %v", pathNode.Operation.OperationType)

 }
--- a/pkg/yqlib/doc/Add.md
+++ b/pkg/yqlib/doc/Add.md
@@ -1,9 +1,9 @@
 Add behaves differently according to the type of the LHS:
 - arrays: concatenate
- number scalars: arithmetic addition
- string scalars: concatenate
+- number scalars: arithmetic addition (soon)
+- string scalars: concatenate (soon)

-Use `+=` as append assign for things like increment. Note that `.a += .x` is equivalent to running `.a = .a + .x`.
+Use `+=` as append assign for things like increment. `.a += .x` is equivalent to running `.a |= . + .x`.

 ## Concatenate and assign arrays
 Given a sample.yml file of:
@@ -67,19 +67,23 @@ will output
 - 2
 ```

-## Add new object to array
+## Add object to array
 Given a sample.yml file of:
 ```yaml
 a:
-  - dog: woof
+  - 1
+  - 2
+c:
+  cat: meow
 ```
 then
 ```bash
-yq eval '.a + {"cat": "meow"}' sample.yml
+yq eval '.a + .c' sample.yml
 ```
 will output
 ```yaml
- dog: woof
+- 1
+- 2
 - cat: meow
 ```

@@ -127,85 +131,3 @@ b:
  - 4
 ```

-## String concatenation
-Given a sample.yml file of:
-```yaml
-a: cat
-b: meow
-```
-then
-```bash
-yq eval '.a = .a + .b' sample.yml
-```
-will output
-```yaml
-a: catmeow
-b: meow
-```
-
-## Relative string concatenation
-Given a sample.yml file of:
-```yaml
-a: cat
-b: meow
-```
-then
-```bash
-yq eval '.a += .b' sample.yml
-```
-will output
-```yaml
-a: catmeow
-b: meow
-```
-
-## Number addition - float
-If the lhs or rhs are floats then the expression will be calculated with floats.
-
-Given a sample.yml file of:
-```yaml
-a: 3
-b: 4.9
-```
-then
-```bash
-yq eval '.a = .a + .b' sample.yml
-```
-will output
-```yaml
-a: 7.9
-b: 4.9
-```
-
-## Number addition - int
-If both the lhs and rhs are ints then the expression will be calculated with ints.
-
-Given a sample.yml file of:
-```yaml
-a: 3
-b: 4
-```
-then
-```bash
-yq eval '.a = .a + .b' sample.yml
-```
-will output
-```yaml
-a: 7
-b: 4
-```
-
-## Increment number
-Given a sample.yml file of:
-```yaml
-a: 3
-```
-then
-```bash
-yq eval '.a += 1' sample.yml
-```
-will output
-```yaml
-a: 4
-```
-
--- a/pkg/yqlib/doc/Anchor
+++ b/pkg/yqlib/doc/Anchor
@@ -31,22 +31,6 @@ will output
 a: &foobar cat
 ```

-## Set anchor relatively using assign-update
-Given a sample.yml file of:
-```yaml
-a:
-  b: cat
-```
-then
-```bash
-yq eval '.a anchor |= .b' sample.yml
-```
-will output
-```yaml
-a: &cat
-  b: cat
-```
-
 ## Get alias
 Given a sample.yml file of:
 ```yaml
@@ -78,23 +62,6 @@ b: &meow purr
 a: *meow
 ```

-## Set alias relatively using assign-update
-Given a sample.yml file of:
-```yaml
-b: &meow purr
-a:
-  f: meow
-```
-then
-```bash
-yq eval '.a alias |= .f' sample.yml
-```
-will output
-```yaml
-b: &meow purr
-a: *meow
-```
-
 ## Explode alias and anchor
 Given a sample.yml file of:
 ```yaml
--- a/pkg/yqlib/doc/Assign.md
+++ b/pkg/yqlib/doc/Assign.md
@@ -34,27 +34,6 @@ a:
  g: foof
 ```

-## Update node from another file
-Note this will also work when the second file is a scalar (string/number)
-
-Given a sample.yml file of:
-```yaml
-a: apples
-```
-And another sample another.yml file of:
-```yaml
-b: bob
-```
-then
-```bash
-yq eval-all 'select(fileIndex==0).a = select(fileIndex==1) | select(fileIndex==0)' sample.yml another.yml
-```
-will output
-```yaml
-a:
-  b: bob
-```
-
 ## Update node to be the sibling value
 Given a sample.yml file of:
 ```yaml
--- a/pkg/yqlib/doc/Collect
+++ b/pkg/yqlib/doc/Collect
--- a/pkg/yqlib/doc/Comment
+++ b/pkg/yqlib/doc/Comment
@@ -13,22 +13,6 @@ will output
 a: cat # single
 ```

-## Use update assign to perform relative updates
-Given a sample.yml file of:
-```yaml
-a: cat
-b: dog
-```
-then
-```bash
-yq eval '.. lineComment |= .' sample.yml
-```
-will output
-```yaml
-a: cat # cat
-b: dog # dog
-```
-
 ## Set head comment
 Given a sample.yml file of:
 ```yaml
--- a/pkg/yqlib/doc/Delete.md
+++ b/pkg/yqlib/doc/Delete.md
@@ -95,23 +95,3 @@ will output
 b: dog
 ```

-## Recursively delete matching keys
-Given a sample.yml file of:
-```yaml
-a:
-  name: frog
-  b:
-    name: blog
-    age: 12
-```
-then
-```bash
-yq eval 'del(.. | select(has("name")).name)' sample.yml
-```
-will output
-```yaml
-a:
-  b:
-    age: 12
-```
-
--- a/pkg/yqlib/doc/Document
+++ b/pkg/yqlib/doc/Document
@@ -1,4 +1,4 @@
-Use the `documentIndex` operator (or the `di` shorthand) to select nodes of a particular document.
+Use the `documentIndex` operator to select nodes of a particular document.
 ## Retrieve a document index
 Given a sample.yml file of:
 ```yaml
@@ -17,24 +17,6 @@ will output
 1
 ```

-## Retrieve a document index, shorthand
-Given a sample.yml file of:
-```yaml
-a: cat
---
-a: frog
-```
-then
-```bash
-yq eval '.a | di' sample.yml
-```
-will output
-```yaml
-0
---
-1
-```
-
 ## Filter by document index
 Given a sample.yml file of:
 ```yaml
@@ -44,23 +26,7 @@ a: frog
 ```
 then
 ```bash
-yq eval 'select(documentIndex == 1)' sample.yml
-```
-will output
-```yaml
-a: frog
-```
-
-## Filter by document index shorthand
-Given a sample.yml file of:
-```yaml
-a: cat
---
-a: frog
-```
-then
-```bash
-yq eval 'select(di == 1)' sample.yml
+yq eval 'select(. | documentIndex == 1)' sample.yml
 ```
 will output
 ```yaml
@@ -76,7 +42,7 @@ a: frog
 ```
 then
 ```bash
-yq eval '.a | ({"match": ., "doc": documentIndex})' sample.yml
+yq eval '.a | ({"match": ., "doc": (. | documentIndex)})' sample.yml
 ```
 will output
 ```yaml
--- a/pkg/yqlib/doc/Env
+++ b/pkg/yqlib/doc/Env
@@ -1,78 +0,0 @@
-This operator is used to handle environment variables usage in path expressions. While environment variables can, of course, be passed in via your CLI with string interpolation, this often comes with complex quote escaping and can be tricky to write and read. Note that there are two forms, `env` which will parse the environment variable as a yaml (be it a map, array, string, number of boolean) and `strenv` which will always parse the argument as a string.
-
-
-## Read string environment variable
-Running
-```bash
-myenv="cat meow" yq eval --null-input '.a = env(myenv)'
-```
-will output
-```yaml
-a: cat meow
-```
-
-## Read boolean environment variable
-Running
-```bash
-myenv="true" yq eval --null-input '.a = env(myenv)'
-```
-will output
-```yaml
-a: true
-```
-
-## Read numeric environment variable
-Running
-```bash
-myenv="12" yq eval --null-input '.a = env(myenv)'
-```
-will output
-```yaml
-a: 12
-```
-
-## Read yaml environment variable
-Running
-```bash
-myenv="{b: fish}" yq eval --null-input '.a = env(myenv)'
-```
-will output
-```yaml
-a: {b: fish}
-```
-
-## Read boolean environment variable as a string
-Running
-```bash
-myenv="true" yq eval --null-input '.a = strenv(myenv)'
-```
-will output
-```yaml
-a: "true"
-```
-
-## Read numeric environment variable as a string
-Running
-```bash
-myenv="12" yq eval --null-input '.a = strenv(myenv)'
-```
-will output
-```yaml
-a: "12"
-```
-
-## Dynamic key lookup with environment variable
-Given a sample.yml file of:
-```yaml
-cat: meow
-dog: woof
-```
-then
-```bash
-myenv="cat" yq eval '.[env(myenv)]' sample.yml
-```
-will output
-```yaml
-meow
-```
-
--- a/pkg/yqlib/doc/File
+++ b/pkg/yqlib/doc/File
@@ -1,11 +1,9 @@
 File operators are most often used with merge when needing to merge specific files together. Note that when doing this, you will need to use `eval-all` to ensure all yaml documents are loaded into memory before performing the merge (as opposed to `eval` which runs the expression once per document).

-Note that the `fileIndex` operator has a short alias of `fi`.
-
 ## Merging files
 Note the use of eval-all to ensure all documents are loaded into memory.
 ```bash
-yq eval-all 'select(fi == 0) * select(filename == "file2.yaml")' file1.yaml file2.yaml
+yq eval-all 'select(fileIndex == 0) * select(filename == "file2.yaml")' file1.yaml file2.yaml
 ```
 ## Get filename
 Given a sample.yml file of:
@@ -18,7 +16,7 @@ yq eval 'filename' sample.yml
 ```
 will output
 ```yaml
-sample.yml
+sample.yaml
 ```

 ## Get file index
@@ -35,17 +33,3 @@ will output
 0
 ```

-## Get file index alias
-Given a sample.yml file of:
-```yaml
-a: cat
-```
-then
-```bash
-yq eval 'fi' sample.yml
-```
-will output
-```yaml
-0
-```
-
--- a/pkg/yqlib/doc/Multiply.md
+++ b/pkg/yqlib/doc/Multiply.md
@@ -180,7 +180,7 @@ g: thongs
 f: *cat
 ```

-## Merge copies anchor names
+## Merge does not copy anchor names
 Given a sample.yml file of:
 ```yaml
 a:
@@ -197,7 +197,7 @@ yq eval '.c * .a' sample.yml
 will output
 ```yaml
 g: thongs
-c: &cat frog
+c: frog
 ```

 ## Merge with merge anchors
--- a/pkg/yqlib/doc/Recursive
+++ b/pkg/yqlib/doc/Recursive
@@ -1,154 +0,0 @@
-This operator recursively matches (or globs) all children nodes given of a particular element, including that node itself. This is most often used to apply a filter recursively against all matches. It can be used in either the 
-
-## match values form `..`
-This will, like the `jq` equivalent, recursively match all _value_ nodes. Use it to find/manipulate particular values.
-
-For instance to set the `style` of all _value_ nodes in a yaml doc, excluding map keys:
-
-```bash
-yq eval '.. style= "flow"' file.yaml
-```
-
-## match values and map keys form `...`
-The also includes map keys in the results set. This is particularly useful in YAML as unlike JSON, map keys can have their own styling, tags and use anchors and aliases.
-
-For instance to set the `style` of all nodes in a yaml doc, including the map keys:
-
-```bash
-yq eval '... style= "flow"' file.yaml
-```
-## Recurse map (values only)
-Given a sample.yml file of:
-```yaml
-a: frog
-```
-then
-```bash
-yq eval '..' sample.yml
-```
-will output
-```yaml
-a: frog
-frog
-```
-
-## Recursively find nodes with keys
-Note that this example has wrapped the expression in `[]` to show that there are two matches returned. You do not have to wrap in `[]` in your path expression.
-
-Given a sample.yml file of:
-```yaml
-a:
-  name: frog
-  b:
-    name: blog
-    age: 12
-```
-then
-```bash
-yq eval '[.. | select(has("name"))]' sample.yml
-```
-will output
-```yaml
- name: frog
-  b:
-    name: blog
-    age: 12
- name: blog
-  age: 12
-```
-
-## Recursively find nodes with values
-Given a sample.yml file of:
-```yaml
-a:
-  nameA: frog
-  b:
-    nameB: frog
-    age: 12
-```
-then
-```bash
-yq eval '.. | select(. == "frog")' sample.yml
-```
-will output
-```yaml
-frog
-frog
-```
-
-## Recurse map (values and keys)
-Note that the map key appears in the results
-
-Given a sample.yml file of:
-```yaml
-a: frog
-```
-then
-```bash
-yq eval '...' sample.yml
-```
-will output
-```yaml
-a: frog
-a
-frog
-```
-
-## Aliases are not traversed
-Given a sample.yml file of:
-```yaml
-a: &cat
-  c: frog
-b: *cat
-```
-then
-```bash
-yq eval '[..]' sample.yml
-```
-will output
-```yaml
- a: &cat
-    c: frog
-  b: *cat
- &cat
-  c: frog
- frog
- *cat
-```
-
-## Merge docs are not traversed
-Given a sample.yml file of:
-```yaml
-foo: &foo
-  a: foo_a
-  thing: foo_thing
-  c: foo_c
-bar: &bar
-  b: bar_b
-  thing: bar_thing
-  c: bar_c
-foobarList:
-  b: foobarList_b
-  !!merge <<:
-    - *foo
-    - *bar
-  c: foobarList_c
-foobar:
-  c: foobar_c
-  !!merge <<: *foo
-  thing: foobar_thing
-```
-then
-```bash
-yq eval '.foobar | [..]' sample.yml
-```
-will output
-```yaml
- c: foobar_c
-  !!merge <<: *foo
-  thing: foobar_thing
- foobar_c
- *foo
- foobar_thing
-```
-
--- a/pkg/yqlib/doc/Recursive
+++ b/pkg/yqlib/doc/Recursive
@@ -0,0 +1,63 @@
+This operator recursively matches all children nodes given of a particular element, including that node itself. This is most often used to apply a filter recursively against all matches, for instance to set the `style` of all nodes in a yaml doc:
+
+```bash
+yq eval '.. style= "flow"' file.yaml
+```
+## Aliases are not traversed
+Given a sample.yml file of:
+```yaml
+a: &cat
+  c: frog
+b: *cat
+```
+then
+```bash
+yq eval '[..]' sample.yml
+```
+will output
+```yaml
+- a: &cat
+    c: frog
+  b: *cat
+- &cat
+  c: frog
+- frog
+- *cat
+```
+
+## Merge docs are not traversed
+Given a sample.yml file of:
+```yaml
+foo: &foo
+  a: foo_a
+  thing: foo_thing
+  c: foo_c
+bar: &bar
+  b: bar_b
+  thing: bar_thing
+  c: bar_c
+foobarList:
+  b: foobarList_b
+  !!merge <<:
+    - *foo
+    - *bar
+  c: foobarList_c
+foobar:
+  c: foobar_c
+  !!merge <<: *foo
+  thing: foobar_thing
+```
+then
+```bash
+yq eval '.foobar | [..]' sample.yml
+```
+will output
+```yaml
+- c: foobar_c
+  !!merge <<: *foo
+  thing: foobar_thing
+- foobar_c
+- *foo
+- foobar_thing
+```
+
--- a/pkg/yqlib/doc/Style.md
+++ b/pkg/yqlib/doc/Style.md
@@ -40,26 +40,6 @@ c: "3.2"
 e: "true"
 ```

-## Set double quote style on map keys too
-Given a sample.yml file of:
-```yaml
-a: cat
-b: 5
-c: 3.2
-e: true
-```
-then
-```bash
-yq eval '... style="double"' sample.yml
-```
-will output
-```yaml
-"a": "cat"
-"b": "5"
-"c": "3.2"
-"e": "true"
-```
-
 ## Set single quote style
 Given a sample.yml file of:
 ```yaml
@@ -145,19 +125,19 @@ will output
 {a: cat, b: 5, c: 3.2, e: true}
 ```

-## Reset style - or pretty print
-Set empty (default) quote style, note the usage of `...` to match keys too. Note that there is a `--prettyPrint/-P` short flag for this.
+## Pretty print
+Set empty (default) quote style

 Given a sample.yml file of:
 ```yaml
 a: cat
-"b": 5
-'c': 3.2
-"e": true
+b: 5
+c: 3.2
+e: true
 ```
 then
 ```bash
-yq eval '... style=""' sample.yml
+yq eval '.. style=""' sample.yml
 ```
 will output
 ```yaml
@@ -167,22 +147,6 @@ c: 3.2
 e: true
 ```

-## Set style relatively with assign-update
-Given a sample.yml file of:
-```yaml
-a: single
-b: double
-```
-then
-```bash
-yq eval '.[] style |= .' sample.yml
-```
-will output
-```yaml
-a: 'single'
-b: "double"
-```
-
 ## Read style
 Given a sample.yml file of:
 ```yaml
--- a/pkg/yqlib/doc/Tag.md
+++ b/pkg/yqlib/doc/Tag.md
@@ -22,21 +22,7 @@ will output
 !!seq
 ```

-## Set custom tag
-Given a sample.yml file of:
-```yaml
-a: str
-```
-then
-```bash
-yq eval '.a tag = "!!mikefarah"' sample.yml
-```
-will output
-```yaml
-a: !!mikefarah str
-```
-
-## Find numbers and convert them to strings
+## Convert numbers to strings
 Given a sample.yml file of:
 ```yaml
 a: cat
--- a/pkg/yqlib/doc/Traverse.md
+++ b/pkg/yqlib/doc/Traverse.md
@@ -48,24 +48,6 @@ will output
 frog
 ```

-## Dynamic keys
-Expressions within [] can be used to dynamically lookup / calculate keys
-
-Given a sample.yml file of:
-```yaml
-b: apple
-apple: crispy yum
-banana: soft yum
-```
-then
-```bash
-yq eval '.[.b]' sample.yml
-```
-will output
-```yaml
-crispy yum
-```
-
 ## Children don't exist
 Nodes are added dynamically while traversing

@@ -124,7 +106,7 @@ b: *cat
 ```
 then
 ```bash
-yq eval '.b[]' sample.yml
+yq eval '.b.[]' sample.yml
 ```
 will output
 ```yaml
@@ -308,7 +290,7 @@ foobar:
 ```
 then
 ```bash
-yq eval '.foobar[]' sample.yml
+yq eval '.foobar.[]' sample.yml
 ```
 will output
 ```yaml
@@ -374,7 +356,7 @@ foobar:
 ```
 then
 ```bash
-yq eval '.foobarList[]' sample.yml
+yq eval '.foobarList.[]' sample.yml
 ```
 will output
 ```yaml
--- a/pkg/yqlib/doc/headers/Add.md
+++ b/pkg/yqlib/doc/headers/Add.md
@@ -1,6 +1,6 @@
 Add behaves differently according to the type of the LHS:
 - arrays: concatenate
- number scalars: arithmetic addition
- string scalars: concatenate
+- number scalars: arithmetic addition (soon)
+- string scalars: concatenate (soon)

-Use `+=` as append assign for things like increment. Note that `.a += .x` is equivalent to running `.a = .a + .x`.
+Use `+=` as append assign for things like increment. `.a += .x` is equivalent to running `.a |= . + .x`.
--- a/pkg/yqlib/doc/headers/Collect
+++ b/pkg/yqlib/doc/headers/Collect
--- a/pkg/yqlib/doc/headers/Document
+++ b/pkg/yqlib/doc/headers/Document
@@ -1 +1 @@
-Use the `documentIndex` operator (or the `di` shorthand) to select nodes of a particular document.
+Use the `documentIndex` operator to select nodes of a particular document.
--- a/pkg/yqlib/doc/headers/Env
+++ b/pkg/yqlib/doc/headers/Env
@@ -1,2 +0,0 @@
-This operator is used to handle environment variables usage in path expressions. While environment variables can, of course, be passed in via your CLI with string interpolation, this often comes with complex quote escaping and can be tricky to write and read. Note that there are two forms, `env` which will parse the environment variable as a yaml (be it a map, array, string, number of boolean) and `strenv` which will always parse the argument as a string.
-
--- a/pkg/yqlib/doc/headers/File
+++ b/pkg/yqlib/doc/headers/File
@@ -1,9 +1,7 @@
 File operators are most often used with merge when needing to merge specific files together. Note that when doing this, you will need to use `eval-all` to ensure all yaml documents are loaded into memory before performing the merge (as opposed to `eval` which runs the expression once per document).

-Note that the `fileIndex` operator has a short alias of `fi`.
-
 ## Merging files
 Note the use of eval-all to ensure all documents are loaded into memory.
 ```bash
-yq eval-all 'select(fi == 0) * select(filename == "file2.yaml")' file1.yaml file2.yaml
+yq eval-all 'select(fileIndex == 0) * select(filename == "file2.yaml")' file1.yaml file2.yaml
 ```
--- a/pkg/yqlib/doc/headers/Recursive
+++ b/pkg/yqlib/doc/headers/Recursive
@@ -1,19 +0,0 @@
-This operator recursively matches (or globs) all children nodes given of a particular element, including that node itself. This is most often used to apply a filter recursively against all matches. It can be used in either the 
-
-## match values form `..`
-This will, like the `jq` equivalent, recursively match all _value_ nodes. Use it to find/manipulate particular values.
-
-For instance to set the `style` of all _value_ nodes in a yaml doc, excluding map keys:
-
-```bash
-yq eval '.. style= "flow"' file.yaml
-```
-
-## match values and map keys form `...`
-The also includes map keys in the results set. This is particularly useful in YAML as unlike JSON, map keys can have their own styling, tags and use anchors and aliases.
-
-For instance to set the `style` of all nodes in a yaml doc, including the map keys:
-
-```bash
-yq eval '... style= "flow"' file.yaml
-```
--- a/pkg/yqlib/doc/headers/Recursive
+++ b/pkg/yqlib/doc/headers/Recursive
@@ -0,0 +1,5 @@
+This operator recursively matches all children nodes given of a particular element, including that node itself. This is most often used to apply a filter recursively against all matches, for instance to set the `style` of all nodes in a yaml doc:
+
+```bash
+yq eval '.. style= "flow"' file.yaml
+```
--- a/pkg/yqlib/encoder.go
+++ b/pkg/yqlib/encoder.go
@@ -50,7 +50,7 @@ func (ye *yamlEncoder) Encode(node *yaml.Node) error {
 	}

 	if ye.colorise {
-		return colorizeAndPrint(tempBuffer.Bytes(), ye.destination)
+		return ColorizeAndPrint(tempBuffer.Bytes(), ye.destination)
 	}
 	return nil
 }
--- a/pkg/yqlib/expression_tokeniser.go
+++ b/pkg/yqlib/expression_tokeniser.go
@@ -1,407 +0,0 @@
-package yqlib
-
-import (
-	"fmt"
-	"strconv"
-
-	lex "github.com/timtadh/lexmachine"
-	"github.com/timtadh/lexmachine/machines"
-)
-
-func skip(*lex.Scanner, *machines.Match) (interface{}, error) {
-	return nil, nil
-}
-
-type tokenType uint32
-
-const (
-	operationToken = 1 << iota
-	openBracket
-	closeBracket
-	openCollect
-	closeCollect
-	openCollectObject
-	closeCollectObject
-	traverseArrayCollect
-)
-
-type token struct {
-	TokenType            tokenType
-	Operation            *Operation
-	AssignOperation      *Operation // e.g. tag (GetTag) op becomes AssignTag if '=' follows it
-	CheckForPostTraverse bool       // e.g. [1]cat should really be [1].cat
-
-}
-
-func (t *token) toString() string {
-	if t.TokenType == operationToken {
-		log.Debug("toString, its an op")
-		return t.Operation.toString()
-	} else if t.TokenType == openBracket {
-		return "("
-	} else if t.TokenType == closeBracket {
-		return ")"
-	} else if t.TokenType == openCollect {
-		return "["
-	} else if t.TokenType == closeCollect {
-		return "]"
-	} else if t.TokenType == openCollectObject {
-		return "{"
-	} else if t.TokenType == closeCollectObject {
-		return "}"
-	} else if t.TokenType == traverseArrayCollect {
-		return ".["
-
-	} else {
-		return "NFI"
-	}
-}
-
-func pathToken(wrapped bool) lex.Action {
-	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
-		value := string(m.Bytes)
-		value = value[1:]
-		if wrapped {
-			value = unwrap(value)
-		}
-		log.Debug("PathToken %v", value)
-		op := &Operation{OperationType: traversePathOpType, Value: value, StringValue: value}
-		return &token{TokenType: operationToken, Operation: op, CheckForPostTraverse: true}, nil
-	}
-}
-
-func documentToken() lex.Action {
-	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
-		var numberString = string(m.Bytes)
-		numberString = numberString[1:]
-		var number, errParsingInt = strconv.ParseInt(numberString, 10, 64) // nolint
-		if errParsingInt != nil {
-			return nil, errParsingInt
-		}
-		log.Debug("documentToken %v", string(m.Bytes))
-		op := &Operation{OperationType: documentFilterOpType, Value: number, StringValue: numberString}
-		return &token{TokenType: operationToken, Operation: op, CheckForPostTraverse: true}, nil
-	}
-}
-
-func opToken(op *operationType) lex.Action {
-	return opTokenWithPrefs(op, nil, nil)
-}
-
-func opAssignableToken(opType *operationType, assignOpType *operationType) lex.Action {
-	return opTokenWithPrefs(opType, assignOpType, nil)
-}
-
-func assignOpToken(updateAssign bool) lex.Action {
-	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
-		log.Debug("assignOpToken %v", string(m.Bytes))
-		value := string(m.Bytes)
-		op := &Operation{OperationType: assignOpType, Value: assignOpType.Type, StringValue: value, UpdateAssign: updateAssign}
-		return &token{TokenType: operationToken, Operation: op}, nil
-	}
-}
-
-func opTokenWithPrefs(op *operationType, assignOpType *operationType, preferences interface{}) lex.Action {
-	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
-		log.Debug("opTokenWithPrefs %v", string(m.Bytes))
-		value := string(m.Bytes)
-		op := &Operation{OperationType: op, Value: op.Type, StringValue: value, Preferences: preferences}
-		var assign *Operation
-		if assignOpType != nil {
-			assign = &Operation{OperationType: assignOpType, Value: assignOpType.Type, StringValue: value, Preferences: preferences}
-		}
-		return &token{TokenType: operationToken, Operation: op, AssignOperation: assign}, nil
-	}
-}
-
-func assignAllCommentsOp(updateAssign bool) lex.Action {
-	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
-		log.Debug("assignAllCommentsOp %v", string(m.Bytes))
-		value := string(m.Bytes)
-		op := &Operation{
-			OperationType: assignCommentOpType,
-			Value:         assignCommentOpType.Type,
-			StringValue:   value,
-			UpdateAssign:  updateAssign,
-			Preferences:   &commentOpPreferences{LineComment: true, HeadComment: true, FootComment: true},
-		}
-		return &token{TokenType: operationToken, Operation: op}, nil
-	}
-}
-
-func literalToken(pType tokenType, checkForPost bool) lex.Action {
-	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
-		return &token{TokenType: pType, CheckForPostTraverse: checkForPost}, nil
-	}
-}
-
-func unwrap(value string) string {
-	return value[1 : len(value)-1]
-}
-
-func numberValue() lex.Action {
-	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
-		var numberString = string(m.Bytes)
-		var number, errParsingInt = strconv.ParseInt(numberString, 10, 64) // nolint
-		if errParsingInt != nil {
-			return nil, errParsingInt
-		}
-
-		return &token{TokenType: operationToken, Operation: createValueOperation(number, numberString)}, nil
-	}
-}
-
-func floatValue() lex.Action {
-	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
-		var numberString = string(m.Bytes)
-		var number, errParsingInt = strconv.ParseFloat(numberString, 64) // nolint
-		if errParsingInt != nil {
-			return nil, errParsingInt
-		}
-		return &token{TokenType: operationToken, Operation: createValueOperation(number, numberString)}, nil
-	}
-}
-
-func booleanValue(val bool) lex.Action {
-	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
-		return &token{TokenType: operationToken, Operation: createValueOperation(val, string(m.Bytes))}, nil
-	}
-}
-
-func stringValue(wrapped bool) lex.Action {
-	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
-		value := string(m.Bytes)
-		if wrapped {
-			value = unwrap(value)
-		}
-		return &token{TokenType: operationToken, Operation: createValueOperation(value, value)}, nil
-	}
-}
-
-func envOp(strenv bool) lex.Action {
-	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
-		value := string(m.Bytes)
-		preferences := &envOpPreferences{}
-
-		if strenv {
-			// strenv( )
-			value = value[7 : len(value)-1]
-			preferences.StringValue = true
-		} else {
-			//env( )
-			value = value[4 : len(value)-1]
-		}
-
-		envOperation := createValueOperation(value, value)
-		envOperation.OperationType = envOpType
-		envOperation.Preferences = preferences
-
-		return &token{TokenType: operationToken, Operation: envOperation}, nil
-	}
-}
-
-func nullValue() lex.Action {
-	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
-		return &token{TokenType: operationToken, Operation: createValueOperation(nil, string(m.Bytes))}, nil
-	}
-}
-
-func selfToken() lex.Action {
-	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
-		op := &Operation{OperationType: selfReferenceOpType}
-		return &token{TokenType: operationToken, Operation: op}, nil
-	}
-}
-
-func initLexer() (*lex.Lexer, error) {
-	lexer := lex.NewLexer()
-	lexer.Add([]byte(`\(`), literalToken(openBracket, false))
-	lexer.Add([]byte(`\)`), literalToken(closeBracket, true))
-
-	lexer.Add([]byte(`\.\[`), literalToken(traverseArrayCollect, false))
-	lexer.Add([]byte(`\.\.`), opTokenWithPrefs(recursiveDescentOpType, nil, &recursiveDescentPreferences{RecurseArray: true,
-		TraversePreferences: &traversePreferences{FollowAlias: false, IncludeMapKeys: false}}))
-
-	lexer.Add([]byte(`\.\.\.`), opTokenWithPrefs(recursiveDescentOpType, nil, &recursiveDescentPreferences{RecurseArray: true,
-		TraversePreferences: &traversePreferences{FollowAlias: false, IncludeMapKeys: true}}))
-
-	lexer.Add([]byte(`,`), opToken(unionOpType))
-	lexer.Add([]byte(`:\s*`), opToken(createMapOpType))
-	lexer.Add([]byte(`length`), opToken(lengthOpType))
-	lexer.Add([]byte(`sortKeys`), opToken(sortKeysOpType))
-	lexer.Add([]byte(`select`), opToken(selectOpType))
-	lexer.Add([]byte(`has`), opToken(hasOpType))
-	lexer.Add([]byte(`explode`), opToken(explodeOpType))
-	lexer.Add([]byte(`or`), opToken(orOpType))
-	lexer.Add([]byte(`and`), opToken(andOpType))
-	lexer.Add([]byte(`not`), opToken(notOpType))
-	lexer.Add([]byte(`\/\/`), opToken(alternativeOpType))
-
-	lexer.Add([]byte(`documentIndex`), opToken(getDocumentIndexOpType))
-	lexer.Add([]byte(`di`), opToken(getDocumentIndexOpType))
-
-	lexer.Add([]byte(`style`), opAssignableToken(getStyleOpType, assignStyleOpType))
-
-	lexer.Add([]byte(`tag`), opAssignableToken(getTagOpType, assignTagOpType))
-	lexer.Add([]byte(`anchor`), opAssignableToken(getAnchorOpType, assignAnchorOpType))
-	lexer.Add([]byte(`alias`), opAssignableToken(getAliasOptype, assignAliasOpType))
-	lexer.Add([]byte(`filename`), opToken(getFilenameOpType))
-	lexer.Add([]byte(`fileIndex`), opToken(getFileIndexOpType))
-	lexer.Add([]byte(`fi`), opToken(getFileIndexOpType))
-	lexer.Add([]byte(`path`), opToken(getPathOpType))
-
-	lexer.Add([]byte(`lineComment`), opTokenWithPrefs(getCommentOpType, assignCommentOpType, &commentOpPreferences{LineComment: true}))
-
-	lexer.Add([]byte(`headComment`), opTokenWithPrefs(getCommentOpType, assignCommentOpType, &commentOpPreferences{HeadComment: true}))
-
-	lexer.Add([]byte(`footComment`), opTokenWithPrefs(getCommentOpType, assignCommentOpType, &commentOpPreferences{FootComment: true}))
-
-	lexer.Add([]byte(`comments\s*=`), assignAllCommentsOp(false))
-	lexer.Add([]byte(`comments\s*\|=`), assignAllCommentsOp(true))
-
-	lexer.Add([]byte(`collect`), opToken(collectOpType))
-
-	lexer.Add([]byte(`\s*==\s*`), opToken(equalsOpType))
-	lexer.Add([]byte(`\s*=\s*`), assignOpToken(false))
-
-	lexer.Add([]byte(`del`), opToken(deleteChildOpType))
-
-	lexer.Add([]byte(`\s*\|=\s*`), assignOpToken(true))
-
-	lexer.Add([]byte("( |\t|\n|\r)+"), skip)
-
-	lexer.Add([]byte(`d[0-9]+`), documentToken())
-	lexer.Add([]byte(`\."[^ "]+"`), pathToken(true))
-	lexer.Add([]byte(`\.[^ \}\{\:\[\],\|\.\[\(\)=]+`), pathToken(false))
-	lexer.Add([]byte(`\.`), selfToken())
-
-	lexer.Add([]byte(`\|`), opToken(pipeOpType))
-
-	lexer.Add([]byte(`-?\d+(\.\d+)`), floatValue())
-	lexer.Add([]byte(`-?[1-9](\.\d+)?[Ee][-+]?\d+`), floatValue())
-	lexer.Add([]byte(`-?\d+`), numberValue())
-
-	lexer.Add([]byte(`[Tt][Rr][Uu][Ee]`), booleanValue(true))
-	lexer.Add([]byte(`[Ff][Aa][Ll][Ss][Ee]`), booleanValue(false))
-
-	lexer.Add([]byte(`[Nn][Uu][Ll][Ll]`), nullValue())
-	lexer.Add([]byte(`~`), nullValue())
-
-	lexer.Add([]byte(`"[^"]*"`), stringValue(true))
-	lexer.Add([]byte(`strenv\([^\)]+\)`), envOp(true))
-	lexer.Add([]byte(`env\([^\)]+\)`), envOp(false))
-
-	lexer.Add([]byte(`\[`), literalToken(openCollect, false))
-	lexer.Add([]byte(`\]`), literalToken(closeCollect, true))
-	lexer.Add([]byte(`\{`), literalToken(openCollectObject, false))
-	lexer.Add([]byte(`\}`), literalToken(closeCollectObject, true))
-	lexer.Add([]byte(`\*`), opTokenWithPrefs(multiplyOpType, nil, &multiplyPreferences{AppendArrays: false}))
-	lexer.Add([]byte(`\*\+`), opTokenWithPrefs(multiplyOpType, nil, &multiplyPreferences{AppendArrays: true}))
-	lexer.Add([]byte(`\+`), opToken(addOpType))
-	lexer.Add([]byte(`\+=`), opToken(addAssignOpType))
-
-	err := lexer.Compile()
-	if err != nil {
-		return nil, err
-	}
-	return lexer, nil
-}
-
-type expressionTokeniser interface {
-	Tokenise(expression string) ([]*token, error)
-}
-
-type expressionTokeniserImpl struct {
-	lexer *lex.Lexer
-}
-
-func newExpressionTokeniser() expressionTokeniser {
-	var lexer, err = initLexer()
-	if err != nil {
-		panic(err)
-	}
-	return &expressionTokeniserImpl{lexer}
-}
-
-func (p *expressionTokeniserImpl) Tokenise(expression string) ([]*token, error) {
-	scanner, err := p.lexer.Scanner([]byte(expression))
-
-	if err != nil {
-		return nil, fmt.Errorf("Parsing expression: %v", err)
-	}
-	var tokens []*token
-	for tok, err, eof := scanner.Next(); !eof; tok, err, eof = scanner.Next() {
-
-		if tok != nil {
-			currentToken := tok.(*token)
-			log.Debugf("Tokenising %v", currentToken.toString())
-			tokens = append(tokens, currentToken)
-		}
-		if err != nil {
-			return nil, fmt.Errorf("Parsing expression: %v", err)
-		}
-	}
-	var postProcessedTokens = make([]*token, 0)
-
-	skipNextToken := false
-
-	for index := range tokens {
-		if skipNextToken {
-			skipNextToken = false
-		} else {
-			postProcessedTokens, skipNextToken = p.handleToken(tokens, index, postProcessedTokens)
-		}
-	}
-
-	return postProcessedTokens, nil
-}
-
-func (p *expressionTokeniserImpl) handleToken(tokens []*token, index int, postProcessedTokens []*token) (tokensAccum []*token, skipNextToken bool) {
-	skipNextToken = false
-	currentToken := tokens[index]
-
-	if currentToken.TokenType == traverseArrayCollect {
-		//need to put a traverse array then a collect currentToken
-		// do this by adding traverse then converting currentToken to collect
-
-		op := &Operation{OperationType: traverseArrayOpType, StringValue: "TRAVERSE_ARRAY"}
-		postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
-
-		currentToken = &token{TokenType: openCollect}
-
-	}
-
-	if index != len(tokens)-1 && currentToken.AssignOperation != nil &&
-		tokens[index+1].TokenType == operationToken &&
-		tokens[index+1].Operation.OperationType == assignOpType {
-		currentToken.Operation = currentToken.AssignOperation
-		currentToken.Operation.UpdateAssign = tokens[index+1].Operation.UpdateAssign
-		skipNextToken = true
-	}
-
-	postProcessedTokens = append(postProcessedTokens, currentToken)
-
-	if index != len(tokens)-1 && currentToken.CheckForPostTraverse &&
-		tokens[index+1].TokenType == operationToken &&
-		tokens[index+1].Operation.OperationType == traversePathOpType {
-		op := &Operation{OperationType: shortPipeOpType, Value: "PIPE"}
-		postProcessedTokens = append(postProcessedTokens, &token{TokenType: operationToken, Operation: op})
-	}
-	if index != len(tokens)-1 && currentToken.CheckForPostTraverse &&
-		tokens[index+1].TokenType == openCollect {
-
-		op := &Operation{OperationType: shortPipeOpType, Value: "PIPE"}
-		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
@@ -1,5 +1,3 @@
-// Use the top level Evaluator or StreamEvaluator to evaluate expressions and return matches.
-//
 package yqlib

 import (
@@ -13,85 +11,84 @@ import (

 var log = logging.MustGetLogger("yq-lib")

-type operationType struct {
+type OperationType struct {
 	Type       string
 	NumArgs    uint // number of arguments to the op
 	Precedence uint
-	Handler    operatorHandler
+	Handler    OperatorHandler
 }

 // operators TODO:
+// - cookbook doc for common things
 // - mergeEmpty (sets only if the document is empty, do I do that now?)

-var orOpType = &operationType{Type: "OR", NumArgs: 2, Precedence: 20, Handler: orOperator}
-var andOpType = &operationType{Type: "AND", NumArgs: 2, Precedence: 20, Handler: andOperator}
+var Or = &OperationType{Type: "OR", NumArgs: 2, Precedence: 20, Handler: OrOperator}
+var And = &OperationType{Type: "AND", NumArgs: 2, Precedence: 20, Handler: AndOperator}

-var unionOpType = &operationType{Type: "UNION", NumArgs: 2, Precedence: 10, Handler: unionOperator}
+var Union = &OperationType{Type: "UNION", NumArgs: 2, Precedence: 10, Handler: UnionOperator}

-var pipeOpType = &operationType{Type: "PIPE", NumArgs: 2, Precedence: 30, Handler: pipeOperator}
+var Pipe = &OperationType{Type: "PIPE", NumArgs: 2, Precedence: 30, Handler: PipeOperator}

-var assignOpType = &operationType{Type: "ASSIGN", NumArgs: 2, Precedence: 40, Handler: assignUpdateOperator}
-var addAssignOpType = &operationType{Type: "ADD_ASSIGN", NumArgs: 2, Precedence: 40, Handler: addAssignOperator}
+var Assign = &OperationType{Type: "ASSIGN", NumArgs: 2, Precedence: 40, Handler: AssignUpdateOperator}
+var AddAssign = &OperationType{Type: "ADD_ASSIGN", NumArgs: 2, Precedence: 40, Handler: AddAssignOperator}

-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 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}
-var assignAliasOpType = &operationType{Type: "ASSIGN_ALIAS", NumArgs: 2, Precedence: 40, Handler: assignAliasOperator}
+var AssignAttributes = &OperationType{Type: "ASSIGN_ATTRIBUTES", NumArgs: 2, Precedence: 40, Handler: AssignAttributesOperator}
+var AssignStyle = &OperationType{Type: "ASSIGN_STYLE", NumArgs: 2, Precedence: 40, Handler: AssignStyleOperator}
+var AssignTag = &OperationType{Type: "ASSIGN_TAG", NumArgs: 2, Precedence: 40, Handler: AssignTagOperator}
+var AssignComment = &OperationType{Type: "ASSIGN_COMMENT", NumArgs: 2, Precedence: 40, Handler: AssignCommentsOperator}
+var AssignAnchor = &OperationType{Type: "ASSIGN_ANCHOR", NumArgs: 2, Precedence: 40, Handler: AssignAnchorOperator}
+var AssignAlias = &OperationType{Type: "ASSIGN_ALIAS", NumArgs: 2, Precedence: 40, Handler: AssignAliasOperator}

-var multiplyOpType = &operationType{Type: "MULTIPLY", NumArgs: 2, Precedence: 45, Handler: multiplyOperator}
-var addOpType = &operationType{Type: "ADD", NumArgs: 2, Precedence: 45, Handler: addOperator}
-var alternativeOpType = &operationType{Type: "ALTERNATIVE", NumArgs: 2, Precedence: 45, Handler: alternativeOperator}
+var Multiply = &OperationType{Type: "MULTIPLY", NumArgs: 2, Precedence: 45, Handler: MultiplyOperator}
+var Add = &OperationType{Type: "ADD", NumArgs: 2, Precedence: 45, Handler: AddOperator}
+var Alternative = &OperationType{Type: "ALTERNATIVE", NumArgs: 2, Precedence: 45, Handler: AlternativeOperator}

-var equalsOpType = &operationType{Type: "EQUALS", NumArgs: 2, Precedence: 40, Handler: equalsOperator}
-var createMapOpType = &operationType{Type: "CREATE_MAP", NumArgs: 2, Precedence: 40, Handler: createMapOperator}
+var Equals = &OperationType{Type: "EQUALS", NumArgs: 2, Precedence: 40, Handler: EqualsOperator}
+var CreateMap = &OperationType{Type: "CREATE_MAP", NumArgs: 2, Precedence: 40, Handler: CreateMapOperator}

-var shortPipeOpType = &operationType{Type: "SHORT_PIPE", NumArgs: 2, Precedence: 45, Handler: pipeOperator}
+var ShortPipe = &OperationType{Type: "SHORT_PIPE", NumArgs: 2, Precedence: 45, Handler: PipeOperator}

-var lengthOpType = &operationType{Type: "LENGTH", NumArgs: 0, Precedence: 50, Handler: lengthOperator}
-var collectOpType = &operationType{Type: "COLLECT", NumArgs: 0, Precedence: 50, Handler: collectOperator}
-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}
-var getAnchorOpType = &operationType{Type: "GET_ANCHOR", NumArgs: 0, Precedence: 50, Handler: getAnchorOperator}
-var getAliasOptype = &operationType{Type: "GET_ALIAS", NumArgs: 0, Precedence: 50, Handler: getAliasOperator}
-var getDocumentIndexOpType = &operationType{Type: "GET_DOCUMENT_INDEX", NumArgs: 0, Precedence: 50, Handler: getDocumentIndexOperator}
-var getFilenameOpType = &operationType{Type: "GET_FILENAME", NumArgs: 0, Precedence: 50, Handler: getFilenameOperator}
-var getFileIndexOpType = &operationType{Type: "GET_FILE_INDEX", NumArgs: 0, Precedence: 50, Handler: getFileIndexOperator}
-var getPathOpType = &operationType{Type: "GET_PATH", NumArgs: 0, Precedence: 50, Handler: getPathOperator}
+var Length = &OperationType{Type: "LENGTH", NumArgs: 0, Precedence: 50, Handler: LengthOperator}
+var Collect = &OperationType{Type: "COLLECT", NumArgs: 0, Precedence: 50, Handler: CollectOperator}
+var GetStyle = &OperationType{Type: "GET_STYLE", NumArgs: 0, Precedence: 50, Handler: GetStyleOperator}
+var GetTag = &OperationType{Type: "GET_TAG", NumArgs: 0, Precedence: 50, Handler: GetTagOperator}
+var GetComment = &OperationType{Type: "GET_COMMENT", NumArgs: 0, Precedence: 50, Handler: GetCommentsOperator}
+var GetAnchor = &OperationType{Type: "GET_ANCHOR", NumArgs: 0, Precedence: 50, Handler: GetAnchorOperator}
+var GetAlias = &OperationType{Type: "GET_ALIAS", NumArgs: 0, Precedence: 50, Handler: GetAliasOperator}
+var GetDocumentIndex = &OperationType{Type: "GET_DOCUMENT_INDEX", NumArgs: 0, Precedence: 50, Handler: GetDocumentIndexOperator}
+var GetFilename = &OperationType{Type: "GET_FILENAME", NumArgs: 0, Precedence: 50, Handler: GetFilenameOperator}
+var GetFileIndex = &OperationType{Type: "GET_FILE_INDEX", NumArgs: 0, Precedence: 50, Handler: GetFileIndexOperator}
+var GetPath = &OperationType{Type: "GET_PATH", NumArgs: 0, Precedence: 50, Handler: GetPathOperator}

-var explodeOpType = &operationType{Type: "EXPLODE", NumArgs: 1, Precedence: 50, Handler: explodeOperator}
-var sortKeysOpType = &operationType{Type: "SORT_KEYS", NumArgs: 1, Precedence: 50, Handler: sortKeysOperator}
+var Explode = &OperationType{Type: "EXPLODE", NumArgs: 1, Precedence: 50, Handler: ExplodeOperator}
+var SortKeys = &OperationType{Type: "SORT_KEYS", NumArgs: 1, Precedence: 50, Handler: SortKeysOperator}

-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 CollectObject = &OperationType{Type: "COLLECT_OBJECT", NumArgs: 0, Precedence: 50, Handler: CollectObjectOperator}
+var TraversePath = &OperationType{Type: "TRAVERSE_PATH", NumArgs: 0, Precedence: 50, Handler: TraversePathOperator}
+var TraverseArray = &OperationType{Type: "TRAVERSE_ARRAY", NumArgs: 1, Precedence: 50, Handler: TraverseArrayOperator}

-var documentFilterOpType = &operationType{Type: "DOCUMENT_FILTER", NumArgs: 0, Precedence: 50, Handler: traversePathOperator}
-var selfReferenceOpType = &operationType{Type: "SELF", NumArgs: 0, Precedence: 50, 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 DocumentFilter = &OperationType{Type: "DOCUMENT_FILTER", NumArgs: 0, Precedence: 50, Handler: TraversePathOperator}
+var SelfReference = &OperationType{Type: "SELF", NumArgs: 0, Precedence: 50, Handler: SelfOperator}
+var ValueOp = &OperationType{Type: "VALUE", NumArgs: 0, Precedence: 50, Handler: ValueOperator}
+var Not = &OperationType{Type: "NOT", NumArgs: 0, Precedence: 50, Handler: NotOperator}
+var Empty = &OperationType{Type: "EMPTY", NumArgs: 50, Handler: EmptyOperator}

-var recursiveDescentOpType = &operationType{Type: "RECURSIVE_DESCENT", NumArgs: 0, Precedence: 50, Handler: recursiveDescentOperator}
+var RecursiveDescent = &OperationType{Type: "RECURSIVE_DESCENT", NumArgs: 0, Precedence: 50, Handler: RecursiveDescentOperator}

-var selectOpType = &operationType{Type: "SELECT", NumArgs: 1, Precedence: 50, Handler: selectOperator}
-var hasOpType = &operationType{Type: "HAS", NumArgs: 1, Precedence: 50, Handler: hasOperator}
-var deleteChildOpType = &operationType{Type: "DELETE", NumArgs: 1, Precedence: 40, Handler: deleteChildOperator}
-var deleteImmediateChildOpType = &operationType{Type: "DELETE_IMMEDIATE_CHILD", NumArgs: 1, Precedence: 40, Handler: deleteImmediateChildOperator}
+var Select = &OperationType{Type: "SELECT", NumArgs: 1, Precedence: 50, Handler: SelectOperator}
+var Has = &OperationType{Type: "HAS", NumArgs: 1, Precedence: 50, Handler: HasOperator}
+var DeleteChild = &OperationType{Type: "DELETE", NumArgs: 1, Precedence: 40, Handler: DeleteChildOperator}
+var DeleteImmediateChild = &OperationType{Type: "DELETE_IMMEDIATE_CHILD", NumArgs: 1, Precedence: 40, Handler: DeleteImmediateChildOperator}

 type Operation struct {
-	OperationType *operationType
+	OperationType *OperationType
 	Value         interface{}
 	StringValue   string
 	CandidateNode *CandidateNode // used for Value Path elements
 	Preferences   interface{}
-	UpdateAssign  bool // used for assign ops, when true it means we evaluate the rhs given the lhs
 }

-func createValueOperation(value interface{}, stringValue string) *Operation {
+func CreateValueOperation(value interface{}, stringValue string) *Operation {
 	var node yaml.Node = yaml.Node{Kind: yaml.ScalarNode}
 	node.Value = stringValue

@@ -109,7 +106,7 @@ func createValueOperation(value interface{}, stringValue string) *Operation {
 	}

 	return &Operation{
-		OperationType: valueOpType,
+		OperationType: ValueOp,
 		Value:         value,
 		StringValue:   stringValue,
 		CandidateNode: &CandidateNode{Node: &node},
@@ -118,13 +115,13 @@ func createValueOperation(value interface{}, stringValue string) *Operation {

 // debugging purposes only
 func (p *Operation) toString() string {
-	if p.OperationType == traversePathOpType {
+	if p.OperationType == TraversePath {
 		return fmt.Sprintf("%v", p.Value)
-	} else if p.OperationType == documentFilterOpType {
+	} else if p.OperationType == DocumentFilter {
 		return fmt.Sprintf("d%v", p.Value)
-	} else if p.OperationType == selfReferenceOpType {
+	} else if p.OperationType == SelfReference {
 		return "SELF"
-	} else if p.OperationType == valueOpType {
+	} else if p.OperationType == ValueOp {
 		return fmt.Sprintf("%v (%T)", p.Value, p.Value)
 	} else {
 		return fmt.Sprintf("%v", p.OperationType.Type)
--- a/pkg/yqlib/matchKeyString.go
+++ b/pkg/yqlib/matchKeyString.go
@@ -1,6 +1,6 @@
 package yqlib

-func matchKey(name string, pattern string) (matched bool) {
+func Match(name string, pattern string) (matched bool) {
 	if pattern == "" {
 		return name == pattern
 	}
--- a/pkg/yqlib/operator_add.go
+++ b/pkg/yqlib/operator_add.go
@@ -4,22 +4,21 @@ import (
 	"fmt"

 	"container/list"
-	"strconv"

 	yaml "gopkg.in/yaml.v3"
 )

-func createAddOp(lhs *ExpressionNode, rhs *ExpressionNode) *ExpressionNode {
-	return &ExpressionNode{Operation: &Operation{OperationType: addOpType},
-		Lhs: lhs,
+func createSelfAddOp(rhs *PathTreeNode) *PathTreeNode {
+	return &PathTreeNode{Operation: &Operation{OperationType: Add},
+		Lhs: &PathTreeNode{Operation: &Operation{OperationType: SelfReference}},
 		Rhs: rhs}
 }

-func addAssignOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
-	assignmentOp := &Operation{OperationType: assignOpType}
-	assignmentOp.UpdateAssign = false
+func AddAssignOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+	assignmentOp := &Operation{OperationType: Assign}
+	assignmentOp.Preferences = &AssignOpPreferences{true}

-	assignmentOpNode := &ExpressionNode{Operation: assignmentOp, Lhs: expressionNode.Lhs, Rhs: createAddOp(expressionNode.Lhs, expressionNode.Rhs)}
+	assignmentOpNode := &PathTreeNode{Operation: assignmentOp, Lhs: pathNode.Lhs, Rhs: createSelfAddOp(pathNode.Rhs)}
 	return d.GetMatchingNodes(matchingNodes, assignmentOpNode)
 }

@@ -37,17 +36,22 @@ func toNodes(candidate *CandidateNode) []*yaml.Node {

 }

-func addOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func AddOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("Add operator")

-	return crossFunction(d, matchingNodes, expressionNode, add)
+	return crossFunction(d, matchingNodes, pathNode, add)
 }

 func add(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
-	lhs.Node = unwrapDoc(lhs.Node)
-	rhs.Node = unwrapDoc(rhs.Node)
+	lhs.Node = UnwrapDoc(lhs.Node)
+	rhs.Node = UnwrapDoc(rhs.Node)

-	target := lhs.CreateChild(nil, &yaml.Node{})
+	target := &CandidateNode{
+		Path:     lhs.Path,
+		Document: lhs.Document,
+		Filename: lhs.Filename,
+		Node:     &yaml.Node{},
+	}
 	lhsNode := lhs.Node

 	switch lhsNode.Kind {
@@ -59,48 +63,7 @@ func add(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*Candida
 		target.Node.Tag = "!!seq"
 		target.Node.Content = append(lhsNode.Content, toNodes(rhs)...)
 	case yaml.ScalarNode:
-		if rhs.Node.Kind != yaml.ScalarNode {
-			return nil, fmt.Errorf("%v (%v) cannot be added to a %v", rhs.Node.Tag, rhs.Path, lhsNode.Tag)
-		}
-		target.Node.Kind = yaml.ScalarNode
-		target.Node.Style = lhsNode.Style
-		return addScalars(target, lhsNode, rhs.Node)
-	}
-
-	return target, nil
-}
-
-func addScalars(target *CandidateNode, lhs *yaml.Node, rhs *yaml.Node) (*CandidateNode, error) {
-
-	if lhs.Tag == "!!str" {
-		target.Node.Tag = "!!str"
-		target.Node.Value = lhs.Value + rhs.Value
-	} else if lhs.Tag == "!!int" && rhs.Tag == "!!int" {
-		lhsNum, err := strconv.Atoi(lhs.Value)
-		if err != nil {
-			return nil, err
-		}
-		rhsNum, err := strconv.Atoi(rhs.Value)
-		if err != nil {
-			return nil, err
-		}
-		sum := lhsNum + rhsNum
-		target.Node.Tag = "!!int"
-		target.Node.Value = fmt.Sprintf("%v", sum)
-	} else if (lhs.Tag == "!!int" || lhs.Tag == "!!float") && (rhs.Tag == "!!int" || rhs.Tag == "!!float") {
-		lhsNum, err := strconv.ParseFloat(lhs.Value, 64)
-		if err != nil {
-			return nil, err
-		}
-		rhsNum, err := strconv.ParseFloat(rhs.Value, 64)
-		if err != nil {
-			return nil, err
-		}
-		sum := lhsNum + rhsNum
-		target.Node.Tag = "!!float"
-		target.Node.Value = fmt.Sprintf("%v", sum)
-	} else {
-		return nil, fmt.Errorf("%v cannot be added to %v", lhs.Tag, rhs.Tag)
+		return nil, fmt.Errorf("Scalars not yet supported for addition")
 	}

 	return target, nil
--- a/pkg/yqlib/operator_add_test.go
+++ b/pkg/yqlib/operator_add_test.go
@@ -38,11 +38,11 @@ var addOperatorScenarios = []expressionScenario{
 		},
 	},
 	{
-		description: "Add new object to array",
-		document:    `a: [{dog: woof}]`,
-		expression:  `.a + {"cat": "meow"}`,
+		description: "Add object to array",
+		document:    `{a: [1,2], c: {cat: meow}}`,
+		expression:  `.a + .c`,
 		expected: []string{
-			"D0, P[a], (!!seq)::[{dog: woof}, {cat: meow}]\n",
+			"D0, P[a], (!!seq)::[1, 2, {cat: meow}]\n",
 		},
 	},
 	{
@@ -61,48 +61,6 @@ var addOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::{a: [1, 2, 3, 4], b: [3, 4]}\n",
 		},
 	},
-	{
-		description: "String concatenation",
-		document:    `{a: cat, b: meow}`,
-		expression:  `.a = .a + .b`,
-		expected: []string{
-			"D0, P[], (doc)::{a: catmeow, b: meow}\n",
-		},
-	},
-	{
-		description: "Relative string concatenation",
-		document:    `{a: cat, b: meow}`,
-		expression:  `.a += .b`,
-		expected: []string{
-			"D0, P[], (doc)::{a: catmeow, b: meow}\n",
-		},
-	},
-	{
-		description:    "Number addition - float",
-		subdescription: "If the lhs or rhs are floats then the expression will be calculated with floats.",
-		document:       `{a: 3, b: 4.9}`,
-		expression:     `.a = .a + .b`,
-		expected: []string{
-			"D0, P[], (doc)::{a: 7.9, b: 4.9}\n",
-		},
-	},
-	{
-		description:    "Number addition - int",
-		subdescription: "If both the lhs and rhs are ints then the expression will be calculated with ints.",
-		document:       `{a: 3, b: 4}`,
-		expression:     `.a = .a + .b`,
-		expected: []string{
-			"D0, P[], (doc)::{a: 7, b: 4}\n",
-		},
-	},
-	{
-		description: "Increment number",
-		document:    `{a: 3}`,
-		expression:  `.a += 1`,
-		expected: []string{
-			"D0, P[], (doc)::{a: 4}\n",
-		},
-	},
 }

 func TestAddOperatorScenarios(t *testing.T) {
--- a/pkg/yqlib/operator_alternative.go
+++ b/pkg/yqlib/operator_alternative.go
@@ -7,14 +7,14 @@ import (
 // corssFunction no matches
 // can boolean use crossfunction

-func alternativeOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func AlternativeOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- alternative")
-	return crossFunction(d, matchingNodes, expressionNode, alternativeFunc)
+	return crossFunction(d, matchingNodes, pathNode, alternativeFunc)
 }

 func alternativeFunc(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
-	lhs.Node = unwrapDoc(lhs.Node)
-	rhs.Node = unwrapDoc(rhs.Node)
+	lhs.Node = UnwrapDoc(lhs.Node)
+	rhs.Node = UnwrapDoc(rhs.Node)
 	log.Debugf("Alternative LHS: %v", lhs.Node.Tag)
 	log.Debugf("-          RHS: %v", rhs.Node.Tag)

--- a/pkg/yqlib/operator_anchors_aliases.go
+++ b/pkg/yqlib/operator_anchors_aliases.go
@@ -3,25 +3,23 @@ package yqlib
 import (
 	"container/list"

-	yaml "gopkg.in/yaml.v3"
+	"gopkg.in/yaml.v3"
 )

-func assignAliasOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func AssignAliasOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {

 	log.Debugf("AssignAlias operator!")

+	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+	if err != nil {
+		return nil, err
+	}
 	aliasName := ""
-	if !expressionNode.Operation.UpdateAssign {
-		rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
-		if err != nil {
-			return nil, err
-		}
-		if rhs.Front() != nil {
-			aliasName = rhs.Front().Value.(*CandidateNode).Node.Value
-		}
+	if rhs.Front() != nil {
+		aliasName = rhs.Front().Value.(*CandidateNode).Node.Value
 	}

-	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
+	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)

 	if err != nil {
 		return nil, err
@@ -30,53 +28,39 @@ func assignAliasOperator(d *dataTreeNavigator, matchingNodes *list.List, express
 	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		log.Debugf("Setting aliasName : %v", candidate.GetKey())
-
-		if expressionNode.Operation.UpdateAssign {
-			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
-			if err != nil {
-				return nil, err
-			}
-			if rhs.Front() != nil {
-				aliasName = rhs.Front().Value.(*CandidateNode).Node.Value
-			}
-		}
-
 		candidate.Node.Kind = yaml.AliasNode
 		candidate.Node.Value = aliasName
 	}
 	return matchingNodes, nil
 }

-func getAliasOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func GetAliasOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("GetAlias operator!")
 	var results = list.New()

 	for el := matchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		node := &yaml.Node{Kind: yaml.ScalarNode, Value: candidate.Node.Value, Tag: "!!str"}
-		result := candidate.CreateChild(nil, node)
-		results.PushBack(result)
+		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		results.PushBack(lengthCand)
 	}
 	return results, nil
 }

-func assignAnchorOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func AssignAnchorOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {

 	log.Debugf("AssignAnchor operator!")

+	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+	if err != nil {
+		return nil, err
+	}
 	anchorName := ""
-	if !expressionNode.Operation.UpdateAssign {
-		rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
-		if err != nil {
-			return nil, err
-		}
-
-		if rhs.Front() != nil {
-			anchorName = rhs.Front().Value.(*CandidateNode).Node.Value
-		}
+	if rhs.Front() != nil {
+		anchorName = rhs.Front().Value.(*CandidateNode).Node.Value
 	}

-	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
+	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)

 	if err != nil {
 		return nil, err
@@ -85,24 +69,12 @@ func assignAnchorOperator(d *dataTreeNavigator, matchingNodes *list.List, expres
 	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		log.Debugf("Setting anchorName of : %v", candidate.GetKey())
-
-		if expressionNode.Operation.UpdateAssign {
-			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
-			if err != nil {
-				return nil, err
-			}
-
-			if rhs.Front() != nil {
-				anchorName = rhs.Front().Value.(*CandidateNode).Node.Value
-			}
-		}
-
 		candidate.Node.Anchor = anchorName
 	}
 	return matchingNodes, nil
 }

-func getAnchorOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func GetAnchorOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("GetAnchor operator!")
 	var results = list.New()

@@ -110,19 +82,19 @@ func getAnchorOperator(d *dataTreeNavigator, matchingNodes *list.List, expressio
 		candidate := el.Value.(*CandidateNode)
 		anchor := candidate.Node.Anchor
 		node := &yaml.Node{Kind: yaml.ScalarNode, Value: anchor, Tag: "!!str"}
-		result := candidate.CreateChild(nil, node)
-		results.PushBack(result)
+		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		results.PushBack(lengthCand)
 	}
 	return results, nil
 }

-func explodeOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func ExplodeOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- ExplodeOperation")

 	for el := matchMap.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)

-		rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
+		rhs, err := d.GetMatchingNodes(nodeToMap(candidate), pathNode.Rhs)

 		if err != nil {
 			return nil, err
--- a/pkg/yqlib/operator_anchors_aliases_test.go
+++ b/pkg/yqlib/operator_anchors_aliases_test.go
@@ -21,14 +21,6 @@ var anchorOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::a: &foobar cat\n",
 		},
 	},
-	{
-		description: "Set anchor relatively using assign-update",
-		document:    `a: {b: cat}`,
-		expression:  `.a anchor |= .b`,
-		expected: []string{
-			"D0, P[], (doc)::a: &cat {b: cat}\n",
-		},
-	},
 	{
 		description: "Get alias",
 		document:    `{b: &billyBob meow, a: *billyBob}`,
@@ -45,14 +37,6 @@ var anchorOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::{b: &meow purr, a: *meow}\n",
 		},
 	},
-	{
-		description: "Set alias relatively using assign-update",
-		document:    `{b: &meow purr, a: {f: meow}}`,
-		expression:  `.a alias |= .f`,
-		expected: []string{
-			"D0, P[], (doc)::{b: &meow purr, a: *meow}\n",
-		},
-	},
 	{
 		description: "Explode alias and anchor",
 		document:    `{f : {a: &a cat, b: *a}}`,
--- a/pkg/yqlib/operator_assign.go
+++ b/pkg/yqlib/operator_assign.go
@@ -2,21 +2,27 @@ package yqlib

 import "container/list"

-func assignUpdateOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
-	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
+type AssignOpPreferences struct {
+	UpdateAssign bool
+}
+
+func AssignUpdateOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
 	if err != nil {
 		return nil, err
 	}
+	preferences := pathNode.Operation.Preferences.(*AssignOpPreferences)
+
 	var rhs *list.List
-	if !expressionNode.Operation.UpdateAssign {
-		rhs, err = d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
+	if !preferences.UpdateAssign {
+		rhs, err = d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
 	}

 	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)

-		if expressionNode.Operation.UpdateAssign {
-			rhs, err = d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
+		if preferences.UpdateAssign {
+			rhs, err = d.GetMatchingNodes(nodeToMap(candidate), pathNode.Rhs)
 		}

 		if err != nil {
@@ -27,25 +33,27 @@ func assignUpdateOperator(d *dataTreeNavigator, matchingNodes *list.List, expres
 		first := rhs.Front()

 		if first != nil {
-			rhsCandidate := first.Value.(*CandidateNode)
-			rhsCandidate.Node = unwrapDoc(rhsCandidate.Node)
-			candidate.UpdateFrom(rhsCandidate)
+			candidate.UpdateFrom(first.Value.(*CandidateNode))
 		}
 	}
-
+	// // if there was nothing given, perhaps we are creating a new yaml doc
+	// if matchingNodes.Len() == 0 {
+	// 	log.Debug("started with nothing, returning LHS, %v", lhs.Len())
+	// 	return lhs, nil
+	// }
 	return matchingNodes, nil
 }

 // does not update content or values
-func assignAttributesOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
-	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
+func AssignAttributesOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
 	if err != nil {
 		return nil, err
 	}
 	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)

-		rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
+		rhs, err := d.GetMatchingNodes(nodeToMap(candidate), pathNode.Rhs)

 		if err != nil {
 			return nil, err
--- a/pkg/yqlib/operator_assign_test.go
+++ b/pkg/yqlib/operator_assign_test.go
@@ -20,16 +20,6 @@ var assignOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::{a: {g: foof}}\n",
 		},
 	},
-	{
-		description:    "Update node from another file",
-		subdescription: "Note this will also work when the second file is a scalar (string/number)",
-		document:       `{a: apples}`,
-		document2:      "{b: bob}",
-		expression:     `select(fileIndex==0).a = select(fileIndex==1) | select(fileIndex==0)`,
-		expected: []string{
-			"D0, P[], (doc)::{a: {b: bob}}\n",
-		},
-	},
 	{
 		description: "Update node to be the sibling value",
 		document:    `{a: {b: child}, b: sibling}`,
--- a/pkg/yqlib/operator_booleans.go
+++ b/pkg/yqlib/operator_booleans.go
@@ -7,7 +7,7 @@ import (
 )

 func isTruthy(c *CandidateNode) (bool, error) {
-	node := unwrapDoc(c.Node)
+	node := UnwrapDoc(c.Node)
 	value := true

 	if node.Tag == "!!null" {
@@ -27,8 +27,8 @@ type boolOp func(bool, bool) bool

 func performBoolOp(op boolOp) func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
 	return func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
-		lhs.Node = unwrapDoc(lhs.Node)
-		rhs.Node = unwrapDoc(rhs.Node)
+		lhs.Node = UnwrapDoc(lhs.Node)
+		rhs.Node = UnwrapDoc(rhs.Node)

 		lhsTrue, errDecoding := isTruthy(lhs)
 		if errDecoding != nil {
@@ -44,23 +44,23 @@ func performBoolOp(op boolOp) func(d *dataTreeNavigator, lhs *CandidateNode, rhs
 	}
 }

-func orOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func OrOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- orOp")
-	return crossFunction(d, matchingNodes, expressionNode, performBoolOp(
+	return crossFunction(d, matchingNodes, pathNode, performBoolOp(
 		func(b1 bool, b2 bool) bool {
 			return b1 || b2
 		}))
 }

-func andOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func AndOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- AndOp")
-	return crossFunction(d, matchingNodes, expressionNode, performBoolOp(
+	return crossFunction(d, matchingNodes, pathNode, performBoolOp(
 		func(b1 bool, b2 bool) bool {
 			return b1 && b2
 		}))
 }

-func notOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func NotOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- notOperation")
 	var results = list.New()

--- a/pkg/yqlib/operator_collect.go
+++ b/pkg/yqlib/operator_collect.go
@@ -6,7 +6,7 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )

-func collectOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func CollectOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- collectOperation")

 	if matchMap.Len() == 0 {
@@ -18,22 +18,21 @@ func collectOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *
 	var results = list.New()

 	node := &yaml.Node{Kind: yaml.SequenceNode, Tag: "!!seq"}
-	var collectC *CandidateNode
-	if matchMap.Front() != nil {
-		collectC = matchMap.Front().Value.(*CandidateNode).CreateChild(nil, node)
-		if len(collectC.Path) > 0 {
-			collectC.Path = collectC.Path[:len(collectC.Path)-1]
-		}
-	} else {
-		collectC = &CandidateNode{Node: node}
-	}
+
+	var document uint = 0
+	var path []interface{}

 	for el := matchMap.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		log.Debugf("Collecting %v", NodeToString(candidate))
-		node.Content = append(node.Content, unwrapDoc(candidate.Node))
+		if path == nil && candidate.Path != nil && len(candidate.Path) > 1 {
+			path = candidate.Path[:len(candidate.Path)-1]
+			document = candidate.Document
+		}
+		node.Content = append(node.Content, candidate.Node)
 	}

+	collectC := &CandidateNode{Node: node, Document: document, Path: path}
 	results.PushBack(collectC)

 	return results, nil
--- a/pkg/yqlib/operator_collect_object.go
+++ b/pkg/yqlib/operator_collect_object.go
@@ -17,7 +17,7 @@ import (
 ...
 */

-func collectObjectOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func CollectObjectOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- collectObjectOperation")

 	if matchMap.Len() == 0 {
@@ -35,7 +35,7 @@ func collectObjectOperator(d *dataTreeNavigator, matchMap *list.List, expression
 	for el := matchMap.Front(); el != nil; el = el.Next() {
 		candidateNode := el.Value.(*CandidateNode)
 		for i := 0; i < len(first.Node.Content); i++ {
-			rotated[i].PushBack(candidateNode.CreateChild(i, candidateNode.Node.Content[i]))
+			rotated[i].PushBack(createChildCandidate(candidateNode, i))
 		}
 	}

@@ -52,15 +52,22 @@ func collectObjectOperator(d *dataTreeNavigator, matchMap *list.List, expression

 }

+func createChildCandidate(candidate *CandidateNode, index int) *CandidateNode {
+	return &CandidateNode{
+		Document: candidate.Document,
+		Path:     candidate.CreateChildPath(index),
+		Filename: candidate.Filename,
+		Node:     candidate.Node.Content[index],
+	}
+}
+
 func collect(d *dataTreeNavigator, aggregate *list.List, remainingMatches *list.List) (*list.List, error) {
 	if remainingMatches.Len() == 0 {
 		return aggregate, nil
 	}

 	candidate := remainingMatches.Remove(remainingMatches.Front()).(*CandidateNode)
-
-	splatted, err := splat(d, nodeToMap(candidate),
-		&traversePreferences{FollowAlias: false, IncludeMapKeys: false})
+	splatted, err := Splat(d, nodeToMap(candidate))

 	for splatEl := splatted.Front(); splatEl != nil; splatEl = splatEl.Next() {
 		splatEl.Value.(*CandidateNode).Path = nil
@@ -87,7 +94,7 @@ func collect(d *dataTreeNavigator, aggregate *list.List, remainingMatches *list.

 			newCandidate.Path = nil

-			newCandidate, err = multiply(&multiplyPreferences{AppendArrays: false})(d, newCandidate, splatCandidate)
+			newCandidate, err = multiply(&MultiplyPreferences{AppendArrays: false})(d, newCandidate, splatCandidate)
 			if err != nil {
 				return nil, err
 			}
--- a/pkg/yqlib/operator_collect_object_test.go
+++ b/pkg/yqlib/operator_collect_object_test.go
@@ -110,5 +110,5 @@ func TestCollectObjectOperatorScenarios(t *testing.T) {
 	for _, tt := range collectObjectOperatorScenarios {
 		testScenario(t, &tt)
 	}
-	documentScenarios(t, "Create, Collect into Object", collectObjectOperatorScenarios)
+	documentScenarios(t, "Collect into Object", collectObjectOperatorScenarios)
 }
--- a/pkg/yqlib/operator_collect_test.go
+++ b/pkg/yqlib/operator_collect_test.go
@@ -13,15 +13,6 @@ var collectOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!seq)::[]\n",
 		},
 	},
-	{
-		skipDoc:  true,
-		document: "{a: apple}\n---\n{b: frog}",
-
-		expression: `[.]`,
-		expected: []string{
-			"D0, P[], (!!seq)::- {a: apple}\n- {b: frog}\n",
-		},
-	},
 	{
 		skipDoc:    true,
 		document:   ``,
--- a/pkg/yqlib/operator_comments.go
+++ b/pkg/yqlib/operator_comments.go
@@ -4,53 +4,38 @@ import (
 	"container/list"
 	"strings"

-	yaml "gopkg.in/yaml.v3"
+	"gopkg.in/yaml.v3"
 )

-type commentOpPreferences struct {
+type CommentOpPreferences struct {
 	LineComment bool
 	HeadComment bool
 	FootComment bool
 }

-func assignCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func AssignCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {

 	log.Debugf("AssignComments operator!")

-	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
+	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+	if err != nil {
+		return nil, err
+	}
+	comment := ""
+	if rhs.Front() != nil {
+		comment = rhs.Front().Value.(*CandidateNode).Node.Value
+	}
+
+	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)

 	if err != nil {
 		return nil, err
 	}

-	preferences := expressionNode.Operation.Preferences.(*commentOpPreferences)
-
-	comment := ""
-	if !expressionNode.Operation.UpdateAssign {
-		rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
-		if err != nil {
-			return nil, err
-		}
-
-		if rhs.Front() != nil {
-			comment = rhs.Front().Value.(*CandidateNode).Node.Value
-		}
-	}
+	preferences := pathNode.Operation.Preferences.(*CommentOpPreferences)

 	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
-
-		if expressionNode.Operation.UpdateAssign {
-			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
-			if err != nil {
-				return nil, err
-			}
-
-			if rhs.Front() != nil {
-				comment = rhs.Front().Value.(*CandidateNode).Node.Value
-			}
-		}
-
 		log.Debugf("Setting comment of : %v", candidate.GetKey())
 		if preferences.LineComment {
 			candidate.Node.LineComment = comment
@@ -66,8 +51,8 @@ func assignCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, expr
 	return matchingNodes, nil
 }

-func getCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
-	preferences := expressionNode.Operation.Preferences.(*commentOpPreferences)
+func GetCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+	preferences := pathNode.Operation.Preferences.(*CommentOpPreferences)
 	log.Debugf("GetComments operator!")
 	var results = list.New()

@@ -84,8 +69,8 @@ func getCommentsOperator(d *dataTreeNavigator, matchingNodes *list.List, express
 		comment = strings.Replace(comment, "# ", "", 1)

 		node := &yaml.Node{Kind: yaml.ScalarNode, Value: comment, Tag: "!!str"}
-		result := candidate.CreateChild(nil, node)
-		results.PushBack(result)
+		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		results.PushBack(lengthCand)
 	}
 	return results, nil
 }
--- a/pkg/yqlib/operator_comments_test.go
+++ b/pkg/yqlib/operator_comments_test.go
@@ -13,39 +13,6 @@ var commentOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::a: cat # single\n",
 		},
 	},
-	{
-		skipDoc:    true,
-		document:   "a: cat\nb: dog",
-		expression: `.a lineComment=.b`,
-		expected: []string{
-			"D0, P[], (doc)::a: cat # dog\nb: dog\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   "a: cat\n---\na: dog",
-		expression: `.a lineComment |= documentIndex`,
-		expected: []string{
-			"D0, P[], (doc)::a: cat # 0\n",
-			"D1, P[], (doc)::a: dog # 1\n",
-		},
-	},
-	{
-		description: "Use update assign to perform relative updates",
-		document:    "a: cat\nb: dog",
-		expression:  `.. lineComment |= .`,
-		expected: []string{
-			"D0, P[], (!!map)::a: cat # cat\nb: dog # dog\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   "a: cat\nb: dog",
-		expression: `.. comments |= .`,
-		expected: []string{
-			"D0, P[], (!!map)::a: cat # cat\n# cat\n\n# cat\nb: dog # dog\n# dog\n\n# dog\n",
-		},
-	},
 	{
 		description: "Set head comment",
 		document:    `a: cat`,
--- a/pkg/yqlib/operator_create_map.go
+++ b/pkg/yqlib/operator_create_map.go
@@ -6,7 +6,7 @@ import (
 	"gopkg.in/yaml.v3"
 )

-func createMapOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func CreateMapOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- createMapOperation")

 	//each matchingNodes entry should turn into a sequence of keys to create.
@@ -22,14 +22,14 @@ func createMapOperator(d *dataTreeNavigator, matchingNodes *list.List, expressio

 		for matchingNodeEl := matchingNodes.Front(); matchingNodeEl != nil; matchingNodeEl = matchingNodeEl.Next() {
 			matchingNode := matchingNodeEl.Value.(*CandidateNode)
-			sequenceNode, err := sequenceFor(d, matchingNode, expressionNode)
+			sequenceNode, err := sequenceFor(d, matchingNode, pathNode)
 			if err != nil {
 				return nil, err
 			}
 			sequences.PushBack(sequenceNode)
 		}
 	} else {
-		sequenceNode, err := sequenceFor(d, nil, expressionNode)
+		sequenceNode, err := sequenceFor(d, nil, pathNode)
 		if err != nil {
 			return nil, err
 		}
@@ -40,7 +40,7 @@ func createMapOperator(d *dataTreeNavigator, matchingNodes *list.List, expressio

 }

-func sequenceFor(d *dataTreeNavigator, matchingNode *CandidateNode, expressionNode *ExpressionNode) (*CandidateNode, error) {
+func sequenceFor(d *dataTreeNavigator, matchingNode *CandidateNode, pathNode *PathTreeNode) (*CandidateNode, error) {
 	var path []interface{}
 	var document uint = 0
 	var matches = list.New()
@@ -51,14 +51,14 @@ func sequenceFor(d *dataTreeNavigator, matchingNode *CandidateNode, expressionNo
 		matches = nodeToMap(matchingNode)
 	}

-	mapPairs, err := crossFunction(d, matches, expressionNode,
+	mapPairs, err := crossFunction(d, matches, pathNode,
 		func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
 			node := yaml.Node{Kind: yaml.MappingNode, Tag: "!!map"}
 			log.Debugf("LHS:", NodeToString(lhs))
 			log.Debugf("RHS:", NodeToString(rhs))
 			node.Content = []*yaml.Node{
-				unwrapDoc(lhs.Node),
-				unwrapDoc(rhs.Node),
+				UnwrapDoc(lhs.Node),
+				UnwrapDoc(rhs.Node),
 			}

 			return &CandidateNode{Node: &node, Document: document, Path: path}, nil
--- a/pkg/yqlib/operator_delete.go
+++ b/pkg/yqlib/operator_delete.go
@@ -7,9 +7,9 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )

-func deleteChildOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func DeleteChildOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {

-	nodesToDelete, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
+	nodesToDelete, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)

 	if err != nil {
 		return nil, err
@@ -19,11 +19,11 @@ func deleteChildOperator(d *dataTreeNavigator, matchingNodes *list.List, express
 		candidate := el.Value.(*CandidateNode)

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

-		deleteImmediateChildOpNode := &ExpressionNode{
+		deleteImmediateChildOpNode := &PathTreeNode{
 			Operation: deleteImmediateChildOp,
 			Rhs:       createTraversalTree(candidate.Path[0 : len(candidate.Path)-1]),
 		}
@@ -36,20 +36,20 @@ func deleteChildOperator(d *dataTreeNavigator, matchingNodes *list.List, express
 	return matchingNodes, nil
 }

-func deleteImmediateChildOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
-	parents, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
+func DeleteImmediateChildOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+	parents, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)

 	if err != nil {
 		return nil, err
 	}

-	childPath := expressionNode.Operation.Value
+	childPath := pathNode.Operation.Value

 	log.Debug("childPath to remove %v", childPath)

 	for el := parents.Front(); el != nil; el = el.Next() {
 		parent := el.Value.(*CandidateNode)
-		parentNode := unwrapDoc(parent.Node)
+		parentNode := UnwrapDoc(parent.Node)
 		if parentNode.Kind == yaml.MappingNode {
 			deleteFromMap(parent, childPath)
 		} else if parentNode.Kind == yaml.SequenceNode {
@@ -64,7 +64,7 @@ func deleteImmediateChildOperator(d *dataTreeNavigator, matchingNodes *list.List

 func deleteFromMap(candidate *CandidateNode, childPath interface{}) {
 	log.Debug("deleteFromMap")
-	node := unwrapDoc(candidate.Node)
+	node := UnwrapDoc(candidate.Node)
 	contents := node.Content
 	newContents := make([]*yaml.Node, 0)

@@ -72,7 +72,11 @@ func deleteFromMap(candidate *CandidateNode, childPath interface{}) {
 		key := contents[index]
 		value := contents[index+1]

-		childCandidate := candidate.CreateChild(key.Value, value)
+		childCandidate := &CandidateNode{
+			Node:     value,
+			Document: candidate.Document,
+			Path:     candidate.CreateChildPath(key.Value),
+		}

 		shouldDelete := key.Value == childPath

@@ -87,7 +91,7 @@ func deleteFromMap(candidate *CandidateNode, childPath interface{}) {

 func deleteFromArray(candidate *CandidateNode, childPath interface{}) {
 	log.Debug("deleteFromArray")
-	node := unwrapDoc(candidate.Node)
+	node := UnwrapDoc(candidate.Node)
 	contents := node.Content
 	newContents := make([]*yaml.Node, 0)

--- a/pkg/yqlib/operator_delete_test.go
+++ b/pkg/yqlib/operator_delete_test.go
@@ -61,14 +61,6 @@ var deleteOperatorScenarios = []expressionScenario{
 			"D0, P[], (doc)::{b: dog}\n",
 		},
 	},
-	{
-		description: "Recursively delete matching keys",
-		document:    `{a: {name: frog, b: {name: blog, age: 12}}}`,
-		expression:  `del(.. | select(has("name")).name)`,
-		expected: []string{
-			"D0, P[], (!!map)::{a: {b: {age: 12}}}\n",
-		},
-	},
 }

 func TestDeleteOperatorScenarios(t *testing.T) {
--- a/pkg/yqlib/operator_document_index.go
+++ b/pkg/yqlib/operator_document_index.go
@@ -7,13 +7,13 @@ import (
 	"gopkg.in/yaml.v3"
 )

-func getDocumentIndexOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func GetDocumentIndexOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	var results = list.New()

 	for el := matchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		node := &yaml.Node{Kind: yaml.ScalarNode, Value: fmt.Sprintf("%v", candidate.Document), Tag: "!!int"}
-		scalar := candidate.CreateChild(nil, node)
+		scalar := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
 		results.PushBack(scalar)
 	}
 	return results, nil
--- a/pkg/yqlib/operator_document_index_test.go
+++ b/pkg/yqlib/operator_document_index_test.go
@@ -14,27 +14,10 @@ var documentIndexScenarios = []expressionScenario{
 			"D1, P[a], (!!int)::1\n",
 		},
 	},
-	{
-		description: "Retrieve a document index, shorthand",
-		document:    "a: cat\n---\na: frog\n",
-		expression:  `.a | di`,
-		expected: []string{
-			"D0, P[a], (!!int)::0\n",
-			"D1, P[a], (!!int)::1\n",
-		},
-	},
 	{
 		description: "Filter by document index",
 		document:    "a: cat\n---\na: frog\n",
-		expression:  `select(documentIndex == 1)`,
-		expected: []string{
-			"D1, P[], (doc)::a: frog\n",
-		},
-	},
-	{
-		description: "Filter by document index shorthand",
-		document:    "a: cat\n---\na: frog\n",
-		expression:  `select(di == 1)`,
+		expression:  `select(. | documentIndex == 1)`,
 		expected: []string{
 			"D1, P[], (doc)::a: frog\n",
 		},
@@ -42,7 +25,7 @@ var documentIndexScenarios = []expressionScenario{
 	{
 		description: "Print Document Index with matches",
 		document:    "a: cat\n---\na: frog\n",
-		expression:  `.a | ({"match": ., "doc": documentIndex})`,
+		expression:  `.a | ({"match": ., "doc": (. | documentIndex)})`,
 		expected: []string{
 			"D0, P[], (!!map)::match: cat\ndoc: 0\n",
 			"D0, P[], (!!map)::match: frog\ndoc: 1\n",
--- a/pkg/yqlib/operator_env.go
+++ b/pkg/yqlib/operator_env.go
@@ -1,50 +0,0 @@
-package yqlib
-
-import (
-	"container/list"
-	"fmt"
-	"os"
-	"strings"
-
-	yaml "gopkg.in/yaml.v3"
-)
-
-type envOpPreferences struct {
-	StringValue bool
-}
-
-func envOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
-	envName := expressionNode.Operation.CandidateNode.Node.Value
-	log.Debug("EnvOperator, env name:", envName)
-
-	rawValue := os.Getenv(envName)
-
-	preferences := expressionNode.Operation.Preferences.(*envOpPreferences)
-
-	var node *yaml.Node
-	if preferences.StringValue {
-		node = &yaml.Node{
-			Kind:  yaml.ScalarNode,
-			Tag:   "!!str",
-			Value: rawValue,
-		}
-	} else if rawValue == "" {
-		return nil, fmt.Errorf("Value for env variable '%v' not provided in env()", envName)
-	} else {
-		var dataBucket yaml.Node
-		decoder := yaml.NewDecoder(strings.NewReader(rawValue))
-		errorReading := decoder.Decode(&dataBucket)
-		if errorReading != nil {
-			return nil, errorReading
-		}
-		//first node is a doc
-		node = unwrapDoc(&dataBucket)
-	}
-	log.Debug("ENV tag", node.Tag)
-	log.Debug("ENV value", node.Value)
-	log.Debug("ENV Kind", node.Kind)
-
-	target := &CandidateNode{Node: node}
-
-	return nodeToMap(target), nil
-}
--- a/pkg/yqlib/operator_env_test.go
+++ b/pkg/yqlib/operator_env_test.go
@@ -1,72 +0,0 @@
-package yqlib
-
-import (
-	"testing"
-)
-
-var envOperatorScenarios = []expressionScenario{
-	{
-		description:         "Read string environment variable",
-		environmentVariable: "cat meow",
-		expression:          `.a = env(myenv)`,
-		expected: []string{
-			"D0, P[], ()::a: cat meow\n",
-		},
-	},
-	{
-		description:         "Read boolean environment variable",
-		environmentVariable: "true",
-		expression:          `.a = env(myenv)`,
-		expected: []string{
-			"D0, P[], ()::a: true\n",
-		},
-	},
-	{
-		description:         "Read numeric environment variable",
-		environmentVariable: "12",
-		expression:          `.a = env(myenv)`,
-		expected: []string{
-			"D0, P[], ()::a: 12\n",
-		},
-	},
-	{
-		description:         "Read yaml environment variable",
-		environmentVariable: "{b: fish}",
-		expression:          `.a = env(myenv)`,
-		expected: []string{
-			"D0, P[], ()::a: {b: fish}\n",
-		},
-	},
-	{
-		description:         "Read boolean environment variable as a string",
-		environmentVariable: "true",
-		expression:          `.a = strenv(myenv)`,
-		expected: []string{
-			"D0, P[], ()::a: \"true\"\n",
-		},
-	},
-	{
-		description:         "Read numeric environment variable as a string",
-		environmentVariable: "12",
-		expression:          `.a = strenv(myenv)`,
-		expected: []string{
-			"D0, P[], ()::a: \"12\"\n",
-		},
-	},
-	{
-		description:         "Dynamic key lookup with environment variable",
-		environmentVariable: "cat",
-		document:            `{cat: meow, dog: woof}`,
-		expression:          `.[env(myenv)]`,
-		expected: []string{
-			"D0, P[cat], (!!str)::meow\n",
-		},
-	},
-}
-
-func TestEnvOperatorScenarios(t *testing.T) {
-	for _, tt := range envOperatorScenarios {
-		testScenario(t, &tt)
-	}
-	documentScenarios(t, "Env Variable Operators", envOperatorScenarios)
-}
--- a/pkg/yqlib/operator_equals.go
+++ b/pkg/yqlib/operator_equals.go
@@ -4,21 +4,18 @@ import (
 	"container/list"
 )

-func equalsOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func EqualsOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- equalsOperation")
-	return crossFunction(d, matchingNodes, expressionNode, isEquals)
+	return crossFunction(d, matchingNodes, pathNode, isEquals)
 }

 func isEquals(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
 	value := false

-	lhsNode := unwrapDoc(lhs.Node)
-	rhsNode := unwrapDoc(rhs.Node)
-
-	if lhsNode.Tag == "!!null" {
-		value = (rhsNode.Tag == "!!null")
+	if lhs.Node.Tag == "!!null" {
+		value = (rhs.Node.Tag == "!!null")
 	} else {
-		value = matchKey(lhsNode.Value, rhsNode.Value)
+		value = Match(lhs.Node.Value, rhs.Node.Value)
 	}
 	log.Debugf("%v == %v ? %v", NodeToString(lhs), NodeToString(rhs), value)
 	return createBooleanCandidate(lhs, value), nil
--- a/pkg/yqlib/operator_equals_test.go
+++ b/pkg/yqlib/operator_equals_test.go
@@ -5,15 +5,6 @@ import (
 )

 var equalsOperatorScenarios = []expressionScenario{
-	{
-		skipDoc:    true,
-		document:   "cat",
-		document2:  "dog",
-		expression: "select(fi==0) == select(fi==1)",
-		expected: []string{
-			"D0, P[], (!!bool)::false\n",
-		},
-	},
 	{
 		description: "Match string",
 		document:    `[cat,goat,dog]`,
--- a/pkg/yqlib/operator_file.go
+++ b/pkg/yqlib/operator_file.go
@@ -7,7 +7,7 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )

-func getFilenameOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func GetFilenameOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("GetFilename")

 	var results = list.New()
@@ -15,14 +15,14 @@ func getFilenameOperator(d *dataTreeNavigator, matchingNodes *list.List, express
 	for el := matchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		node := &yaml.Node{Kind: yaml.ScalarNode, Value: candidate.Filename, Tag: "!!str"}
-		result := candidate.CreateChild(nil, node)
-		results.PushBack(result)
+		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		results.PushBack(lengthCand)
 	}

 	return results, nil
 }

-func getFileIndexOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func GetFileIndexOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("GetFileIndex")

 	var results = list.New()
@@ -30,8 +30,8 @@ func getFileIndexOperator(d *dataTreeNavigator, matchingNodes *list.List, expres
 	for el := matchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		node := &yaml.Node{Kind: yaml.ScalarNode, Value: fmt.Sprintf("%v", candidate.FileIndex), Tag: "!!int"}
-		result := candidate.CreateChild(nil, node)
-		results.PushBack(result)
+		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		results.PushBack(lengthCand)
 	}

 	return results, nil
--- a/pkg/yqlib/operator_file_test.go
+++ b/pkg/yqlib/operator_file_test.go
@@ -21,22 +21,6 @@ var fileOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!int)::0\n",
 		},
 	},
-	{
-		description: "Get file index alias",
-		document:    `{a: cat}`,
-		expression:  `fi`,
-		expected: []string{
-			"D0, P[], (!!int)::0\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   "a: cat\nb: dog",
-		expression: `.. lineComment |= filename`,
-		expected: []string{
-			"D0, P[], (!!map)::a: cat # sample.yml\nb: dog # sample.yml\n",
-		},
-	},
 }

 func TestFileOperatorsScenarios(t *testing.T) {
--- a/pkg/yqlib/operator_has.go
+++ b/pkg/yqlib/operator_has.go
@@ -7,12 +7,12 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )

-func hasOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func HasOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {

 	log.Debugf("-- hasOperation")
 	var results = list.New()

-	rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
+	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
 	wanted := rhs.Front().Value.(*CandidateNode).Node
 	wantedKey := wanted.Value

@@ -24,9 +24,8 @@ func hasOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode
 		candidate := el.Value.(*CandidateNode)

 		// grab the first value
-		candidateNode := unwrapDoc(candidate.Node)
-		var contents = candidateNode.Content
-		switch candidateNode.Kind {
+		var contents = candidate.Node.Content
+		switch candidate.Node.Kind {
 		case yaml.MappingNode:
 			candidateHasKey := false
 			for index := 0; index < len(contents) && !candidateHasKey; index = index + 2 {
--- a/pkg/yqlib/operator_has_test.go
+++ b/pkg/yqlib/operator_has_test.go
@@ -5,14 +5,6 @@ import (
 )

 var hasOperatorScenarios = []expressionScenario{
-	{
-		skipDoc:    true,
-		document:   `a: hello`,
-		expression: `has("a")`,
-		expected: []string{
-			"D0, P[], (!!bool)::true\n",
-		},
-	},
 	{
 		description: "Has map key",
 		document: `- a: "yes"
--- a/pkg/yqlib/operator_length.go
+++ b/pkg/yqlib/operator_length.go
@@ -7,13 +7,13 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )

-func lengthOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func LengthOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- lengthOperation")
 	var results = list.New()

 	for el := matchMap.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
-		targetNode := unwrapDoc(candidate.Node)
+		targetNode := UnwrapDoc(candidate.Node)
 		var length int
 		switch targetNode.Kind {
 		case yaml.ScalarNode:
@@ -27,8 +27,8 @@ func lengthOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *E
 		}

 		node := &yaml.Node{Kind: yaml.ScalarNode, Value: fmt.Sprintf("%v", length), Tag: "!!int"}
-		result := candidate.CreateChild(nil, node)
-		results.PushBack(result)
+		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		results.PushBack(lengthCand)
 	}

 	return results, nil
--- a/pkg/yqlib/operator_multiply.go
+++ b/pkg/yqlib/operator_multiply.go
@@ -8,16 +8,16 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )

-type crossFunctionCalculation func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error)
+type CrossFunctionCalculation func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error)

-func crossFunction(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode, calculation crossFunctionCalculation) (*list.List, error) {
-	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
+func crossFunction(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode, calculation CrossFunctionCalculation) (*list.List, error) {
+	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
 	if err != nil {
 		return nil, err
 	}
 	log.Debugf("crossFunction LHS len: %v", lhs.Len())

-	rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
+	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)

 	if err != nil {
 		return nil, err
@@ -43,19 +43,19 @@ func crossFunction(d *dataTreeNavigator, matchingNodes *list.List, expressionNod
 	return results, nil
 }

-type multiplyPreferences struct {
+type MultiplyPreferences struct {
 	AppendArrays bool
 }

-func multiplyOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func MultiplyOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- MultiplyOperator")
-	return crossFunction(d, matchingNodes, expressionNode, multiply(expressionNode.Operation.Preferences.(*multiplyPreferences)))
+	return crossFunction(d, matchingNodes, pathNode, multiply(pathNode.Operation.Preferences.(*MultiplyPreferences)))
 }

-func multiply(preferences *multiplyPreferences) func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
+func multiply(preferences *MultiplyPreferences) func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
 	return func(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode) (*CandidateNode, error) {
-		lhs.Node = unwrapDoc(lhs.Node)
-		rhs.Node = unwrapDoc(rhs.Node)
+		lhs.Node = UnwrapDoc(lhs.Node)
+		rhs.Node = UnwrapDoc(rhs.Node)
 		log.Debugf("Multipling LHS: %v", lhs.Node.Tag)
 		log.Debugf("-          RHS: %v", rhs.Node.Tag)

@@ -64,7 +64,12 @@ func multiply(preferences *multiplyPreferences) func(d *dataTreeNavigator, lhs *
 		if lhs.Node.Kind == yaml.MappingNode && rhs.Node.Kind == yaml.MappingNode ||
 			(lhs.Node.Kind == yaml.SequenceNode && rhs.Node.Kind == yaml.SequenceNode) {

-			var newBlank = lhs.CreateChild(nil, &yaml.Node{})
+			var newBlank = &CandidateNode{
+				Path:     lhs.Path,
+				Document: lhs.Document,
+				Filename: lhs.Filename,
+				Node:     &yaml.Node{},
+			}
 			var newThing, err = mergeObjects(d, newBlank, lhs, false)
 			if err != nil {
 				return nil, err
@@ -80,9 +85,7 @@ func mergeObjects(d *dataTreeNavigator, lhs *CandidateNode, rhs *CandidateNode,
 	var results = list.New()

 	// shouldn't recurse arrays if appending
-	prefs := &recursiveDescentPreferences{RecurseArray: !shouldAppendArrays,
-		TraversePreferences: &traversePreferences{FollowAlias: false}}
-	err := recursiveDecent(d, results, nodeToMap(rhs), prefs)
+	err := recursiveDecent(d, results, nodeToMap(rhs), !shouldAppendArrays)
 	if err != nil {
 		return nil, err
 	}
@@ -107,16 +110,16 @@ func applyAssignment(d *dataTreeNavigator, pathIndexToStartFrom int, lhs *Candid

 	lhsPath := rhs.Path[pathIndexToStartFrom:]

-	assignmentOp := &Operation{OperationType: assignAttributesOpType}
+	assignmentOp := &Operation{OperationType: AssignAttributes}
 	if rhs.Node.Kind == yaml.ScalarNode || rhs.Node.Kind == yaml.AliasNode {
-		assignmentOp.OperationType = assignOpType
-		assignmentOp.UpdateAssign = false
+		assignmentOp.OperationType = Assign
+		assignmentOp.Preferences = &AssignOpPreferences{false}
 	} else if shouldAppendArrays && rhs.Node.Kind == yaml.SequenceNode {
-		assignmentOp.OperationType = addAssignOpType
+		assignmentOp.OperationType = AddAssign
 	}
-	rhsOp := &Operation{OperationType: valueOpType, CandidateNode: rhs}
+	rhsOp := &Operation{OperationType: ValueOp, CandidateNode: rhs}

-	assignmentOpNode := &ExpressionNode{Operation: assignmentOp, Lhs: createTraversalTree(lhsPath), Rhs: &ExpressionNode{Operation: rhsOp}}
+	assignmentOpNode := &PathTreeNode{Operation: assignmentOp, Lhs: createTraversalTree(lhsPath), Rhs: &PathTreeNode{Operation: rhsOp}}

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

--- a/pkg/yqlib/operator_multiply_test.go
+++ b/pkg/yqlib/operator_multiply_test.go
@@ -132,11 +132,11 @@ b:
 		},
 	},
 	{
-		description: "Merge copies anchor names",
+		description: "Merge does not copy anchor names",
 		document:    `{a: {c: &cat frog}, b: {f: *cat}, c: {g: thongs}}`,
 		expression:  `.c * .a`,
 		expected: []string{
-			"D0, P[c], (!!map)::{g: thongs, c: &cat frog}\n",
+			"D0, P[c], (!!map)::{g: thongs, c: frog}\n",
 		},
 	},
 	{
--- a/pkg/yqlib/operator_path.go
+++ b/pkg/yqlib/operator_path.go
@@ -16,7 +16,7 @@ func createPathNodeFor(pathElement interface{}) *yaml.Node {
 	}
 }

-func getPathOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func GetPathOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("GetPath")

 	var results = list.New()
@@ -31,8 +31,8 @@ func getPathOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionN
 			content[pathIndex] = createPathNodeFor(path)
 		}
 		node.Content = content
-		result := candidate.CreateChild(nil, node)
-		results.PushBack(result)
+		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		results.PushBack(lengthCand)
 	}

 	return results, nil
--- a/pkg/yqlib/operator_pipe.go
+++ b/pkg/yqlib/operator_pipe.go
@@ -2,10 +2,10 @@ package yqlib

 import "container/list"

-func pipeOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
-	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
+func PipeOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
 	if err != nil {
 		return nil, err
 	}
-	return d.GetMatchingNodes(lhs, expressionNode.Rhs)
+	return d.GetMatchingNodes(lhs, pathNode.Rhs)
 }
--- a/pkg/yqlib/operator_recursive_descent.go
+++ b/pkg/yqlib/operator_recursive_descent.go
@@ -6,16 +6,10 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )

-type recursiveDescentPreferences struct {
-	TraversePreferences *traversePreferences
-	RecurseArray        bool
-}
-
-func recursiveDescentOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func RecursiveDescentOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	var results = list.New()

-	preferences := expressionNode.Operation.Preferences.(*recursiveDescentPreferences)
-	err := recursiveDecent(d, results, matchMap, preferences)
+	err := recursiveDecent(d, results, matchMap, true)
 	if err != nil {
 		return nil, err
 	}
@@ -23,24 +17,24 @@ func recursiveDescentOperator(d *dataTreeNavigator, matchMap *list.List, express
 	return results, nil
 }

-func recursiveDecent(d *dataTreeNavigator, results *list.List, matchMap *list.List, preferences *recursiveDescentPreferences) error {
+func recursiveDecent(d *dataTreeNavigator, results *list.List, matchMap *list.List, recurseArray bool) error {
 	for el := matchMap.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)

-		candidate.Node = unwrapDoc(candidate.Node)
+		candidate.Node = UnwrapDoc(candidate.Node)

 		log.Debugf("Recursive Decent, added %v", NodeToString(candidate))
 		results.PushBack(candidate)

 		if candidate.Node.Kind != yaml.AliasNode && len(candidate.Node.Content) > 0 &&
-			(preferences.RecurseArray || candidate.Node.Kind != yaml.SequenceNode) {
+			(recurseArray || candidate.Node.Kind != yaml.SequenceNode) {

-			children, err := splat(d, nodeToMap(candidate), preferences.TraversePreferences)
+			children, err := Splat(d, nodeToMap(candidate))

 			if err != nil {
 				return err
 			}
-			err = recursiveDecent(d, results, children, preferences)
+			err = recursiveDecent(d, results, children, recurseArray)
 			if err != nil {
 				return err
 			}
--- a/pkg/yqlib/operator_recursive_descent_test.go
+++ b/pkg/yqlib/operator_recursive_descent_test.go
@@ -13,14 +13,6 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!map)::{}\n",
 		},
 	},
-	{
-		skipDoc:    true,
-		document:   `{}`,
-		expression: `...`,
-		expected: []string{
-			"D0, P[], (!!map)::{}\n",
-		},
-	},
 	{
 		skipDoc:    true,
 		document:   `[]`,
@@ -29,14 +21,6 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!seq)::[]\n",
 		},
 	},
-	{
-		skipDoc:    true,
-		document:   `[]`,
-		expression: `...`,
-		expected: []string{
-			"D0, P[], (!!seq)::[]\n",
-		},
-	},
 	{
 		skipDoc:    true,
 		document:   `cat`,
@@ -47,50 +31,13 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 	},
 	{
 		skipDoc:    true,
-		document:   `cat`,
-		expression: `...`,
-		expected: []string{
-			"D0, P[], (!!str)::cat\n",
-		},
-	},
-	{
-		description: "Recurse map (values only)",
-		document:    `{a: frog}`,
-		expression:  `..`,
+		document:   `{a: frog}`,
+		expression: `..`,
 		expected: []string{
 			"D0, P[], (!!map)::{a: frog}\n",
 			"D0, P[a], (!!str)::frog\n",
 		},
 	},
-	{
-		description:    "Recursively find nodes with keys",
-		subdescription: "Note that this example has wrapped the expression in `[]` to show that there are two matches returned. You do not have to wrap in `[]` in your path expression.",
-		document:       `{a: {name: frog, b: {name: blog, age: 12}}}`,
-		expression:     `[.. | select(has("name"))]`,
-		expected: []string{
-			"D0, P[], (!!seq)::- {name: frog, b: {name: blog, age: 12}}\n- {name: blog, age: 12}\n",
-		},
-	},
-	{
-		description: "Recursively find nodes with values",
-		document:    `{a: {nameA: frog, b: {nameB: frog, age: 12}}}`,
-		expression:  `.. | select(. == "frog")`,
-		expected: []string{
-			"D0, P[a nameA], (!!str)::frog\n",
-			"D0, P[a b nameB], (!!str)::frog\n",
-		},
-	},
-	{
-		description:    "Recurse map (values and keys)",
-		subdescription: "Note that the map key appears in the results",
-		document:       `{a: frog}`,
-		expression:     `...`,
-		expected: []string{
-			"D0, P[], (!!map)::{a: frog}\n",
-			"D0, P[a], (!!str)::a\n",
-			"D0, P[a], (!!str)::frog\n",
-		},
-	},
 	{
 		skipDoc:    true,
 		document:   `{a: {b: apple}}`,
@@ -101,18 +48,6 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 			"D0, P[a b], (!!str)::apple\n",
 		},
 	},
-	{
-		skipDoc:    true,
-		document:   `{a: {b: apple}}`,
-		expression: `...`,
-		expected: []string{
-			"D0, P[], (!!map)::{a: {b: apple}}\n",
-			"D0, P[a], (!!str)::a\n",
-			"D0, P[a], (!!map)::{b: apple}\n",
-			"D0, P[a b], (!!str)::b\n",
-			"D0, P[a b], (!!str)::apple\n",
-		},
-	},
 	{
 		skipDoc:    true,
 		document:   `[1,2,3]`,
@@ -124,17 +59,6 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 			"D0, P[2], (!!int)::3\n",
 		},
 	},
-	{
-		skipDoc:    true,
-		document:   `[1,2,3]`,
-		expression: `...`,
-		expected: []string{
-			"D0, P[], (!!seq)::[1, 2, 3]\n",
-			"D0, P[0], (!!int)::1\n",
-			"D0, P[1], (!!int)::2\n",
-			"D0, P[2], (!!int)::3\n",
-		},
-	},
 	{
 		skipDoc:    true,
 		document:   `[{a: cat},2,true]`,
@@ -147,39 +71,12 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 			"D0, P[2], (!!bool)::true\n",
 		},
 	},
-	{
-		skipDoc:    true,
-		document:   `[{a: cat},2,true]`,
-		expression: `...`,
-		expected: []string{
-			"D0, P[], (!!seq)::[{a: cat}, 2, true]\n",
-			"D0, P[0], (!!map)::{a: cat}\n",
-			"D0, P[0 a], (!!str)::a\n",
-			"D0, P[0 a], (!!str)::cat\n",
-			"D0, P[1], (!!int)::2\n",
-			"D0, P[2], (!!bool)::true\n",
-		},
-	},
 	{
 		description: "Aliases are not traversed",
 		document:    `{a: &cat {c: frog}, b: *cat}`,
 		expression:  `[..]`,
 		expected: []string{
-			"D0, P[], (!!seq)::- {a: &cat {c: frog}, b: *cat}\n- &cat {c: frog}\n- frog\n- *cat\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   `{a: &cat {c: frog}, b: *cat}`,
-		expression: `...`,
-		expected: []string{
-			"D0, P[], (!!map)::{a: &cat {c: frog}, b: *cat}\n",
-			"D0, P[a], (!!str)::a\n",
-			"D0, P[a], (!!map)::&cat {c: frog}\n",
-			"D0, P[a c], (!!str)::c\n",
-			"D0, P[a c], (!!str)::frog\n",
-			"D0, P[b], (!!str)::b\n",
-			"D0, P[b], (alias)::*cat\n",
+			"D0, P[a], (!!seq)::- {a: &cat {c: frog}, b: *cat}\n- &cat {c: frog}\n- frog\n- *cat\n",
 		},
 	},
 	{
@@ -187,15 +84,7 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 		document:    mergeDocSample,
 		expression:  `.foobar | [..]`,
 		expected: []string{
-			"D0, P[], (!!seq)::- c: foobar_c\n  !!merge <<: *foo\n  thing: foobar_thing\n- foobar_c\n- *foo\n- foobar_thing\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   mergeDocSample,
-		expression: `.foobar | [...]`,
-		expected: []string{
-			"D0, P[], (!!seq)::- c: foobar_c\n  !!merge <<: *foo\n  thing: foobar_thing\n- c\n- foobar_c\n- !!merge <<\n- *foo\n- thing\n- foobar_thing\n",
+			"D0, P[foobar], (!!seq)::- c: foobar_c\n  !!merge <<: *foo\n  thing: foobar_thing\n- foobar_c\n- *foo\n- foobar_thing\n",
 		},
 	},
 	{
@@ -211,27 +100,11 @@ var recursiveDescentOperatorScenarios = []expressionScenario{
 			"D0, P[foobarList c], (!!str)::foobarList_c\n",
 		},
 	},
-	{
-		skipDoc:    true,
-		document:   mergeDocSample,
-		expression: `.foobarList | ...`,
-		expected: []string{
-			"D0, P[foobarList], (!!map)::b: foobarList_b\n!!merge <<: [*foo, *bar]\nc: foobarList_c\n",
-			"D0, P[foobarList b], (!!str)::b\n",
-			"D0, P[foobarList b], (!!str)::foobarList_b\n",
-			"D0, P[foobarList <<], (!!merge)::!!merge <<\n",
-			"D0, P[foobarList <<], (!!seq)::[*foo, *bar]\n",
-			"D0, P[foobarList << 0], (alias)::*foo\n",
-			"D0, P[foobarList << 1], (alias)::*bar\n",
-			"D0, P[foobarList c], (!!str)::c\n",
-			"D0, P[foobarList c], (!!str)::foobarList_c\n",
-		},
-	},
 }

 func TestRecursiveDescentOperatorScenarios(t *testing.T) {
 	for _, tt := range recursiveDescentOperatorScenarios {
 		testScenario(t, &tt)
 	}
-	documentScenarios(t, "Recursive Descent (Glob)", recursiveDescentOperatorScenarios)
+	documentScenarios(t, "Recursive Descent", recursiveDescentOperatorScenarios)
 }
--- a/pkg/yqlib/operator_select.go
+++ b/pkg/yqlib/operator_select.go
@@ -4,7 +4,7 @@ import (
 	"container/list"
 )

-func selectOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func SelectOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {

 	log.Debugf("-- selectOperation")
 	var results = list.New()
@@ -12,7 +12,7 @@ func selectOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNo
 	for el := matchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)

-		rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
+		rhs, err := d.GetMatchingNodes(nodeToMap(candidate), pathNode.Rhs)

 		if err != nil {
 			return nil, err
--- a/pkg/yqlib/operator_self.go
+++ b/pkg/yqlib/operator_self.go
@@ -2,6 +2,6 @@ package yqlib

 import "container/list"

-func selfOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func SelfOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	return matchMap, nil
 }
--- a/pkg/yqlib/operator_sort_keys.go
+++ b/pkg/yqlib/operator_sort_keys.go
@@ -7,17 +7,17 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )

-func sortKeysOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func SortKeysOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {

 	for el := matchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
-		rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
+		rhs, err := d.GetMatchingNodes(nodeToMap(candidate), pathNode.Rhs)
 		if err != nil {
 			return nil, err
 		}

 		for childEl := rhs.Front(); childEl != nil; childEl = childEl.Next() {
-			node := unwrapDoc(childEl.Value.(*CandidateNode).Node)
+			node := UnwrapDoc(childEl.Value.(*CandidateNode).Node)
 			if node.Kind == yaml.MappingNode {
 				sortKeys(node)
 			}
--- a/pkg/yqlib/operator_style.go
+++ b/pkg/yqlib/operator_style.go
@@ -4,47 +4,40 @@ import (
 	"container/list"
 	"fmt"

-	yaml "gopkg.in/yaml.v3"
+	"gopkg.in/yaml.v3"
 )

-func parseStyle(customStyle string) (yaml.Style, error) {
-	if customStyle == "tagged" {
-		return yaml.TaggedStyle, nil
-	} else if customStyle == "double" {
-		return yaml.DoubleQuotedStyle, nil
-	} else if customStyle == "single" {
-		return yaml.SingleQuotedStyle, nil
-	} else if customStyle == "literal" {
-		return yaml.LiteralStyle, nil
-	} else if customStyle == "folded" {
-		return yaml.FoldedStyle, nil
-	} else if customStyle == "flow" {
-		return yaml.FlowStyle, nil
-	} else if customStyle != "" {
-		return 0, fmt.Errorf("Unknown style %v", customStyle)
-	}
-	return 0, nil
-}
-
-func assignStyleOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func AssignStyleOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {

 	log.Debugf("AssignStyleOperator: %v")
-	var style yaml.Style
-	if !expressionNode.Operation.UpdateAssign {
-		rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
-		if err != nil {
-			return nil, err
-		}

-		if rhs.Front() != nil {
-			style, err = parseStyle(rhs.Front().Value.(*CandidateNode).Node.Value)
-			if err != nil {
-				return nil, err
-			}
-		}
+	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+	if err != nil {
+		return nil, err
+	}
+	customStyle := ""
+
+	if rhs.Front() != nil {
+		customStyle = rhs.Front().Value.(*CandidateNode).Node.Value
 	}

-	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
+	var style yaml.Style
+	if customStyle == "tagged" {
+		style = yaml.TaggedStyle
+	} else if customStyle == "double" {
+		style = yaml.DoubleQuotedStyle
+	} else if customStyle == "single" {
+		style = yaml.SingleQuotedStyle
+	} else if customStyle == "literal" {
+		style = yaml.LiteralStyle
+	} else if customStyle == "folded" {
+		style = yaml.FoldedStyle
+	} else if customStyle == "flow" {
+		style = yaml.FlowStyle
+	} else if customStyle != "" {
+		return nil, fmt.Errorf("Unknown style %v", customStyle)
+	}
+	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)

 	if err != nil {
 		return nil, err
@@ -53,27 +46,13 @@ func assignStyleOperator(d *dataTreeNavigator, matchingNodes *list.List, express
 	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		log.Debugf("Setting style of : %v", candidate.GetKey())
-		if expressionNode.Operation.UpdateAssign {
-			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
-			if err != nil {
-				return nil, err
-			}
-
-			if rhs.Front() != nil {
-				style, err = parseStyle(rhs.Front().Value.(*CandidateNode).Node.Value)
-				if err != nil {
-					return nil, err
-				}
-			}
-		}
-
 		candidate.Node.Style = style
 	}

 	return matchingNodes, nil
 }

-func getStyleOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func GetStyleOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("GetStyleOperator")

 	var results = list.New()
@@ -100,8 +79,8 @@ func getStyleOperator(d *dataTreeNavigator, matchingNodes *list.List, expression
 			style = "<unknown>"
 		}
 		node := &yaml.Node{Kind: yaml.ScalarNode, Value: style, Tag: "!!str"}
-		result := candidate.CreateChild(nil, node)
-		results.PushBack(result)
+		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		results.PushBack(lengthCand)
 	}

 	return results, nil
--- a/pkg/yqlib/operator_style_test.go
+++ b/pkg/yqlib/operator_style_test.go
@@ -21,22 +21,6 @@ var styleOperatorScenarios = []expressionScenario{
 			"D0, P[], (!!map)::a: \"cat\"\nb: \"5\"\nc: \"3.2\"\ne: \"true\"\n",
 		},
 	},
-	{
-		description: "Set double quote style on map keys too",
-		document:    `{a: cat, b: 5, c: 3.2, e: true}`,
-		expression:  `... style="double"`,
-		expected: []string{
-			"D0, P[], (!!map)::\"a\": \"cat\"\n\"b\": \"5\"\n\"c\": \"3.2\"\n\"e\": \"true\"\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   "bing: &foo frog\na:\n  c: cat\n  <<: [*foo]",
-		expression: `(... | select(tag=="!!str")) style="single"`,
-		expected: []string{
-			"D0, P[], (!!map)::'bing': &foo 'frog'\n'a':\n    'c': 'cat'\n    !!merge <<: [*foo]\n",
-		},
-	},
 	{
 		description: "Set single quote style",
 		document:    `{a: cat, b: 5, c: 3.2, e: true}`,
@@ -86,22 +70,14 @@ e: >-
 		},
 	},
 	{
-		description:    "Reset style - or pretty print",
-		subdescription: "Set empty (default) quote style, note the usage of `...` to match keys too. Note that there is a `--prettyPrint/-P` short flag for this.",
-		document:       `{a: cat, "b": 5, 'c': 3.2, "e": true}`,
-		expression:     `... style=""`,
+		description:    "Pretty print",
+		subdescription: "Set empty (default) quote style",
+		document:       `{a: cat, b: 5, c: 3.2, e: true}`,
+		expression:     `.. style=""`,
 		expected: []string{
 			"D0, P[], (!!map)::a: cat\nb: 5\nc: 3.2\ne: true\n",
 		},
 	},
-	{
-		description: "Set style relatively with assign-update",
-		document:    `{a: single, b: double}`,
-		expression:  `.[] style |= .`,
-		expected: []string{
-			"D0, P[], (doc)::{a: 'single', b: \"double\"}\n",
-		},
-	},
 	{
 		skipDoc:    true,
 		document:   `{a: cat, b: double}`,
--- a/pkg/yqlib/operator_tag.go
+++ b/pkg/yqlib/operator_tag.go
@@ -3,26 +3,24 @@ package yqlib
 import (
 	"container/list"

-	yaml "gopkg.in/yaml.v3"
+	"gopkg.in/yaml.v3"
 )

-func assignTagOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func AssignTagOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {

 	log.Debugf("AssignTagOperator: %v")
+
+	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
+	if err != nil {
+		return nil, err
+	}
 	tag := ""

-	if !expressionNode.Operation.UpdateAssign {
-		rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
-		if err != nil {
-			return nil, err
-		}
-
-		if rhs.Front() != nil {
-			tag = rhs.Front().Value.(*CandidateNode).Node.Value
-		}
+	if rhs.Front() != nil {
+		tag = rhs.Front().Value.(*CandidateNode).Node.Value
 	}

-	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
+	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)

 	if err != nil {
 		return nil, err
@@ -31,32 +29,22 @@ func assignTagOperator(d *dataTreeNavigator, matchingNodes *list.List, expressio
 	for el := lhs.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
 		log.Debugf("Setting tag of : %v", candidate.GetKey())
-		if expressionNode.Operation.UpdateAssign {
-			rhs, err := d.GetMatchingNodes(nodeToMap(candidate), expressionNode.Rhs)
-			if err != nil {
-				return nil, err
-			}
-
-			if rhs.Front() != nil {
-				tag = rhs.Front().Value.(*CandidateNode).Node.Value
-			}
-		}
-		unwrapDoc(candidate.Node).Tag = tag
+		candidate.Node.Tag = tag
 	}

 	return matchingNodes, nil
 }

-func getTagOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func GetTagOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("GetTagOperator")

 	var results = list.New()

 	for el := matchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
-		node := &yaml.Node{Kind: yaml.ScalarNode, Value: unwrapDoc(candidate.Node).Tag, Tag: "!!str"}
-		result := candidate.CreateChild(nil, node)
-		results.PushBack(result)
+		node := &yaml.Node{Kind: yaml.ScalarNode, Value: candidate.Node.Tag, Tag: "!!str"}
+		lengthCand := &CandidateNode{Node: node, Document: candidate.Document, Path: candidate.Path}
+		results.PushBack(lengthCand)
 	}

 	return results, nil
--- a/pkg/yqlib/operator_tag_test.go
+++ b/pkg/yqlib/operator_tag_test.go
@@ -19,45 +19,13 @@ var tagOperatorScenarios = []expressionScenario{
 		},
 	},
 	{
-		skipDoc:    true,
-		document:   `{a: cat, b: 5, c: 3.2, e: true, f: []}`,
-		expression: `tag`,
-		expected: []string{
-			"D0, P[], (!!str)::'!!map'\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   `32`,
-		expression: `. tag= "!!str"`,
-		expected: []string{
-			"D0, P[], (doc)::\"32\"\n",
-		},
-	},
-	{
-		description: "Set custom tag",
-		document:    `{a: str}`,
-		expression:  `.a tag = "!!mikefarah"`,
-		expected: []string{
-			"D0, P[], (doc)::{a: !!mikefarah str}\n",
-		},
-	},
-	{
-		description: "Find numbers and convert them to strings",
+		description: "Convert numbers to strings",
 		document:    `{a: cat, b: 5, c: 3.2, e: true}`,
 		expression:  `(.. | select(tag == "!!int")) tag= "!!str"`,
 		expected: []string{
 			"D0, P[], (!!map)::{a: cat, b: \"5\", c: 3.2, e: true}\n",
 		},
 	},
-	{
-		skipDoc:    true,
-		document:   `{a: "!!frog", b: "!!customTag"}`,
-		expression: `.[] tag |= .`,
-		expected: []string{
-			"D0, P[], (doc)::{a: !!frog \"!!frog\", b: !!customTag \"!!customTag\"}\n",
-		},
-	},
 }

 func TestTagOperatorScenarios(t *testing.T) {
--- a/pkg/yqlib/operator_traverse_path.go
+++ b/pkg/yqlib/operator_traverse_path.go
@@ -9,21 +9,20 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )

-type traversePreferences struct {
-	FollowAlias    bool
-	IncludeMapKeys bool
+type TraversePreferences struct {
+	DontFollowAlias bool
 }

-func splat(d *dataTreeNavigator, matches *list.List, prefs *traversePreferences) (*list.List, error) {
-	return traverseNodesWithArrayIndices(matches, make([]*yaml.Node, 0), prefs)
+func Splat(d *dataTreeNavigator, matches *list.List) (*list.List, error) {
+	return traverseNodesWithArrayIndices(matches, make([]*yaml.Node, 0), false)
 }

-func traversePathOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func TraversePathOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	log.Debugf("-- Traversing")
 	var matchingNodeMap = list.New()

 	for el := matchMap.Front(); el != nil; el = el.Next() {
-		newNodes, err := traverse(d, el.Value.(*CandidateNode), expressionNode.Operation)
+		newNodes, err := traverse(d, el.Value.(*CandidateNode), pathNode.Operation)
 		if err != nil {
 			return nil, err
 		}
@@ -54,8 +53,12 @@ func traverse(d *dataTreeNavigator, matchingNode *CandidateNode, operation *Oper
 	switch value.Kind {
 	case yaml.MappingNode:
 		log.Debug("its a map with %v entries", len(value.Content)/2)
-		prefs := &traversePreferences{FollowAlias: true}
-		return traverseMap(matchingNode, operation.StringValue, prefs, false)
+		followAlias := true
+
+		if operation.Preferences != nil {
+			followAlias = !operation.Preferences.(*TraversePreferences).DontFollowAlias
+		}
+		return traverseMap(matchingNode, operation.StringValue, followAlias, false)

 	case yaml.SequenceNode:
 		log.Debug("its a sequence of %v things!", len(value.Content))
@@ -67,31 +70,34 @@ func traverse(d *dataTreeNavigator, matchingNode *CandidateNode, operation *Oper
 		return traverse(d, matchingNode, operation)
 	case yaml.DocumentNode:
 		log.Debug("digging into doc node")
-
-		return traverse(d, matchingNode.CreateChild(nil, matchingNode.Node.Content[0]), operation)
+		return traverse(d, &CandidateNode{
+			Node:      matchingNode.Node.Content[0],
+			Filename:  matchingNode.Filename,
+			FileIndex: matchingNode.FileIndex,
+			Document:  matchingNode.Document}, operation)
 	default:
 		return list.New(), nil
 	}
 }

-func traverseArrayOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func TraverseArrayOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	// rhs is a collect expression that will yield indexes to retreive of the arrays

-	rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
+	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
 	if err != nil {
 		return nil, err
 	}

 	var indicesToTraverse = rhs.Front().Value.(*CandidateNode).Node.Content
-	prefs := &traversePreferences{FollowAlias: true}
-	return traverseNodesWithArrayIndices(matchingNodes, indicesToTraverse, prefs)
+
+	return traverseNodesWithArrayIndices(matchingNodes, indicesToTraverse, true)
 }

-func traverseNodesWithArrayIndices(matchingNodes *list.List, indicesToTraverse []*yaml.Node, prefs *traversePreferences) (*list.List, error) {
+func traverseNodesWithArrayIndices(matchingNodes *list.List, indicesToTraverse []*yaml.Node, followAlias bool) (*list.List, error) {
 	var matchingNodeMap = list.New()
 	for el := matchingNodes.Front(); el != nil; el = el.Next() {
 		candidate := el.Value.(*CandidateNode)
-		newNodes, err := traverseArrayIndices(candidate, indicesToTraverse, prefs)
+		newNodes, err := traverseArrayIndices(candidate, indicesToTraverse, followAlias)
 		if err != nil {
 			return nil, err
 		}
@@ -101,7 +107,7 @@ func traverseNodesWithArrayIndices(matchingNodes *list.List, indicesToTraverse [
 	return matchingNodeMap, nil
 }

-func traverseArrayIndices(matchingNode *CandidateNode, indicesToTraverse []*yaml.Node, prefs *traversePreferences) (*list.List, error) { // call this if doc / alias like the other traverse
+func traverseArrayIndices(matchingNode *CandidateNode, indicesToTraverse []*yaml.Node, followAlias bool) (*list.List, error) { // call this if doc / alias like the other traverse
 	node := matchingNode.Node
 	if node.Tag == "!!null" {
 		log.Debugf("OperatorArrayTraverse got a null - turning it into an empty array")
@@ -112,28 +118,32 @@ func traverseArrayIndices(matchingNode *CandidateNode, indicesToTraverse []*yaml

 	if node.Kind == yaml.AliasNode {
 		matchingNode.Node = node.Alias
-		return traverseArrayIndices(matchingNode, indicesToTraverse, prefs)
+		return traverseArrayIndices(matchingNode, indicesToTraverse, followAlias)
 	} else if node.Kind == yaml.SequenceNode {
 		return traverseArrayWithIndices(matchingNode, indicesToTraverse)
 	} else if node.Kind == yaml.MappingNode {
-		return traverseMapWithIndices(matchingNode, indicesToTraverse, prefs)
+		return traverseMapWithIndices(matchingNode, indicesToTraverse, followAlias)
 	} else if node.Kind == yaml.DocumentNode {
-		return traverseArrayIndices(matchingNode.CreateChild(nil, matchingNode.Node.Content[0]), indicesToTraverse, prefs)
+		return traverseArrayIndices(&CandidateNode{
+			Node:      matchingNode.Node.Content[0],
+			Filename:  matchingNode.Filename,
+			FileIndex: matchingNode.FileIndex,
+			Document:  matchingNode.Document}, indicesToTraverse, followAlias)
 	}
 	log.Debugf("OperatorArrayTraverse skipping %v as its a %v", matchingNode, node.Tag)
 	return list.New(), nil
 }

-func traverseMapWithIndices(candidate *CandidateNode, indices []*yaml.Node, prefs *traversePreferences) (*list.List, error) {
+func traverseMapWithIndices(candidate *CandidateNode, indices []*yaml.Node, followAlias bool) (*list.List, error) {
 	if len(indices) == 0 {
-		return traverseMap(candidate, "", prefs, true)
+		return traverseMap(candidate, "", followAlias, true)
 	}

 	var matchingNodeMap = list.New()

 	for _, indexNode := range indices {
 		log.Debug("traverseMapWithIndices: %v", indexNode.Value)
-		newNodes, err := traverseMap(candidate, indexNode.Value, prefs, false)
+		newNodes, err := traverseMap(candidate, indexNode.Value, followAlias, false)
 		if err != nil {
 			return nil, err
 		}
@@ -146,13 +156,17 @@ func traverseMapWithIndices(candidate *CandidateNode, indices []*yaml.Node, pref
 func traverseArrayWithIndices(candidate *CandidateNode, indices []*yaml.Node) (*list.List, error) {
 	log.Debug("traverseArrayWithIndices")
 	var newMatches = list.New()
-	node := unwrapDoc(candidate.Node)
+	node := UnwrapDoc(candidate.Node)
 	if len(indices) == 0 {
 		log.Debug("splatting")
 		var index int64
 		for index = 0; index < int64(len(node.Content)); index = index + 1 {

-			newMatches.PushBack(candidate.CreateChild(index, node.Content[index]))
+			newMatches.PushBack(&CandidateNode{
+				Document: candidate.Document,
+				Path:     candidate.CreateChildPath(index),
+				Node:     node.Content[index],
+			})
 		}
 		return newMatches, nil

@@ -179,18 +193,22 @@ func traverseArrayWithIndices(candidate *CandidateNode, indices []*yaml.Node) (*
 			return nil, fmt.Errorf("Index [%v] out of range, array size is %v", index, contentLength)
 		}

-		newMatches.PushBack(candidate.CreateChild(index, node.Content[indexToUse]))
+		newMatches.PushBack(&CandidateNode{
+			Node:     node.Content[indexToUse],
+			Document: candidate.Document,
+			Path:     candidate.CreateChildPath(index),
+		})
 	}
 	return newMatches, nil
 }

 func keyMatches(key *yaml.Node, wantedKey string) bool {
-	return matchKey(key.Value, wantedKey)
+	return Match(key.Value, wantedKey)
 }

-func traverseMap(matchingNode *CandidateNode, key string, prefs *traversePreferences, splat bool) (*list.List, error) {
+func traverseMap(matchingNode *CandidateNode, key string, followAlias bool, splat bool) (*list.List, error) {
 	var newMatches = orderedmap.NewOrderedMap()
-	err := doTraverseMap(newMatches, matchingNode, key, prefs, splat)
+	err := doTraverseMap(newMatches, matchingNode, key, followAlias, splat)

 	if err != nil {
 		return nil, err
@@ -201,8 +219,13 @@ func traverseMap(matchingNode *CandidateNode, key string, prefs *traversePrefere
 		valueNode := &yaml.Node{Tag: "!!null", Kind: yaml.ScalarNode, Value: "null"}
 		node := matchingNode.Node
 		node.Content = append(node.Content, &yaml.Node{Kind: yaml.ScalarNode, Value: key}, valueNode)
-		candidateNode := matchingNode.CreateChild(key, valueNode)
+		candidateNode := &CandidateNode{
+			Node:     valueNode,
+			Path:     append(matchingNode.Path, key),
+			Document: matchingNode.Document,
+		}
 		newMatches.Set(candidateNode.GetKey(), candidateNode)
+
 	}

 	results := list.New()
@@ -214,7 +237,7 @@ func traverseMap(matchingNode *CandidateNode, key string, prefs *traversePrefere
 	return results, nil
 }

-func doTraverseMap(newMatches *orderedmap.OrderedMap, candidate *CandidateNode, wantedKey string, prefs *traversePreferences, splat bool) error {
+func doTraverseMap(newMatches *orderedmap.OrderedMap, candidate *CandidateNode, wantedKey string, followAlias bool, splat bool) error {
 	// value.Content is a concatenated array of key, value,
 	// so keys are in the even indexes, values in odd.
 	// merge aliases are defined first, but we only want to traverse them
@@ -229,19 +252,19 @@ func doTraverseMap(newMatches *orderedmap.OrderedMap, candidate *CandidateNode,

 		log.Debug("checking %v (%v)", key.Value, key.Tag)
 		//skip the 'merge' tag, find a direct match first
-		if key.Tag == "!!merge" && prefs.FollowAlias {
+		if key.Tag == "!!merge" && followAlias {
 			log.Debug("Merge anchor")
-			err := traverseMergeAnchor(newMatches, candidate, value, wantedKey, prefs, splat)
+			err := traverseMergeAnchor(newMatches, candidate, value, wantedKey, splat)
 			if err != nil {
 				return err
 			}
 		} else if splat || keyMatches(key, wantedKey) {
 			log.Debug("MATCHED")
-			if prefs.IncludeMapKeys {
-				candidateNode := candidate.CreateChild(key.Value, key)
-				newMatches.Set(fmt.Sprintf("keyOf-%v", candidateNode.GetKey()), candidateNode)
+			candidateNode := &CandidateNode{
+				Node:     value,
+				Path:     candidate.CreateChildPath(key.Value),
+				Document: candidate.Document,
 			}
-			candidateNode := candidate.CreateChild(key.Value, value)
 			newMatches.Set(candidateNode.GetKey(), candidateNode)
 		}
 	}
@@ -249,14 +272,18 @@ func doTraverseMap(newMatches *orderedmap.OrderedMap, candidate *CandidateNode,
 	return nil
 }

-func traverseMergeAnchor(newMatches *orderedmap.OrderedMap, originalCandidate *CandidateNode, value *yaml.Node, wantedKey string, prefs *traversePreferences, splat bool) error {
+func traverseMergeAnchor(newMatches *orderedmap.OrderedMap, originalCandidate *CandidateNode, value *yaml.Node, wantedKey string, splat bool) error {
 	switch value.Kind {
 	case yaml.AliasNode:
-		candidateNode := originalCandidate.CreateChild(nil, value.Alias)
-		return doTraverseMap(newMatches, candidateNode, wantedKey, prefs, splat)
+		candidateNode := &CandidateNode{
+			Node:     value.Alias,
+			Path:     originalCandidate.Path,
+			Document: originalCandidate.Document,
+		}
+		return doTraverseMap(newMatches, candidateNode, wantedKey, true, splat)
 	case yaml.SequenceNode:
 		for _, childValue := range value.Content {
-			err := traverseMergeAnchor(newMatches, originalCandidate, childValue, wantedKey, prefs, splat)
+			err := traverseMergeAnchor(newMatches, originalCandidate, childValue, wantedKey, splat)
 			if err != nil {
 				return err
 			}
--- a/pkg/yqlib/operator_traverse_path_test.go
+++ b/pkg/yqlib/operator_traverse_path_test.go
@@ -54,15 +54,6 @@ var traversePathOperatorScenarios = []expressionScenario{
 			"D0, P[{}], (!!str)::frog\n",
 		},
 	},
-	{
-		description:    "Dynamic keys",
-		subdescription: `Expressions within [] can be used to dynamically lookup / calculate keys`,
-		document:       `{b: apple, apple: crispy yum, banana: soft yum}`,
-		expression:     `.[.b]`,
-		expected: []string{
-			"D0, P[apple], (!!str)::crispy yum\n",
-		},
-	},
 	{
 		description:    "Children don't exist",
 		subdescription: "Nodes are added dynamically while traversing",
@@ -146,15 +137,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		description: "Traversing aliases with splat",
 		document:    `{a: &cat {c: frog}, b: *cat}`,
-		expression:  `.b[]`,
-		expected: []string{
-			"D0, P[b c], (!!str)::frog\n",
-		},
-	},
-	{
-		skipDoc:    true,
-		document:   `{a: &cat {c: frog}, b: *cat}`,
-		expression: `.b.[]`,
+		expression:  `.b.[]`,
 		expected: []string{
 			"D0, P[b c], (!!str)::frog\n",
 		},
@@ -226,17 +209,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		description: "Splatting merge anchors",
 		document:    mergeDocSample,
-		expression:  `.foobar[]`,
-		expected: []string{
-			"D0, P[foobar c], (!!str)::foo_c\n",
-			"D0, P[foobar a], (!!str)::foo_a\n",
-			"D0, P[foobar thing], (!!str)::foobar_thing\n",
-		},
-	},
-	{
-		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",
@@ -287,18 +260,7 @@ var traversePathOperatorScenarios = []expressionScenario{
 	{
 		description: "Splatting merge anchor lists",
 		document:    mergeDocSample,
-		expression:  `.foobarList[]`,
-		expected: []string{
-			"D0, P[foobarList b], (!!str)::bar_b\n",
-			"D0, P[foobarList a], (!!str)::foo_a\n",
-			"D0, P[foobarList thing], (!!str)::bar_thing\n",
-			"D0, P[foobarList c], (!!str)::foobarList_c\n",
-		},
-	},
-	{
-		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",
@@ -350,6 +312,14 @@ var traversePathOperatorScenarios = []expressionScenario{
 			"D0, P[a 2], (!!str)::c\n",
 		},
 	},
+	{
+		skipDoc:    true,
+		document:   `{a: [a,b,c]}`,
+		expression: `.a.[0]`,
+		expected: []string{
+			"D0, P[a 0], (!!str)::a\n",
+		},
+	},
 	{
 		skipDoc:    true,
 		document:   `{a: [a,b,c]}`,
--- a/pkg/yqlib/operator_union.go
+++ b/pkg/yqlib/operator_union.go
@@ -2,12 +2,12 @@ package yqlib

 import "container/list"

-func unionOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
-	lhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Lhs)
+func UnionOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
+	lhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Lhs)
 	if err != nil {
 		return nil, err
 	}
-	rhs, err := d.GetMatchingNodes(matchingNodes, expressionNode.Rhs)
+	rhs, err := d.GetMatchingNodes(matchingNodes, pathNode.Rhs)
 	if err != nil {
 		return nil, err
 	}
--- a/pkg/yqlib/operator_value.go
+++ b/pkg/yqlib/operator_value.go
@@ -2,7 +2,7 @@ package yqlib

 import "container/list"

-func valueOperator(d *dataTreeNavigator, matchMap *list.List, expressionNode *ExpressionNode) (*list.List, error) {
-	log.Debug("value = %v", expressionNode.Operation.CandidateNode.Node.Value)
-	return nodeToMap(expressionNode.Operation.CandidateNode), nil
+func ValueOperator(d *dataTreeNavigator, matchMap *list.List, pathNode *PathTreeNode) (*list.List, error) {
+	log.Debug("value = %v", pathNode.Operation.CandidateNode.Node.Value)
+	return nodeToMap(pathNode.Operation.CandidateNode), nil
 }
--- a/pkg/yqlib/operators.go
+++ b/pkg/yqlib/operators.go
@@ -7,16 +7,16 @@ import (
 	"gopkg.in/yaml.v3"
 )

-type operatorHandler func(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error)
+type OperatorHandler func(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error)

-func unwrapDoc(node *yaml.Node) *yaml.Node {
+func UnwrapDoc(node *yaml.Node) *yaml.Node {
 	if node.Kind == yaml.DocumentNode {
 		return node.Content[0]
 	}
 	return node
 }

-func emptyOperator(d *dataTreeNavigator, matchingNodes *list.List, expressionNode *ExpressionNode) (*list.List, error) {
+func EmptyOperator(d *dataTreeNavigator, matchingNodes *list.List, pathNode *PathTreeNode) (*list.List, error) {
 	return list.New(), nil
 }

@@ -26,7 +26,7 @@ func createBooleanCandidate(owner *CandidateNode, value bool) *CandidateNode {
 		valString = "false"
 	}
 	node := &yaml.Node{Kind: yaml.ScalarNode, Value: valString, Tag: "!!bool"}
-	return owner.CreateChild(nil, node)
+	return &CandidateNode{Node: node, Document: owner.Document, Path: owner.Path}
 }

 func nodeToMap(candidate *CandidateNode) *list.List {
@@ -35,14 +35,14 @@ func nodeToMap(candidate *CandidateNode) *list.List {
 	return elMap
 }

-func createTraversalTree(path []interface{}) *ExpressionNode {
+func createTraversalTree(path []interface{}) *PathTreeNode {
 	if len(path) == 0 {
-		return &ExpressionNode{Operation: &Operation{OperationType: selfReferenceOpType}}
+		return &PathTreeNode{Operation: &Operation{OperationType: SelfReference}}
 	} else if len(path) == 1 {
-		return &ExpressionNode{Operation: &Operation{OperationType: traversePathOpType, Value: path[0], StringValue: fmt.Sprintf("%v", path[0])}}
+		return &PathTreeNode{Operation: &Operation{OperationType: TraversePath, Value: path[0], StringValue: fmt.Sprintf("%v", path[0])}}
 	}
-	return &ExpressionNode{
-		Operation: &Operation{OperationType: shortPipeOpType},
+	return &PathTreeNode{
+		Operation: &Operation{OperationType: ShortPipe},
 		Lhs:       createTraversalTree(path[0:1]),
 		Rhs:       createTraversalTree(path[1:])}
 }
--- a/pkg/yqlib/operators_test.go
+++ b/pkg/yqlib/operators_test.go
@@ -17,9 +17,7 @@ import (
 type expressionScenario struct {
 	description           string
 	subdescription        string
-	environmentVariable   string
 	document              string
-	document2             string
 	expression            string
 	expected              []string
 	skipDoc               bool
@@ -30,7 +28,7 @@ func testScenario(t *testing.T, s *expressionScenario) {
 	var results *list.List
 	var err error

-	node, err := NewExpressionParser().ParseExpression(s.expression)
+	node, err := treeCreator.ParsePath(s.expression)
 	if err != nil {
 		t.Error(fmt.Errorf("Error parsing expression %v of %v: %v", s.expression, s.description, err))
 		return
@@ -43,14 +41,6 @@ func testScenario(t *testing.T, s *expressionScenario) {
 			t.Error(err, s.document, s.expression)
 			return
 		}
-		if s.document2 != "" {
-			moreInputs, err := readDocuments(strings.NewReader(s.document2), "another.yml", 1)
-			if err != nil {
-				t.Error(err, s.document, s.expression)
-				return
-			}
-			inputs.PushBackList(moreInputs)
-		}
 	} else {
 		candidateNode := &CandidateNode{
 			Document:  0,
@@ -62,11 +52,7 @@ func testScenario(t *testing.T, s *expressionScenario) {

 	}

-	if s.environmentVariable != "" {
-		os.Setenv("myenv", s.environmentVariable)
-	}
-
-	results, err = NewDataTreeNavigator().GetMatchingNodes(inputs, node)
+	results, err = treeNavigator.GetMatchingNodes(inputs, node)

 	if err != nil {
 		t.Error(fmt.Errorf("%v: %v", err, s.expression))
@@ -106,16 +92,16 @@ func copyFromHeader(title string, out *os.File) error {
 	return err
 }

-func formatYaml(yaml string, filename string) string {
+func formatYaml(yaml string) string {
 	var output bytes.Buffer
 	printer := NewPrinter(bufio.NewWriter(&output), false, true, false, 2, true)

-	node, err := NewExpressionParser().ParseExpression(".. style= \"\"")
+	node, err := treeCreator.ParsePath(".. style= \"\"")
 	if err != nil {
 		panic(err)
 	}
 	streamEvaluator := NewStreamEvaluator()
-	err = streamEvaluator.Evaluate(filename, strings.NewReader(yaml), node, printer)
+	err = streamEvaluator.Evaluate("sample.yaml", strings.NewReader(yaml), node, printer)
 	if err != nil {
 		panic(err)
 	}
@@ -142,125 +128,63 @@ func documentScenarios(t *testing.T, title string, scenarios []expressionScenari

 	for _, s := range scenarios {
 		if !s.skipDoc {
-			documentScenario(t, w, s)
+
+			writeOrPanic(w, fmt.Sprintf("## %v\n", s.description))
+
+			if s.subdescription != "" {
+				writeOrPanic(w, s.subdescription)
+				writeOrPanic(w, "\n\n")
+			}
+			formattedDoc := ""
+			if s.document != "" {
+				if s.dontFormatInputForDoc {
+					formattedDoc = s.document + "\n"
+				} else {
+					formattedDoc = formatYaml(s.document)
+				}
+				//TODO: pretty here
+				writeOrPanic(w, "Given a sample.yml file of:\n")
+
+				writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n", formattedDoc))
+				writeOrPanic(w, "then\n")
+				if s.expression != "" {
+					writeOrPanic(w, fmt.Sprintf("```bash\nyq eval '%v' sample.yml\n```\n", s.expression))
+				} else {
+					writeOrPanic(w, "```bash\nyq eval sample.yml\n```\n")
+				}
+			} else {
+				writeOrPanic(w, "Running\n")
+				writeOrPanic(w, fmt.Sprintf("```bash\nyq eval --null-input '%v'\n```\n", s.expression))
+			}
+
+			writeOrPanic(w, "will output\n")
+
+			var output bytes.Buffer
+			var err error
+			printer := NewPrinter(bufio.NewWriter(&output), false, true, false, 2, true)
+			streamEvaluator := NewStreamEvaluator()
+
+			if s.document != "" {
+				node, err := treeCreator.ParsePath(s.expression)
+				if err != nil {
+					t.Error(err, s.expression)
+				}
+				err = streamEvaluator.Evaluate("sample.yaml", strings.NewReader(formattedDoc), node, printer)
+
+				if err != nil {
+					t.Error(err, s.expression)
+				}
+			} else {
+				err = streamEvaluator.EvaluateNew(s.expression, printer)
+				if err != nil {
+					t.Error(err, s.expression)
+				}
+			}
+
+			writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n\n", output.String()))
+
 		}
+
 	}
 	w.Flush()
 }
-
-func documentScenario(t *testing.T, w *bufio.Writer, s expressionScenario) {
-	writeOrPanic(w, fmt.Sprintf("## %v\n", s.description))
-
-	if s.subdescription != "" {
-		writeOrPanic(w, s.subdescription)
-		writeOrPanic(w, "\n\n")
-	}
-
-	formattedDoc, formattedDoc2 := documentInput(w, s)
-
-	writeOrPanic(w, "will output\n")
-
-	documentOutput(t, w, s, formattedDoc, formattedDoc2)
-}
-
-func documentInput(w *bufio.Writer, s expressionScenario) (string, string) {
-	formattedDoc := ""
-	formattedDoc2 := ""
-	command := "eval"
-
-	envCommand := ""
-
-	if s.environmentVariable != "" {
-		envCommand = fmt.Sprintf("myenv=\"%v\" ", s.environmentVariable)
-		os.Setenv("myenv", s.environmentVariable)
-	}
-
-	if s.document != "" {
-		if s.dontFormatInputForDoc {
-			formattedDoc = s.document + "\n"
-		} else {
-			formattedDoc = formatYaml(s.document, "sample.yml")
-		}
-
-		writeOrPanic(w, "Given a sample.yml file of:\n")
-		writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n", formattedDoc))
-
-		files := "sample.yml"
-
-		if s.document2 != "" {
-			if s.dontFormatInputForDoc {
-				formattedDoc2 = s.document2 + "\n"
-			} else {
-				formattedDoc2 = formatYaml(s.document2, "another.yml")
-			}
-
-			writeOrPanic(w, "And another sample another.yml file of:\n")
-			writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n", formattedDoc2))
-			files = "sample.yml another.yml"
-			command = "eval-all"
-		}
-
-		writeOrPanic(w, "then\n")
-
-		if s.expression != "" {
-			writeOrPanic(w, fmt.Sprintf("```bash\n%vyq %v '%v' %v\n```\n", envCommand, command, s.expression, files))
-		} else {
-			writeOrPanic(w, fmt.Sprintf("```bash\n%vyq %v %v\n```\n", envCommand, command, files))
-		}
-	} else {
-		writeOrPanic(w, "Running\n")
-		writeOrPanic(w, fmt.Sprintf("```bash\n%vyq %v --null-input '%v'\n```\n", envCommand, command, s.expression))
-	}
-	return formattedDoc, formattedDoc2
-}
-
-func documentOutput(t *testing.T, w *bufio.Writer, s expressionScenario, formattedDoc string, formattedDoc2 string) {
-	var output bytes.Buffer
-	var err error
-	printer := NewPrinter(bufio.NewWriter(&output), false, true, false, 2, true)
-
-	node, err := NewExpressionParser().ParseExpression(s.expression)
-	if err != nil {
-		t.Error(fmt.Errorf("Error parsing expression %v of %v: %v", s.expression, s.description, err))
-		return
-	}
-
-	inputs := list.New()
-
-	if s.document != "" {
-		inputs, err = readDocuments(strings.NewReader(formattedDoc), "sample.yml", 0)
-		if err != nil {
-			t.Error(err, s.document, s.expression)
-			return
-		}
-		if s.document2 != "" {
-			moreInputs, err := readDocuments(strings.NewReader(formattedDoc2), "another.yml", 1)
-			if err != nil {
-				t.Error(err, s.document, s.expression)
-				return
-			}
-			inputs.PushBackList(moreInputs)
-		}
-	} else {
-		candidateNode := &CandidateNode{
-			Document:  0,
-			Filename:  "",
-			Node:      &yaml.Node{Tag: "!!null"},
-			FileIndex: 0,
-		}
-		inputs.PushBack(candidateNode)
-
-	}
-
-	results, err := NewDataTreeNavigator().GetMatchingNodes(inputs, node)
-	if err != nil {
-		t.Error(err, s.expression)
-	}
-
-	err = printer.PrintResults(results)
-	if err != nil {
-		t.Error(err, s.expression)
-	}
-
-	writeOrPanic(w, fmt.Sprintf("```yaml\n%v```\n\n", output.String()))
-}
--- a/pkg/yqlib/expression_processing_test.go
+++ b/pkg/yqlib/expression_processing_test.go
@@ -137,11 +137,6 @@ var pathTests = []struct {
 		append(make([]interface{}, 0), "SELF", "ASSIGN_COMMENT", "str (string)"),
 		append(make([]interface{}, 0), "SELF", "str (string)", "ASSIGN_COMMENT"),
 	},
-	{
-		`. lineComment |= "str"`,
-		append(make([]interface{}, 0), "SELF", "ASSIGN_COMMENT", "str (string)"),
-		append(make([]interface{}, 0), "SELF", "str (string)", "ASSIGN_COMMENT"),
-	},
 	{
 		`.a.b tag="!!str"`,
 		append(make([]interface{}, 0), "a", "SHORT_PIPE", "b", "ASSIGN_TAG", "!!str (string)"),
@@ -164,8 +159,8 @@ var pathTests = []struct {
 	},
 }

-var tokeniser = newExpressionTokeniser()
-var postFixer = newExpressionPostFixer()
+var tokeniser = NewPathTokeniser()
+var postFixer = NewPathPostFixer()

 func TestPathParsing(t *testing.T) {
 	for _, tt := range pathTests {
--- a/pkg/yqlib/expression_postfix.go
+++ b/pkg/yqlib/expression_postfix.go
@@ -6,40 +6,40 @@ import (
 	logging "gopkg.in/op/go-logging.v1"
 )

-type expressionPostFixer interface {
-	ConvertToPostfix([]*token) ([]*Operation, error)
+type PathPostFixer interface {
+	ConvertToPostfix([]*Token) ([]*Operation, error)
 }

-type expressionPostFixerImpl struct {
+type pathPostFixer struct {
 }

-func newExpressionPostFixer() expressionPostFixer {
-	return &expressionPostFixerImpl{}
+func NewPathPostFixer() PathPostFixer {
+	return &pathPostFixer{}
 }

-func popOpToResult(opStack []*token, result []*Operation) ([]*token, []*Operation) {
-	var newOp *token
+func popOpToResult(opStack []*Token, result []*Operation) ([]*Token, []*Operation) {
+	var newOp *Token
 	opStack, newOp = opStack[0:len(opStack)-1], opStack[len(opStack)-1]
 	return opStack, append(result, newOp.Operation)
 }

-func (p *expressionPostFixerImpl) ConvertToPostfix(infixTokens []*token) ([]*Operation, error) {
+func (p *pathPostFixer) ConvertToPostfix(infixTokens []*Token) ([]*Operation, error) {
 	var result []*Operation
 	// surround the whole thing with quotes
-	var opStack = []*token{&token{TokenType: openBracket}}
-	var tokens = append(infixTokens, &token{TokenType: closeBracket})
+	var opStack = []*Token{&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)
-		switch currentToken.TokenType {
-		case openBracket, openCollect, openCollectObject:
-			opStack = append(opStack, currentToken)
-		case closeCollect, closeCollectObject:
-			var opener tokenType = openCollect
-			var collectOperator *operationType = collectOpType
-			if currentToken.TokenType == closeCollectObject {
-				opener = openCollectObject
-				collectOperator = collectObjectOpType
+	for _, token := range tokens {
+		log.Debugf("postfix processing token %v, %v", token.toString(), token.Operation)
+		switch token.TokenType {
+		case OpenBracket, OpenCollect, OpenCollectObject:
+			opStack = append(opStack, token)
+		case CloseCollect, CloseCollectObject:
+			var opener TokenType = OpenCollect
+			var collectOperator *OperationType = Collect
+			if token.TokenType == CloseCollectObject {
+				opener = OpenCollectObject
+				collectOperator = CollectObject
 			}
 			itemsInMiddle := false
 			for len(opStack) > 0 && opStack[len(opStack)-1].TokenType != opener {
@@ -48,7 +48,7 @@ func (p *expressionPostFixerImpl) ConvertToPostfix(infixTokens []*token) ([]*Ope
 			}
 			if !itemsInMiddle {
 				// must be an empty collection, add the empty object as a LHS parameter
-				result = append(result, &Operation{OperationType: emptyOpType})
+				result = append(result, &Operation{OperationType: Empty})
 			}
 			if len(opStack) == 0 {
 				return nil, errors.New("Bad path expression, got close collect brackets without matching opening bracket")
@@ -56,10 +56,10 @@ func (p *expressionPostFixerImpl) ConvertToPostfix(infixTokens []*token) ([]*Ope
 			// now we should have [] as the last element on the opStack, get rid of it
 			opStack = opStack[0 : len(opStack)-1]
 			//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}})
-		case closeBracket:
-			for len(opStack) > 0 && opStack[len(opStack)-1].TokenType != openBracket {
+			opStack = append(opStack, &Token{TokenType: OperationToken, Operation: &Operation{OperationType: ShortPipe}})
+			opStack = append(opStack, &Token{TokenType: OperationToken, Operation: &Operation{OperationType: collectOperator}})
+		case CloseBracket:
+			for len(opStack) > 0 && opStack[len(opStack)-1].TokenType != OpenBracket {
 				opStack, result = popOpToResult(opStack, result)
 			}
 			if len(opStack) == 0 {
@@ -69,22 +69,22 @@ func (p *expressionPostFixerImpl) ConvertToPostfix(infixTokens []*token) ([]*Ope
 			opStack = opStack[0 : len(opStack)-1]

 		default:
-			var currentPrecedence = currentToken.Operation.OperationType.Precedence
+			var currentPrecedence = token.Operation.OperationType.Precedence
 			// pop off higher precedent operators onto the result
 			for len(opStack) > 0 &&
-				opStack[len(opStack)-1].TokenType == operationToken &&
+				opStack[len(opStack)-1].TokenType == OperationToken &&
 				opStack[len(opStack)-1].Operation.OperationType.Precedence >= currentPrecedence {
 				opStack, result = popOpToResult(opStack, result)
 			}
 			// add this operator to the opStack
-			opStack = append(opStack, currentToken)
+			opStack = append(opStack, token)
 		}
 	}

 	if log.IsEnabledFor(logging.DEBUG) {
 		log.Debugf("PostFix Result:")
-		for _, currentToken := range result {
-			log.Debugf("> %v", currentToken.toString())
+		for _, token := range result {
+			log.Debugf("> %v", token.toString())
 		}
 	}

--- a/pkg/yqlib/path_tokeniser.go
+++ b/pkg/yqlib/path_tokeniser.go
@@ -0,0 +1,354 @@
+package yqlib
+
+import (
+	"fmt"
+	"strconv"
+
+	lex "github.com/timtadh/lexmachine"
+	"github.com/timtadh/lexmachine/machines"
+)
+
+func skip(*lex.Scanner, *machines.Match) (interface{}, error) {
+	return nil, nil
+}
+
+type TokenType uint32
+
+const (
+	OperationToken = 1 << iota
+	OpenBracket
+	CloseBracket
+	OpenCollect
+	CloseCollect
+	OpenCollectObject
+	CloseCollectObject
+	TraverseArrayCollect
+)
+
+type Token struct {
+	TokenType            TokenType
+	Operation            *Operation
+	AssignOperation      *Operation // e.g. tag (GetTag) op becomes AssignTag if '=' follows it
+	CheckForPostTraverse bool       // e.g. [1]cat should really be [1].cat
+
+}
+
+func (t *Token) toString() string {
+	if t.TokenType == OperationToken {
+		log.Debug("toString, its an op")
+		return t.Operation.toString()
+	} else if t.TokenType == OpenBracket {
+		return "("
+	} else if t.TokenType == CloseBracket {
+		return ")"
+	} else if t.TokenType == OpenCollect {
+		return "["
+	} else if t.TokenType == CloseCollect {
+		return "]"
+	} else if t.TokenType == OpenCollectObject {
+		return "{"
+	} else if t.TokenType == CloseCollectObject {
+		return "}"
+	} else if t.TokenType == TraverseArrayCollect {
+		return ".["
+
+	} else {
+		return "NFI"
+	}
+}
+
+func pathToken(wrapped bool) lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		value := string(m.Bytes)
+		value = value[1:]
+		if wrapped {
+			value = unwrap(value)
+		}
+		log.Debug("PathToken %v", value)
+		op := &Operation{OperationType: TraversePath, Value: value, StringValue: value}
+		return &Token{TokenType: OperationToken, Operation: op, CheckForPostTraverse: true}, nil
+	}
+}
+
+func documentToken() lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		var numberString = string(m.Bytes)
+		numberString = numberString[1:]
+		var number, errParsingInt = strconv.ParseInt(numberString, 10, 64) // nolint
+		if errParsingInt != nil {
+			return nil, errParsingInt
+		}
+		log.Debug("documentToken %v", string(m.Bytes))
+		op := &Operation{OperationType: DocumentFilter, Value: number, StringValue: numberString}
+		return &Token{TokenType: OperationToken, Operation: op, CheckForPostTraverse: true}, nil
+	}
+}
+
+func opToken(op *OperationType) lex.Action {
+	return opTokenWithPrefs(op, nil, nil)
+}
+
+func opAssignableToken(opType *OperationType, assignOpType *OperationType) lex.Action {
+	return opTokenWithPrefs(opType, assignOpType, nil)
+}
+
+func opTokenWithPrefs(op *OperationType, assignOpType *OperationType, preferences interface{}) lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		log.Debug("opTokenWithPrefs %v", string(m.Bytes))
+		value := string(m.Bytes)
+		op := &Operation{OperationType: op, Value: op.Type, StringValue: value, Preferences: preferences}
+		var assign *Operation
+		if assignOpType != nil {
+			assign = &Operation{OperationType: assignOpType, Value: assignOpType.Type, StringValue: value, Preferences: preferences}
+		}
+		return &Token{TokenType: OperationToken, Operation: op, AssignOperation: assign}, nil
+	}
+}
+
+func literalToken(pType TokenType, checkForPost bool) lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		return &Token{TokenType: pType, CheckForPostTraverse: checkForPost}, nil
+	}
+}
+
+func unwrap(value string) string {
+	return value[1 : len(value)-1]
+}
+
+func numberValue() lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		var numberString = string(m.Bytes)
+		var number, errParsingInt = strconv.ParseInt(numberString, 10, 64) // nolint
+		if errParsingInt != nil {
+			return nil, errParsingInt
+		}
+
+		return &Token{TokenType: OperationToken, Operation: CreateValueOperation(number, numberString)}, nil
+	}
+}
+
+func floatValue() lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		var numberString = string(m.Bytes)
+		var number, errParsingInt = strconv.ParseFloat(numberString, 64) // nolint
+		if errParsingInt != nil {
+			return nil, errParsingInt
+		}
+		return &Token{TokenType: OperationToken, Operation: CreateValueOperation(number, numberString)}, nil
+	}
+}
+
+func booleanValue(val bool) lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		return &Token{TokenType: OperationToken, Operation: CreateValueOperation(val, string(m.Bytes))}, nil
+	}
+}
+
+func stringValue(wrapped bool) lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		value := string(m.Bytes)
+		if wrapped {
+			value = unwrap(value)
+		}
+		return &Token{TokenType: OperationToken, Operation: CreateValueOperation(value, value)}, nil
+	}
+}
+
+func nullValue() lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		return &Token{TokenType: OperationToken, Operation: CreateValueOperation(nil, string(m.Bytes))}, nil
+	}
+}
+
+func selfToken() lex.Action {
+	return func(s *lex.Scanner, m *machines.Match) (interface{}, error) {
+		op := &Operation{OperationType: SelfReference}
+		return &Token{TokenType: OperationToken, Operation: op}, nil
+	}
+}
+
+func initLexer() (*lex.Lexer, error) {
+	lexer := lex.NewLexer()
+	lexer.Add([]byte(`\(`), literalToken(OpenBracket, false))
+	lexer.Add([]byte(`\)`), literalToken(CloseBracket, true))
+
+	// lexer.Add([]byte(`\.\[\]`), pathToken(false)) // traverseCollect(false)
+	lexer.Add([]byte(`\.\[`), literalToken(TraverseArrayCollect, false))
+	lexer.Add([]byte(`\.\.`), opToken(RecursiveDescent))
+
+	lexer.Add([]byte(`,`), opToken(Union))
+	lexer.Add([]byte(`:\s*`), opToken(CreateMap))
+	lexer.Add([]byte(`length`), opToken(Length))
+	lexer.Add([]byte(`sortKeys`), opToken(SortKeys))
+	lexer.Add([]byte(`select`), opToken(Select))
+	lexer.Add([]byte(`has`), opToken(Has))
+	lexer.Add([]byte(`explode`), opToken(Explode))
+	lexer.Add([]byte(`or`), opToken(Or))
+	lexer.Add([]byte(`and`), opToken(And))
+	lexer.Add([]byte(`not`), opToken(Not))
+	lexer.Add([]byte(`\/\/`), opToken(Alternative))
+
+	lexer.Add([]byte(`documentIndex`), opToken(GetDocumentIndex))
+
+	lexer.Add([]byte(`style`), opAssignableToken(GetStyle, AssignStyle))
+
+	lexer.Add([]byte(`tag`), opAssignableToken(GetTag, AssignTag))
+	lexer.Add([]byte(`anchor`), opAssignableToken(GetAnchor, AssignAnchor))
+	lexer.Add([]byte(`alias`), opAssignableToken(GetAlias, AssignAlias))
+	lexer.Add([]byte(`filename`), opToken(GetFilename))
+	lexer.Add([]byte(`fileIndex`), opToken(GetFileIndex))
+	lexer.Add([]byte(`path`), opToken(GetPath))
+
+	lexer.Add([]byte(`lineComment`), opTokenWithPrefs(GetComment, AssignComment, &CommentOpPreferences{LineComment: true}))
+
+	lexer.Add([]byte(`headComment`), opTokenWithPrefs(GetComment, AssignComment, &CommentOpPreferences{HeadComment: true}))
+
+	lexer.Add([]byte(`footComment`), opTokenWithPrefs(GetComment, AssignComment, &CommentOpPreferences{FootComment: true}))
+
+	lexer.Add([]byte(`comments\s*=`), opTokenWithPrefs(AssignComment, nil, &CommentOpPreferences{LineComment: true, HeadComment: true, FootComment: true}))
+
+	lexer.Add([]byte(`collect`), opToken(Collect))
+
+	lexer.Add([]byte(`\s*==\s*`), opToken(Equals))
+	lexer.Add([]byte(`\s*=\s*`), opTokenWithPrefs(Assign, nil, &AssignOpPreferences{false}))
+
+	lexer.Add([]byte(`del`), opToken(DeleteChild))
+
+	lexer.Add([]byte(`\s*\|=\s*`), opTokenWithPrefs(Assign, nil, &AssignOpPreferences{true}))
+
+	// lexer.Add([]byte(`\.\[-?[0-9]+\]`), arrayIndextoken(true)) // traverseCollect(true)
+
+	lexer.Add([]byte("( |\t|\n|\r)+"), skip)
+
+	lexer.Add([]byte(`d[0-9]+`), documentToken())
+	lexer.Add([]byte(`\."[^ "]+"`), pathToken(true))
+	lexer.Add([]byte(`\.[^ \}\{\:\[\],\|\.\[\(\)=]+`), pathToken(false))
+	lexer.Add([]byte(`\.`), selfToken())
+
+	lexer.Add([]byte(`\|`), opToken(Pipe))
+
+	lexer.Add([]byte(`-?\d+(\.\d+)`), floatValue())
+	lexer.Add([]byte(`-?[1-9](\.\d+)?[Ee][-+]?\d+`), floatValue())
+	lexer.Add([]byte(`-?\d+`), numberValue())
+
+	lexer.Add([]byte(`[Tt][Rr][Uu][Ee]`), booleanValue(true))
+	lexer.Add([]byte(`[Ff][Aa][Ll][Ss][Ee]`), booleanValue(false))
+
+	lexer.Add([]byte(`[Nn][Uu][Ll][Ll]`), nullValue())
+	lexer.Add([]byte(`~`), nullValue())
+
+	lexer.Add([]byte(`"[^"]*"`), stringValue(true))
+
+	lexer.Add([]byte(`\[`), literalToken(OpenCollect, false))
+	lexer.Add([]byte(`\]`), literalToken(CloseCollect, true))
+	lexer.Add([]byte(`\{`), literalToken(OpenCollectObject, false))
+	lexer.Add([]byte(`\}`), literalToken(CloseCollectObject, true))
+	lexer.Add([]byte(`\*`), opTokenWithPrefs(Multiply, nil, &MultiplyPreferences{AppendArrays: false}))
+	lexer.Add([]byte(`\*\+`), opTokenWithPrefs(Multiply, nil, &MultiplyPreferences{AppendArrays: true}))
+	lexer.Add([]byte(`\+`), opToken(Add))
+	lexer.Add([]byte(`\+=`), opToken(AddAssign))
+
+	err := lexer.Compile()
+	if err != nil {
+		return nil, err
+	}
+	return lexer, nil
+}
+
+type PathTokeniser interface {
+	Tokenise(path string) ([]*Token, error)
+}
+
+type pathTokeniser struct {
+	lexer *lex.Lexer
+}
+
+func NewPathTokeniser() PathTokeniser {
+	var lexer, err = initLexer()
+	if err != nil {
+		panic(err)
+	}
+	return &pathTokeniser{lexer}
+}
+
+func (p *pathTokeniser) Tokenise(path string) ([]*Token, error) {
+	scanner, err := p.lexer.Scanner([]byte(path))
+
+	if err != nil {
+		return nil, fmt.Errorf("Parsing expression: %v", err)
+	}
+	var tokens []*Token
+	for tok, err, eof := scanner.Next(); !eof; tok, err, eof = scanner.Next() {
+
+		if tok != nil {
+			token := tok.(*Token)
+			log.Debugf("Tokenising %v", token.toString())
+			tokens = append(tokens, token)
+		}
+		if err != nil {
+			return nil, fmt.Errorf("Parsing expression: %v", err)
+		}
+	}
+	var postProcessedTokens = make([]*Token, 0)
+
+	skipNextToken := false
+
+	for index := range tokens {
+		if skipNextToken {
+			skipNextToken = false
+		} else {
+			postProcessedTokens, skipNextToken = p.handleToken(tokens, index, postProcessedTokens)
+		}
+	}
+
+	return postProcessedTokens, nil
+}
+
+func (p *pathTokeniser) handleToken(tokens []*Token, index int, postProcessedTokens []*Token) (tokensAccum []*Token, skipNextToken bool) {
+	skipNextToken = false
+	token := tokens[index]
+
+	if token.TokenType == TraverseArrayCollect {
+		//need to put a traverse array then a collect token
+		// do this by adding traverse then converting token to collect
+
+		op := &Operation{OperationType: TraverseArray, StringValue: "TRAVERSE_ARRAY"}
+		postProcessedTokens = append(postProcessedTokens, &Token{TokenType: OperationToken, Operation: op})
+
+		token = &Token{TokenType: OpenCollect}
+
+	}
+
+	if index != len(tokens)-1 && token.AssignOperation != nil &&
+		tokens[index+1].TokenType == OperationToken &&
+		tokens[index+1].Operation.OperationType == Assign {
+		token.Operation = token.AssignOperation
+		skipNextToken = true
+	}
+
+	postProcessedTokens = append(postProcessedTokens, token)
+
+	if index != len(tokens)-1 && token.CheckForPostTraverse &&
+		tokens[index+1].TokenType == OperationToken &&
+		tokens[index+1].Operation.OperationType == TraversePath {
+		op := &Operation{OperationType: ShortPipe, Value: "PIPE"}
+		postProcessedTokens = append(postProcessedTokens, &Token{TokenType: OperationToken, Operation: op})
+	}
+	if index != len(tokens)-1 && token.CheckForPostTraverse &&
+		tokens[index+1].TokenType == OpenCollect {
+
+		op := &Operation{OperationType: ShortPipe, Value: "PIPE"}
+		postProcessedTokens = append(postProcessedTokens, &Token{TokenType: OperationToken, Operation: op})
+
+		op = &Operation{OperationType: TraverseArray}
+		postProcessedTokens = append(postProcessedTokens, &Token{TokenType: OperationToken, Operation: op})
+	}
+	if index != len(tokens)-1 && token.CheckForPostTraverse &&
+		tokens[index+1].TokenType == TraverseArrayCollect {
+
+		op := &Operation{OperationType: ShortPipe, Value: "PIPE"}
+		postProcessedTokens = append(postProcessedTokens, &Token{TokenType: OperationToken, Operation: op})
+
+	}
+	return postProcessedTokens, skipNextToken
+}
--- a/pkg/yqlib/expression_parser.go
+++ b/pkg/yqlib/expression_parser.go
@@ -5,28 +5,29 @@ import (
 	"strings"
 )

-var myPathTokeniser = newExpressionTokeniser()
-var myPathPostfixer = newExpressionPostFixer()
+var myPathTokeniser = NewPathTokeniser()
+var myPathPostfixer = NewPathPostFixer()

-type ExpressionNode struct {
+type PathTreeNode struct {
 	Operation *Operation
-	Lhs       *ExpressionNode
-	Rhs       *ExpressionNode
+	Lhs       *PathTreeNode
+	Rhs       *PathTreeNode
 }

-type ExpressionParser interface {
-	ParseExpression(expression string) (*ExpressionNode, error)
+type PathTreeCreator interface {
+	ParsePath(path string) (*PathTreeNode, error)
+	CreatePathTree(postFixPath []*Operation) (*PathTreeNode, error)
 }

-type expressionParserImpl struct {
+type pathTreeCreator struct {
 }

-func NewExpressionParser() ExpressionParser {
-	return &expressionParserImpl{}
+func NewPathTreeCreator() PathTreeCreator {
+	return &pathTreeCreator{}
 }

-func (p *expressionParserImpl) ParseExpression(expression string) (*ExpressionNode, error) {
-	tokens, err := myPathTokeniser.Tokenise(expression)
+func (p *pathTreeCreator) ParsePath(path string) (*PathTreeNode, error) {
+	tokens, err := myPathTokeniser.Tokenise(path)
 	if err != nil {
 		return nil, err
 	}
@@ -35,18 +36,18 @@ func (p *expressionParserImpl) ParseExpression(expression string) (*ExpressionNo
 	if err != nil {
 		return nil, err
 	}
-	return p.createExpressionTree(Operations)
+	return p.CreatePathTree(Operations)
 }

-func (p *expressionParserImpl) createExpressionTree(postFixPath []*Operation) (*ExpressionNode, error) {
-	var stack = make([]*ExpressionNode, 0)
+func (p *pathTreeCreator) CreatePathTree(postFixPath []*Operation) (*PathTreeNode, error) {
+	var stack = make([]*PathTreeNode, 0)

 	if len(postFixPath) == 0 {
 		return nil, nil
 	}

 	for _, Operation := range postFixPath {
-		var newNode = ExpressionNode{Operation: Operation}
+		var newNode = PathTreeNode{Operation: Operation}
 		log.Debugf("pathTree %v ", Operation.toString())
 		if Operation.OperationType.NumArgs > 0 {
 			numArgs := Operation.OperationType.NumArgs
--- a/pkg/yqlib/expression_parser_test.go
+++ b/pkg/yqlib/expression_parser_test.go
@@ -7,36 +7,36 @@ import (
 )

 func TestPathTreeNoArgsForTwoArgOp(t *testing.T) {
-	_, err := NewExpressionParser().ParseExpression("=")
+	_, err := treeCreator.ParsePath("=")
 	test.AssertResultComplex(t, "'=' expects 2 args but there is 0", err.Error())
 }

 func TestPathTreeOneLhsArgsForTwoArgOp(t *testing.T) {
-	_, err := NewExpressionParser().ParseExpression(".a =")
+	_, err := treeCreator.ParsePath(".a =")
 	test.AssertResultComplex(t, "'=' expects 2 args but there is 1", err.Error())
 }

 func TestPathTreeOneRhsArgsForTwoArgOp(t *testing.T) {
-	_, err := NewExpressionParser().ParseExpression("= .a")
+	_, err := treeCreator.ParsePath("= .a")
 	test.AssertResultComplex(t, "'=' expects 2 args but there is 1", err.Error())
 }

 func TestPathTreeTwoArgsForTwoArgOp(t *testing.T) {
-	_, err := NewExpressionParser().ParseExpression(".a = .b")
+	_, err := treeCreator.ParsePath(".a = .b")
 	test.AssertResultComplex(t, nil, err)
 }

 func TestPathTreeNoArgsForOneArgOp(t *testing.T) {
-	_, err := NewExpressionParser().ParseExpression("explode")
+	_, err := treeCreator.ParsePath("explode")
 	test.AssertResultComplex(t, "'explode' expects 1 arg but received none", err.Error())
 }

 func TestPathTreeOneArgForOneArgOp(t *testing.T) {
-	_, err := NewExpressionParser().ParseExpression("explode(.)")
+	_, err := treeCreator.ParsePath("explode(.)")
 	test.AssertResultComplex(t, nil, err)
 }

 func TestPathTreeExtraArgs(t *testing.T) {
-	_, err := NewExpressionParser().ParseExpression("sortKeys(.) explode(.)")
+	_, err := treeCreator.ParsePath("sortKeys(.) explode(.)")
 	test.AssertResultComplex(t, "expected end of expression but found 'explode', please check expression syntax", err.Error())
 }
--- a/pkg/yqlib/printer.go
+++ b/pkg/yqlib/printer.go
@@ -24,7 +24,6 @@ type resultsPrinter struct {
 	previousDocIndex   uint
 	previousFileIndex  int
 	printedMatches     bool
-	treeNavigator      DataTreeNavigator
 }

 func NewPrinter(writer io.Writer, outputToJSON bool, unwrapScalar bool, colorsEnabled bool, indent int, printDocSeparators bool) Printer {
@@ -36,7 +35,6 @@ func NewPrinter(writer io.Writer, outputToJSON bool, unwrapScalar bool, colorsEn
 		indent:             indent,
 		printDocSeparators: printDocSeparators,
 		firstTimePrinting:  true,
-		treeNavigator:      NewDataTreeNavigator(),
 	}
 }

@@ -76,9 +74,9 @@ func (p *resultsPrinter) PrintResults(matchingNodes *list.List) error {
 	log.Debug("PrintResults for %v matches", matchingNodes.Len())
 	var err error
 	if p.outputToJSON {
-		explodeOp := Operation{OperationType: explodeOpType}
-		explodeNode := ExpressionNode{Operation: &explodeOp}
-		matchingNodes, err = p.treeNavigator.GetMatchingNodes(matchingNodes, &explodeNode)
+		explodeOp := Operation{OperationType: Explode}
+		explodeNode := PathTreeNode{Operation: &explodeOp}
+		matchingNodes, err = treeNavigator.GetMatchingNodes(matchingNodes, &explodeNode)
 		if err != nil {
 			return err
 		}
--- a/pkg/yqlib/stream_evaluator.go
+++ b/pkg/yqlib/stream_evaluator.go
@@ -8,27 +8,24 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )

-// A yaml expression evaluator that runs the expression multiple times for each given yaml document.
-// Uses less memory than loading all documents and running the expression once, but this cannot process
-// cross document expressions.
 type StreamEvaluator interface {
-	Evaluate(filename string, reader io.Reader, node *ExpressionNode, printer Printer) error
+	Evaluate(filename string, reader io.Reader, node *PathTreeNode, printer Printer) error
 	EvaluateFiles(expression string, filenames []string, printer Printer) error
 	EvaluateNew(expression string, printer Printer) error
 }

 type streamEvaluator struct {
 	treeNavigator DataTreeNavigator
-	treeCreator   ExpressionParser
+	treeCreator   PathTreeCreator
 	fileIndex     int
 }

 func NewStreamEvaluator() StreamEvaluator {
-	return &streamEvaluator{treeNavigator: NewDataTreeNavigator(), treeCreator: NewExpressionParser()}
+	return &streamEvaluator{treeNavigator: NewDataTreeNavigator(), treeCreator: NewPathTreeCreator()}
 }

 func (s *streamEvaluator) EvaluateNew(expression string, printer Printer) error {
-	node, err := s.treeCreator.ParseExpression(expression)
+	node, err := treeCreator.ParsePath(expression)
 	if err != nil {
 		return err
 	}
@@ -41,7 +38,7 @@ func (s *streamEvaluator) EvaluateNew(expression string, printer Printer) error
 	inputList := list.New()
 	inputList.PushBack(candidateNode)

-	matches, errorParsing := s.treeNavigator.GetMatchingNodes(inputList, node)
+	matches, errorParsing := treeNavigator.GetMatchingNodes(inputList, node)
 	if errorParsing != nil {
 		return errorParsing
 	}
@@ -50,7 +47,7 @@ func (s *streamEvaluator) EvaluateNew(expression string, printer Printer) error

 func (s *streamEvaluator) EvaluateFiles(expression string, filenames []string, printer Printer) error {

-	node, err := s.treeCreator.ParseExpression(expression)
+	node, err := treeCreator.ParsePath(expression)
 	if err != nil {
 		return err
 	}
@@ -73,7 +70,7 @@ func (s *streamEvaluator) EvaluateFiles(expression string, filenames []string, p
 	return nil
 }

-func (s *streamEvaluator) Evaluate(filename string, reader io.Reader, node *ExpressionNode, printer Printer) error {
+func (s *streamEvaluator) Evaluate(filename string, reader io.Reader, node *PathTreeNode, printer Printer) error {

 	var currentIndex uint

@@ -97,7 +94,7 @@ func (s *streamEvaluator) Evaluate(filename string, reader io.Reader, node *Expr
 		inputList := list.New()
 		inputList.PushBack(candidateNode)

-		matches, errorParsing := s.treeNavigator.GetMatchingNodes(inputList, node)
+		matches, errorParsing := treeNavigator.GetMatchingNodes(inputList, node)
 		if errorParsing != nil {
 			return errorParsing
 		}
--- a/pkg/yqlib/utils.go
+++ b/pkg/yqlib/utils.go
@@ -9,6 +9,9 @@ import (
 	yaml "gopkg.in/yaml.v3"
 )

+var treeNavigator = NewDataTreeNavigator()
+var treeCreator = NewPathTreeCreator()
+
 func readStream(filename string) (io.Reader, error) {
 	if filename == "-" {
 		return bufio.NewReader(os.Stdin), nil
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Mike Farah	822d56a673	tests passsing!	2020-12-27 22:47:19 +11:00
Mike Farah	4e1a1025c3	wip	2020-12-27 22:29:00 +11:00
Mike Farah	7b54bead5e	wip	2020-12-27 22:14:26 +11:00
Mike Farah	f7f8bed955	wip	2020-12-27 09:55:21 +11:00
Mike Farah	6a13c8b78f	Traverse Array Operator	2020-12-27 09:55:21 +11:00
				`@@ -1,2 +0,0 @@`
				This operator is used to handle environment variables usage in path expressions. While environment variables can, of course, be passed in via your CLI with string interpolation, this often comes with complex quote escaping and can be tricky to write and read. Note that there are two forms, `env` which will parse the environment variable as a yaml (be it a map, array, string, number of boolean) and `strenv` which will always parse the argument as a string.