Ask HN: Your favorite syntactic sugar from any language?

(For those not familiar: $_ is the default variable in Perl. Many operations use this variable if you don't specify one. You can use $_ like "it" in English: "Read in a line of input. If it ends in a newline..." In most languages, you would have to deal with "Read it into where?" and "If what ends in a newline?" But in Perl, if you don't specify where to read the line to, it goes into $_, and if you don't specify what you want to see if it ends in a newline, it checks $_, and so on...)

For those not familiar, you can have the reader just discard an expression, so like (list 1 #;2 3) becomes (list 1 3), but you can handily comment out a giant function call or if expression or something while you work on it.

Scheme's nestable multiline comments are also nice. I'm not sure which language was first, but I think more languages are getting them now (Kotlin has them IIRC).

If I need a quick-and-dirty map over a list of something, a

  (\x -> x + 1) a

  std::for_each(a.start(), a.end(),
   [](float x) {  
            return x + 1;  
        } // end of lambda expression  
   )

http://www.ai.sri.com/~pkarp/loop.html

http://www.lispworks.com/documentation/HyperSpec/Body/m_loop...

  >>> first = {"a": 1}
  >>> second = {"b": 2}
  >>> merged = {**x, **y}
  >>> print(merged)
  {"a": 1, "b": 2}

>>> int(‘x’, y)

...where x is the string/number you want to convert and y is the base.

I haven’t found a practical use case but it’s been a lot of fun to play with.

Instead of:

listOfThings.foreach(x => println(x))

You can just type

listOfThings foreach println

Type inference is also great.

Scala in general has lots and lots of syntactic sugar, which is kind of the point of Scala.

Honroable mention:

Rubys &. operator

instead of

y = x.nil? ? nil : x.foo

y = x&.foo

Or just use a language which has some sort of null savety like Option types.

  if condition?
    return
  end

  if !i_probably_shouldnt?
    do_something
  end

  return if condition?

  do_something unless i_probably_shouldnt?

https://coderwall.com/p/jwzppw/the-existential-operator-in-c...

  public override string ToString() => $"{fname} {lname}".Trim();

  foo = 5
  bar = 4.5005
  print(f'foo is {foo} and the first bit of bar is {bar:0.2f}')

  first, *_, last = function_that_returns_ten_things()

  foo = {'x':5,'y':6}
  bar = Point(**foo)

At first I hated it because of how incomprehensible it was to someone coming from seemingly every other language, but I've started to use it more and more and wishing it existed in other languages.

It's especially useful for when the variable access is many characters. e.g. `if hackerNews.frontPage.votingCircleExists:` with nil checks is `if hackerNews && hackerNews.frontPage && hackerNews.frontPage.votingCircleExists`

and with & operator is: `if hackerNews&.frontPage&.votingCircleExists`.

Slices that support negative indexes. List and dictionary comprehensions are amazing: { (X,Y): X2 + Y for X in range(10) for Y in someiter if Y > 5} I love that they become generators when you use () instead of []. Pure genius. Generators from a function containing yield or yield from equally beautiful. % for string interpolation was so good they had to bring it back. Tripple quotes using """ and ''' are hard to beat. Using func(list) to unpack a list into a functions arguments. Or func(dict) to unpack a map by name. Using args and kwargs to implimentaions variadic functions. I love indentation based code blocks. The way 'and' and 'or' can return values is so much better than a ?: terinary. I think I dumped a third of the Python spec there.

I could use a multi-line lambda but it's not a huge omission. Pipelines like bash | pipe or F# |> would be welcome.

go's select statement is also subtle but smart. Doing multiple waits in one thread is tricky to impossible in most any other language.

Built in regex like perl is always nice when you have it.

I'm sure I missed something gushing over Python, but tapping this out over the phone if already killing my thumb.

Java desperately needs groovys's safe navigation operator a?.getB()?.getC(). It's like a normal method call but returns null if the receiver is null instead of throwing an NPE.

"=~" in Perl and globbing in shell are not syntactic sugar. They are fundamental parts of the languages.

`a ||= b` sets a to b, unless a is already defined.

I see async/await as the only way to write asynchronous code that's readable

[foo, bar, ...baz] ES6 Destructuring