bit of code taken from the jsonata-test section and modified so that comments (like this one) can be written in the code enables:

- comments in jsonata code
- fields with any character in their name i.e 'Field #' or "$ CURRENCY"

use case:

import (
	"encoding/json"
	"fmt"
	"log"

	jsonata "github.com/blues/jsonata-go"
)

const jsonString = `
    {
        "orders": [
            {"price": 10, "quantity": 3},
            {"price": 0.5, "quantity": 10},
            {"price": 100, "quantity": 1}
        ]
    }
`

func main() {

	var data interface{}

	// Decode JSON.
	err := json.Unmarshal([]byte(jsonString), &data)
	if err != nil {
		log.Fatal(err)
	}
	
	jsonataCode := "$sum(orders.(price*quantity)) /* this is an inline comment!*/"
	
	cleanCode := jsonata.Clean(jsonataCode)

	// Create expression.
	e := jsonata.MustCompile(cleanCode)

	// Evaluate.
	res, err := e.Eval(data)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(res)
	// Output: 135
}

This function will remove exact duplicate objects in a jsonata result. You can't always use $distinct() where you want to (only on top level calls) so this is a go 'distinct' that you can run after you've done jsonata work.

It's a simple function but saves people having to discover this themselves.

I figured this would be a useful function to embed in the go package - because then people can run it like this within go:

	e := jsonata.MustCompile("$sum(orders.(price*quantity))")

	// Evaluate.
	res, err := e.Eval(data)
	if err != nil {
		log.Fatal(err)
	}

        f, err := jsonata.Distinct(res)
	if err != nil {
		log.Fatal(err)
	}
        // f will be a distinct set of results

Changes

• float to decimal
• setting DivisionPrecision = 8

PR Type

What kind of change does this PR introduce?

• [ ] Bugfix
• [ ] Feature
• [ ] Code style update (formatting, local variables)
• [x] Refactoring (no functional changes, no api changes)
• [ ] Build related changes
• [ ] CI related changes
• [ ] Documentation content changes
• [ ] angular.io application / infrastructure changes
• [ ] Other... Please describe:

Does this PR introduce a breaking change?

• [ ] Yes
• [x] No

Excuse. I have defined a jsonata.Extension, for example:

"mandatory": { Func: func(input string) (string, error) { if input == "" { return input, errors.New(" input is required ") } return input, nil }, }

If the parameter is not passed to “input”, how can I make jsonata not report an error?

Hi,

First, thanks for the library. I want to cache the compiled expression and use it concurrently across threads. Is this possible?

See this feature in the .Net version. https://github.com/mikhail-barg/jsonata.net.native

Thanks

includes commits from https://github.com/ASJadeTech/jsonata-go and https://github.com/xiatechs/jsonata-go

features:

• add refactored decimal precision logic
• add ability to include /* comments */ and ability to use $."Fields with spaces"
• adds a simple join function 0 $sjoin(obj1, obj2, "id", "id) etc

Firstly - excellent work porting jsonata to Golang. Impressive. I have a request:

In original JSONATA they have # and @ operators which enable JOIN like operations on data (a simplification on top of usage of map and filter) i.e

$$.new.additionalfeatures @ $T1.$$.old.items @ $T2[$T1.id = $T2.id].{
    "id": $T1.id,
    "color": $T1.colour,
    "name": $T2.name
}

and currently you'd need to do something like

$$.old.items.{
    "id": $.id,
    "name": $.name,
    "color": ($filter($$.new.additionalfeatures, function($i){$i.id = $.id})).colour
}

It would be useful to have at least the @ operator added to the Go port of jsonata.

I appreciate this would be a fiddly bit of work - so it's a 'nice to have'.

In try.jsonata.org, the following evaluate identically as a way of demoting the entire source object into a field.

{ "event":$[0] }

...and...

{ "event":$[] }

...are equivalent to...

{ "event":$ }

In jsonata-go, $[0] does what one would expect, but the others do not.