Pegjs: 매개변수화 가능한 규칙 구현

이것이 상당한 양의 작업을 절약하거나 현재 불가능한 것을 가능하게 만드는 특정 사용 사례가 있습니까?

수준이 인수로 전달된 규칙을 호출하여 들여쓰기 수준을 훨씬 쉽게 구문 분석할 수 있습니다.

또한 순수한 DRY 논리에서 "이 문자로 구분된 이스케이프 시퀀스와 같은 항목"과 같은 작업을 수행할 때 규칙(및 해당 작업 !)을 세 번 수행하는 것보다 delimited('\'', '\\') 와 같은 것을 호출하는 것이 좋습니다. .

나는 더 명확했어야 했다. "특정"으로 "나는 X 언어의 문법에 대해 작업하고 있었고 거기에는 하나로 결합될 수 있는 5가지 규칙이 있습니다. 여기 그것들이 있습니다:"와 같은 것을 찾고 있었습니다. 즉, 저는 실제 세계를 보고 싶었습니다. 사용 사례 및 실제 코드. 이를 통해 이 기능이 어떤 경우에 얼마나 많은 사람들에게 유용할지 더 잘 판단할 수 있습니다.

이 기능 자체에 반대하므로 이것을 받아들이지 마십시오. 나는 일반적으로 복잡성과 구현 비용 때문에 소수의 언어 또는 개발자에게만 유용한 기능을 구현하고 싶지 않습니다. 그리고 이 경우 비용이 상대적으로 높습니다.

자바스크립트용 파서를 작성하기만 하면 string = delimited_by('\'') / delimited_by('\"') 를 가질 수 있고 나중에 regexp = delimited_by('/') 를 가질 수 있습니다.

최근에 나는 내 자신의 언어에 대한 파서를 작성하고 있습니다. 나는 파이썬을 위해 작성한 PEG 프레임워크에 다음과 같은 것을 가지고 있습니다.

LeftAssociative(op, subrule): l:subrule rest:(op subrule)* -> a_recursive_function_that_reverses_rest_and_makes_bintrees(l, op, subrule)

그리고 다음과 같이 쓸 수 있습니다.

...
exp_mult = LeftAssociative(/[\*\/%]/, exp_paren)
exp_add = LeftAssociative(/[\+-]/, exp_mult)

C++만큼 많은 우선 순위 수준(모든 연산자와 몇 가지 추가)이 있으므로 in이 얼마나 유용한지 상상해 보겠습니다. 아직 구문 분석이 끝나지 않았지만 이미 12번이나 사용하고 있습니다.

'가져오기' 기능과 결합하면 좋을 것입니다.

require(CommaSeparatedList.pegjs)
require(StringLiteral.pegjs)
require(IntegerLiteral.pegjs)

...

Function
 = name:FuncName "(" args:CommaSeparatedList(Literal)  ")" 

Hash
= "{"   props:CommaSeparatedList(Prop)   "}"

Prop
= Key ":" Literal

Literal =
  StringLiteral / IntegerLiteral

(이것은 OP의 요청보다 조금 더 복잡하지만 자신의 스레드를 정당화하기에는 너무 가까워 보였습니다.)

저는 PEG.js의 도움으로 R5RS Scheme 파서를 만들고 있습니다. 컨텍스트 인식 구문 분석이 필요한 유사 인용을 제외하고는 모든 것이 장밋빛입니다. 많은 양의 어색한 사후 처리를 피하면서 템플릿에서 즉석 규칙 생성을 위해 규칙을 매개변수화할 수 있으면 유용할 것입니다. 예를 들어, 단순화된 준인용 문법은 다음과 같을 수 있습니다.

    quasiquotation = qq[1]
    qq[n] = "`" qq_template[n]
    qq_template[0] = expression
    qq_template[n] = simple_datum / list_qq_template[n] / unquotation[n]
    list_qq_template[n] = "(" qq_template[n]* ")" / qq[n+1]
    unquotation[n] = "," qq_template[n-1]

