Pegjs: 시퀀스에서 단일 반환 값을 나타내는 간결한 방법 제공

나는 이것이 일반적인 문제라는 데 동의합니다. 그러나 해결할 가치가 있는지 확실하지 않습니다. 다시 말해서, 충분히 자주 발생하는지, 솔루션을 구현하여 PEG.js에 복잡성을 추가하는 것을 정당화할 만큼 고통을 유발하는지 여부는 확실하지 않습니다.

이 문제를 열어두고 1.0.0 이후에 고려하도록 표시하겠습니다.

동의. 1.0에서 정말 보고 싶습니다. 나는 @ 구문에 그다지 열광하지 않습니다. IMHO는 이렇게 하는 것이 좋습니다. "최상위 수준" 레이블이 하나만 있는 경우 해당 레이블을 암시적으로 반환합니다. 따라서 다음 대신:

rule = space* a:(text space+ otherText)+ newLine* { return a; }

당신은 얻을:

rule = space* a:(text space+ otherText)+ newLine*

그리고 레이블이 특별히 의미 있는 것이 아닌 경우에도 다음을 허용하십시오.

rule = space* :(text space+ otherText)+ newLine*

따라서 레이블 이름을 완전히 건너뜁니다.

@mulderr @ 연산자가 더 낫다고 생각합니다.

@의 경우 +1 - 이것은 내 코드 전체에서 많이 반복됩니다.

이 작업을 수행하는 몇 가지 간결한 방법에 대한 +1입니다.

이 고통은 ES6이 화살표 함수를 사용하여 처리하는 JS의 장황한 function 구문과 유사한 것 같습니다. 아마도 비슷한 것이 여기에 사용될 수 있습니까? 다음과 같은 것:

rule = (space* a:(text space+ otherText) newLine*) => a

이것은 매우 유연하고 여전히 명시적이며( @wildeyes 의 관심사) 구문과 구현 모두에서 기본 JS를

나는 다음과 같은 것을 조금 상상했습니다.

additive = left:multiplicative "+" right:additive {= left + right; }

여기서 = (문자 선택에 대해 자유롭게 토론할 수 있음)는 공백이 아닌 블록의 첫 번째 문자로 return .

이는 전체 표현식에서도 작동하며 변환 패스로 가능해야 합니다.

소식이 있나요? 왜 additive = left:multiplicative "+" right:additive { => left + right } 아닌가요?

이제 화살표 기능이 작동하는 방식( (left, right) => left + right )을 고려할 때 확실히 직관적으로 느껴질 것입니다.

실제로 이 기능으로 개선될 parser.pegjs 파일의 위치에 대한 몇 가지 예가 있습니다.

예를 들어:

  = head:ActionExpression tail:(__ "/" __ ActionExpression)* {
      return tail.length > 0
        ? {
            type: "choice",
            alternatives: buildList(head, tail, 3),
            location: location()
          }
        : head;
    }

시퀀스에서 ActionExpression의 위치에 직관적으로 연결되지 않은 buildList 호출의 매직 넘버 3 때문에 취약합니다. buildList 함수 자체는 두 가지 다른 작업을 결합하여 복잡합니다. @ 식과 es6 스프레드 구문을 사용하면 다음과 같이 더 깔끔해집니다.

  = head:ActionExpression tail:(__ "/" __ @ActionExpression)* {
      return tail.length > 0
        ? {
            type: "choice",
            alternatives: [head, ...tail],
            location: location()
          }
        : head;
    }

이것은 거의 구문상의 설탕이므로 parser.pegjs에서 ActionExpression을 수정하는 것만으로 이 기능을 파서에 추가할 수 있었습니다.

  = ExtractSequenceExpression
  / expression:SequenceExpression code:(__ CodeBlock)? {
      return code !== null
        ? {
            type: "action",
            expression: expression,
            code: code[1],
            location: location()
          }
        : expression;
    }

ExtractExpression
  = "@" __ expression:PrefixedExpression {
      return {
        type: "labeled",
        label: "value",
        expression: expression,
        location: location()
      };
    }

