Características del lenguaje de programación semi-único Killer [cerrado]

Al aprender un nuevo lenguaje de programación, a veces te encuentras con una función de lenguaje que te hace desear tenerlo en tus otros lenguajes de programación que conoces.

¿Cuáles son algunas de las características del lenguaje que en el momento de aprender eran muy nuevas para usted y que desearía que tuvieran otros lenguajes de programación?

Un ejemplo de esto son los generadores en Python o C #. Otros ejemplos pueden incluir comprensiones de listas en Python, plantillas en C ++ o LINQ en .NET o evaluación diferida en Haskell.

¿Qué otras características de lenguaje semi-únicas ha encontrado que fueran completamente nuevas y esclarecedoras para usted? ¿Hay otras características de los lenguajes de programación más antiguos que eran únicos y han pasado de moda?

Prácticamente cualquier cosa en Haskell

• Mónadas Sí, la gran palabra aterradora que hace que los analizadores, IO, operaciones en listas y otras cosas sean increíblemente fáciles (una vez que notas un patrón común)
• Flechas Lo mismo para usuarios avanzados;)
• Cosas estándar como lambdas, etc.
• Funciones de curry
• Tipos de datos algebraicos
• La coincidencia de patrones

Y muchos más.

PD. Sí. Soy fanático de Haskell si alguien me pregunta.

Macros Lisp.

El lenguaje macro de Lisp es Lisp, con algunas características de sintaxis predefinidas por conveniencia. Al usarlos, es posible agregar características principales al lenguaje, como la elección de estilos de orientación a objetos o la coincidencia determinista tipo Prolog, sin mirar fuera de lugar. Hace setfposible la macro, que es una macro conceptualmente muy poderosa: (setf A B)significa que, cuando evalúas A, obtendrás B, y eso se puede extender a cualquier límite que desees.

La metaprogramación de plantillas de C ++ es capaz de cosas similares, pero en un lenguaje muy diferente al de C ++ normal.

El decorador de Python.

Es extremadamente fácil implementar la memorización o la sincronización de la función utilizando el decorador.

Ejemplo de temporizador de funciones.

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

Ahora, si tiene una función para la que desea programar, simplemente puede hacer esto,

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

Verás algo como

La función 'foo' tomó 3 segundos.

Transmitir a void*C. Puede convertir todo a bytes sin formato y hacer lo que quiera con estos datos.

(Sí, hoy en día es único ...)

Ceda en Python

En Python (y creo en C #), puede definir un denominado generador que pausa la ejecución de la función en una yieldinstrucción, devuelve el valor y en las llamadas posteriores, reinicia la función donde se dejó (con el estado preservado entre las llamadas). Esto es ideal para generar largas listas de valores donde solo le interesa el valor actual de la función (que es muy común). Le permite construir secuencias potencialmente infinitamente largas mientras solo ocupa un espacio muy limitado en la memoria.

Expresiones lambda (cierres, funciones anidadas, métodos anónimos, como se llamen).

Primero los encontré en Perl, los amé al instante y me pregunté por qué otros idiomas no los tienen. Hoy en día supongo que ya no es tan único; incluso PHP ha logrado hackearlos de alguna manera. Pero eran semi-únicos en ese momento.

Continuaciones de Scheme (más tarde adoptado por algunos otros idiomas, incluido Ruby).

Los conjuntos en Delphi son muy útiles, casi solo una matriz booleana con nombre. Son muy útiles para guardar un formulario de configuración con 32 casillas de verificación. Pero tienen todas las mismas funciones de teoría de conjuntos (es decir, diferencia, intersección, unión).

No estoy seguro de si han pasado de moda, pero los uso todo el tiempo.

Enviar

De Erlang Envía un mensaje asíncrono a otro hilo.

Expr1 ! Expr2

Recibir

De Erlang Recibe un mensaje de otro hilo.

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

Propiedades de 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;
}

Uniones en C

Honestamente, no puedo decir que no he escrito suficiente C para hacer ninguno de estos, pero he trabajado con el código de otros que lo hace.

Cuando se trata de empaquetar mezclas de diferentes datos en aplicaciones que manipulan bits / bytes sin procesar, como redes o almacenamiento de datos binarios. En idiomas fuertemente tipados no hay una manera fácil de hacer el equivalente.

Renuncia:

Aunque las Uniones son extremadamente útiles en algunos casos, no se encuentran en la mayoría de los idiomas de nivel superior porque no son de tipo seguro. Es decir, puede hacer que los datos sangren a través de los límites de las variables utilizando uniones (un gran no no en el mundo de tipo seguro). Con un gran poder viene una gran responsabilidad.

Realmente me gusta el modificador a menos que sea en Ruby . Parece tan natural y reemplaza muchos escenarios en los que su código parece ser muy desordenado sin él.

puts "All good" unless input.nil?

¿Cómo no te puede gustar eso? :RE

elegantes sintaxis de argumentos de python

No estoy seguro de cuán único es esto, pero en Python puedes hacer cosas geniales como hacer que los pares de palabras clave se conviertan automáticamente en un diccionario y viceversa. Lo mismo con las listas:

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

documentos de Python (desplácese hacia abajo para ver más argumentos para pegar)

El preprocesador C. Incluso puede escribir código común en diferentes plataformas con --de menos o más-- ifdefs.

Categorías Objective-C

Las categorías ofrecen una manera fácil de extender la funcionalidad de un objeto en tiempo de ejecución (piense en composición versus herencia). El ejemplo clásico es agregar un corrector ortográfico a la clase NSString.

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

También es útil para la corrección de errores de bajo impacto, ya que la implementación de un método por parte de una categoría anulará la implementación de sus padres.

El método de inyección de Ruby combinado con la función Symbol # to_proc de Ruby 1.9 le permite a uno escribir un código increíblemente conciso (pero aún legible):

p.ej (1..10).inject(:+)

que suma los enteros del 1 al 10 => 55

Ver ejemplos como este me hizo querer aprender Ruby, que acabo de empezar a hacer.

El mecanismo de enlace en JavaFX (RIP). La palabra clave bind le permite vincular el valor de una variable al valor de una expresión y deshacerse de todos esos feos oyentes del código repetitivo.

Si bien JavaFX fue un gran fracaso en muchos sentidos, encontré muchas características del lenguaje de script bastante agradable.

La combinación de cadenas más la evaluación de la función de tiempo de compilación en D es una característica asesina bastante única. Sí, técnicamente son dos características, pero el verdadero poder proviene de combinarlas. Con esta combinación, puede escribir funciones D regulares que generan código como una cadena en tiempo de compilación, y luego mezclar este código en cualquier ámbito y hacer que se evalúe como código D regular. El código está totalmente compilado estáticamente y se ejecuta exactamente como si hubiera sido escrito a mano. Esta característica incluso se utiliza para solucionar un par de situaciones difíciles en la biblioteca estándar.