이 기능을 도구에 추가하는 데 관심이 있다면 이 기능의 개발에 기여하고 싶습니다.

이것을 하는 주된 이유는 문맥에 민감한 문법을 ​​지원하기 위한 것입니다. 제가 틀리지 않는다면 가장 인기 있는 언어는 (C와 파이썬에 문맥에 특정한 것들이 있다는 것을 확실히 압니다). Trevor Jim에 따르면 Haskell도 컨텍스트가 없으며 대부분의 언어가 다음과 같이 자유롭지 않다고 주장합니다.

http://trevorjim.com/haskell-is-not-context-free/
http://trevorjim.com/how-to-prove-that-a-programming-language-is-context-free/

(PEG와 같이) 역추적할 수 있는 파서에서 외부 상태를 사용하는 것은 위험하며 이 파서에서 볼 수 있는 것과 같은 문제를 생성할 수 있습니다.

{   var countCs = 0;
}

start = ((x/y) ws*)* { return countCs }

x = "ab" c "d"
y = "a" bc "e"

c = "c" { countCs++; }
bc = "bc" { countCs++; }

ws = " " / "\n"

위는 1의 정답 대신 2를 반환합니다. 이와 같은 문제는 추론하기 어려울 수 있고, 찾기 어려운 교활한 버그를 생성할 수 있으며, 발견되면 우아하게 해결하는 것은 훨씬 더 어려울 수 있습니다. . PEG에서 반환된 데이터의 사후 처리를 수행하지 않고 이 작업을 수행하는 방법조차 명확하지 않습니다. 어떻게 든 파서 자체에 카운트가 필요한 경우 단순히 운이 좋지 않습니다.

현재 (위험하게) 외부 상태를 사용하는 것이 컨텍스트에 민감한 문법을 ​​구문 분석하는 유일한 방법입니다. 매개변수화된 규칙을 사용하면 파서는 유효하지 않은 상태의 위험 없이 이것을 구문 분석할 수 있습니다.

start = countCs:((x<0>/y<0>) ws*)* { return countCs.reduce(function(a,b){return a+b[0];}, 0); }

x<count> = "ab" theCount:c<count> "d" { return theCount; }
y<count> = "a" theCount:bc<count> "e" { return theCount; }

c<count> = "c" { return count++; }
bc<count> = "bc" { return count++; }

ws = " " / "\n"

David, 당신은 실제 상황에 대해 물었고 파이썬의 공백 들여쓰기 구문은 분명히 여기의 예입니다. Lima(내가 PEG로 만들고 있는 프로그래밍 언어)에서 유사한 공백 들여쓰기 구문을 수행하고 싶습니다. 하지만 실수로 모든 것을 지옥으로 몰아넣는 잘못된 상태를 만들 수 있을 때 그런 것을 구현하고 싶지 않습니다. C의 x* y(x x y 또는 y가 x 형식 값에 대한 포인터로 정의됨)와 같이 컨텍스트가 필요한 구문 분석 구조의 이름을 지정할 수 있습니다.

구문 분석이 가능한 컨텍스트에 민감한 문법의 경우 이미 매개변수화된 규칙과 일치하는 하위 표현식에서 반환된 정보를 반드시 전달해야 합니다. 그렇지 않으면 구문 분석기가 컨텍스트를 실제로 사용할 수 없습니다. 다음은 매개변수화된 구문 분석을 사용할 수 있고 이전에 일치한 표현식의 레이블에 (변수로) 액세스할 수 있는 경우에만 작동하는 Lima에 대해 고려 중인 문자열 유형의 실제 예입니다.

literalStringWithExplicitLength = "string[" n:number ":" characters<n> "]"
number = n:[0-9]* {return parseInt(n.join(''));}
characters<n> = c:. { // base case
  if(n>0) return null; // don't match base case unless n is 0
  else return c;
}
/ c:. cs:characters<n-1> {
  ret c+cs
}

