jqjq.test

# Test case format is the same as jq --run-tests uses
#
# Format:
# filter expression line
# input JSON line
# zero or more output JSON lines

# null
null
null
null

# number
123, 1.23, 0.123, .123, .123e1, 1.23e1, 2E3, 1.23e+1, 1.23E-2
null
123
1.23
0.123
0.123
1.23
12.3
2000
12.3
0.0123

# string
"abc"
null
"abc"

# string interpolation
"aaa \(123)"
null
"aaa 123"

"aaa \(.) ccc \(.) ddd"
123
"aaa 123 ccc 123 ddd"

"aaa \("a" + . + "c") ccc"
"b"
"aaa abc ccc"

"\("")"
null
""

"aaa \("bbb \("ccc") ddd") eee"
null
"aaa bbb ccc ddd eee"

"aaa \(1,2,3) bbb"
null
"aaa 1 bbb"
"aaa 2 bbb"
"aaa 3 bbb"

"aaa \(def f: .; f) bbb"
[1,2,3]
"aaa [1,2,3] bbb"

"aaa \({a:1}) bbb \([1,2,3]) ccc \(["a","b"])"
null
"aaa {\"a\":1} bbb [1,2,3] ccc [\"a\",\"b\"]"

# unicode codepoint escape
"\u006a\u0071\u1234\uFFff\u0000"
null
"jq\u1234\uffff\u0000"

# surrogate pairs
"\ud83d\udca9", "\uD83D\uDCA9"
null
"💩"
"💩"

"a\u006a\u0071\ud83d\udca9 \(111) a\u006a\u0071\ud83d\udca9 \(222) a\u006a\u0071\ud83d\udca9"
null
"ajq💩 111 ajq💩 222 ajq💩"

"escape \"\n\r\t\f\b\\\/ literal"
null
"escape \"\n\r\t\f\b\\\/ literal"
# TODO: invalid escape

# @format string
@text "aaa \(.) bbb \(.) ccc"
"abc"
"aaa abc bbb abc ccc"

@json "aaa \(.) bbb \(.) ccc"
"abc"
"aaa \"abc\" bbb \"abc\" ccc"

@uri "aaa \(.) bbb \(.)"
"abcäሴ💩"
"aaa abc%C3%A4%E1%88%B4%F0%9F%92%A9 bbb abc%C3%A4%E1%88%B4%F0%9F%92%A9"

# array literal
[]
null
[]

[1,2,3]
null
[1,2,3]

[1,.,empty,3]
2
[1,2,3]

# object literal
{}
null
{}

{a: 1}
null
{"a": 1}

# trailing comma
{a: 1,}
null
{"a": 1}

# priority
{a: 1, a: 2}
null
{"a": 2}

{a}
{"a": 1}
{"a": 1}

{"a"}
{"a": 1}
{"a": 1}

1 as $a | {$a}
null
{"a": 1}

{("a"+"b"): 1}
null
{"ab": 1}

{a: 1, b: 2} | 3 as $c | {a, "b", $c, ("d"): 4}
null
{"a": 1, "b": 2, "c": 3, "d": 4}

# empty key or value means empty output
{a: empty}
null

{(empty): 1}
null

{a: 1, b: empty}
null

{a: 1, b: {c: empty}}
null

{("a","b"): (1,2)}
null
{"a":1}
{"a":2}
{"b":1}
{"b":2}

{a: 1, ("b","c"): (2,3), d: 4}
null
{"a":1,"b":2,"d":4}
{"a":1,"b":3,"d":4}
{"a":1,"c":2,"d":4}
{"a":1,"c":3,"d":4}

{a:"aa",b:"bb",c:3,d:4} | {(.a,.b): (.c,.d)}
null
{"aa":3}
{"aa":4}
{"bb":3}
{"bb":4}

# object val allows | but no other operator
{a: 123 | -., b: 4}
null
{"a":-123,"b":4}

# binding
. as $a | $a
123
123

. as $a | .+$a as $c | $c
123
246

# destructing
. as [$a,$b,$c,$d] | [$d,$c,$b,$a]
[1,2,3]
[null,3,2,1]

