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

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 3

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 4

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 5

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 6

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 7

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 8

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 9

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 10

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 11

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 12

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 13

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 14

Monads (Example is F#)

async {
    let! asyncValue = getSomethingAsync
    if asyncValue = something then
        do! alertSomeone asyncValue
        do! alertSomeoneElse asyncValue
}

Answer 15

Scala

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

Answer 16

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 17

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 18

The List Comprehensions from Python

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

Answer 19

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 20

Smalltalk

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

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

Answer 21

Javascript

Resize the Length of an Array

length property is a not read only. You can use it to increase or decrease the size of an array.

var myArray = [1,2,3];
myArray.length // 3 elements.
myArray.length = 2; //Deletes the last element.
myArray.length = 20 // Adds 18 elements to the array;
//the elements have the undefined value. A sparse array.

Answer 22

Java

obviously the main method

public static void main (String [] args)

Getters and Setters method

Setter

public void setVar(datatype variable) {
  privateVar = variable;
}

Getter

public datatype getVar() {
  return privateVar;
}

Answer 23

As an Oracle developer, the one feature I couldn't live without is how SQL integrates simply and cleanly with PL/SQL.

Answer 24

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 25

PHP

On-the-fly include()

It simply work great for inserting a function library, 3rd party API, headers, footers, and really anything else I can think of. There is no rule as to where its placed within the file, so I never have to fight with my compiler.

<?
// the web page
include('header.php');
echo '<span>some HTML I want here</span>';
include('body-template.php');
echo '<span>some stuff I want here</span>';
include('footer.php');
?>

oh oops, I forgot my javascript I want in my footer..

<?
// footer.php
echo '</div>'; // body content wrapper
echo '<span>my footer is just this line.<br /></span>';
echo '</html>';
include('javascript.js.php'); // <--- yeah I just added this just now, no problem
?>

For me it makes the process so much easier.

Answer 26

Surprised no one mentioned keyword methods in Smalltalk, one of the languages best features.

A method can have a name broken up by colons, like:

Table >> atRow:column:put:

(The >> is just a documentation shorthand for showing the class that owns the method.)

To call it, you'd use each part of the name as a specifier:

aCell := DataCell new.
aTable := Table new.
aTable atRow: 3 column: 2 put: aCell

I find it much more readable than table.addCell(3, 2, aCell); even if it is a little more verbose sometimes.

Answer 27

The ?: and ?. operators in Groovy. They handle any nulls that may happen during a sequence of method calls, so you can do stuff like:

food = pizzaChain.nearestOpenPlace?.orderPizza() ?: makeSandwich()

..and not worry if there's still a pizza place open or not :)

Answer 28

In R probably the vectorization in the conditions combined with index power. This allows you to do something like :

x <- 1:10 # a vector from 1 to 10
mean(x[x<5]) # takes the mean of all numbers smaller than 5

This is a trivial example, it works with matrices, arrays, lists, more complex conditions as well. And it's a manyfold faster than any kind of looping structure.

Answer 29

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 30

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.