Syntactic sugar

In computer science, syntactic sugar is syntax within a programming language that is designed to make things easier to read or to express. It makes the language "sweeter" for human use: things can be expressed more clearly, more concisely, or in an alternative style that some may prefer.

For example, many programming languages provide special syntax for referencing and updating array elements. Abstractly, an array reference is a procedure of two arguments: an array and a subscript vector, which could be expressed as get_array(Array, vector(i,j)). Instead, many languages provide syntax such as Array[i,j]. Similarly an array element update is a procedure consisting of three arguments, for example set_array(Array, vector(i,j), value), but many languages provide syntax such as Array[i,j] = value.

A construct in a language is syntactic sugar if it can be removed from the language without any effect on what the language can do: functionality and expressive power will remain the same.

Language processors, including compilers and static analyzers, often expand sugared constructs into more fundamental constructs before processing, a process sometimes called "desugaring".

Origins

The term syntactic sugar was coined by Peter J. Landin in 1964 to describe the surface syntax of a simple ALGOL-like programming language which was defined semantically in terms of the applicative expressions of lambda calculus,[1][2] centered on lexically replacing λ with "where".

Later programming languages, such as CLU, ML and Scheme, extended the term to refer to syntax within a language which could be defined in terms of a language core of essential constructs; the convenient, higher-level features could be "desugared" and decomposed into that subset.[3] This is, in fact, the usual mathematical practice of building up from primitives.

Building on Landin's distinction between essential language constructs and syntactic sugar, in 1991, Matthias Felleisen proposed a codification of "expressive power" to align with "widely held beliefs" in the literature. He defined "more expressive" to mean that without the language constructs in question, a program would have to be completely reorganized.[4]

