• In
COBOL, many of the intermediate keywords are syntactic sugar that may optionally be omitted. For example, the sentence MOVE A B. and the sentence MOVE A TO B. perform exactly the same function, but the second makes the action to be performed clearer. • In
Perl, {{code|unless (condition) {...}|perl}} is syntactic sugar for {{code|if (not condition) {...}|perl}}. Additionally, any statement can be followed by a condition, so is equivalent to {{code|if (condition) {...}|perl}}, but the former is more naturally formatted on a single line. • In the
C language, the a[i] notation is syntactic sugar for *(a + i). Likewise, the a->x notation is syntactic sugar for
accessing members using the
dereference operator (*a).x. • The using statement in
C# ensures that certain objects are disposed of correctly. The compiler expands the statement into a
try-finally block. •
C++ and
C from
C23 onwards allow auto x = expr as a shorthand for decltype(expr) x = expr in C++ or typeof(expr) x = expr in C. • Python
list comprehensions (such as for a list of squares) and
decorators (such as @staticmethod). • In
Haskell, a string, denoted in quotation marks, is semantically equivalent to a list of characters. An optional language extension
OverloadedStrings allows string literals to produce other types of values, such as Text, as well. • In the
tidyverse collection of
R packages, the
pipe, denoted by %>%, declares that the data (or output of the function) preceding the pipe will serve as the first argument for the function following the pipe. So, x %>% f(y) is equivalent to f(x,y). • In
SQL, a mere JOIN is equivalent to an INNER JOIN, the latter clarifying that the join statement is specifically an inner join operation as opposed to an outer join operation. Likewise, one may omit the OUTER from the LEFT OUTER JOIN, RIGHT OUTER JOIN and FULL OUTER JOIN. •
Extension method in OOP languages in the form of
myObject.myMethod(parameter1, parameter2, parameter3) is syntactic sugar for calling a global function as myMethod(
myObject, parameter1, parameter2, parameter3). The reference to the object is passed as a hidden argument, usually accessible from within the method as
this. •
A parameter called by reference is syntactic sugar for technically passing a
pointer as the parameter, but syntactically handling it as the variable itself, to avoid constant pointer de-referencing in the code inside the function. • Various languages offer import statements to allow adding symbols from another
namespace into the current scope. • In C++, a using statement is such an example for importing a single symbol into scope, while a using namespace namespace imports all symbols from that namespace into scope. • In C#, a using statement adds all symbols from a namespace into scope. • In
Java, an import is such an example. For example import javax.swing.*; allows the programmer to reference a
Swing object such as javax.swing.JButton using just the name JButton. • In
Python, a from import statement imports a single symbol into scope, while a from import * statement imports all symbols from that namespace into scope. • In
Rust, a use statement is used for importing symbols into scope. • In
JavaScript, if the key and value are the same in an object, you have the option to write it just once. For example, {name: name} is equivalent to {name}. This is called the Shorthand Property. • In the
ES6 version of
JavaScript, arrow functions have a short form (x) => x + 1, which is equivalent to the longer form {{code|2=javascript|1=(x) => { return x + 1; } }}. • In
Scala, triple question marks (???) is equivalent to . This is useful to mark a place for code that has not yet been written. == Criticism ==