ExtractSequenceExpression
  = head:(__ PrefixedExpression)* _ extract:ExtractExpression tail:(__ PrefixedExpression)* {
      return {
        type: "action",
        expression: {
          type: "sequence",
          elements: extractList(head, 1).concat(extract, extractList(tail, 1)),
          location: location()
        },
        code: "return value;",
        location: location()
      }
    }

@ 표기법을 사용하여 parser.pegjs를 단순화하는 방법을 보여주는 요지를 확인했습니다.

@ 표기법을 사용하면 시퀀스에서 원하는 값을 쉽게 추출할 수 있으므로 extractOptional, extractList 및 buildList 함수는 완전히 제거되었습니다.

https://gist.github.com/krisnye/a6c2aac94ffc0e222754c52d69e44b83

@krisnye 구문 설탕이 더 많이 있으면 다음과 같이 표시됩니다.

https://github.com/polkovnikov-ph/newpeg/blob/master/parse.np

이 구문 기능에 :: 및 # 조합을 사용할 생각입니다( #545 의 설명/이유 참조).

• :: 바인딩 연산자
• # 확장 연산자

// this is imported into grammar
class List extends Array {
  constructor() { this.isList = true; }
}

// grammar
number = _ ::value+ _
value = ::int #(_ "," _ ::int)* { return new List(); }
int = $[0-9]+
_ = [ \t]*

• 규칙의 루트 시퀀스에서 :: 는 표현식의 결과를 규칙 결과로 반환합니다.
• 중첩된 시퀀스에서 :: 는 중첩된 표현식의 결과를 시퀀스 결과로 반환합니다.
• 하나 이상의 :: 가 사용되면 표시된 표현식의 결과가 배열로 반환됩니다.
• # 가 포함된 중첩 시퀀스에 :: 되면 결과가 상위 ​​배열로 푸시됩니다.
• 규칙에 :: / # 와 함께 코드 블록이 있는 경우 먼저 실행한 다음 결과 push 메서드를 사용합니다.

이러한 규칙에 따라 09 , 55, 7 를 위의 예제에서 생성된 파서에 전달하면 다음이 생성됩니다.

result = [
    isList: true
    0: "09"
    1: "55"
    2: "7"
]

result instanceof Array # true in ES2015+ enviroments
result instanceof List # true

규칙의 루트 시퀀스에서 ::는 표현식의 결과를 규칙 결과로 반환합니다.
중첩된 시퀀스에서 ::는 중첩된 표현식의 결과를 시퀀스 결과로 반환합니다.

왜 이것들이 분리되어 있습니까? 시퀀스의 " :: 가 시퀀스의 인수 결과를 생성하지 않는 이유는 무엇입니까?"

::가 하나 이상 사용되면 표시된 표현식의 결과가 배열로 반환됩니다.

그건 나쁜 생각이야. 이 경우 구제하는 것이 좋습니다. 여러 유형의 값을 배열로 결합하는 것은 의미가 없습니다. (튜플이지만 JS에서는 거의 쓸모가 없습니다.)

#이 시퀀스에 사용되면 결과는 Array#가 부모의 배열에 연결됩니다.

이제 그것은 끔찍한 생각입니다. 이것은 분명히 불필요한 { return xs.push(x), xs } 제거하기 위한 곤지름입니다. 이러한 특별한 경우를 만드는 것은 의미가 없습니다. 매개변수화된 규칙을 사용하여 일반적인 방식으로 해결할 수 있기 때문입니다. 연산자에 사용할 단일 문자 시퀀스는 많지 않으며 낭비해서는 안됩니다.

규칙에 ::/#와 함께 코드 블록이 있는 경우 먼저 실행한 다음 결과 푸시 메서드를 사용합니다.

따라서 f = ::"a" { return "b" } 는 결과적으로 ["a", "b"] 를 가져야 합니까?

통과 09 . 55: 7을 위의 예에서 생성된 파서에 대입하면 다음이 생성됩니다.

그렇지 않습니다. 언급된 . 또는 : . 설명된 동작이 결과를 생성하는 방식도 알 수 없습니다.

숫자 = _ ::값+ _