이것은 string[10:abcdefghij] 와 같은 문자열을 구문 분석할 수 있습니다. 있는 그대로의 멋진 순수 PEG.js로는 그렇게 할 수 없습니다. 당신은 다음과 같은 끔찍한 일을했습니다.

{ var literalStringLengthLeft=undefined;
}
literalStringWithExplicitLength = "string[" n:specialNumber ":" characters "]"
specialNumber = n:number {
  literalStringLengthLeft = n;
  return n;
}
number = n:[0-9]* {return parseInt(n.join(''));}
characters = c:character cs:characters? {
  return c + cs
}
character = c:. {
  if(literalStringLengthLeft > 0) {
    literalStringLengthLeft--;
    return c;
  } else {
    literalStringLengthLeft = undefined;
    return null; // doesn't match
  }
}

많은 프로토콜에는 이러한 종류의 구문 분석이 필요합니다. 예를 들어 IPv4 패킷에는 전체 길이를 설명하는 필드가 있습니다. 나머지 패킷을 적절하게 구문 분석하려면 해당 컨텍스트가 필요합니다. IPv6, UDP 및 기타 패킷 기반 프로토콜도 마찬가지입니다. TCP를 사용하는 대부분의 프로토콜은 동일한 개념적 문자 스트림을 사용하여 완전히 별개의 여러 개체를 전송할 수 있어야 하기 때문에 이와 같은 것이 필요합니다.

어쨌든, 나는 이것이 좋은 기능일 뿐만 아니라 강력한 기능일 뿐만 아니라 많은 파서(현재로서는 PEG.js 포함 ).

Pegasus (대부분의 구문을 peg.js와 공유하는 프로젝트)는 상태 사전을 변경할 수 있는 기능이 제공되는 #STATE{} 표현식을 사용하여 이 문제를 해결합니다. 이 상태 사전은 규칙이 역추적될 때 역추적됩니다. 이를 통해 중요한 공백 구문 분석을 지원할 수 있습니다(자세한 내용 은 중요한 공백에 대한 Wiki 항목 참조).

또한 구문 분석 커서와 함께 상태를 역추적하여 상태 저장 규칙에 대해서도 메모이제이션을 수행할 수 있습니다.

Peg.js도 같은 작업을 쉽게 수행할 수 있다고 생각합니다.

규칙이 역추적할 때 Pegasus는 역추적 상태를 어떻게 관리합니까? 변경된 전체 프로그램 상태의 스냅샷을 유지하고 되돌릴 수 있다고 상상할 수 있지만 비용이 많이 듭니다. 변경된 변수만 스냅샷으로 유지하는 것을 상상할 수 있지만, 사용자가 이를 지정해야 파서를 생성하는 데 복잡성이 추가되거나 파서가 일부 코드에서 변경된 모든 상태를 어떻게든 파악해야 합니다. 이들 중 어느 것도 이상적이지 않은데 페가수스는 어떻게 합니까?

이론적으로 파서는 A. 작업이 클로저에 대기 중이고 파서가 완전히 완료된 후에만 실행되고 B. 파서가 완료된 후에 실행되기 때문에 규칙 일치를 취소할 수 없는 경우 파서는 잘못 실행된 작업을 피할 수 있습니다. 아마도 그 계획이 페가수스에서 수행된 상태 역추적보다 더 최적일 것입니다.

또한 무효 상태의 문제를 수정하는 것은 실제로 매우 좋지만 string[10:abcdefghij]와 같은 문자열 리터럴과 관련하여 제기한 표현성 문제는 해결되지 않지만 작동 방식에 확실히 관심이 있습니다.