Notable examples
  • 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.
  • Augmented assignment or compound assignment operators: For example, a += b is equivalent to a = a + b in C and similar languages, assuming a has no side effects such as if a is a regular variable.[5][6] Some languages, such as Python[7] may allow overloading augmented assignment operators, so they may behave differently than standard ones.
  • In Perl, unless (condition) {...} is syntactic sugar for if (not condition) {...}. Additionally, any statement can be followed by a condition, so statement if condition is equivalent to if (condition) {statement}, 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).[8] 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.[9]
  • The C# language allows variables to be declared as var x = expr, which allows the compiler to infer the type of x from the expression expr, instead of requiring an explicit type declaration. Similarly, C++ allows auto x = expr since C++11.
  • Python list comprehensions (such as [x*x for x in range(10)] 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.
  • 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.[10] So, x %>% f(y) is equivalent to f(x,y).
  • In SQL, JOIN is equivalent to INNER JOIN, the latter clarifying that the join statement is specifically an inner join operation as opposed to an outer join operation.
  • Method calling 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.
  • Parameters called by reference is a syntax sugar for technically passing a pointer to the parameter, but syntactically handling it as the variable itself, to avoid constant de-referencing of pointer in the code inside the function.

Criticism

Some programmers feel that these syntax usability features are either unimportant or outright frivolous. Notably, special syntactic forms make a language less uniform and its specification more complex, and may cause problems as programs become large and complex. This view is particularly widespread in the Lisp community, as Lisp has very simple and regular syntax, and the surface syntax can easily be modified.[11] For example, Alan Perlis once quipped in "Epigrams on Programming", in a reference to bracket-delimited languages, that "Syntactic sugar causes cancer of the semi-colons".[12]

Another maxim with similar meaning is: "syntactic sugar causes semantic cavities".

Derivative terms

Syntactic salt

The metaphor has been extended by coining the term syntactic salt, which indicates a feature designed to make it harder to write bad code.[13] Specifically, syntactic salt is a hoop that programmers must jump through just to prove that they know what is going on, rather than to express a program action. For example, in Java and Pascal assigning a float value to a variable declared as an int without additional syntax explicitly stating that intention will result in a compile error, while C and C++ will automatically truncate any floats assigned to an int. However this is not syntax, but semantics.

In C#, when hiding an inherited class member, a compiler warning is issued unless the new keyword is used to specify that the hiding is intentional.[14] To avoid potential bugs owing to the similarity of the switch statement syntax with that of C or C++, C# requires a break for each non-empty case label of a switch (unless goto, return, or throw is used) even though it does not allow implicit fall-through.[15] (Using goto and specifying the subsequent label produces a C/C++-like fall-through.)

Syntactic salt may defeat its purpose by making the code unreadable and thus worsen its quality – in extreme cases, the essential part of the code may be shorter than the overhead introduced to satisfy language requirements.

An alternative to syntactic salt is generating compiler warnings when there is high probability that the code is a result of a mistake – a practice common in modern C/C++ compilers.

Syntactic saccharin

Other extensions are syntactic saccharin and syntactic syrup, meaning gratuitous syntax that does not make programming any easier.[16][17][18][19]

Sugared types

Data types with core syntactic support are said to be "sugared types." [20] [21] [22] Common examples include quote-delimited strings, curly braces for object and record types, and square brackets for Arrays.

Notes
  1. Landin, Peter J. (1964). "The mechanical evaluation of expressions" (PDF). The Computer Journal. Computer Journal. 6 (4): 308–320. doi:10.1093/comjnl/6.4.308. Retrieved 21 July 2014.
  2. Abelson & Sussman 1996, Chapter 1, footnote 11.
  3. Barbara Liskov, "A History of CLU", MIT Laboratory for Computer Science Technical Report 561 (1993)
  4. Felleisen, Matthias (December 1991). "On the Expressive Power of Programming Languages". Science of Computer Programming. Springer-Verlag. 17 (1–3): 35–75. doi:10.1016/0167-6423(91)90036-W. Retrieved 19 July 2014.
  5. "C Compound Assignment". msdn.microsoft.com. Microsoft. Retrieved 20 June 2016. However, the compound-assignment expression is not equivalent to the expanded version because the compound-assignment expression evaluates expression1 only once, while the expanded version evaluates expression1 twice: in the addition operation and in the assignment operation.
  6. Garavaglia, Emilio (26 July 2015). "Why are shortcuts like x += y considered good practice?". stackexchange.com. Retrieved 20 June 2016. optimization can [be done] if 'finding x' has no side effects
  7. {cite web |url=https://docs.python.org/3/reference/datamodel.html#object.__iadd__ |title=Python Data model |date=21 December 2020 |webiste=docs.python.org}
  8. Eric S. Raymond (11 October 1996). The New Hacker's Dictionary – 3rd Edition. MIT Press. p. 432. ISBN 978-0-262-68092-9. Retrieved 5 August 2012.
  9. "using Statement (C# Reference)". Retrieved 16 September 2014.
  10. "magrittr: Vignette". Retrieved 24 December 2018.
  11. Abelson & Sussman 1996, Chapter 1, footnote 11.
  12. Perlis 1982, Epigram #3.
  13. "The Jargon File - syntactic salt". 2003-06-12. Archived from the original on 2003-06-12. Retrieved 2018-03-19.
  14. "new Modifier (C# Reference)". microsoft.com. Microsoft. Retrieved 3 August 2015.
  15. "switch (C# Reference)". microsoft.com. Microsoft. Retrieved 3 August 2015.
  16. "syntactic sugar". catb.org. Retrieved 3 August 2015.
  17. Boiten, Eerke A.; Möller, Bernhard (2002-06-26). Mathematics of Program Construction. ISBN 9783540438571. Retrieved 3 August 2015.
  18. Dean, Thomas (2004). Talking with Computers: Explorations in the Science and Technology of Computing. Cambridge University Press. p. 115. ISBN 9780521542043.
  19. Harrison, William; Sheard, Tim (July 8–10, 2002). "Fine control of demand in Haskell" (PDF). Mathematics of Program Construction: 6th International Conference, MPC 2002, Dagstuhl Castle, Germany, July 8–10, 2002. Proceedings. International Conference on Mathematics of Program Construction. Dagstuhl Castle, Germany: Springer Berlin Heidelberg. p. 93. doi:10.1007/3-540-45442-X_6. S2CID 10059915.
  20. Chugh, Ravi (2013). Nested Refinement Types for JavaScript (PhD). UC San Diego.
  21. "C Language LLVM Documentation". clang.llvm.org. Retrieved 30 June 2020.
  22. "The Secret Life of Types in Swift". medium.com/@slavapestov. Retrieved 30 June 2020.

References
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.