Как я могу преобразовать большое различаемое объединенное дерево в читаемую форму? - PullRequest
2 голосов
/ 29 сентября 2010

Следующий тип явно довольно большой, поэтому ручное написание кода для преобразования его в читаемую форму было бы утомительно. Я хотел бы знать самый простой способ отобразить дерево в удобочитаемой форме.

type Element =
| Nil
| Token of Token
| Expression of Element * Element
| ExpressionNoIn of Element * Element
| AssignmentExpression of Element * AssignmentOperator * Element
| AssignmentExpressionNoIn of Element * AssignmentOperator * Element
| ConditionalExpression of Element * Element * Element
| ConditionalExpressionNoIn of Element * Element * Element
| LogicalORExpression of Element * Element
| LogicalORExpressionNoIn of Element * Element
| LogicalANDExpression of Element * Element
| LogicalANDExpressionNoIn of Element * Element
| BitwiseORExpression of Element * Element
| BitwiseORExpressionNoIn of Element * Element
| BitwiseXORExpression of Element * Element
| BitwiseXORExpressionNoIn of Element * Element
| BitwiseANDExpression of Element * Element
| BitwiseANDExpressionNoIn of Element * Element
| EqualityExpression of Element * EqualityOperator * Element
| EqualityExpressionNoIn of Element * EqualityOperator * Element
| RelationalExpression of Element * RelationalOperator * Element
| RelationalExpressionNoIn of Element * RelationalOperator * Element
| ShiftExpression of Element * BitwiseShiftOperator * Element
| AdditiveExpression of Element * AdditiveOperator * Element
| MultiplicativeExpression of Element * MultiplicativeOperator * Element
| UnaryExpression of UnaryOperator * Element
| PostfixExpression of Element * PostfixOperator
| MemberExpression of Element * Element
| Arguments of Element * Element
| ArgumentList of Element
| CallExpression of Element * Element
| NewExpression of NewOperator * Element
| LeftHandSideExpression of Element
| PrimaryExpression of Element
| ObjectLiteral of Element
| PropertyNameAndValueList of Element * Element
| PropertyAssignment of Element * Element * Element 
| PropertyName of Element
| PropertySetParameterList of Element
| ArrayLiteral of Element * Element
| Elision of Element * Element
| ElementList of Element * Element * Element     
| Statement of Element
| Block of Element
| StatementList of Element * Element
| VariableStatement of Element
| VariableDeclarationList of Element * Element
| VariableDeclarationListNoIn of Element * Element
| VariableDeclaration of Element * Element
| VariableDeclarationNoIn of Element * Element
| Initialiser of Element
| InitialiserNoIn of Element
| EmptyStatement
| ExpressionStatement of Element
| IfStatement of Element * Element * Element 
| IterationStatement of Element * Element * Element * Element
| ContinueStatement of Element
| BreakStatement of Element
| ReturnStatement of Element
| WithStatement of Element * Element
| SwitchStatement of Element * Element
| CaseBlock of Element * Element * Element
| CaseClauses of Element * Element
| CaseClause of Element * Element
| DefaultClause of Element
| LabelledStatement of Element * Element
| ThrowStatement of Element
| TryStatement of Element * Element * Element
| Catch of Element * Element
| Finally of Element
| DebuggerStatement    
| FunctionDeclaration of Element * Element * Element
| FunctionExpression of Element * Element * Element
| FormalParameterList of Element * Element
| FunctionBody of Element    
| SourceElement of Element
| SourceElements of Element * Element
| Program of Element

Вот пример того, как это может отображаться. (Это немного отличается от того, что я произвел некоторое время назад.)