전체 프로그램의 상태를 역추적하지 않습니다. 불변의 상태 사전을 유지합니다. 커서와 함께 현재 상태 사전을 저장하고 커서가 역추적될 때마다 상태 사전도 함께 역추적됩니다. 딕셔너리는 #STATE{} 액션 이외의 어느 곳에서나 변경할 수 없으며 각 상태가 변경되기 직전에 복사됩니다.

커서를 이동할 때마다 추가 변수를 설정하면 성능이 약간 저하되지만 상태 저장 규칙을 메모하는 기능보다 훨씬 중요합니다. 또한 상태 사전의 불변 특성으로 인해 변경될 때까지 공유할 수 있기 때문에 이로 인해 수많은 메모리 할당이 발생하지 않습니다. 예를 들어, 파서에 상태가 없으면 단일(빈) 상태 사전이라는 하나의 할당만 있을 것입니다.

JavaScript에는 (내가 아는 한) 객체를 변경할 수 없도록 만드는 기능이 없지만 대부분은 안전 기능이었습니다. Peg.js는 각 #STATE{} 코드 블록을 처리하기 전에 상태 사전을 복사하고 커서가 역추적될 때마다 역추적하면 됩니다.

아, 그래서 사용자는 기본적으로 어떤 상태를 변경하는지 지정해야 합니다. 꽤 괜찮은데. 그러나 여전히 매개변수화가 수행하는 것과 동일한 이점을 실제로 다루지는 않는다고 생각합니다. 다른 것들에 그 자체로 유용할 것 같습니다.

방금 env 변수를 사용하여 액세스할 수 있는 환경을 제공하는 포크를 작성했습니다. https://github.com/tebbi/pegjs
이는 위에서 제안한 #STATE{} 객체와 동일합니다.
파싱 ​​기능이 남아있을 때마다 복원되는 (패키지-) 전역 변수를 사용하는 빠른 해킹입니다. env 의 복사는 Object.create()로 수행됩니다.

다음은 Python에서 공백으로 정의된 블록을 구문 분석하는 데 사용하는 문법의 예입니다.

{
  env.indLevel = -1
}

block =
  empty
  ind:ws* &{
    if (ind.length <= env.indLevel) return false;
    env.indLevel = ind.length;
    return true;
  }
  first:statement? rest:indStatement*
  {
    if (first) rest.unshift(first);
    return rest;
  }

indStatement =
  "\n" empty ind:ws* &{ return env.indLevel === ind.length; }
  stm:statement
  {return stm; }

statement =
    id:identifier ws* ":" ws* "\n"
    bl:block { return [id, bl]; }
  / identifier

identifier = s:[a-z]* { return s.join(""); }

empty = (ws* "\n")*

ws = [ \t\r]

다음은 결과 구문 분석기에 대한 입력 예입니다.

b:
   c
   d:
       e
   f
g

PEG.js가 규칙에 대해 어떤 종류의 매개변수도 지원하지 않는다는 인상을 받았습니다. 이는 놀라운 일입니다. 이 기능은 저에게 매우 중요합니다.

내가 필요한 것은 OP의 요청보다 간단합니다. OP는 매개변수에 따라 문법 자체를 수정하기를 원하지만 최소한 정수를 규칙에 전달하면 됩니다. 기본적으로 다음과 같은 LLLPG 규칙을 번역하고 싶습니다(여기서 PrefixExpr 는 -x 와 같은 접두어 표현식 또는 식별자...)와 같은 우선순위가 높은 표현식입니다.

