Caratteristiche del linguaggio di programmazione semi-univoco di Killer [chiuso]

Quando impari un nuovo linguaggio di programmazione a volte ti imbatti in una funzione linguistica che ti fa desiderare di averlo negli altri linguaggi di programmazione che conosci.

Quali sono alcune funzionalità linguistiche che al momento dell'apprendimento erano molto nuove per te e che vorresti avessero gli altri tuoi linguaggi di programmazione.

Un esempio di ciò sono i generatori in Python o C #. Altri esempi possono comprendere la comprensione dell'elenco in Python, il modello in C ++ o LINQ in .NET o la valutazione pigra in Haskell.

Quali altre caratteristiche linguistiche semi-uniche hai scoperto che erano completamente nuove e illuminanti per te? Esistono altre caratteristiche dei linguaggi di programmazione precedenti che erano uniche e fuori moda?

Praticamente qualsiasi cosa a Haskell

• Monadi. Sì, la grande parola spaventosa che rende parsermente facili i parser, l'IO, le operazioni sugli elenchi e altre cose così facili (una volta notato uno schema comune)
• Frecce. Lo stesso per utenti esperti;)
• Roba standard come lambda ecc.
• Funzioni curriculari
• Tipi di dati algebrici
• Corrispondenza del modello

E molti altri.

PS. Sì. Sono un fan di Haskell se qualcuno lo chiedesse.

Macro Lisp.

Il linguaggio macro Lisp è Lisp, con alcune funzioni di sintassi predefinite per motivi di praticità. Usandoli, è possibile aggiungere funzionalità importanti al linguaggio, come la scelta degli stili di orientamento degli oggetti o la corrispondenza deterministica simile a Prolog, senza guardare fuori posto. Rende setfpossibile la macro, che è una macro concettualmente molto potente: (setf A B)significa che, quando valuti A, otterrai Be che può essere estesa a qualsiasi limite ti piaccia.

La metaprogrammazione del modello C ++ è capace di cose simili, ma in un linguaggio molto diverso dal normale C ++.

Decoratore di Python.

È estremamente facile implementare la memorizzazione o il tempismo della funzione usando il decoratore.

Esempio di un timer funzione.

class FuncTimer(object):
    """ Time how much time a function takes """
    def __init__(self, fn):
        self.fn = fn
        self.memo = {}
        self.start_time = time.time()
    def __call__(self, *args):
        self.memo['return'] = self.fn(*args)
        print("Function '%s' took %u seconds" % (self.fn.__name__, time.time() - self.start_time))
        return self.memo['return']

Ora se hai una funzione per cui vuoi passare il tempo, puoi semplicemente farlo,

@FuncTimer
def foo():
    # foo's implememtation goes here

Vedrai qualcosa come

La funzione "pippo" ha impiegato 3 secondi.

Trasmissione void*in C. È possibile eseguire il cast di tutto in byte non elaborati e fare ciò che si desidera con questi dati.

