Cosa è idiomatico?

Capisco un "linguaggio" come un'operazione o modello comune che in una lingua particolare non è semplificata dalla sintassi del linguaggio principale, come l'incremento di interi:

i = i + 1;

In C ++, questo linguaggio è semplificato da un operatore:

++i;

Tuttavia, quando qualcuno usa il termine "idiomatico", non sono sicuro di come capirlo. Cosa rende "idiomatico" un pezzo di codice?

Un modo idiomatico di scrivere del codice è quando lo scrivi in ​​un modo molto specifico a causa di idiomi specifici della lingua che altre lingue non hanno.

Ad esempio, in C ++, lo sfruttamento del linguaggio RAII porta a modi di scrivere codice C ++ gestendo risorse idiomatiche.

Un altro esempio potrebbe essere la comprensione delle liste in Python per generare liste. È idiomatico perché avresti usato la comprensione dell'elenco in Python idiomatico ma avresti potuto fare lo stesso usando una funzione di generatore in qualsiasi altra lingua o persino in Python.

Spesso, qualcuno che prova una nuova lingua senza usare gli idiomi specifici di questa lingua non scriverà un codice idiomatico.

Definizione normale

Usare, contenere o denotare espressioni naturali per un madrelingua

Definizione di programmazione

Utilizzando, contenenti, o che denota espressioni che sono naturali a un [inserire la lingua] programmatore

Idiomatico nel contesto della programmazione di solito può essere definito come "il modo più naturale per esprimere qualcosa in una lingua"

Vedo che la parola idiomatica appare particolarmente in Ruby. In Ruby ci sono enormi capacità di meta-programmazione e per scrivere un codice Ruby idiomatico, di solito è necessario utilizzarle.

Nota che solo perché un pezzo di codice è idiomatico, non significa che sia pulito o addirittura conciso. Molte volte devi scendere a compromessi.

Quindi, fondamentalmente, l'idioma si riferisce più comunemente al modo più comune di scrivere qualcosa in una lingua, spesso includendo "gergo" (modi di dire). Se un pezzo di codice non è idiomatico, può essere perfettamente leggibile, conciso, pulito e corretto, ma può sembrare / apparire imbarazzante nella lingua usata. È una preferenza di gusto se riscrivere in modo idiomatico una tale parte di codice sarebbe effettivamente una buona cosa e debba essere valutata caso per caso

L'inglese idiomatico, ad esempio, può dipendere dalla regione. L'uso della parola bumè probabilmente richiesto per l'inglese inglese idiomatico, mentre buttè più appropriato per l'inglese americano. (Non so molto inglese britannico purtroppo: /)

Il miglior esempio che posso escogitare, in cima alla mia testa, per qualcosa di idiomatico, viene da Ruby.

In molte lingue, puoi iterare con:

for( start; end; increment){
    code;
}

O qualcosa di molto simile. Molte lingue hanno anche un foreach(x in SetOfXes)costrutto. Ma l'iterazione idiomatica di Ruby include cose come:

collection.each do |current|
  current.do_stuff
end

e persino

10.times do |x|
  puts x
end

Vedo questi come idiomatici perché rappresentano un modo di fare qualcosa che è meno comune e che rappresenta qualcosa al centro della filosofia del suo dominio. Ruby ha una filosofia sull'interazione con oggetti che, sebbene non unica, non è onnipresente.

Su una nota semantica, ogni volta che sento la parola idiomatica, il mio cervello completa automaticamente il pensiero come "idiomatico a ..." - lo analizzo solo riflessivamente in relazione a un argomento specifico.

Gli idiomi sono di solito il modo migliore per esprimere una situazione comune e relativamente complessa in una lingua. L'incremento non è un linguaggio o qualcosa del genere. Usando l'incremento del prefisso invece del postfisso, potresti sostenere di essere un linguaggio C ++.

I modi di dire sono il modo migliore per usare una lingua, come determinato da utenti esperti. Un vero linguaggio C ++ sarebbe oggetti funzione. Un altro linguaggio sarebbe RAII. Non c'è niente nella lingua che ti dica che devi liberare risorse nel distruttore. Ma è idiomatico farlo. Un altro esempio è rappresentato dai modelli: è idiomatico usare i modelli per tutto ciò che puoi, ma non c'è nulla che ti impedisca di usare eccessivamente l'eredità.

La tua definizione non mi sembra corretta. Un linguaggio è un modo di scrivere qualcosa che può o non può essere possibile in altre lingue, ma che è un luogo comune in questa lingua. Di solito, è più breve dell'alternativa, ma non è davvero un requisito.

Potrebbe essere più facile spiegarlo parlando di ciò che non è idiomatico. In C ++, è abbastanza idiomatico scrivere:

Foo* p = SomeThingThatReturnsAFooPointer(arg, param, x, y);
if(p)
{
 // whatever
}

È ancora più idiomatico scrivere:

Foo* p; 
if(p = SomeThingThatReturnsAFooPointer(arg, param, x, y))
{
 // whatever
}

Questo codice fa esattamente la stessa cosa: alcune persone che non conoscono C ++ potrebbero leggerlo come test per vedere se p è uguale a ciò che restituisce la funzione, ma non è quello che fa.

Confronta con quello che qualcuno potrebbe scrivere, in modo molto non idiomatico, che proviene da un'altra lingua:

Foo* p = SomeThingThatReturnsAFooPointer(arg, param, x, y);
if(p !=NULL)
{
 // whatever
}

Vedrai anche queste cose come non idiomatiche:

if (x>0)
  return true;
else
 return false;

Perché l'approccio idiomatico è

return (x>0);

I modi non idiomatici non sono sbagliati, ma di solito impiegano più tempo a scrivere e impiegano sempre più tempo a leggere, per coloro che conoscono gli idiomi. Se ti chiamo "il ragazzo che piangeva lupo" e conosci la storia, è più veloce che se ti spiegassi come i falsi allarmi inducono le persone a ignorarti. Il problema, ovviamente, è se non conosci la storia e non sai cosa hanno a che fare i lupi con ciò di cui stiamo parlando. Allo stesso modo, può essere un problema se non l'hai mai visto return x<y;prima e davvero non sai cosa fa.

Quando ci sono diversi modi per esprimere qualcosa, il modo più comune o comunemente accettato. Ad esempio, usando un'istruzione strutturata in C invece dell'equivalente esatto usando le istruzioni goto.