또한 _ 를 사용해서는 안 됩니다. 토큰의 오른쪽 또는 왼쪽으로 이동하며 문법을 위해 한 번 선택된 쪽입니다. 오른쪽에 있는 경우 기본 규칙도 _ 시작해야 하며 그 반대의 경우도 마찬가지입니다.

start = _ value
value = ::int #("," _ ::int)* { return new List(); }
number = ::$[0-9]+ _
_ = [ \t]*

JavaScript 예제에서 구현된 클래스의 예(실제 구현이 아님):

ClassMethod
  = head:FunctionHead __ params:FunctionParameters __ body:FunctionBody {
      return {
        type: "method",
        name: head[ 1 ],
        modifiers: head[ 0 ],
        params: params,
        body: body
      };
    }

// `::` inside the zero_or_more "( ... )*" builds an array as we want,
// so this rule returns `[FunctionModifier[], Identifier]` as expected
MethodHead = (::MethodModifier __)* ("function" __)? ::Identifier

// https://github.com/tc39/proposal-class-fields#private-fields
MethodModifier
  = "#"
  / "static"
  / "async"

FunctionParameters
  = "(" __ head:FunctionParam tail:(__ "," __ ::FunctionParam)* __ ")" {
      // due to `::`, tail is `FunctionParam[]` instead of `[__, "", __, FunctionParam][]`
      return [ head ].concat( tail );
    }
    / "(" __ ")" { return []; }

FunctionParam
  = name:Identifier value:(__ "=" __ ::Expression)? {
      return { name, value };
    }

FunctionBody = "{" __ ::SourceElements? __ "}"

왜 이것들이 분리되어 있습니까? 시퀀스의 :: 시퀀스의 인수 결과를 생성하지 않는 이유는 무엇입니까?"

같은거 아닌가요? MethodHead , FunctionParam 및 FunctionBody 와 같은 다양한 사용 사례의 결과를 쉽게 이해할 수 있도록 더 명확하게 만들었습니다.

여러 유형의 값을 배열로 결합하는 것은 의미가 없습니다. (튜플이지만 JS에서는 거의 쓸모가 없습니다.)

내 의견으로는 AST(생성된 파서의 가장 일반적인 결과)를 작성할 때 다음과 같이 작성하는 대신 MethodHead 와 같은 사용 사례를 단순화합니다.

MethodHead
  = modifiers:(::MethodModifier __)* ("function" __)? name:Identifier {
      return [ modifiers, name ];
    }

좀 더 생각해 본 결과, 유스 케이스를 단순화하기는 하지만 개발자가 실수를 할 가능성(문법을 구현하는 방식이나 결과가 액션으로 처리되는 방식)도 열리므로 다음과 같이 생각합니다. multipleSingleReturns (기본값: false )와 같은 옵션 뒤에 있는 사용 사례가 여기에서 가장 좋은 조치가 될 것입니다(이 기능이 구현된 경우).

#이 시퀀스에 사용되면 결과는 Array#가 부모의 배열에 연결됩니다.

이제 그것은 끔찍한 생각입니다. 이것은 분명히 불필요한 { return xs.push(x), xs }

또한 FunctionParameters 와 같은 보다 일반적인 사용 사례에서 다음과 같이 작성하는 것이 더 좋습니다.

// should always return `FunctionParam[]`
FunctionParameters
  = "(" __ ::FunctionParam #(__ "," __ ::FunctionParam)* __ ")"
  / "(" __ ")" { return []; }

매개변수화된 규칙을 사용하여 일반적인 방식으로 해결할 수 있습니다.

나중에 계속 진행하는 방법을 아직 잘 모르기 때문에 매개변수화된 규칙 전에 단일 반환 값을 구현해야 한다고 생각합니다(템플릿을 사용하는 것을 좋아하지만 rule < .., .. > = .. 를 사용하면 PEG.js 문법이므로 좀 더 잘 맞도록 약간의 구문 변경을 생각하려고 합니다.) 하지만 그건 별개의 문제입니다.

연산자에 사용할 단일 문자 시퀀스는 많지 않으며 낭비해서는 안됩니다.

맞는 말이지만 현재의 상황 자체가 이와 같을 때 사용하지 않으면 그것도 나쁩니다.

