#2 has definitely bitten me, but I see that less of a failure of CS and more of a failure of the design of $.each(). The case is pretty well documented in CS though... the last code line is 'return'ed... if your code unexpectedly returns false, then really you are just bitten by the design of $.each().
For each loops are great, but there is certainly value in having $.each be a function as well as a statement. For example, if you want to pass it to another function in more functional style programming: do_something($.each);
"or it might be possible to reduce your input first so that you are only iterating over the things you actually want to iterate over..."
It seems you don't understand the point of returning false from $.each, it is not to filter, it is to stop early. For example, if you are doing a linear search for something, it is reasonable to want to stop after you find it. There is no way to "iterate over the things you actually want to iterate over".
I also wouldn't use something called $.each to do a linear search. I'd use underscore.js _.find(), which has a sane api, you return true when you want to stop. This thing I'm looking for has been found.
Array.forEach and _.each() chose not to support returning false. I can only assume that is @jashkenas being wise.
For example, I use swank (https://github.com/swank-js/swank-js) to send javascript to the current page in my browser from Emacs. I couldn't live without it. I'd have to figure out how to dynamically compile it, and I'm not sure if there's any restrictions with piece-meal compilation.
It's definitely a separate community and I'd lose out on lots of good tools if I had to use it. I'm glad nobody wants to use it where I work.
// beginning of file
Coffeescript = require('coffee-script');
// compilation
Coffeescript.compile(line, {bare: true});
e.g. var f = eval(Coffeescript.compile("(x) -> x + 1", {bare: true}));
f(1) // ==> trueYes, there is a learning curve and it does things slightly differently. The implicit return value is just something you read once and then integrate. True, function hoisting is lost in cs, but that has never been a problem for me.
Mapping values in an object:
{a, b} = c
Backslash to continue lines: a = long_variable_name \
+ other_long variable name
Switch statements without a parameter: switch
when function_that_needs_to_return_true
stuff
But the bigger problem is just having no idea how things will parse. For example, this works: a = b +
c
But this doesn't: a = b
+ c
And then this works: switch a
when b, c, d
e()
But this doesn't (a multi-line form you might want to use if the variable names were really long): switch a
when b,
c,
d
e()
And this doesn't: switch a
when b
when c
when d
e()
After trial-and-error, you discover it has to be this, with a seemingly random backslashes: switch a
when b, \
c, \
d
e()
I could go on and on -- but you get the point. The whole language is only discoverable via trial and error. None of this is documented. (Apologies for taking up so much vertical space of the comments!!)http://coffeescript.org/#destructuring
On backslashes:
https://github.com/jashkenas/coffee-script/issues/2457
Basically, if statements are that long, the code should be refactored. This makes it easier to read and reduces the opportunity for bugs. That pattern is one of the main reasons I like CoffeeScript.
switch a
when b, c, d
e()
Is clearly explained here: condition = (a) -> a in [
b,
c,
d
]
switch
when condition(a)
e()
This is a technique which is already possible in JavaScript, an example (not mine) from 2007: http://saintjohnshawn.com/2007/05/24/javascript-example-swit...The supposed "correct way" you support moves the values outside of the switch statement, which completely destroys reading comprehension of the code. It explodes the number of lines of code necessary. This isn't refactoring, it's complete code obfuscation.
It also makes the switch statement itself completely superfluous, since you might as well just do a series of if / else if's, and save an extra line of code. I mean, the whole point of switch is to pass a parameter and compare it against values.
For instance, look at the recently posted Matches.js [1] -- there are many reasons to factor out the test case when the test case is unusual. 80 character test cases are unusual.
[1] http://news.ycombinator.com/item?id=4516576
EDIT:
80 character test cases (variables or otherwise) should be factored out. The readability and purpose of the method is compromised if you have 5 groups of 30 constants. Factor the groups out into individual maintainable functions. Then there is one function per case, and an overview of the entire switch can be seen in a few rows rather than several pages.
switch (operation_code) {
case SUGGEST_ACTION:
...
break;
case PERFORM_ACTION_PREAUTHORIZE:
case PERFORM_ACTION_AUTHORIZE:
case PERFORM_ACTION_POSTAUTHORIZE:
...
break;
case DELETE_ACTION_REVERSIBLE:
case DELETE_ACTION_IRREVERSIBLE:
case DELETE_ACTION_NOT_PREAUTHORIZED:
case DELETE_ACTION_PREAUTHORIZED:
...
break;
case UNDO_ACTION:
...
break;
(5 more groups of 30 more constants...)
}
It's not variable names that push an 80 character limit. It's about translating groups of shorter constants, that taken together go over 80 lines, and which have similar prefixes, so they look very nice listed vertically, and make it very clear where their differences and similarities are.I stand by my point: telling people that, in CoffeeScript, it's proper to "refactor" this into a switch statement with no parameter and creating entire new functions, is bizarre.
2) This has to do with the unary plus operator more than just cs - since +varname is an expression, it treats it as such. Fair complaint - I've never run into that. Also, this works just fine if you put the plus on the end of the first line:
a = long_var_name +
hey_another_var
3) When would you use those?4+5) Are cases of the unary operator in 2)
6-10) Sure, this is limiting if you want to write switch statements like that.
I feel that your coding style is different, or that you're listing edge cases to be contrarian. Coffeescript has a much smaller range of syntax deviations but that's part of what allows it to be so brief and clean.
a = b
+ c
Line-breaks end statements in CoffeeScript, this is the same as a = b; +c
That should be pretty apparent. Your other examples are mostly abuses, and you'll not find "documentation on forbidden syntax" for any other language either.Javascript or Coffeescript shouldn't ever have lines ending with a backslash.
Though the switch one seems surprising (read: a flaw) since it is usually safe to end a line with a comma in vanilla js.
http://inimino.org/~inimino/blog/javascript_semicolons
Basically, you can almost always remove the semicolons without trouble and more often then not problems occur from semicolons not being inserted then from them being inserted in unexpected positions. The "returning an object literal" case is the only common case where a semicolon is mischeviously inserted.
http://google-styleguide.googlecode.com/svn/trunk/javascript...
switch a
when b
, c
, d
e()(Genuine question, not an snarky comment)
Edit: Huh! I thought you meant "variable hoisting", which is the most evil language feature that's ever bitten me!
This is an introduction to "function hoisting": http://elegantcode.com/2011/03/24/basic-javascript-part-12-f... - Very very interesting.
If I recall correctly the main reason why this feature is not supported by CoffeeScript is because of some awkward IE bug though.
If your inner function names are sufficiently descriptive, you can write the high-level behaviour of the outer function at the top, first to be read, to get a quick overview of what it does. Then declare the inner functions below that (this also requires that the inner functions must not have surprising side-effects).
I've never seen or tried out code like that in practice, but it seems like it could work.
Putting syntactic sugar aside, while some things are very welcome (list comprehensions, ===, ?), there are two main reasons why I would be wary of using CoffeeScript again:
1. Complete lack of documentation for syntax. Because there are basically no more braces and parentheses, CoffeeScript just tries to guess what you're doing, as far as I can tell, based on a bunch of internal heuristics. Unfortunately, there's no way for me to learn how to write parseable code without constantly pasting into the coffeescript.org site, and seeing if CoffeeScript understands it or not. This is the first language I've ever used where the syntax rules are essentially unknowable, and a lot of time gets wasted trying to discover them through trial and error.
2. Unexpected side effects. For example, functions return the last evaluated value by default. If you're using $.each(), and your function's last line is something that returns false (like a separate function you call), then your $.each() loop will terminate unexpectedly early, since jQuery does that when it receives a false. So CoffeeScript isn't just a wrapper around JavaScript, but it really changes its behavior. Another example: CoffeeScript gets rid of function hoisting. A significant JavaScript feature, completely gone.
I personally am slower to code in CoffeeScript, because I know JavaScript 100% inside and out, but with CoffeeScript that isn't really possible, because so much of its implementation is undocumented. I mean, many times you're forced to end a line with a backslash in order to continue it, and even the existence of that necessary feature isn't mentioned once in the docs.
But a lot of people seem to love the syntax, and that seems to outweigh the negatives for them. I personally don't find JavaScript that ugly, but coding in a language I can't ever fully understand gives me a huge headache.