Killer semi-unique programming language features

Question

When learning a new programming language you sometimes come across a language feature which makes you wish you had it in your other programming languages that you know.

What are some language feature which were at the time of learning very new to you and that you wish your other programming languages had.

An example of this is generators in Python or C#. Other examples may include list comprehensions in Python, template in C++ or LINQ in .NET or lazy evaluation in Haskell.

What other semi-unique language features have you come across which were completely new and enlightening to you? Are there other features of older programming languages which were unique and have fallen out of fashion?

Answer 1

Practically anything in Haskell

• Monads. Yes - the big scary word that makes increadibly easy parsers, IO, operations on Lists and other things so easy (once you notice common pattern)
• Arrows. The same for advanced users ;)
• Standard stuff like lambdas etc.
• Currying functions
• Algebraic data types
• Pattern matching

And many more.

PS. Yes. I am Haskell fanboy if anyone asked.

Answer 2

Lisp macros.

The Lisp macro language is Lisp, with a few predefined syntax features for the sake of convenience. Using them, it is possible to add major features to the language, such as one's choice of object orientation styles or Prolog-like deterministic matching, without looking out of place. It makes the setf macro possible, which is a conceptually very powerful macro: (setf A B) means that, when you evaluate A you will get B, and that can be extended to any limit you like.

C++ template metaprogramming is capable of similar things, but in a much different language than regular C++.

Answer 3

Python's decorator.

It's extremely easy to implement memoization or timing of function using the decorator.

Example of a function timer.

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

Now if you have a function foo you want to time, you can simply do this,

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

You will see something like,

Function 'foo' took 3 seconds.

Answer 4

Casting to void* in C. You can cast everything to raw bytes, and do whatever you want with these data.

(Yes, nowadays it's unique...)

Answer 5

Yield in Python

In Python (and I believe in C#), you can define a so-called generator that pauses function execution at a yield statement, returns the value and on subsequent calls, restarts the function where it left off (with the state preserved between calls). This is great for generating long lists of values where you are only interested in the current value of the function (which is very common). It allows you to build potentially infinitely long sequences while only occupying very limited space in memory.

Answer 6

Lambda expressions (closures, nested functions, anonymous methods, whatever you call them).

I first came across them in Perl, instantly loved them and wondered why other languages don’t have them. Nowadays I guess it’s not that unique anymore; even PHP have managed to hack them in somehow. But they were semi-unique at the time.

Answer 7

Continuations from Scheme (later adopted by a few other languages including Ruby.)

Answer 8

Sets in Delphi are very useful, pretty much just a named boolean array. They're very useful for saving a settings form with 32 checkboxes. But they've got all the same set theory functions (i.e. difference, intersection, union).

I'm not sure if they've fallen out of fashion, but I use them all the time.

Answer 9

Send

From Erlang. Sends a message asynchronous to another thread.

Expr1 ! Expr2

Receive

From Erlang. Receives a message from another thread.

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

Answer 10

I really like the unless modifier in Ruby. It seems so natural and replaces a lot of scenarios where your code just seems to be very messy without it.

puts "All good" unless input.nil?

How can you not like that? :D

Answer 11

C# Properties

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

Answer 12

Unions in C

I can't honestly say that I haven't written enough C to make any of these myself but I have worked with other's code that does.

When it comes down to packaging mixtures of different data in applications that manipulate raw bits/bytes such as networking or binary data storage. In strongly typed languages theres just no easy way to do the equivalent.

Disclaimer:

Although Unions are extremely useful in some cases, they aren't found in most higher level languages because they aren't type safe. IE, you can make data bleed across boundaries of variables using unions (a big no no in the type safe world). With great power comes great responsibility.

Answer 13

fancy python argument syntaxes

I'm not sure how unique this is, but in python you can do cool stuff like have keyword pairs automatically made into a dictionary and back. Same with lists:

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 (scroll down for more argument pasing stuff)

Answer 14

The C preprocessor. You can even write common code to different platforms with - less or more - ifdefs.

Answer 15

Objective-C Categories

Categories offer an easy way to extend an object's functionality at runtime (think composition versus inheritance). The classic example is to add a spellchecker to the NSString class.

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

Also useful for low impact bug-fixes, since a category's implementation of a method will override its parents implementation.

Answer 16

Ruby's inject method combined with the Symbol#to_proc feature of Ruby 1.9 lets one write some incredibly concise (but still readable) code:

e.g. (1..10).inject(:+)

which sums the integers 1 through 10 => 55

Seeing examples like this made me want to learn Ruby, which I've just started doing.

Answer 17

The Binding Mechanism in JavaFX (R.I.P). The bind keyword enables you to bind the value of a variable to the value of an expression and getting you rid of all those ugly Listener whatsoever boilerplate code.

While JavaFX was quite a fail in many ways, I found many features of the scripting language quite nice.

Answer 18

String mixins plus compile time function evaluation in D is a pretty unique killer feature. Yes, technically it's two features, but the real power comes from combining them. With this combination, you can write regular D functions that generate code as a string at compile time, and then mix this code into any scope and have it be evaluated as regular D code. The code is fully statically compiled and executes exactly as if it had been handwritten. This feature is even used to work around a couple sticky situations in the standard library.