전처리 지시문을 구현하는 일부 언어에서 확장 연산자로 사용된다는 것을 기억한 후 이 사용 사례에 # 를 사용하려고 생각했습니다. 이것이 본질적으로 이 사용 사례가 여기에서 다루는 내용입니다.

따라서 f = ::"a" { return "b" } 는 결과적으로 ["a", "b"] 를 가져야 합니까?

코드 블록이 포함 된 객체와 같은 배열을 반환 파서 과연 아니 push 방법 (가 될 수 있도록 f = ::"a" { return [ "b" ] } 복귀 [ "b", "a" ] 결과) 따라서 어레이뿐만 아니라 유사한 방식으로 작동하도록 구현된 동일한 방법이 있는 사용자 정의 노드에 푸시할 수 있습니다. 그것을 읽은 후 이것이 어떻게 생각의 첫 번째 기차였는가를 보았을 때 이것이 pushSingleReturns 와 같은 옵션 뒤에 있는지 이해하는 것이 더 false (기본값)인 경우 단일 반환 값을 포함하는 시퀀스 뒤에 코드 블록이 있으면 오류가 발생합니다.

통과 09 . 55: 7을 위의 예에서 생성된 파서에 대입하면 다음이 생성됩니다.

그렇지 않습니다. . 또는 : 언급되지 않았습니다.

죄송합니다. 주어진 예제를 다시 작성할 때 남겨진 실수였습니다.

또한 _ 를 사용해서는 안 됩니다. 토큰의 오른쪽 또는 왼쪽으로 이동하며 문법을 위해 한 번 선택된 쪽입니다. 오른쪽에 있는 경우 기본 규칙도 _ 시작해야 하며 그 반대의 경우도 마찬가지입니다.

나는 이것이 단지 선호도의 문제라고 생각합니다 :smile:, 비록 이 예를 이해하는 것이 더 쉬웠을 것이라고 생각하지만:

number = _ ::value+ EOS
...
EOS = !.

설명된 동작이 결과를 생성하는 방식도 알 수 없습니다.

이 업데이트된 댓글이 내가 말하려는 내용을 이해하는 데 도움이 됩니까? 그렇지 않은 경우 이해하지 못하는 부분이 무엇인지 이해하십시오.

장소별로 제공되는 변경 사항이 극도로 명확하지 않고 추가 오류의 원인일 뿐이라는 @polkovnikov-ph에 동의합니다.

#이 시퀀스에 사용되면 결과는 Array#가 부모의 배열에 연결됩니다.

start = #('a') 문법에서 무엇을 반환해야 합니까? 내가 이해하는 한, 그는 배열을 병합하기 위한 구문 설탕이 어떻게 되는지 생각했습니다. 이 연산자가 필요하다고 생각하지 않습니다. 가장 분명한 용도(구분 기호가 있는 멤버 목록 표현)를 사용하려면 특수 구문을 만드는 것이 좋습니다(#30 및 내 포크, https://github.com/Mingun/pegjs/commit/db4b2b102982a53dbed1f579477c85c06f8b92e6 참조).

규칙에 ::/#와 함께 코드 블록이 있는 경우 먼저 실행한 다음 결과 푸시 메서드를 사용합니다.

매우 불분명한 행동입니다. 문법 소스의 작업은 표현식 뒤에 위치하며 일반적으로 표현식 구문 분석 후에 호출됩니다. 그리고 갑자기 어떻게 든 구문 분석 전에 호출되기 시작합니다. 레이블은 어떻게 작동합니까?

나머지 3점은 당신이 그럭저럭 설명하여 그들의 명확한 감각이 탈출하기 시작했습니다. 설명에 첫 번째와 두 번째 경우를 구분하는 이유가 @polkovnikov-ph에 얼마나 정확하게 기록되었습니까? 두 가지 간단한 규칙만 실행됩니다.

1. :: (솔직히 말해서, 나는 이 캐릭터의 선택이 마음에 들지 않습니다. 너무 시끄럽습니다) 표현식이 이 문자로 표시된 sequence 노드 요소에서 이 문자가 반환된다는 사실로 이어지기 전에
2. 시퀀스에서 이러한 요소가 하나만 있으면 결과가 반환되고, 그렇지 않으면 결과 배열이 반환됩니다.

