Try APL(tryapl.org)

    multi parse ( 'if',  $ where /\s+/, …, '{', *@_ ) {…}
    multi parse ( 'for', $ where /\s+/, …, '{', *@_ ) {…}
    …

    grammar JSON::Parser::Example {

        token TOP       { \s* <value> \s* }

        rule object     { '{' ~ '}' <pairlist>  }
        rule pairlist   { <pair> * % ','        }
        rule pair       { <string> ':' <value>  }

        rule array      { '[' ~ ']' <arraylist> }
        rule arraylist  {  <value> * % ','      }

        proto token value {*}

        token value:sym<number> {
            '-'?                          # optional negation
            [ 0 | <[1..9]> <[0..9]>* ]    # no leading 0 allowed
            [ '.' <[0..9]>+ ]?            # optional decimal point
            [ <[eE]> <[+-]>? <[0..9]>+ ]? # optional exponent
        }

        token value:sym<true>    { <sym>    }
        token value:sym<false>   { <sym>    }
        token value:sym<null>    { <sym>    }

        token value:sym<object>  { <object> }
        token value:sym<array>   { <array>  }
        token value:sym<string>  { <string> }

        token string {
            ｢"｣ ~ ｢"｣ [ <str> | ｢\｣ <str=.str_escape> ]*
        }

        token str { <-["\\\t\x[0A]]>+ }
        token str_escape { <["\\/bfnrt]> }
    }

    my $json = Q:to/END/;
    {
      "foo": ["bar", "baz"],
      "ultimate-answer": 42
    }
    END
    my $result = JSON::Parser::Example.parse($json);
    say $result;

    ｢{
      "foo": ["bar", "baz"],
      "ultimate-answer": 42
    }
    ｣
     value => ｢{
      "foo": ["bar", "baz"],
      "ultimate-answer": 42
    }
    ｣
      object => ｢{
      "foo": ["bar", "baz"],
      "ultimate-answer": 42
    }
    ｣
       pairlist => ｢"foo": ["bar", "baz"],
      "ultimate-answer": 42
    ｣
        pair => ｢"foo": ["bar", "baz"]｣
         string => ｢"foo"｣
          str => ｢foo｣
         value => ｢["bar", "baz"]｣
          array => ｢["bar", "baz"]｣
           arraylist => ｢"bar", "baz"｣
            value => ｢"bar"｣
             string => ｢"bar"｣
              str => ｢bar｣
            value => ｢"baz"｣
             string => ｢"baz"｣
              str => ｢baz｣
        pair => ｢"ultimate-answer": 42
    ｣
         string => ｢"ultimate-answer"｣
          str => ｢ultimate-answer｣
         value => ｢42｣

    my @pairs = $result<value><object><pairlist><pair>;

    my @keys = @pairs.map( *.<string>.substr(1,*-1) );
    my @values = @pairs.map( *.<value> );

    say @pairs.first( *.<string><str> eq 'ultimate-answer' )<value>;
    # ｢42｣

    grammar Extended::JSON::Example is JSON::Parser::Example {
        rule pair { <key=.value> ':' <value>  } # replaces existing rule

        # adds to the existing set of value tokens.
        token value:sym<Inf>    { <sym> }
        token value:sym<-Inf>   { <sym> }
        token value:sym<NaN>    { <sym> }
    }

    ab qalpha α
    ab qbeta β 
    ab qup ↑
    ab qall ∀ 
    ab qnot ¬