A tipagem de pato deve afetar as convenções de nomenclatura?

5

Sou um desenvolvedor de C ++ / C # e recentemente comecei a aprender Python. Acho que entendo o conceito de tipagem de pato agora, exceto por uma coisa.

Quando estou codificando em C ++ ou C #, às vezes, crio classes completamente não relacionadas que possuem métodos similares com assinaturas semelhantes, por exemplo: Create (), Open (), Close (), ProcessData (), etc. grande coisa em C + + ou C # (a menos que você queira mexer com modelos C ++), mas em linguagens com a digitação de pato como Python isso poderia causar um desastre. Considere o seguinte exemplo:

class DbTransaction:
    def rollback(self):
        pass

class SourceControlChangeset:
    def rollback(self):
        pass

def rollback_transaction(transaction):
    transaction.rollback()

transaction = DbTransaction()
changeset = SourceControlChangeset()
rollback_transaction(transaction)
rollback_transaction(changeset) # Oops!

Talvez seja um pouco artificial, mas acho que isso pode acontecer facilmente em um grande projeto com muitas classes.

O que devo fazer nesta situação? Eu acho que a verificação de tipos não é "pythonic", então minha única idéia é mudar a convenção de nomenclatura para métodos de classe como este:

class DbTransaction:
    def rollback_transaction(self):
        pass

class SourceControlChangeset:
    def rollback_changeset(self):
        pass

Alguma idéia?

    
por RX_DID_RX 03.05.2014 / 13:48
fonte

2 respostas

5

Em Limpar código , Robert Martin argumenta que, mesmo com a tipagem estática, você deve evitar o que ele chama de "punição", o que significa dar o mesmo nome a dois métodos que não são semanticamente semelhantes. Isso significa que, se você considerar que transaction.rollback e changeset.rollback são semanticamente diferentes, tente escolher outro nome para um deles, independentemente de estar praticando ou não uma tipagem de pato.

Em seu exemplo específico, o nome torna a semântica de cada caso óbvia, mesmo que o contexto seja diferente, portanto, não há problema em deixar o nome igual. Você está preocupado principalmente em evitar a passagem acidental de um tipo de objeto para um contexto destinado ao outro.

Para ser franco, esse é o trade-off que você faz ao escolher a digitação de pato. Você aumenta o risco de usar o tipo errado, o que requer um pouco mais de testes, mas em troca você ganha mais reutilização com menos problemas. Se você deseja os benefícios da strong tipagem estática, escolha seu idioma e arquitetura de acordo. Você não pode ter seu bolo e comê-lo também.

    
por 04.05.2014 / 03:30
fonte
1

O infeliz efeito colateral de Duck Typing é que às vezes não é um pato, mesmo que ele ande como um pato e fique como um pato. A Duck Typing só funciona em áreas limitadas de similaridade.

Seu exemplo, no entanto, é um problema. Você nunca deve rollback_transaction(transaction) , você deve sempre transaction.rollback() . Se você tiver um motivo válido para encapsular o comportamento de um método, você deve fazê-lo "de forma objetiva", não processual, criando um objeto wrapper cujo método envolva o método do objeto interno.

    
por 03.05.2014 / 15:28
fonte