Como lidar com parâmetros singulares e plurais para funções

5

Muitas vezes, quando estou escrevendo um conjunto de funções de utilitário, me vejo querendo uma função que aplica alguma lógica a vários itens, bem como uma função que faz o mesmo com apenas um único item. Existem muitas soluções possíveis para isso, mas eu sempre me vejo indo e voltando.

  • Eu poderia escrever uma versão exclusivamente singular da função ( modify_item(item) ) e usar map , compreensão ou foreach externamente. Eu não quero fazer isso toda vez que eu chamo isso com vários itens.
  • Eu poderia escrever uma versão exclusivamente explícita do plural da função ( modify_items(items) ) que faz a iteração dentro dela. Mas eu não quero chamá-lo com uma lista de cada vez também. Melhor do que sempre singular, mas ainda assim difícil de chamar. Isso também suportaria melhor as operações em massa.
  • Eu poderia escrever uma função agnóstica que verifica o tipo de entrada ( modify_item(item) ). Se não for iterável, ele será agrupado em uma lista e depois será iterado. Esta parece ser a melhor opção, mas a atração dos operadores sempre me pega ...
  • Eu poderia escrever uma função agnóstica que toma um número variável de entradas (modify_item (* items)) e itera sobre elas. Isso me dá uma boa sintaxe de chamada e empacota automaticamente os itens em um iterável para mim. O problema que sempre encontro aqui é que adicionar argumentos subseqüentes ou argumentos de palavras-chave é estranho.
  • Finalmente, eu poderia simplesmente jogar minhas mãos e escrever uma função plural como acima, e uma singular que envolveria o parâmetro em uma lista e passaria para o plural. Então eu teria que escrever o dobro das funções, o que é bobo.

Parece que as bibliotecas javascript geralmente fazem a opção de verificação de tipo (# 3), e essa é a que eu mais gosto. Nesse caso, você tem a questão de nomear convenções. Acho que sou a favor do singular, mas não tenho certeza disso.

Os exemplos estão em python, mas essa questão pode ser aplicada à maioria dos idiomas.

    
por JStaab 08.09.2015 / 18:44
fonte

2 respostas

0

Um amigo meu me convenceu da opção número três, com a adição de que ele usa uma função auxiliar chamada ensure_plural para garantir que a entrada esteja no plural antes de continuar. Isso o mantém legal e declarativo. A função auxiliar pode ter algumas formas diferentes:

  • Como decorador, apenas modificaria as entradas antes mesmo de chegar à função principal. O problema é que teria que assumir algumas coisas.
  • Poderia ser chamado apenas no valor que precisa ser plural quando necessário.
  • Eu também criei uma versão chamada if_plural , que pegaria um valor e uma função e retornaria o resultado da aplicação da função diretamente ao valor se singular, ou do mapeamento da função sobre o valor se plural .
por 10.09.2015 / 00:14
fonte
7

Nestes casos, costumo fazer duas versões da função, com a versão múltipla simplesmente chamando a versão singular, algo assim:

class Foo:
  def transform_entity(bar):
    return do_things(bar)

  def transform_entities(bars):
    return [transform_entity(b) for b in bars]

É bastante auto-explicativo, evita qualquer quebra explícita, e permite que você use argumentos corretamente sem quebra manual (ao contrário de tentar fazer algo terrível com varargs).

    
por 09.09.2015 / 02:46
fonte