@[LL(1)]
rule Expr(context::Precedence)::LNode @{
    {prec::Precedence;}
    e:PrefixExpr(context)
    greedy
    (   // Infix operator
        &{context.CanParse(prec=InfixPrecedenceOf(LT($LI)))}
        t:(NormalOp|BQString|Dot|Assignment)
        rhs:Expr(prec)
        { ... }
    |   // Method_calls(with arguments), indexers[with indexes], generic!arguments
        &{context.CanParse(P.Primary)}
        e=FinishPrimaryExpr(e)
    |   // Suffix operator
        ...
    )*
    {return e;}
};
// Helper rule that parses one of the syntactically special primary expressions
@[private] rule FinishPrimaryExpr(e::LNode)::LNode @{
(   // call(function)
    "(" list:ExprList(ref endMarker) ")"
    { ... }
    |   // ! operator (generic #of)
        "!" ...
    |   // Indexer / square brackets
        {var args = (new VList!LNode { e });}
        "[" args=ExprList(args) "]"
        { ... }
    )
    {return e;}
};

내 언어 에는 25개의 우선 순위 수준이 있으며 이러한 규칙을 사용하여 거의 모든 항목을 단일 규칙으로 처리하도록 축소했습니다( Precedence 는 운영자). 게다가 내 언어에는 무한한 수의 연산자(기본적으로 모든 구두점 시퀀스)가 있으며 연산자의 우선 순위는 구문 분석된 후에 결정됩니다. 25가지 종류의 연산자 각각에 대해 별도의 규칙을 사용하여 일반적인 방식으로 언어를 구문 분석하는 것은 _기술적으로_ 가능하지만 그렇게 하는 것은 끔찍한 방법이 될 것입니다.

또한 여기에서 내부 규칙 FinishPrimaryExpr 이 둘러싸는 규칙에서 전달된 매개변수를 통합하는 구문 트리를 구성하는 것을 볼 수 있습니다.

그래서 ... 매개변수를 PEG.js 규칙에 전달할 방법이 있습니까?

+1! 제 경우에는 일부 구분 기호를 전역적으로 구성할 수 있는 구문에 대한 파서를 생성하고 싶습니다. 이 경우 구분 기호 리터럴을 술어와 결합된 모든 것과 일치하는 표현식으로 교체하여 이를 달성할 수 있지만 모든 일치가 단순히 변수로 대체될 수 있다면 훨씬 더 우아하고 효율적입니다.

+1, 가까운 장래에 이것이 구현되는 것을 볼 기회가 있습니까?

또 다른 사용 사례. 이것은 javascript.pegjs 예시에서 가져온 것입니다.

(...)

RelationalExpression
  = head:ShiftExpression
    tail:(__ RelationalOperator __ ShiftExpression)*
    { return buildBinaryExpression(head, tail); }

RelationalOperator
  = "<="
  / ">="
  / $("<" !"<")
  / $(">" !">")
  / $InstanceofToken
  / $InToken

RelationalExpressionNoIn
  = head:ShiftExpression
    tail:(__ RelationalOperatorNoIn __ ShiftExpression)*
    { return buildBinaryExpression(head, tail); }

RelationalOperatorNoIn
  = "<="
  / ">="
  / $("<" !"<")
  / $(">" !">")
  / $InstanceofToken

(...)

  (...)
  / ForToken __
    "(" __
    init:(ExpressionNoIn __)? ";" __
    test:(Expression __)? ";" __
    update:(Expression __)?
    ")" __
    body:Statement
  (...)

(...)

이러한 모든 ...NoIn 규칙(그리고 많은 규칙이 있음)은 단순히 for in 문 때문에 필요합니다. 이것에 대한 훨씬 더 나은 접근 방식은 다음과 같습니다.

(...)

RelationalExpression<allowIn>
  = head:ShiftExpression
    tail:(__ RelationalOperator<allowIn> __ ShiftExpression)*
    { return buildBinaryExpression(head, tail); }

RelationalOperator<allowIn>
  = "<="
  / ">="
  / $("<" !"<")
  / $(">" !">")
  / $InstanceofToken
  / &{ return allowIn; } InToken
    {return "in";}

(...)

  (...)
  / ForToken __
    "(" __
    init:(Expression<false> __)? ";" __
    test:(Expression<true> __)? ";" __
    update:(Expression<true> __)?
    ")" __
    body:Statement
  (...)

