Dovrei preoccuparmi di cercare di inventare i nomi per questi? [chiuso]

Question

Dovrei preoccuparmi di cercare di inventare i nomi per questi? [chiuso]

#1 da (2 voti)
#2 da (1 voti)
#3 da (1 voti)

0

Se dovessi attraversare codice come questo nei tuoi viaggi, i nomi brevi ti infastidirebbero?

let setPropertyAssignment = 
    parser {
        let! a = setIdentifierName
        let! b = propertyName
        let! c = openParenthesis 
        let! d = propertySetParameterList
        let! e = closeParenthesis 
        let! f = openCurlyBracket 
        let! g = functionBody
        let! h = closeCurlyBracket
        return Node(NodeType.PropertyAssignment, [a;b;c;d;e;f;g;h])
    }

Ecco il parser più grande nel progetto:

let iterationStatement = 
    parser {
        let! a = doKeyWord
        let! b = statement
        let! c = whileKeyWord
        let! d = openParenthesis
        let! e = expression
        let! f = closeParenthesis
        let! g = statementTerminator
        let symbols = [a; b; c; d; e; f; g]
        return Node(NodeType.IterationStatement, symbols)
    } +++ parser {
        let! a = whileKeyWord
        let! b = openParenthesis
        let! c = expression
        let! d = closeParenthesis
        let! e = statement
        let symbols = [a; b; c; d; e]
        return Node(NodeType.IterationStatement, symbols)
    } +++ parser {
        let! a = forKeyWord
        let! b = openParenthesis
        let! c = maybeOne expressionNoIn
        let! d = semiColon
        let! e = maybeOne expression
        let! f = semiColon
        let! g = maybeOne expression
        let! h = closeParenthesis
        let! i = statement
        let symbols = [a;b] @ c @ [d] @ e @ [f] @ g @ [h;i]              
        return Node(NodeType.IterationStatement, symbols)
    } +++ parser {
        let! a = forKeyWord
        let! b = openParenthesis
        let! c = varKeyWord
        let! d = variableDeclarationListNoIn
        let! e = semiColon
        let! f = maybeOne expression
        let! g = semiColon
        let! h = maybeOne expression
        let! i = closeParenthesis
        let! j = statement
        let symbols = [a;b;c;d;e] @ f @ [g] @ h @ [i;j]
        return Node(NodeType.IterationStatement, symbols)
    } +++ parser {
        let! a = forKeyWord
        let! b = openParenthesis
        let! c = leftHandSideExpression
        let! d = inKeyWord
        let! e = expression
        let! f = closeParenthesis
        let! g = statement
        let symbols = [a;b;c;d;e;f;g]               
        return Node(NodeType.IterationStatement, symbols)
    }  +++ parser {
        let! a = forKeyWord
        let! b = openParenthesis
        let! a = varKeyWord
        let! c = variableDeclarationNoIn
        let! a = inKeyWord
        let! c = expression
        let! d = closeParenthesis
        let! e = statement
        let symbols = [a; b; c; d; e]
        return Node(NodeType.IterationStatement, symbols)
    }

naming f#

posta ChaosPandion 15.09.2010 - 22:44

fonte

3 risposte

2

Dipende dalla complessità. Con qualcosa di queste dimensioni, è abbastanza ovvio cosa stai facendo e perché. Renderlo molto più grande - una pagina o giù di lì - e diventerà molto confuso molto rapidamente.

risposta data 15.09.2010 - 22:50

fonte

1

Beneficerai di una funzione wrapper che prende un elenco di parser di 'a (il tuo a a i sopra) e restituisce un parser singolo di 'a list . In questo modo non avresti bisogno di assegnare nomi a questi parser intermedi; potresti rilasciarli direttamente in un elenco.

risposta data 15.09.2010 - 23:56

fonte

Leggi altre domande sui tag naming f#

Script / strumento per importare serie di istantanee, ognuna delle quali è una nuova edizione, in GIT, popolando l'albero dei sorgenti? [chiuso] Scrittura / discussioni sull'estetica del codice? [chiuso]

score 1 · Accepted Answer

I nomi variabili di char singe mantengono leggibili le parti importanti. Per il mio occhio è molto più prezioso nominare le variabili usa e getta.

So poco di F #, ma se qualcosa di simile all'esempio qui sotto è possibile, lo troverei un po 'più semplice dal momento che non sono coinvolti compiti extra:

let setPropertyAssignment = 
  parser {
    return Node(NodeType.PropertyAssignment,
                  [
                   Lazy.force setIdentifierName;
                   Lazy.force propertyName;
                   Lazy.force openParenthesis;
                   Lazy.force propertySetParameterList;
                   Lazy.force closeParenthesis;
                   Lazy.force openCurlyBracket;
                   Lazy.force functionBody;
                   Lazy.force closeCurlyBracket
                  ]
               )
  }