Ask HN: Your favorite syntactic sugar from any language?

32 pointsby davegaueralmost 7 years ago

Most programming languages I've encountered, no matter how otherwise unappealing, have at least one syntactic feature that makes them really pleasurable for at least some type of task.Some things I miss when I don't have them are:* "=~" for regex matching (as in Perl and Ruby)* "{foo:['bar','baz']}" for quick data structures (as in JavaScript)* "for f in *; do echo $f; done" for looping over a 'glob' of files (as in Bash)What's your favorite bit of sugar?

42 comments

jwilkalmost 7 years ago

Syntactic sugar is not another name for "really cool syntax". They are non-essential constructs, which could be removed without much effect on the language, except for readability."=~" in Perl and globbing in shell are not syntactic sugar. They are fundamental parts of the languages.

评论 #17324535 未加载

评论 #17324727 未加载

artemisynaalmost 7 years ago

Haskell has way too much syntactic sugar some of the time, but I really appreciate its anonymous function syntax.If I need a quick-and-dirty map over a list of something, a<pre><code> (\x -> x + 1) a </code></pre> is much nicer than a<pre><code> std::for_each(a.start(), a.end(), [](float x) { return x + 1; } // end of lambda expression ) </code></pre> or whatnot that I have to do in C++.

评论 #17324562 未加载

评论 #17324481 未加载

评论 #17325369 未加载

kjeetgillalmost 7 years ago

I love love love almost everything about Python's syntax.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.

评论 #17324537 未加载

评论 #17327042 未加载

评论 #17324585 未加载

rehemiaualmost 7 years ago

Pipeline operator ( |> ) in functional programming languages (Elixir, F#, Elm)

hprotagonistalmost 7 years ago

I really like C#'s => operator, especially in the context of expression-body members.<pre><code> public override string ToString() => $"{fname} {lname}".Trim(); </code></pre> I am overjoyed with newer python's f-strings.<pre><code> foo = 5 bar = 4.5005 print(f'foo is {foo} and the first bit of bar is {bar:0.2f}') </code></pre> I really like python's * and * unpacking, and especially that you can do it in the middle with throwaways:<pre><code> first, *_, last = function_that_returns_ten_things() </code></pre> or for building kwarg-only classes from dicts:<pre><code> foo = {'x':5,'y':6} bar = Point(**foo)</code></pre>

AnimalMuppetalmost 7 years ago

The defaults in Perl, especially the default variable.(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...)

评论 #17324634 未加载

fvdessenalmost 7 years ago

I really like python's array slices, a[5:] b[2:3], and list comprehensions, [x * 2 for x in array if x > 0]

评论 #17324376 未加载

评论 #17324335 未加载

评论 #17324738 未加载

LordHeinialmost 7 years ago

Beying somewhat of a functinal fanboy i really like Scalas (and oder functinal languages) point free style.Instead of:listOfThings.foreach(x => println(x))You can just typelistOfThings foreach printlnType 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 &. operatorinstead ofy = x.nil? ? nil : x.fooy = x&.fooOr just use a language which has some sort of null savety like Option types.

ioddlyalmost 7 years ago

Scheme's expression comments are really quite handy, but only possible to implement in languages where everything is an expression.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).

评论 #17330932 未加载

christophilusalmost 7 years ago

For me, it's Clojure's threading macros. They're like the `|>` operator on steroids. Also from Clojure, the ability to use maps and keywords as functions in a lot of cases, such as: `(map :hello [{:hello "world"}]) ; ["world"]` and `({:hello "world"} :hello) ; "world"` It comes in really handy more often than I would have thought.

Pete_Dalmost 7 years ago

Common Lisp's LOOP macro is a fearsome beast.<a href="http://www.ai.sri.com/~pkarp/loop.html" rel="nofollow">http://www.ai.sri.com/~pkarp/loop.html</a><a href="http://www.lispworks.com/documentation/HyperSpec/Body/m_loop.htm" rel="nofollow">http://www.lispworks.com/documentation/HyperSpec/Body/m_loop...</a>

kendallparkalmost 7 years ago

Ruby inline conditionals. They read like English. Short and sweet.<pre><code> if condition? return end if !i_probably_shouldnt? do_something end </code></pre> Becomes:<pre><code> return if condition? do_something unless i_probably_shouldnt?</code></pre>

评论 #17324564 未加载

评论 #17324695 未加载

himomalmost 7 years ago

Technically, any Turing-complete language can be mapped to any other Turing complete language, so it’s possible to have non-trivial syntatic sugar do anything. (Use brainfuck as IR, lol.) >:) But yeah, SS is more like:<pre><code> ++x; // x = x + 1 </code></pre> Nifty syntax<pre><code> &:foo Ruby method name to callable syntax foo&.bar Ruby check nil before calling bar foo?.bar Swift optional presence check if(x = foo!.bar!) { x.something() } foo ?? bar Swift nil-coalescing foo || bar Ruby nil-coalescing <<1,4,8,45>> Erlang bit syntax (binary literals), with typing and endianess 5b432140 Erlang arbitrary base literals List comprehensions Erlang, Python, Binary comprehensions in Erlang 2> Pixels = <<213,45,132,64,76,32,76,0,0,234,32,15>>. <<213,45,132,64,76,32,76,0,0,234,32,15>> 3> RGB = [ {R,G,B} || <<R:8,G:8,B:8>> <= Pixels ]. [{213,45,132},{64,76,32},{76,0,0},{234,32,15}] -- from LearnYouSomeErlang Show anon fn’s in many languages using utf8 λ. Swift property lifecycle callbacks</code></pre>

Doxinalmost 7 years ago

I'm absolutely positively in love with "Universal function call syntax" from D, it makes the following:<pre><code> foo.bar(baz) </code></pre> compile to the following if foo has no property bar:<pre><code> bar(foo, baz) </code></pre> It allows you to trivially extend classes from libraries without meddling with their code or breaking other code using the library. e.g. if you define:<pre><code> string helloWorldize(string input){ return "Hello, "~input; } </code></pre> You can then do this anywhere "helloWorldize" is in scope:<pre><code> "bob".helloWorldize(); </code></pre> And because of the strong type system and smart compiler you'll never run into situations where you call helloWorldize when you don't mean to.

city41almost 7 years ago

I miss CoffeeScript's existential operator now that all my projects are standard ES6.<a href="https://coderwall.com/p/jwzppw/the-existential-operator-in-coffeescript" rel="nofollow">https://coderwall.com/p/jwzppw/the-existential-operator-in-c...</a>

评论 #17326781 未加载

ralstonalmost 7 years ago

Python 3.5+<pre><code> >>> first = {"a": 1} >>> second = {"b": 2} >>> merged = {**x, **y} >>> print(merged) {"a": 1, "b": 2}</code></pre>

评论 #17324438 未加载

评论 #17324436 未加载

frflalmost 7 years ago

Sorry, this comment will not really benefit the matter at hand, but I'd like to share a relevant quote I quite enjoyed when I first read it> Syntactic sugar causes cancer of the semicolon. - Alan Perlis

snarfybarfyalmost 7 years ago

Multiline strings aka 'here documents' in most Shells.Rich datastructure literals in Clojure for sets #{'foo'}, maps {:a 1, :b 2}, lists (1,2,3) vectors [1, 2, 3]The serialization format EDN is basically JSON on steroids.<a href="https://github.com/edn-format/edn" rel="nofollow">https://github.com/edn-format/edn</a>

laogaialmost 7 years ago

Ruby's & operator.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`.

评论 #17324539 未加载

评论 #17324507 未加载

ezekgalmost 7 years ago

Python/Ruby's kwargs, JavaScript's destructuring syntax, Python list comprehensions, Ruby's array push << method, ranges, and literal array expressions

nunezalmost 7 years ago

Ruby’s question marks for Boolean functions and exclamation points for mutating ones. I didn’t get t at first, but once I did, I was in love. Perfect for readabiiity.

评论 #17324607 未加载

评论 #17324398 未加载

snappyTertlealmost 7 years ago

Destructuring in almost any functional language and ES6 JS.

amthewizalmost 7 years ago

Ruby's optional parenthesis for function calls. Makes beautiful DSLs like RSpec -<pre><code> describe UsersController do before do allow(controller).to receive(:current_user).and_return(nil) end describe "GET #new" do subject { get :new } it "returns success" do expect(subject).to be_success end end end</code></pre>

评论 #17324762 未加载

EvenThisAcronymalmost 7 years ago

Hands down, it's D's shorthand array operations.<pre><code> int[] a = [1, 2, 3]; int[] b = a[] * 3; assert(b == [3, 6, 9]); a[] += 2; assert(a == [3, 4, 5]); int[] c = a[] + b[]; assert(c == [6, 10, 14]); </code></pre> This of course works with D's slicing syntax so you can do stuff like a[0..1] *= 3.

mabynogyalmost 7 years ago

I use "star" in my programming language to "dereference" generators (run them until they are finished). For example:<pre><code> //block for 4s sleep* 4 //run a modal form let* ok form_confirm "Do you agree?" </code></pre> Those calls are converted to loops.

singularity2001almost 7 years ago

I love kotlin lambdas with «it»:list.filter{ it > 3 }.map{ it + 1 }compare that to shitty Java or C++.Love js map construction by name:fun="..."; map={fun}; map.fun == "..."Nice lambdas and properties are the things I miss most in python, especially python3, where you have to call list(map(...)) all the time (generators are a good idea but why not add proper __str__?)

jedbergalmost 7 years ago

Python list comprehensions.They could be written as multiline loops, that are definitely more readable, but it's just so nice to whip out a list comprehension sometimes:<pre><code> print([int((((1 + 5**0.5) / 2)**n - ((1 - 5**0.5) / 2)**n) / 5**0.5) for n in range(1, 21)])</code></pre>

farleykralmost 7 years ago

I just discovered being able to use Python to convert a number to a different base:>>> 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.

评论 #17324649 未加载

domlebo70almost 7 years ago

Do notation in Haskell, Scala etc. Nothing else comes close

评论 #17324439 未加载

timwisalmost 7 years ago

JavaScript's async/await is our reward for suffering promises. Not perfect, but makes the language a lot more approachable IMO.

AndrewDuckeralmost 7 years ago

The one that's saved me the most time is probably "foreach" as a way of accessing enumerables in c#.Simple, readable, and easy.

nemoniacalmost 7 years ago

If you use pretty much any lisp-like language you can add your own favourite syntactic sugar to the language yourself.

charlieflowersalmost 7 years ago

possibly async/await

RhysUalmost 7 years ago

Haskell dollar operator ($). Last I checked, it fits into the Python grammar if anyone feels PEPpy.

tu7001almost 7 years ago

List comprehension - Python, Haskell.

emorning2almost 7 years ago

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

geoelkhalmost 7 years ago

A lot of things in Ruby likeif !disabled //instead of unless disable

imhalmost 7 years ago

Python 3's string formatting is pretty useful.

aqme28almost 7 years ago

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

pdgonzalez872almost 7 years ago

The pipe operator in Elixir.

BigToachalmost 7 years ago

Decorators in any language.

aphextronalmost 7 years ago

range() in Python[foo, bar, ...baz] ES6 Destructuring