(...)

이것은 예를 들어 JavaScript 문법이 지정되는 방식과 매우 유사합니다. https://tc39.github.io/ecma262/#prod -IterationStatement ( ~In 참고)

현재 개발 중인 언어에는 다음과 같은 정확한 문제가 있습니다. 특정 지점에서만 일부 규칙을 비활성화/활성화하고 싶습니다. JavaScript 문법에 대해 했던 것처럼 영향을 받는 모든 규칙을 복제하는 것을 삼가고 싶습니다.

규칙을 복제하지 않고 이를 달성할 수 있는 다른 방법이 있습니까?

+1, 가까운 장래에 이것이 구현되는 것을 볼 기회가 있습니까?

이 문제에는 마일스톤이 할당되어 있습니다(1.0.0 이후). PEG.js의 현재 버전은 0.10.0입니다. 분명히 포스트 1.0.0 문제는 로드맵 에 따라 0.11.0 릴리스 후 어느 시점에서 발생할 1.0.0 릴리스 이후에 처리됩니다.

이것은 귀하의 질문에 답해야 합니다. 전체 프로세스를 가속화하는 가장 좋은 방법은 0.11.0 및 1.0.0 을 대상으로 하는 문제를 지원하는 것입니다.

규칙을 복제하지 않고 이를 달성할 수 있는 다른 방법이 있습니까?

가능한 방법은 상태를 수동으로 추적한 다음 의미론적 술어를 사용하는 것입니다. 그러나 이 접근 방식은 역추적에 문제가 있으므로 권장하지 않습니다(즉, 규칙 복제와 수동 상태 추적 중 하나를 선택할 때 복제를 선택합니다).

파서에 전달할 수 있는 두 가지 유형의 인수가 있습니다.

1. 가치. Python, Nim 및 Haskell(및 다른 방식의 Scheme)과 같은 언어의 문법은 트리 내부 표현식의 "깊이"에 따라 다릅니다. 올바른 문법을 작성하려면 이 컨텍스트를 어떻게든 통과해야 합니다.
2. 파서. leftAssociative(element, separator) , escapedString(quote) 및 withPosition(parser) 가 좋은 예입니다.

인수가 파서인지 값인지를 어떻게든 표시하는 방법이 있어야 합니다. 올바른 접근 방식을 알아내려고 했을 때 컨텍스트에 전역 변수를 사용하게 되었고 이는 분명히 막다른 골목이었습니다. 누구든지 그것에 대한 아이디어가 있습니까?

매크로 는 어떻습니까?

주어진:

Add <Expression, Add>
  = left:Expression _ '+' _ right:Add
    { return { type: 'add', left, right } }
  / Expression

언제:

  = Add <MyExpression, MyAdd>

MyExpression
  = [0-9]+

그 다음에:

  = left:MyExpression _ '+' _ right:MyAdd
    { return { type: 'add', left, right } }
  / MyExpression

MyExpression
  = [0-9]+

이를 통해 상향식 :smirk에서 규칙을 작성할 수 있습니다.

동의합니다. 개발자가 이 기능을 추가하는 것이 좋습니다. :)

제가 작성하고 있는 업데이트된 JavaScript 문법에 이 기능이 정말 필요합니다. 그래서 이것은 제 위시리스트에 있습니다. 그것을 해보고 그것이 어떻게 작동하는지 볼 것입니다.

@samvv 나는 이것을 매우 다른 경로에서 보았고 아직 전체 스레드를 읽지 않았습니다.
그러나 여기에서 언급한 #572에서 매개변수화된 규칙을 시뮬레이션할 수 있는 기술을 보여주고 있습니다.

즉, 본질적으로 함수 를 중간 구문 분석 결과로 반환합니다.

그 "속임수"는 결코 내 발명품이 아니며 아마도 당신의 목적에 다소 투박한 것 같습니다. 그러나 그것은 당신을 위한 해결 방법일 수 있습니다. "포스트 v1.0"까지... :)