<Expression>
  <AssignmentExpression>
    <ConditionalExpression>
      <LogicalORExpression>
        <LogicalORExpression>
          <LogicalANDExpression>
            <BitwiseORExpression>
              <BitwiseXORExpression>
                <BitwiseANDExpression>
                  <EqualityExpression>
                    <EqualityExpression>
                      <RelationalExpression>
                        <ShiftExpression>
                          <AdditiveExpression>
                            <MultiplicativeExpression>
                              <MultiplicativeExpression>
                                <UnaryExpression>
                                  <PostfixExpression>
                                    <LeftHandSideExpression>
                                      <NewExpression>
                                        <MemberExpression>
                                          <PrimaryExpression>
                                            <TokenNode Value="i" Line="9" Column="13" />
                                          </PrimaryExpression>
                                        </MemberExpression>
                                      </NewExpression>
                                    </LeftHandSideExpression>
                                  </PostfixExpression>
                                </UnaryExpression>
                              </MultiplicativeExpression>
                              <TokenNode Value="%" Line="9" Column="15" />
                              <UnaryExpression>
                                <PostfixExpression>
                                  <LeftHandSideExpression>
                                    <NewExpression>
                                      <MemberExpression>
                                        <PrimaryExpression>
                                          <TokenNode Value="3" Line="9" Column="17" />
                                        </PrimaryExpression>
                                      </MemberExpression>
                                    </NewExpression>
                                  </LeftHandSideExpression>
                                </PostfixExpression>
                              </UnaryExpression>
                            </MultiplicativeExpression>
                          </AdditiveExpression>
                        </ShiftExpression>
                      </RelationalExpression>
                    </EqualityExpression>
                    <TokenNode Value="===" Line="9" Column="19" />
                    <RelationalExpression>
                      <ShiftExpression>
                        <AdditiveExpression>
                          <MultiplicativeExpression>
                            <UnaryExpression>
                              <PostfixExpression>
                                <LeftHandSideExpression>
                                  <NewExpression>
                                    <MemberExpression>
                                      <PrimaryExpression>
                                        <TokenNode Value="0" Line="9" Column="23" />
                                      </PrimaryExpression>
                                    </MemberExpression>
                                  </NewExpression>
                                </LeftHandSideExpression>
                              </PostfixExpression>
                            </UnaryExpression>
                          </MultiplicativeExpression>
                        </AdditiveExpression>
                      </ShiftExpression>
                    </RelationalExpression>
                  </EqualityExpression>
                </BitwiseANDExpression>
              </BitwiseXORExpression>
            </BitwiseORExpression>
          </LogicalANDExpression>
        </LogicalORExpression>
        <TokenNode Value="||" Line="9" Column="25" />
        <LogicalANDExpression>
          <BitwiseORExpression>
            <BitwiseXORExpression>
              <BitwiseANDExpression>
                <EqualityExpression>
                  <EqualityExpression>
                    <RelationalExpression>
                      <ShiftExpression>
                        <AdditiveExpression>
                          <MultiplicativeExpression>
                            <MultiplicativeExpression>
                              <UnaryExpression>
                                <PostfixExpression>
                                  <LeftHandSideExpression>
                                    <NewExpression>
                                      <MemberExpression>
                                        <PrimaryExpression>
                                          <TokenNode Value="i" Line="9" Column="28" />
                                        </PrimaryExpression>
                                      </MemberExpression>
                                    </NewExpression>
                                  </LeftHandSideExpression>
                                </PostfixExpression>
                              </UnaryExpression>
                            </MultiplicativeExpression>
                            <TokenNode Value="%" Line="9" Column="30" />
                            <UnaryExpression>
                              <PostfixExpression>
                                <LeftHandSideExpression>
                                  <NewExpression>
                                    <MemberExpression>
                                      <PrimaryExpression>
                                        <TokenNode Value="5" Line="9" Column="32" />
                                      </PrimaryExpression>
                                    </MemberExpression>
                                  </NewExpression>
                                </LeftHandSideExpression>
                              </PostfixExpression>
                            </UnaryExpression>
                          </MultiplicativeExpression>
                        </AdditiveExpression>
                      </ShiftExpression>
                    </RelationalExpression>
                  </EqualityExpression>
                  <TokenNode Value="===" Line="9" Column="34" />
                  <RelationalExpression>
                    <ShiftExpression>
                      <AdditiveExpression>
                        <MultiplicativeExpression>
                          <UnaryExpression>
                            <PostfixExpression>
                              <LeftHandSideExpression>
                                <NewExpression>
                                  <MemberExpression>
                                    <PrimaryExpression>
                                      <TokenNode Value="0" Line="9" Column="38" />
                                    </PrimaryExpression>
                                  </MemberExpression>
                                </NewExpression>
                              </LeftHandSideExpression>
                            </PostfixExpression>
                          </UnaryExpression>
                        </MultiplicativeExpression>
                      </AdditiveExpression>
                    </ShiftExpression>
                  </RelationalExpression>
                </EqualityExpression>
              </BitwiseANDExpression>
            </BitwiseXORExpression>
          </BitwiseORExpression>
        </LogicalANDExpression>
      </LogicalORExpression>
    </ConditionalExpression>
  </AssignmentExpression>
</Expression>

1 Ответ

3 голосов
/ 29 сентября 2010

Если вы хотите написать общий код обработки объединения, который не должен будет перечислять все случаи объединения, то вам, вероятно, потребуется использовать API-интерфейс отражения F #.Вот простой пример.

Функция formatUnion использует отражение F #.Предполагается, что параметр типа 'T является типом объединения и использует GetUnionFields для получения кортежа, содержащего имя текущего регистра и аргументы.Он печатает текущее имя дела и перебирает все аргументы.Если некоторые из аргументов имеют значение типа 'T (что означает, что это рекурсивное объединение), мы рекурсивно выводим информацию о значении:

let rec formatUnion indent (value:'T) = //' 
  // Get name and arguments of the current union case
  let info, args = Reflection.FSharpValue.GetUnionFields(value, typeof<'T>) //'
  // Print current name (with some indentation)
  printfn "%s%s" indent info.Name
  for a in args do
    match box a with 
    | :? 'T as v ->  
      // Recursive use of the same union type..
      formatUnion (indent + "  ") v
    | _ -> ()

В следующем примере функция выполняется с очень простым значением объединения:

type Element = | Nil | And of Element * Element | Or of Element * Element
formatUnion "" (And(Nil, Or(Nil, Nil)))

// Here is the expected output:
// And
//   Nil
//   Or
//     Nil
//     Nil

В качестве дополнительного примечания, я думаю, что вы могли бы значительно упростить свой дискриминируемый союз, имея регистры для BinaryOperator и UnaryOperator (с одним дополнительным параметром) вместо перечисления всех типов элементовв явном виде.Тогда вы, вероятно, могли бы реализовать функцию напрямую, потому что это было бы довольно просто.Что-то вроде:

type BinaryOperator = LogicalOr | LogicalAnd | BitwiseOr // ...
type UnaryOperator = Statement | Block | Initializer // ...

type Element = 
  | BinaryOperator of BinaryOperator * Element * Element
  | UnaryOperator of UnaryOperator * Element 
Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.
...