. as {$a, b: $b, "c": $c, $d} | [$d,$c,$b,$a]
{"a":1, "b": 2, "c": 3}
[null,3,2,1]

. as {a: $a, b: [[$b]]} | [$a,$b]
{"a":1, "b": [[2]]}
[1,2]

# TODO: object same binding
#. as {a: $a, b: $a} | $a
#{"a":1, "b": [2]}
#1

. as [$a,$a] | $a
[1,2]
2

# valid names
1 as $_ | $_ | 2 as $__ | 3 as $_abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_ | $_, $__, $_abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_
null
1
2
3

def _: 1; def __: 2; def _abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_: 3; _, __, _abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_
null
1
2
3

1 as $_ | $_
null
1

# comma
1,2,3
null
1
2
3

# pipe
1 | .*2
null
2

# empty
empty
null

# identity
.*.*2
2
8

# if
.[] | if . == 1 then "a" end
[1,2]
"a"
2

.[] | if . == 1 then "a" else "b" end
[1,2]
"a"
"b"

.[] | if . == 1 then "a" elif . == 2 then "b" elif . == 3 then "c" else "d" end
[1,2,3,4]
"a"
"b"
"c"
"d"

# zero or more cond outputs
4 | if true,false,true then 1 elif true,false then 2 elif true,false then 3 else . end
null
1
2
3
4
1

2 | if true,empty,true then 1 else . end
null
1
1

2 | if empty then 1 else . end
null

if empty then 1 end
null

if true,true then 1 end
null
1
1

# comparisons
0 == 0, 0 == 1, 1 == 0
null
true
false
false

0 != 0, 0 != 1, 1 != 0
null
false
true
true

0 < 0, 0 < 1, 1 < 0
null
false
true
false

0 <= 0, 0 <= 1, 1 <= 0
null
true
true
false

0 > 0, 0 > 1, 1 > 0
null
false
false
true

0 >= 0, 0 >= 1, 1 >= 0
null
true
false
true

# unary operators
# + not supported by jq?
-1, -(2,3)
null
-1
-2
-3

-(-.)
-123
-123

-(-123)
null
123

# logical operators
true and true, true and false, false and true, false and false
null
true
false
false
false

(true,false) and (true,false)
null
true
false
false

true or true, true or false, false or true, false or false
null
true
true
true
false

(true,false) or (true,false)
null
true
true
false

# arithmetic operators
. + 3
10
13

. - 3
10
7

. * 3
10
30

. / 3
9
3

. % 3
10
1

# functions
def f: 123; f
null
123

def f: .; f
123
123

def f(a): a; f(.*2)
123
246

def f($a): .+$a; f(1,2,3)
1
2
3
4

def f(a): a; f(empty)
null

def f($a): $a; f(empty)
null

# $a is available as a lambda also
def f($a): a | [$a, .]; f(1,2)
null
[1,1]
[1,2]
[2,1]
[2,2]

def f($a; $b; c): [., $a, $b, (.+$a+$b | c)]; f(1,2,3; 10,20; .*2)
100
[100,1,10,222]
[100,1,20,242]
[100,2,10,224]
[100,2,20,244]
[100,3,10,226]
[100,3,20,246]

def a: 20; . + a  + def b: 3; b
100
123

def f: 123; f + f
null
246

# scoping (lexical, can only refer to previous and can't change)
def a: 1; def b: a; def a: 3; b
null
1

# function and lambda arg same name
# TODO: explain lambda not recursive
def f(a): a; def a: 123; f(a)
null
123

def f(f): f; f(123)
null
123

# recursive
def f: if . >= 0 then ., (.-1 | f) else empty end; f
2
2
1
0

# builtins

map(keys)
[{},{"a":1},{"a":1,"b":2},[],[1],[1,2]]
[[],["a"],["a","b"],[],[0],[0,1]]

map(has("a"))
[{},{"a":1}]
[false,true]

map(has(1))
[[],["a"],["a","b"]]
[false,false,true]

del(.a)
{"a":1,"b":2}
{"b":2}

del(.[1])
[1,2,3]
[1,3]

del(.[1],.[1])
[1,2,3]
[1,3]

[], [1,2,3] | map(.*2)
null
[]
[2,4,6]