@meisl Cool, 팁 감사합니다! 시간이 나면 시도해 보겠습니다.

@samvv 오, 아... 제가 좀 중요한 것을 간과한 것 같습니다.

매개변수화된 규칙을 원하는지 여부는 상당한 차이가 있습니다.

• 매개변수에 따라 달라지는 값만 생성할 수 있음
• 또는 (또한) 구문 분석 결정이 매개 변수에 따라 달라지도록 하려면

내가 제안한 것은 전자 에만 도움이되는 반면 후자는 OP의 실제 문제입니다 ...
그 죄송합니다.

그러나 후자의 경우 에도 해결 방법이 있습니다.
그리고 "의존 결정" 부분은 함수를 반환하는 것과 아무 관련이 없습니다...

https://pegjs.org/online 에서 시도해 볼 수 있는 예제를 추가하고 있습니다.

기본 아이디어는 현재 "터미네이터"를 기억하기 위해 전역 상태를 사용하는 것입니다. 그것은 확실히 해킹이며 반복적입니다.
하지만: | 또 다른 구분 기호를 추가하는 것은 str 에 하나의 대안을 추가하는 것을 의미합니다.

  / (t:'|' {term = t}) c:conts t:.&{ return isT(t) }  { return c }

그것은 바로 그 하나 의 문자에서 다른 것들과 다릅니다 |

{
  var term;
  function isT(ch) { return ch === term }
  function isE(ch) { return ch === '\\' }
}
start = str*

str
  = (t:'\"' {term = t}) c:conts t:.&{ return isT(t) }  { return c }
  / (t:'\'' {term = t}) c:conts t:.&{ return isT(t) }  { return c }

conts
  = c:(
        '\\' t:.&{ return isT(t) || isE(t) } { return t }
      /      t:.!{ return isT(t)           } { return t }
    )*
    { return c.join('') }

... 입력에

• "abc" -> ["abc"]
• "a\"bc" -> ["a\"bc"]
• "a\\bc" -> ["a\bc"]
• "a\\b\"c"'a\\b\'' -> ["a\b\"c", "a\b'c"]

추신: 그건 정말 손으로 쓰고 싶은 것이 아닙니다. 저도 압니다. 하지만 이봐, 그것이 당신을 위해 생성 될 것이라고 상상해보십시오... 제 생각에는 원칙적으로 그렇게 생각 합니다 .

@ceymard - 10년이 지난 걸 알지만 #36과 어떻게 다른지 궁금합니다.

우와 기억하는데 시간이 좀 걸렸네요. 10 년 !

이 PR에서 규칙은 인수를 취하고 매개변수화될 수 있습니다. 이것은 유사하지만 다른 규칙의 반복을 피하기 위해 문법 자체에서 사용하기 위한 것입니다.

#36에서 규칙은 문법 자체의 외부에 지정됩니다. 따라서 문법 자체가 매개변수화됩니다.

문법 자체가 규칙이고 따라서 동일한 문제라고 주장할 수 있지만 범위가 다르다고 생각합니다. #36은 아마도 약간의 API 변경을 의미하지만 이 PR은 그렇지 않기 때문에 그렇지 않다고 생각합니다.

따라서 C++ 용어를 매우 잘못된 방식으로 남용하기 위해 전자는 템플릿 정적이고 후자는 생성자 호출입니까?

나는 이 비유가 어느 정도 효과가 있다고 생각합니다. 그렇습니다.

시간내서 설명해주셔서 감사합니다

10년 후에는 또 다른 질문이 있을 것입니다. 2020년 잘 보내세요

내 파서 정의의 중복을 제거하는 데 정말 유용할 것입니다. 나는 의도적으로 매우 편안한 맞춤 문법을 가지고 있으며 약간 다른 컨텍스트에서 일부 규칙을 적용해야 합니다.