(Sì, al giorno d'oggi è unico ...)

Resa in Python

In Python (e credo in C #), puoi definire un cosiddetto generatore che mette in pausa l'esecuzione della funzione in yieldun'istruzione, restituisce il valore e nelle chiamate successive, riavvia la funzione da cui era stata interrotta (con lo stato conservato tra le chiamate). Questo è ottimo per generare lunghi elenchi di valori in cui sei interessato solo al valore corrente della funzione (che è molto comune). Ti permette di costruire sequenze potenzialmente infinitamente lunghe occupando solo uno spazio molto limitato in memoria.

Espressioni lambda (chiusure, funzioni nidificate, metodi anonimi, come li chiami).

Mi sono imbattuto per la prima volta in Perl, li ho subito amati e mi sono chiesto perché altre lingue non li hanno. Oggi credo che non sia più così unico; persino PHP è riuscito a hackerarli in qualche modo. Ma erano semi-unici al momento.

Continuazioni dallo schema (successivamente adottato da alcune altre lingue tra cui Ruby.)

Gli insiemi in Delphi sono molto utili, praticamente solo un array booleano denominato. Sono molto utili per salvare un modulo di impostazioni con 32 caselle di controllo. Ma hanno tutte le stesse funzioni di teoria dell'insieme (cioè differenza, intersezione, unione).

Non sono sicuro che siano passati di moda, ma li uso sempre.

Inviare

Da Erlang. Invia un messaggio asincrono a un altro thread.

Expr1 ! Expr2

Ricevere

Da Erlang. Riceve un messaggio da un altro thread.

receive
    Pattern1 [when GuardSeq1] ->
        Body1;
    ...;
    PatternN [when GuardSeqN] ->
        BodyN
end

Proprietà C #

/// <summary>
/// Get ID
/// </summary>
public int ID
{
    get; set;
}

vs

(Giava)

/**
 * Name of user
 */
private String name;

/**
 * Gets name of user
 * @return Name of user
 */
public String getName() {
    return this.name;
}

/**
 * Sets name of user. 
 * @param name
 */
public void setName(final String name) {
    this.name = name;
}

I sindacati in C.

Onestamente non posso dire di non aver scritto abbastanza C per crearne uno da solo, ma ho lavorato con il codice di altri che lo fa.

Quando si tratta di impacchettare miscele di dati diversi in applicazioni che manipolano bit / byte grezzi come reti o archiviazione di dati binari. Nelle lingue fortemente tipizzate non esiste un modo semplice per fare l'equivalente.

Disclaimer:

Sebbene i sindacati siano estremamente utili in alcuni casi, non si trovano nella maggior parte delle lingue di livello superiore perché non sono sicuri per i tipi. IE, puoi far sanguinare i dati oltre i confini delle variabili usando i sindacati (un grande no no nel tipo di mondo sicuro). Con un grande potere viene una grande responsabilità.

Mi piace molto il modificatore a meno che non sia in Ruby . Sembra così naturale e sostituisce molti scenari in cui il tuo codice sembra essere molto disordinato senza di esso.

puts "All good" unless input.nil?

Come può non piacerti? : D

sintassi degli argomenti di fantasia in pitone

Non sono sicuro di quanto sia unico, ma in Python puoi fare cose interessanti come avere coppie di parole chiave automaticamente trasformate in un dizionario e viceversa. Lo stesso con le liste:

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print "-- This parrot wouldn't", action,
    print "if you put", voltage, "volts through it."
    print "-- Lovely plumage, the", type
    print "-- It's", state, "!"


parrot(1000)
parrot(action = 'VOOOOOM', voltage = 1000000)
parrot('a thousand', state = 'pushing up the daisies')
parrot('a million', 'bereft of life', 'jump')

documenti Python (scorri verso il basso per ulteriori argomenti di discussione)

Il preprocessore C. Puoi persino scrivere codice comune su piattaforme diverse con ifdefs - meno o più -.

Categorie dell'obiettivo-C

Le categorie offrono un modo semplice per estendere la funzionalità di un oggetto in fase di esecuzione (pensa alla composizione rispetto all'eredità). L'esempio classico è aggiungere un controllo ortografico alla classe NSString.

@interface NSString (SpellChecker)
- (BOOL) checkSpelling;
@end

Utile anche per correzioni di bug a basso impatto, poiché l'implementazione di un metodo di una categoria avrà la precedenza sull'implementazione dei genitori.

Il metodo di iniezione di Ruby combinato con la funzione Symbol # to_proc di Ruby 1.9 consente di scrivere un codice incredibilmente conciso (ma ancora leggibile):

per esempio (1..10).inject(:+)

che somma gli interi da 1 a 10 => 55

Vedere esempi come questo mi ha fatto venire voglia di imparare Ruby, che ho appena iniziato a fare.

Il meccanismo di associazione in JavaFX (RIP). La parola chiave bind ti consente di associare il valore di una variabile al valore di un'espressione e di sbarazzarti di tutto quel brutto ascoltatore, qualunque codice di caldaia.

Mentre JavaFX è stato un vero fallimento in molti modi, ho trovato molte funzioni del linguaggio di scripting abbastanza carine.

I mixin di stringhe più la valutazione della funzione del tempo di compilazione in D è una caratteristica killer davvero unica. Sì, tecnicamente sono due caratteristiche, ma il vero potere deriva dal combinarle. Con questa combinazione, è possibile scrivere normali funzioni D che generano il codice come stringa al momento della compilazione, quindi mescolare questo codice in qualsiasi ambito e farlo valutare come normale codice D. Il codice è completamente compilato staticamente ed esegue esattamente come se fosse stato scritto a mano. Questa funzione viene persino utilizzata per aggirare un paio di situazioni problematiche nella libreria standard.