[1,2] | map(., 10)
null
[1,10,2,10]

1,2,3 | select(. == 2)
null
2

# fromjson, tojson
map(tojson | [., (fromjson | ., tojson)])
[null,1,"str",true,[],{},[1,2,3],{"a":123}]
[["null",null,"null"],["1",1,"1"],["\"str\"","str","\"str\""],["true",true,"true"],["[]",[],"[]"],["{}",{},"{}"],["[1,2,3]",[1,2,3],"[1,2,3]"],["{\"a\":123}",{"a":123},"{\"a\":123}"]]

# precedence
# TODO: add more
1+2+3*4*5-6-7/8/9,.|.
null
56.90277777777778
null

# assign
.a = 123
null
{"a":123}

(.a,.b) = 123
null
{"a":123,"b":123}

# update |=
.a = 123 | .a |= . + 1
null
{"a":124}

.a = 123 | (.a,.b) |= . + 3
null
{"a":126,"b":3}

# update +=

.a = 123 | .a += 3
null
{"a":126}

.a = 123 | (.a,.b) += 3
null
{"a":126,"b":3}

# += etc rhs gets lhs input as input, different from |= where rhs get output as lhs as input
.a = 3 | .a += .a + 3
null
{"a":9}

# update -=

.a = 123 | .a -= 3
null
{"a":120}

.a = 123 | .b = 0 | (.a,.b) -= 3
null
{"a":120,"b":-3}

# update *=

.a = 123 | .a *= 3
null
{"a":369}

.a = 123 | .b = 1 | (.a,.b) *= 3
null
{"a":369,"b":3}

# update /=

.a = 120 | .a /= 3
null
{"a":40}

.a = 120 | .b = 3 | (.a,.b) /= 3
null
{"a":40,"b":1}

# update %=

.a = 123 | .a %= 4
null
{"a":3}

.a = 123 | .b = 4 | (.a,.b) %= 4
null
{"a":3,"b":0}

# reduce
reduce (.,2,3) as $v (.; . + $v)
1
7

reduce empty as $v (123; .)
null
123

# foreach
foreach (.,2,3) as $v (.; . + $v)
1
2
4
7

foreach (.,2,3) as $v (.; . + $v; . * 2)
1
4
8
14

foreach empty as $v (123; .)
null

# make sure binding is correct in extract
foreach ("a","b") as $v (0;0;$v)
null
"a"
"b"

# array slice
.[0:], .[1:], .[1:-1], .[1:-2], .[-2:], .[-1:]
[1,2,3,4]
[1,2,3,4]
[2,3,4]
[2,3]
[2]
[3,4]
[4]

.[:0], .[:1], .[:4], .[-2:], .[-1:], .[1:3], .[1:-2]
[1,2,3,4]
[]
[1]
[1,2,3,4]
[3,4]
[4]
[2,3]
[2]

# tests def and "," associativity
# test from jq's jq.test
def f: 1; def g: f, def f: 2; def g: 3; f, def f: g; f, g; def f: 4; [f, def f: g; def g: 5; f, g]+[f,g]
null
[4,1,2,3,3,5,4,1,2,3,3]

# try catch and ?
try .
123
123

try . catch 456
123
123

try error(.)
123

try error(.) catch .
123
123

# try and , and | operator precedence
try error, try error catch 3
null
3

try 1 catch error, try error catch 3
null
1
3

try 1 catch 2 | 3
null
3

# TODO: some try 1 | ... test?

# null error same as empty
try error catch .
null
null

try error(null) catch .
123
null

try (1+"a") catch .
null
"number (1) and string (\"a\") cannot be added"

(1+"a")?
null

error(123)?
null

error(123)? // 456
null
456

# standard library
map(add)
[[], [1], [1,2,3]]
[null,1,6]

join("-")
[1,"a",null,true,false]
"1-a--true-false"

join("-")
[]
""

map(scalars)
[1,"a",null,true,false,{},[]]
[1,"a",null,true,false]

map(not)
[null,false,true,1]
[true,true,false,false]

select(false)
null

map(select(. != 1))
[0,1,2]
[0,2]

map(.,.), map(.), map(empty)
[1,2]
[1,1,2,2]
[1,2]
[]

