What syntax element do you love most in a programming language you use frequently? [closed]

Question

The logical companion to the Which do you hate most question. What's your favorite syntax element in a programming language- what nicety to you like best? I'm sticking with the 'syntax' specification to avoid broader answers like "dynamic typing" or "is interpreted."

Answer 1

The ternary operator (or for pedants, the conditional operator):

<boolean expression> ? expression result if true : expression result if false

Unfortunately, some languages make it difficult to use due to strict restrictions on what conversions can be performed in order to produce a consistent type from both possible outcomes. Nevertheless, it is a wonderful example of a language taking an extremely common pattern and providing a concise, readable means of representing it in code.

Answer 2

Python

Python's comparison syntax is brilliant. I wish all languages had this. In Python, instead of

if x>0 and x<100:
    #do stuff

you can do

if 0<x<100:
   #do stuff

Answer 3

LINQ in C#

What could be cooler than creating both simple and complex logic using natural language?

from item in items
where item.IsActive
group item by item.Category
    into itemCategory
where itemCategory.Count() > 5
orderby itemCategory.Key
select itemCategory

Answer 4

The List Comprehensions from Python

>>> list = [1,2,3,4,5]
>>> [x*2 for x in list]
[2, 4, 6, 8, 10]

Answer 5

Haskell

The syntax for "point-free style," in which, ironically, one uses the point (.) to denote composition. "Point-full" style:

fn x = f ( g ( h x ))

Point-free:

fn :: a -> b
fn = f . g . h

The functions are equivalent, but the latter is considered "cleaner."

Answer 6

The C# Extension Method.

It's a great way to make static method use a little cleaner and clearer:

public static string DoubleUp( this string toDouble ){
    return toDouble + toDouble
}

//elsewhere...
string result = "Ha".DoubleUp().DoubleUp();
//result = "HaHaHaHa"

Answer 7

I'm still on the new language high for C#, so:

Properties

public bool IsCold { get; set; }

public bool IsHot
{
    get { return !IsCold };
    set { IsCold = !value };
}

A simple way to have the benefits of accessors (the ability to modify the implementation without changing the interface) and the benefits of public variables (brevity).

Answer 8

Anonymous Functions (aka Lambda Expressions)

Sometimes you don't have or want to name everything...

collection.remove(x => isOld(x))

collection.first(x => x == true)

collectino.for_each(x => x + 3)

collection.sort((x, y) => x > y)

Answer 9

Python

Array slicing is very elegant.

>>> a = range(10)
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[:5] # first 5 elements
[0, 1, 2, 3, 4]
>>> a[5:] # last 5 elements
[5, 6, 7, 8, 9]
>>> a[::2] # every other element
[0, 2, 4, 6, 8]
>>> a[1::3]
[1, 4, 7]

Answer 10

C# null coalescing operator

the ?? operator which returns the left-hand operand if it is not null, or else it returns the right operand.

I often use it like so

foo = foo ?? GetNewFoo();

Answer 11

Python's lack of braces and the fact it uses whitespace for code indentation.

That combined with pep8 leads to one consistent code style across almost all python code. It also makes the flow of code much easier to follow because you're not wasting lines on syntactic salt. Before I started with python I hated the idea, but once I started coding in it, it's become second nature and anything else looks ugly.

Answer 12

I love the "everything is an expression"-idea, which can be found in haXe (I suppose the feature actually comes from functional languages).

function fib(n) {//the compiler infers the type of this function to Int->Int
    return 
        switch (n) {
            case 0, 1: 
                1;
                /* in case you wonder: case statements can have
                   multiple conditions, but doesn't allow fallthroughs,
                   because it is terminated by the next case/default
                   statement or the closing brace of the switch */
            default: 
                if (n < 0) 
                    fib(n + 2) - fib(n + 1);
                else 
                    fib(n - 1) + fib(n - 2);
        }
}