예:

start =   'a' 'b'   'c'; // => ['a', 'b', 'c']
start = ::'a' 'b'   'c'; // => 'a'
start = ::'a' 'b' ::'c'; // => ['a', 'c']

큰 예는 내가 :: 에서 볼 것으로 예상되는 것을 정확히 설명하고 모호한 사용 사례( # , 여러 :: )를 설명하지 않습니다.

같은거 아닌가요?

그게 내가 물어본거야. 일반적인 방식의 설명은 일반적으로 더 유용합니다. 왜냐하면 독자가 그것이 실제로 같은 것임을 확신하게 하기 때문입니다. 설명해주셔서 감사합니다. :)

제 생각에는 MethodHead와 같은 사용 사례를 단순화할 것입니다.

그러나 대신 객체를 생성하지 않는 이유는 무엇입니까? 표기법에 modifiers: 및 name: 가 있습니다. 결과 JS 객체에 그대로 두십시오. 그러면 멋질 것입니다.

그것은 또한 개발자가 실수를 할 가능성을 열어줍니다(그들이 문법을 구현하는 방식이나 조치에 의해 결과가 처리되는 방식)

처음에는 이것에 대해 글을 쓸 예정이었지만, 나중에는 어려운 논거가 충분하지 않다고 결정했습니다. 동일한 수준의 시퀀스에서 여러 :: 를 허용하지 않는 것이 좋습니다(플래그가 있는 경우에도 제외).

또한 다음과 같이 작성하는 것이 더 좋은 FunctionParameters와 같은 보다 일반적인 사용 사례에 도움이 됩니다.

그러나 그것은 같은 것입니다. 정말 좋은 구문은 inter(FunctionParam, "," __) 입니다.

inter a b = x:a xs:(b ::a)* { return xs.unshift(x), xs; }

rule < .., .. > = .. PEG.js 문법에 많은 노이즈를 추가하는 것 같습니다

사람들은 <...> 가 유형에 사용되기를 기대하지만 이 경우 인수는 유형이 아닙니다. 가장 좋은 방법은 추가 문자가 전혀 없는 Haskell 방법입니다(위의 inter 참조). ; 생략된 PEG.js 문법에서 이것이 어떻게 상호 작용하는지 잘 모르겠습니다. f a b = ... 가 이전 행에 (부분적으로) 포함되는 경우가 있을 수 있습니다.

전처리 지시문을 구현하는 일부 언어에서 확장 연산자로 사용

예, 하지만 스마트하게 사용하는 것이 좋습니다. 배열에 대해 제안된 push 작업 대신 개체에 대한 Object.assign 작업 또는 빈 문자열( eps )과 일치하지만 반환하는 작업으로 사용합니다. 그 주장. 예를 들어,

f = type:#"ident" name:$([a-z]i [a-z0-9_]i+)

"abc" 입력에 대해 {type: "ident", name: "abc"} 를 반환합니다.

아니오, 코드 블록은 파서가 푸시 메소드를 포함하는 배열과 유사한 객체를 반환할 것으로 예상하기 때문에(따라서 f = ::"a" { return [ "b" ] } 반환 [ "b", " a" ] 결과),

오_오

이건 정말 취향의 문제인 것 같아요

뿐만 아니라 성능도 그렇습니다. 모든 토큰의 양쪽에 _ 있는 경우 공백 문자 시퀀스는 후행에만 일치하고 _ 앞에는 아무것도 일치하지 않습니다. parse$_ 대한 추가 호출은 시간이 조금 더 걸립니다. 또한 _ 가 두 배 더 많기 때문에 코드가 더 깁니다.

@Mingun @futagoza 는 디자인 공간을 탐구한다고 생각합니다. 그것은 좋은 일입니다. 특히 그것이 공개되어 있고 우리가 동의하지 않을 기회가 있는 경우에 그렇습니다. :)

가장 중요한 것은 "왜"라고 묻는 것이 아니라 "아니오! 그렇지 않습니다!"라고 말하는 것입니다.