map(min)
[[],[1],[3,1,2]]
[null,1,1]

min_by(.a)
[{"a":3},{"a":1},{"a":1,"last":true},{"a":2}]
{"a":1}

map(max)
[[],[1],[2,3,1]]
[null,1,3]

max_by(.a)
[{"a":1},{"a":3},{"a":3,"last":true},{"a":2}]
{"a":3,"last":true}

map([range(.[0]; .[1]; .[2])])
[[0,0,0],[-10,0,2],[0,-10,-2],[0,10,3],[10,0,3]]
[[],[-10,-8,-6,-4,-2],[0,-2,-4,-6,-8],[0,3,6,9],[]]

map([range(.[0]; .[1])])
[[-2,0],[0,-2],[0,2],[2,0]]
[[-2,-1],[],[0,1],[]]

map([range(.)])
[-1,0,1,2]
[[],[],[0],[0,1]]

map(reverse)
[[],[1],[1,2,3]]
[[],[1],[3,2,1]]

[recurse], [..]
{"a":[1,2,3]}
[{"a":[1,2,3]},[1,2,3],1,2,3]
[{"a":[1,2,3]},[1,2,3],1,2,3]

[recurse(if length == 0 then empty else .[1:] end)]
[1,2,3]
[[1,2,3],[2,3],[3],[]]

[recurse(if length == 0 then empty else .[1:] end; . != [3])]
[1,2,3]
[[1,2,3],[2,3]]

map(sort)
[[],[1],[3,2],[3,1,2]]
[[],[1],[2,3],[1,2,3]]

map(sort)
[[],[{"a":1}],[{"a":3},{"a":2}],[{"a":3},{"a":1},{"a":2}]]
[[],[{"a":1}],[{"a":2},{"a":3}],[{"a":1},{"a":2},{"a":3}]]

sort_by(.b, .a)
[{"a":1,"b":2},{"a":2,"b":1}]
[{"a":2,"b":1},{"a":1,"b":2}]

# stable sort test
sort_by(.a)
[{"a":1,"b":1},{"a":1,"b":2}]
[{"a":1,"b":1},{"a":1,"b":2}]

sort_by(.a)
[{"a":1,"b":2},{"a":1,"b":1}]
[{"a":1,"b":2},{"a":1,"b":1}]

map(group_by(.a))
[[],[{"a":1}],[{"a":1},{"a":2},{"a":1}]]
[[],[[{"a":1}]],[[{"a":1},{"a":1}],[{"a":2}]]]

group_by(.a, .b)
[{"a":1,"b":2},{"a":2},{"a":1,"b":2}]
[[{"a":1,"b":2},{"a":1,"b":2}],[{"a":2}]]

map(group_by(.a))
[[],[{"a":1}],[{"a":1},{"a":2},{"a":1}]]
[[],[[{"a":1}]],[[{"a":1},{"a":1}],[{"a":2}]]]

unique_by(.a, .b)
[{"a":1,"b":2},{"a":2},{"a":1,"b":2}]
[{"a":1,"b":2},{"a":2}]

map(unique)
[[],[1],[3,2,2],[3,1,1,2]]
[[],[1],[2,3],[1,2,3]]

# TODO: better test
try repeat(error("break")) catch .
null
"break"

until(true; .*2)
123
123

[.,1]|until(.[0] < 1; [.[0] - 1, .[1] * .[0]])|.[1]
4
24

while(false; .)
null

[while(. > 0; .-1)]
4
[4,3,2,1]

explode
"jqjq"
[106,113,106,113]

implode
[106,113,106,113]
"jqjq"

to_entries
{"a":1,"b":2}
[{"key":"a","value":1},{"key":"b","value":2}]

from_entries
[{"key":"a","value":1},{"Key":"b","Value":2},{"Name":"c","value":false}]
{"a":1,"b":2,"c":false}

with_entries(.key |= "_"+. | .value += 100)
{"a":1,"b":2}
{"_a":101,"_b":102}

map(flatten)
[[1,[2],[[3]]],{"a":1,"b":[2,{"c":3}]}]
[[1,2,3],[1,2,{"c":3}]]