Basically, the function body is just one expression. A block is evaluated to the last evaluated expression of the block. A loop is evaluated to the last pass (or null, in case the body is never evaluated). And so on. I think, this is very elegant, concise, safe and less cryptic than for example the conditional operator.

Answer 13

I like Common Lisp macros (not sure they fit into the definition of syntax in this question). Macros shorten your code and lengthen your life.

Answer 14

In VB.NET I love the With statement which acts as a shortcut to an object's properties and methods within it's block. It saves typing, and I find it makes some code much more cleaner in the case of very long variable names:

With TransactionDialog.TransactionDatagridView.SelectedRows(0) 
    .Cells(0).Value = Something
    .Cells(0).Value = SomethingElse
    '...
    .Frozen = True
End With

versus:

TransactionDialog.TransactionDatagridView.SelectedRows(0) 
TransactionDialog.TransactionDatagridView.SelectedRows(0).Cells(0).Value = Something
TransactionDialog.TransactionDatagridView.SelectedRows(0).Cells(0).Value = SomethingElse
'...
TransactionDialog.TransactionDatagridView.SelectedRows(0).Frozen = True

Answer 15

Perl 5

Perl 5 absolutely abounds in fantastic syntactic sugar I miss elsewhere, starting with sigils to quickly group variables by type ($scalar, @array, %hash). My absolute favourite is unless, which removes the need to rewrite a complex expression as it's negative or to add an easy-to-overlook not (or, horrors, !) at the start of the expression. Compare:

    if(($x < 10_000) || ($x > 20_000)) { .. }

or

    if(not ($x >= 10_000 and $x <= 20_000)) { .. }

with the elegance of:

    unless($x >= 10_0000 and $x <= 20_000) { .. }

Answer 16

SQL

Throwing a SELECT statement inside a JOIN.

e.g.

SELECT * 
FROM
   foo f
   INNER JOIN (SELECT * FROM Goo WHERE a = 1)  subset
   ON f.id = g.id

Update Removed the C# one

-

Answer 17

Smalltalk

Smalltalk's blocks/anonymous functions/closures have the lightest-weight syntax I have ever seen:

#(1 2 3) select: [:each | each odd]

Answer 18

Python

Dict Comprehensions

Someone mentioned list comprehensions, so I just wanted to add dictionary comprehensions which came in Python 2.7:

>>> def dict_filter(cb, info):
...     return {key:info[key] for key in info if cb(key)}
... 
>>> carson = {"firstname": "Carson", "lastname": "Myers", "age": 20}
>>> privatize = lambda x: x in ('firstname', 'age')
>>> dict_filter(privatize, carson)
{'age': 20, 'firstname': 'Carson'}


>>> {a+1:chr(a+65) for a in range(26)}
{1: 'A', 2: 'B', 3: 'C', 4: 'D', 5: 'E', 6: 'F', 7: 'G', 
 8: 'H', 9: 'I', 10: 'J', 11: 'K', 12: 'L', 13: 'M', 14: 'N', 
 15: 'O', 16: 'P', 17: 'Q', 18: 'R', 19: 'S', 20: 'T', 21: 'U',
 22: 'V', 23: 'W', 24: 'X', 25: 'Y', 26: 'Z'}


>>> def invert(a_dict):
...     return {v:k for k, v in a_dict.iteritems()}
... 
>>> invert({'a':1, 'b':2, 'c':3})
{1: 'a', 2: 'b', 3: 'c'}

Answer 19

I'm a big fan of postfix conditionals in perl and ruby:

return 0 if(!$user);
return 0 if(!$user->can_do_thing);
return 1;

Easy to abuse but great for readability when used properly.

Answer 20

Ruby Block

Pass anonymous function as a parameter

# fetch names of all users
names = users.map { |user| user.name }

# sum of array
sum = numbers.inject { |sum, value| sum + value }

Answer 21

Scala

The fact that I don't have to use "." between function calls. Makes DSLs a breeze.

