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

Praticamente nulla in Haskell

• Monadi. Sì - la grande parola paurosa che rende facilmente comprensibili i parser, l'IO, le operazioni su elenchi e altre cose (una volta che noti un modello comune)
• Frecce. Lo stesso per gli utenti avanzati;)
• roba standard come lambda ecc.
• Funzioni di calcolo
• Tipi di dati algebrici
• Corrispondenza dei pattern

E molti altri.

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

Macro Lisp.

Il linguaggio macro Lisp è Lisp, con alcune funzioni di sintassi predefinite per comodità. Usandoli, è possibile aggiungere importanti caratteristiche alla lingua, come ad esempio la scelta degli stili di orientamento degli oggetti o la corrispondenza deterministica simile a Prolog, senza guardare fuori posto. Rende possibile la macro setf , che è una macro concettualmente molto potente: (setf A B) significa che, quando valuti A otterrai B , e che può essere esteso a qualsiasi limite che ti piace.

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

Il decoratore di Python.

È estremamente semplice implementare la memoizzazione o il cronometraggio 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 foo vuoi il tempo, puoi semplicemente farlo,

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

Vedrai qualcosa di simile,

La funzione 'pippo' ha impiegato 3 secondi.

Trasmissione a void* in C. Puoi trasmettere tutto a byte non elaborati e fare ciò che vuoi con questi dati.

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

Rendimento in Python

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

Espressioni Lambda (chiusure, funzioni annidate, metodi anonimi, qualsiasi cosa tu li chiami).

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

Continuazioni da Schema (successivamente adottato da poche altre lingue incluso Ruby.)

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

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

Invia

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

Expr1 ! Expr2

Ricevi

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

(Java)

/**
 * 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;
}

Unioni in C

Non posso onestamente dire che non ho scritto abbastanza C per creare uno di questi, ma ho lavorato con il codice di altri che lo fa.

Quando si tratta di mescolare miscele di dati diversi in applicazioni che manipolano bit / byte grezzi come la rete o l'archiviazione di dati binari. Nei linguaggi strongmente tipizzati non esiste un modo semplice per fare l'equivalente.

Avviso:

Sebbene i sindacati siano estremamente utili in alcuni casi, non si trovano nella maggior parte delle lingue di livello superiore perché non sono sicuri. IE, puoi eseguire il bleeding dei dati oltre i limiti delle variabili usando i sindacati (un grande no no nel mondo di tipo safe). Con un grande potere derivano grandi responsabilità.

Mi piace molto il se non modificatore 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 puoi non piacerti? : D

sintassi degli argomenti fancy python

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

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')

python docs (scorri verso il basso per ulteriori argomenti sull'argomento)

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

Categorie Objective-C

Le categorie offrono un modo semplice per estendere le funzionalità di un oggetto in fase di esecuzione (si pensi alla composizione e all'ereditarietà). L'esempio classico è di aggiungere un correttore 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 sovrascriverà l'implementazione dei genitori.

Ruby inject metodo combinato con Simbolo # to_proc di Ruby 1.9 consente di scrivere un codice incredibilmente conciso (ma comunque leggibile):

es. (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.

The Binding Mechanism in JavaFX (R.I.P). La parola chiave bind ti consente di associare il valore di una variabile al valore di un'espressione e di sbarazzarti di tutti quei brutti Listener di qualsiasi tipo di codice standard.

Sebbene JavaFX sia stato un vero fallimento in molti modi, ho trovato molte caratteristiche del linguaggio di scripting piuttosto belle.

Le mixine di stringhe più la valutazione della funzione del tempo di compilazione in D è una caratteristica killer piuttosto unica. Sì, tecnicamente sono due caratteristiche, ma il vero potere viene dalla combinazione di esse. Con questa combinazione, puoi scrivere le normali funzioni D che generano il codice come una stringa in fase di compilazione, quindi mischiare questo codice in qualsiasi ambito e farlo valutare come un normale codice D. Il codice è completamente compilato staticamente ed eseguito esattamente come se fosse stato scritto a mano. Questa funzione è anche utilizzata per aggirare un paio di situazioni appiccicose nella libreria standard.