language-features

This is the unabashed attempt of a similar C# question. So what are your favorite F# hidden (or not) features? Most of the features I've used so far aren't exactly hidden but have been quite refreshing. Like how trivial it is to overload operators compared to say C# or VB.NET. And Async<T> has helped me shave off some real ugly code. I'm quite new to the language still so it'd be great to learn what other features are being used in the wild. User defined numeric literals can be defined by providing a module whose name starts with NumericLiteral and which defines certain methods ( FromZero ,

I haven't touched Java since using JBuilder in the late 90's while at University, so I'm a little out of touch - at any rate I've been working on a small Java project this week, and using Intellij IDEA as my IDE, for a change of pace from my regular .Net development. I notice it has support for adding interfaces and @interfaces, what is an @interface, and how does it differ from a normal interface? public interface Test { } vs. public @interface Test { } I've done a bit of searching, but couldn't find a great deal of useful info referring to @interface. The @ symbol denotes an annotation type

In Javascript, one of the reliable ways to convert a string to a number is the Number constructor: var x = Number('09'); // 9, because it defaults to decimal Inspired by this question , I started wondering — what is the difference between the above and: var x =new Number('09'); Number certainly looks better, but it seems like a slightly inappropriate use of a constructor. Are there any side effects or any difference to using it without the new ? If there is no difference, why not, and what is the purpose of new ? In the first case, you are using the Number Constructor Called as a Function , as

Why is Python's intern built-in only for strings? It should be possible to extend intern to classes that are hashable and comparable, right? Ben The purpose of interning things is to be able to compare them by comparing their memory address; you ensure that you never create two objects with the same value (when the program requests the creation of a second object with the same value as an existing object, it instead receives a reference to the pre-existing object). This requires that the things you're interning be immutable ; if the value of an interned object could change, comparing them by

It's somewhat common knowledge that Python functions can have a maximum of 256 arguments. What I'm curious to know is if this limit applies to *args and **kwargs when they're unrolled in the following manner: items = [1,2,3,4,5,6] def do_something(*items): pass I ask because, hypothetically, there might be cases where a list larger than 256 items gets unrolled as a set of *args or **kwargs . vartec WFM >>> fstr = 'def f(%s): pass' % (', '.join(['arg%d' % i for i in range(5000)])) >>> exec(fstr) >>> f <function f at 0x829bae4> Update: as Brian noticed, the limit is on the calling side: >>> exec