Answer 22

Scala:

Pattern matching to extract data out of various structures like lists, tuples, and record types.

val list = List(56, 1, 89, 32)
list match {
  case x1 :: x2 :: xs => {
    println("First: " + x1 + "; Second: " + x2 + "; Rest: " + xs)
  }
}

val t = (3, 6, "Hello")
t match {
  case (_, _, c) => println("Third element of t is: " + c)
}

case class Person(
  firstName: String,
  lastName: String,
  age: Int
)
val rahul = Person("Rahul", "Phulore", 20)
rahul match {
  case Person(_, surname, _) => println("My surname is " + surname)
}

Answer 23

C++

C++0x lambda syntax very quickly grew on me despite its odd use of symbols:

std::vector<int> vec, vec2;
vec.push_back(stuff);
std::transform(vec.begin(), vec.end(), std::back_inserter(vec2),
      [](int x)->int { return (x*x); } );

Unfortunately, it doesn't work in all compilers. :(

Answer 24

Javascript

Using apply to run a function in the context of an object. For example, suppose you have an event handler:

$(function(){
    $('#selectr').keydown(function(){
        // update the UI based on the new value
        if(this.value == 1)
        {
               $('selector2').hide();
        }
     });
});

Now suppose that $("#selectr") already has a value when you initially render the page. You could duplicate the display logic elsewhere, or refactor the above function to receive the target element as a value. Or you could use apply

$(function(){

    var selectr_keydown = function(){
        // update the UI based on the new value
        if(this.value == 1)
        {
               $('selector2').hide();
        }
     };

    selectr_keydown.apply($('#selectr').get(0));//selectr_keydown is run with ``this'' referring to $('#selectr').get(0)

    $('#selectr').keydown(selectr_keydown);
});

Note that I've written this using jQuery, but apply is a pure javascript method.

Answer 25

Scala:

Everything is an expression, including if-else, for, try-catch, match-case.

Examples:

val status = if(on) 1 else 0

val listDoubled = for(x <- list) yield 2 * x

val str = "124"
val i = try { str.toInt } catch { case x => -1 } 

val typeOfX: String = x match {
  case i: Int => "Integer"
  case s: String => "String"
  case _ => "Other"
}

Answer 26

F# forward pipe operator (|>)

Makes code very readable than otherwise.

Example:

// Without |>
List.filter (fun x -> x > 5) (List.map (fun x -> 2 * x) [1; 4; 5; 9]) 

// With |>
[1; 4; 5; 9] |> List.map (fun x -> 2 * x) |> List.filter (fun x -> x > 5)

---

For those who don't know F#, above code is equivalent to following C#:

(new List<int>{1, 4, 5, 9}).Select(x => 2 * x).Where(x => x > 5);

Answer 27

I work mostly with C, which makes me appreciate foreach() quite a bit since it is lacking in my primary language.

Yes, you can implement something a lot like it, with limitations, but it just isn't the same.

Answer 28

Interfaces.

I was introduced to them when I first learned Java in 1997, but I think something similar had existed in other languages (Objective-C?) for a while.

Not everybody likes them, but they have some big advantages:

• They give you more control over the order in which you write classes. You can program against the interface (using mock implementations) hours or even months before the implementing class is written.
• They solve the multiple inheritance problem, even allow inheritance to be dispensed with (e.g. Go)

Answer 29

Javascript

I love the fact that objects are essentially dictionaries so that

someObject.property

is syntactic sugar for

someObject['property']

Answer 30

A very short way to test a boolean and execute a single statement in Javascript:

test && alert("hi!");

Now, if test equals true then the browser will execute alert("hi"); This is because it will only test alert("hi") when test equals true and because Javascript is so loose, you can use this outside an if statement and alert("hi") can be anything

This is not very useful for developing as it will make your code harder to read, but if you have to make a script as small as possible it is very useful indeed