Fonctionnalités semi-uniques du langage de programmation Killer [fermé]

Lorsque vous apprenez un nouveau langage de programmation, vous rencontrez parfois une fonctionnalité de langage qui vous donne envie de l'avoir dans vos autres langages de programmation que vous connaissez.

Quelles sont les fonctionnalités de langage qui étaient au moment de l'apprentissage très nouvelles pour vous et que vous souhaiteriez avoir pour vos autres langages de programmation.

Un exemple de ceci est les générateurs en Python ou C #. D'autres exemples peuvent inclure des listes de compréhension en Python, un modèle en C ++ ou LINQ en .NET ou une évaluation paresseuse en Haskell.

Quelles autres fonctionnalités de langage semi-uniques avez-vous rencontrées qui étaient complètement nouvelles et instructives pour vous? Y a-t-il d'autres caractéristiques des anciens langages de programmation qui étaient uniques et qui sont tombées en désuétude?

Pratiquement rien à Haskell

• Monades. Oui - le gros mot effrayant qui rend les parseurs incroyablement faciles, les E / S, les opérations sur les listes et d'autres choses si faciles (une fois que vous remarquez un modèle commun)
• Flèches. Idem pour les utilisateurs avancés;)
• Des trucs standard comme des lambdas, etc.
• Fonctions de curry
• Types de données algébriques
• Correspondance de motifs

Et beaucoup plus.

PS. Oui. Je suis fanboy de Haskell si quelqu'un le demande.

Macros Lisp.

Le langage macro Lisp est Lisp, avec quelques fonctionnalités de syntaxe prédéfinies pour des raisons de commodité. En les utilisant, il est possible d'ajouter des fonctionnalités majeures au langage, telles que le choix des styles d'orientation d'objet ou la correspondance déterministe de type Prolog, sans regarder à sa place. Cela rend la setfmacro possible, qui est une macro conceptuellement très puissante: (setf A B)signifie que, lorsque vous évaluez, Avous obtiendrez B, et qui peut être étendu à n'importe quelle limite que vous aimez.

La métaprogrammation de modèles C ++ est capable de choses similaires, mais dans un langage très différent du C ++ normal.

Décorateur de Python.

Il est extrêmement facile de mettre en œuvre la mémorisation ou le timing de la fonction à l'aide du décorateur.

Exemple de temporisateur de fonction.

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

Maintenant, si vous avez une fonction que vous voulez chronométrer, vous pouvez simplement le faire,

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

Vous verrez quelque chose comme,

La fonction 'foo' a pris 3 secondes.

Casting void*en C. Vous pouvez tout caster en octets bruts et faire ce que vous voulez avec ces données.