flatten(2)
[[[[2]]]]
[[2]]

transpose
[[1],[2,3,4]]
[[1,2],[null,3],[null,4]]

transpose
[[1,2],[null,3],[null,4]]
[[1,null,null],[2,3,4]]

transpose | transpose
[["a","b","c"],[2,3,4]]
[["a","b","c"],[2,3,4]]

map(all)
[[],[true],[true,true],[false,true],[false,false]]
[true,true,true,false,false]

all(. == 2)
[2,2]
true

all(2,2;. == 2)
null
true

map(any)
[[],[true],[true,true],[false,true],[false,false]]
[false,true,true,true,false]

any(. == 2)
[1,2]
true

any(1,2;. == 2)
null
true

# math functions
[acos,acosh,asin,asinh,atan,atanh,cbrt,ceil,cos,cosh,erf,erfc,exp,exp10,exp2,expm1,fabs,floor,gamma,j0,j1,lgamma,log,log10,log1p,log2,logb,nearbyint,rint,round,significand,sin,sinh,sqrt,tan,tanh,tgamma,trunc,y0,y1] | map(type)
0
["number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number"]

[atan2(0;0),copysign(0;0),drem(0;0),fdim(0;0),fmax(0;0),fmin(0;0),fmod(0;0),hypot(0;0),jn(0;0),ldexp(0;0),nextafter(0;0),nexttoward(0;0),pow(0;0),remainder(0;0),scalb(0;0),scalbln(0;0),yn(0;0)] | map(type)
null
["number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number","number"]

fma(0;0;0) | type
null
"number"

# suffix input
"a" | {a:{a:123}}[.][.]
null
123

."a".b, .a."b", ."a"."b", . "a" . "b"
{"a":{"b":123}}
123
123
123
123

.a.b[]
{"a":{"b":[1,2,3]}}
1
2
3

# suffix optional
.a?
{"a":123}
123

.a[]?
{"a":123}

.a[].b?
{"a":[1,{"b":123}]}
123

.a.b???
{"a":{"b":123}}
123

# literal with suffix
{a:{a:123}}.a.a
null
123

# suffix path
.[].c = 123
{"a":{"c":1},"b":{"c":2}}
{"a":{"c":123},"b":{"c":123}}

# suffix dot between
.[0].[0]
[[1]]
1

# iter
# TODO: iter order for index query
# [[.[0,1][0,1]], [.[][]]]
# [[1,2],[3,4]]
# [[1,3,2,4],[1,2,3,4]]

.[][] += 1
[[1,2],[3,4]]
[[2,3],[4,5]]

# object key using a keyword
{and: 1, as: 2, catch: 3, def: 4, elif: 5, else: 6, end: 7, false: 8, foreach: 9, if: 10, null: 11, or: 12, reduce: 13, then: 14, true: 15, try: 16}
null
{"and":1,"as":2,"catch":3,"def":4,"elif":5,"else":6,"end":7,"false":8,"foreach":9,"if":10,"null":11,"or":12,"reduce":13,"then":14,"true":15,"try":16}

# index using a keyword
[.and, .as, .catch, .def, .elif, .else, .end, .false, .foreach, .if, .null, .or, .reduce, .then, .true, .try]
{"and":1,"as":2,"catch":3,"def":4,"elif":5,"else":6,"end":7,"false":8,"foreach":9,"if":10,"null":11,"or":12,"reduce":13,"then":14,"true":15,"try":16}
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]

# //
empty // empty // 123
null
123

. // . // 123
null
123

(1,null,2,3) // 123
null
1
2
3

null // (1,null,2,3)
null
1
null
2
3

null // 1,2 // 123
null
1
2

