DEV Community

What are your favorite programming language syntax features?

Aivan Monceller on March 27, 2019

I have my own non-exhaustive list, and these are purely based on what I have used: JavaScript, TypeScript, C# Safe Navigation Operator ...
Collapse
 
alchermd profile image
John Alcher

List Comprehensions in Python is an interesting one. I absolutely love them in some cases, and despise them on others.

# Simple and elegant...
squares = [n**2 for n in numbers]


list_a = [...]
list_b = [...]
# ...not on this one IMO, I'd prefer loops instead.
different_num = [(a, b) for a in list_a for b in list_b if a != b]
Collapse
 
geocine profile image
Aivan Monceller

It's my first time to see such syntax since I haven't really touched Python. Looks interesting , I couldn't understand what the last line does though.

Collapse
 
defman profile image
Sergey Kislyakov • Edited

The last line is:

for a in list_a:
    for b in list_b:
        if a != b:
            different_num.append((a, b))
Collapse
 
jdsteinhauser profile image
Jason Steinhauser

Pattern matching like you see in OCaml variants (ReasonML, F#, etc.)

match x with
| 0 -> "Nothin\'"
| 1 -> "One"
| 2 | 3 -> "Deuce or trey!"
| i when i < 10 -> "Still a single digit!"
| _ -> "Big stuff!"

Elixir has something similar in guards:

def f(0), do: "Nothin\'"
def f(1), do: "One"
def f(x) when x == 2 or x == 3, do: "Deuce or trey!"
def f(x) when x < 10, do: "Still a single digit!"
def f(_x), do: "Big stuff!"
Collapse
 
niorad profile image
Antonio Radovcic

+1 for Guards.

Also I really enjoy Pipes, like

my_data
|> dedupe
|> reverse
|> skedoodle

instead of

skedoodle(reverse(dedupe(my_data)))

I think they are even coming to JS.

Collapse
 
geocine profile image
Aivan Monceller

All these things almost look alien to me. I haven't done any heavy functional programming and let alone use a language that was specifically built for such purpose. This is something I'll definitely look into.

Collapse
 
samuraiseoul profile image
Sophie The Lionhart

I'm not sure if I like it really, and I think its an anti-pattern in almost all cases, and some of it can be done via reflection in most languages, and I don't know the name for it...

This BS in PHP:

class Foo {
    public function bar() : int {
        return 42;
    }
}

$functionName = 'bar';
$foo = new Foo();
echo $foo->{$functionName}(); //42
$instanceName = 'foo';
echo $$instanceName->bar(); //42
echo $$instanceName->{$functionName}(); //42

$variableName = 'blackMagic';
$$functionName = 'whut?';
echo $blackMagic; //'whut?'
Collapse
 
havarem profile image
André Jacques

This comes from function pointer in C. You can create a function pointer, like this:

void (* init_sgbd_ptr)(void);
void (* connect_sgbd_ptr)(const char* const);

Let's say that we have an application which could connect to either MySQL or PostgreSQL. In a config file, the software could detect which DBMS is used, and then link all the DBMS interface correctly. Like this

// PostgreSQL interface
void postgres_init(void) { ... }
void postgres_connect(const char* const dsn) { ... }

// MySQL interface
void mysql_init(void) { ... }
void mysql_connect(const char* const dsn) { ... }

So, in the DBMS manager module:

void init_dbms(dbms_type_t dbms_type)
{
    switch (type) {
    case DBMS_TYPE_POSTRESQL:
        init_sgbd_ptr = postgres_init;
        connect_sgbd_ptr = postgres_connect;
        break;

    case DBMS_TYPE_MYSQL:
        init_sgbd_ptr = mysql_init;
        connect_sgbd_ptr = mysql_connect;
        break;
    }
}

This is basically what is happening here. Since PHP is VERY weakly typed, any variable can be either an integer, float, string, boolean, a function pointer. In fact, they are all of those types. It is when you use them that they fall into the intended one #quantumTyped.

Collapse
 
defman profile image
Sergey Kislyakov

Kotlin's function literals with receiver and infix functions are pretty cool.

Function literals with receivers:

class HTML {
    fun body() { ... }
}

fun html(init: HTML.() -> Unit): HTML {
    val html = HTML()
    html.init()
    return html
}

html {
    body()
}

Infix:

infix fun Int.shl(x: Int): Int { ... }

// calling the function using the infix notation
1 shl 2

// is the same as
1.shl(2)
Collapse
 
lexlohr profile image
Alex Lohr

Of those, async/await is certainly my favourite. It makes asynchronous programming so wonderfully obvious. I'm not too big a fan of decorators, because they hide underlying logic, making code less readable, if you're not handling them with care.

Even though it's not yet a native language feature in JavaScript or TypeScript, Observables (reactive programming style) are on their way to become one. Until then, we're fine with rxjs.

I also like the unique concept of borrowing in Rust and I like its traits, which allow for a lot of flexibility in the type system.

Collapse
 
geocine profile image
Aivan Monceller

I was thinking of adding traits here but I have not used it extensively while I was doing PHP. The same is true with it though I believe that it should be handled with care.

I'll definitely checkout Rust.

Collapse
 
biros profile image
Boris Jamot ✊ /

I would say variadics, multiple returns, and interfaces in Go.

Collapse
 
tonymet profile image
Tony Metzidis

golang's "empty" switch statement (a cleaner else-if).

switch {
case cut == true:
    return superReducedString(result)
case result == "":
    return "Empty String"
default:
    return result
}
Collapse
 
geocine profile image
Aivan Monceller

The way switch case work on golang alone is already interesting 😁

Collapse
 
whosthemark profile image
Marcos Campos

It has been a while since I've used C#, but I remember I really liked LINQ queries and local anonymous types that can be type-checked on compilation