(Oui, de nos jours c'est unique ...)

Rendement en Python

En Python (et je crois en C #), vous pouvez définir un soi-disant générateur qui suspend l'exécution de la fonction à une yieldinstruction, renvoie la valeur et lors des appels suivants, redémarre la fonction là où elle s'était arrêtée (avec l'état préservé entre les appels). C'est idéal pour générer de longues listes de valeurs où vous n'êtes intéressé que par la valeur actuelle de la fonction (ce qui est très courant). Il vous permet de créer des séquences potentiellement infiniment longues tout en n'occupant qu'un espace très limité en mémoire.

Expressions lambda (fermetures, fonctions imbriquées, méthodes anonymes, peu importe comment vous les appelez).

Je les ai rencontrés pour la première fois en Perl, je les ai immédiatement aimés et je me suis demandé pourquoi d'autres langues ne les avaient pas. De nos jours, je suppose que ce n'est plus si unique; même PHP a réussi à les pirater d'une manière ou d'une autre. Mais ils étaient semi-uniques à l'époque.

Continuations de Scheme (adopté plus tard par quelques autres langues dont Ruby.)

Les ensembles dans Delphi sont très utiles, à peu près juste un tableau booléen nommé. Ils sont très utiles pour enregistrer un formulaire de paramètres avec 32 cases à cocher. Mais ils ont tous les mêmes fonctions de théorie des ensembles (c'est-à-dire la différence, l'intersection, l'union).

Je ne sais pas s'ils sont passés de mode, mais je les utilise tout le temps.

Envoyer

Depuis Erlang. Envoie un message asynchrone à un autre thread.

Expr1 ! Expr2

Recevoir

Depuis Erlang. Reçoit un message d'un autre fil.

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

Propriétés C #

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

contre

(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;
}

Les syndicats en C

Je ne peux honnêtement pas dire que je n'ai pas écrit assez de C pour en faire moi-même mais j'ai travaillé avec le code des autres qui le fait.

Lorsqu'il s'agit d'empaqueter des mélanges de données différentes dans des applications qui manipulent des bits / octets bruts tels que la mise en réseau ou le stockage de données binaires. Dans les langues fortement typées, il n'y a tout simplement pas de moyen facile de faire l'équivalent.

Avertissement:

Bien que les unions soient extrêmement utiles dans certains cas, elles ne se trouvent pas dans la plupart des langues de niveau supérieur car elles ne sont pas sécurisées. IE, vous pouvez faire saigner les données au-delà des limites des variables en utilisant les unions (un grand non non dans le monde sûr de type). Un grand pouvoir implique de grandes responsabilités.

J'aime vraiment le modificateur sauf dans Ruby . Cela semble si naturel et remplace de nombreux scénarios où votre code semble être très désordonné sans lui.

puts "All good" unless input.nil?

Comment peux tu ne pas aimer cela? :RÉ

syntaxes d'argument fantaisie python

Je ne sais pas à quel point c'est unique, mais en python, vous pouvez faire des trucs sympas comme avoir des paires de mots clés automatiquement transformées en dictionnaire et inversement. Idem pour les listes:

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

documents python (faites défiler vers le bas pour plus d'informations sur le passage d'arguments)

Le préprocesseur C. Vous pouvez même écrire du code commun sur différentes plates-formes avec - moins ou plus - ifdefs.

Catégories Objective-C

Les catégories offrent un moyen simple d'étendre les fonctionnalités d'un objet au moment de l'exécution (pensez à la composition plutôt qu'à l'héritage). L'exemple classique consiste à ajouter un correcteur orthographique à la classe NSString.

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

Également utile pour les corrections de bogues à faible impact, car l'implémentation d'une méthode d'une catégorie remplacera l'implémentation de ses parents.

La méthode d' injection de Ruby combinée avec le symbole # to_proc de Ruby 1.9 permet d'écrire du code incroyablement concis (mais toujours lisible):

par exemple (1..10).inject(:+)

qui additionne les entiers 1 à 10 => 55

Voir des exemples comme celui-ci m'a donné envie d'apprendre Ruby, ce que je viens de commencer à faire.

Le mécanisme de liaison dans JavaFX (RIP). Le mot clé bind vous permet de lier la valeur d'une variable à la valeur d'une expression et de vous débarrasser de tous ces vilains Listener quel que soit le code passe-partout.

Bien que JavaFX ait été un échec à bien des égards, j'ai trouvé de nombreuses fonctionnalités du langage de script assez agréables.

Les mixages de chaînes plus l'évaluation de la fonction de temps de compilation en D sont une caractéristique de tueur assez unique. Oui, techniquement, ce sont deux fonctionnalités, mais la vraie puissance vient de leur combinaison. Avec cette combinaison, vous pouvez écrire des fonctions D normales qui génèrent du code sous forme de chaîne au moment de la compilation, puis mélanger ce code dans n'importe quelle étendue et le faire évaluer en tant que code D normal. Le code est entièrement compilé statiquement et s'exécute exactement comme s'il avait été écrit à la main. Cette fonctionnalité est même utilisée pour contourner quelques situations délicates dans la bibliothèque standard.