try (1,error("a"),2 // 123) catch .
null
1
"a"

try (empty // 1,error("a"),2) catch .
null
1
"a"

# from https://github.com/MiSawa/xq/issues/156
(.foo,.foo,.foo) |= .+1
{"foo":0}
{"foo":3}

# elif mixed with optional else
# if
.[] | if . == 1 then "a" elif . == 2 then "b" end
[1,2,3]
"a"
"b"
3

.[] | if . == 1 then "a" elif . == 2 then "b" elif . == 3 then "c" end
[1,2,3,4]
"a"
"b"
"c"
4

[index(","), rindex(","), indices(",")]
"a,bc,def,ghij,klmno"
[1,13,[1,4,8,13]]

[index("aba"), rindex("aba"), indices("aba")]
"xababababax"
[1,7,[1,3,5,7]]

[index(""), rindex(""), indices("")]
""
[null,null,[]]

[index(",","|"), rindex(",","|"), indices(",","|")]
"a,b|c,d,e||f,g,h,|,|,i,j"
[1,3,22,19,[1,5,7,12,14,16,18,20,22],[3,9,10,17,19]]

[.[] | split(", ")]
["", "a,b, c, d, e,f", ", a,b, c, d, e,f, "]
[[],["a,b","c","d","e,f"],["","a,b","c","d","e,f",""]]

[.[] | split("")]
["", "abc"]
[[],["a","b","c"]]

bsearch(0,2,4)
[1,2,3]
-1
1
-4

# first, first/1, last, last/1
.[] | [[first], [first(.[])], [last], [last(.[])]]
[[],[1],[1,2,3]]
[[null],[],[null],[null]]
[[1],[1],[1],[1]]
 [[1],[1],[3],[3]]

# nth
.[] | [nth(0,2,4)]
[[],[1],[1,2,3]]
[null,null,null]
[1,null,null]
[1,3,null]

nth(-1)
[]
null

# nth/1
.[] | [nth(0,2,4; .[])]
[[],[1],[1,2,3]]
[]
[1]
[1,3]

try nth(-1; empty) catch .
null
"nth doesn't support negative indices"

# shadowing a passed-through intrinsic
def type: 42; type
null
42

# shadowing a builtin
def first: 42; first
null
42

def _orig_type: type; def type: "42" + _orig_type; 123 | type, _orig_type
null
"42number"
"number"

def _orig_first: first; def first: 42 + _orig_first; [123] | first, _orig_first
null
165
123

# binding using a keyword
. as $if | $if
123
123

# suffix dot between []
.[].[]
[[1]]
1

# various regressions
("aa \(123) ") + "bbb"
null
"aa 123 bbb"

# unescape order/overlap
"\u005cn"
null
"\\n"

# paths
map([paths])
[null, {}, [], {"a": [1,2,3], "b": true}]
[[],[],[],[["a"],["a",0],["a",1],["a",2],["b"]]]

# path expressions
[path(.a, .b.c)]
{}
[["a"],["b","c"]]

[path(empty)]
{}
[]

# SKIP_JQ
# test below does not work with standard jq because of missing features or
# they test jqjq specific things

# TODO: proper message
# test binding with path
def t(v; f): try path(v | f) catch "invalid"; [(null, true, false, 1, "abc", [], {}) as $v | t($v; .)]
null
["invalid","invalid","invalid","invalid","invalid","invalid","invalid"]

# literal
[try path(null) catch "i", try path(true) catch "i", try path(false) catch "i", try path("abc") catch "i", try path([]) catch "i", try path({}) catch "i"]
null
[[],"i","i","i","i","i"]

# there is no group/0 in jq
map(group)
[[],[1],[3,2,2],[3,1,1,2]]
[[],[[1]],[[2,2],[3]],[[1,1],[2],[3]]]

# unary plus operator
+123
null
123

+1, +(2,3)
null
1
2
3

+(+.)
123
123

eval(".,.,1,2")
123
123
123
1
2

eval("empty")
null

# make sure internal errors are not caught
try eval("try error({_internal_error: 123}) catch 456") catch .
null
"internal error: 123"

# make sure normal errors are not seen as internal
try eval("try error(123) catch 456") catch .
null
456

# eval in eval
eval("eval(\".,.,1,2\")")
123
123
123
1
2

eval("eval(\"empty\")")
null

path(eval(".a, .b.c"))
null
["a]
["b","c"]

(.a | eval(".a, .b.c")) = 123
null
{"a":{"a":123,"b":{"c":123}}}

# TODO: better parse tests
# comma required between object pairs
try eval("{a b}") catch "failed"
null
"failed"

# comma required between patterns
try eval(". as {$a $b} | .") catch "failed"
null
"failed"