f = type:#"ident" name:$([a-z]i [a-z0-9_]i+) 는 "abc" 입력에 대해 {type: "ident", name: "abc"} 를 반환합니다.

아니, 하하. 그 구문은 _wayyy_ 너무 마술적입니다.

원래 제안된 @ 연산자는 있는 그대로 완벽 하다고 생각합니다. 너무 많은 시간 나는 시퀀스 문제에 부딪칩니다.

sequence
    = first:element rest:(whitespace next:element {return next;})*
    {
        return [first].concat(rest);
    }
    ;

_그런_ _ 반복해서 입력하는 것은 고통스럽습니다. 특히 그보다 더 복잡한 경우에는 더욱 그렇습니다.

그러나 @ 연산자를 사용하면 위의 내용은 다음과 같이 간단해집니다.

sequence = first:element rest:(whitespace @element)* { return [first].concat(rest); };

https://github.com/pegjs/pegjs/issues/235#issuecomment -66915879 또는 https://github.com/pegjs/pegjs/issues/235#issuecomment -67544080을 사용하면 다음과 같이 추가로 축소됩니다.

sequence = first:element rest:(whitespace @element)* => [first].concat(rest);
/* or */
sequence = first:element rest:(whitespace @element)* {=[first].concat(rest)};

... 첫 번째는 내가 매우 부분적입니다.

이것은 달성하기 쉬운 이전 버전과 호환되는 변경인 것처럼 보입니다(누군가가 이미 수행한 것으로 보입니다).

사실 제 착각이 아니라면 사소한 충돌일 수도 있습니다. 0.11.0 @futagoza에 대해 생각할 수 있는 것입니다.

방금 마스터에 추가했습니다. :: 를 다중 뽑기에 사용하고 @ 를 단일 뽑기에 사용할 계획이었지만 레이블과 함께 :: 사용하는 것이 보기에 너무 추하고 혼란스러워서 그 아이디어를 중단했습니다 🙄

나는 이것을 잠시 동안 스스로 구현하기 시작했지만 지금까지 (대신 #579를해야 할 때 😆) 바이트 코드 생성기를 Mingun의 구현에 기반했습니다 (https://github.com/Mingun/pegjs/commit/1c1c852bae91868eaa90d9bd9f7e4f722ea6435 )

https://pegjs.org/development/try (온라인 편집기이지만 PEG 0.11.0-dev 사용)에서 시도해 볼 수 있습니다.

성스러운 전환 시간, 배트맨. 멋진 작업 @futagoza , 이것은 완벽하게 작동했습니다. 대단히 감사합니다. 이것은 이미 npm의 dev 태그로 출시되었습니까? 나는 그것으로 테스트를 시작하고 싶습니다.

기본 문법으로 시도하고 싶은 사람을 위해 이 강아지를 거기에 넣고 "abcd" 와 같은 입력을 제공하십시오.

foo
    = '"' @$bar '"'
    ;

bar
    = [abcd]*
    ;

이것은 이미 npm의 dev 태그에 릴리스되었습니까?

https://www.npmjs.com/package/pegjs/v/0.11.0-dev.325

안녕하세요, 이것은 es6이 있으면 사라지는 문제 중 하나이며, 그 이후로 es6에 추가된 다른 기능을 위해 해당 문자가 필요합니다. 이미 할 수 있는 일에 연산자를 추가하는 것은 매우 비생산적입니다.

이 티켓이 병합되었습니다.

pattern:Pattern init:(_ "=" _ <strong i="7">@a</strong>:AssignmentExpression)?

모든 사람이 본질적으로 이해하고 파서의 다른 부분이 완료되면 무료로 제공되는 es6의 동일한 내용은 다음과 같습니다.

pattern:Pattern init:(_ "=" _ a:AssignmentExpression)? => a

문제는 테스트했을 때 이 pluck 구현이 버그가 있는 것 같으며 물론 릴리스되지 않을 분기에서 수정되었기 때문에 닫힌 것으로 표시된다는 것입니다.

이 문제가 릴리스된 버전에서 수정될 때까지 @futagoza 를 다시 여십시오.