In JavaScript Functions are first class Objects. When you define a function, it is the constructor for that function object. In other words: var gmap = function() { this.add = function() { alert(‘add’); return this; } this.del = function() { alert(‘delete’); return this; } if (this instanceof gmap) { return this.gmap; } else { return … Read more
The following Python lines should be equivalent to what you have (assuming func, or lambda in your code, returns a Boolean): # Any contains = any(func(x) for x in enumerable) # Count count = sum(func(x) for x in enumerable) # Distinct: since we are using a custom comparer here, we need a loop to keep … Read more
If I understand correctly you can add query(“Points > 100”): df = pd.DataFrame({‘Points’:[50,20,38,90,0, np.Inf], ‘Player’:[‘a’,’a’,’a’,’s’,’s’,’s’]}) print (df) Player Points 0 a 50.000000 1 a 20.000000 2 a 38.000000 3 s 90.000000 4 s 0.000000 5 s inf points_series = df.query(“Points < inf”).groupby(“Player”).agg({“Points”: “sum”})[‘Points’] print (points_series) a = points_series[points_series > 100] print (a) Player a 108.0 … Read more
Eh. There’s readability arguments to be made in both directions — there’s such a thing as trying to put too much into a single line. But honestly, I suspect here it’s for historical reasons: pervasive “chaining” behavior hadn’t really become popular or well-known when e.g. Swing was being developed. You could argue that it should’ve … Read more
If you want to avoid unchecked cast warnings from your compiler (and don’t want to @SuppressWarnings(“unchecked”)), then you need to do a little more: First of all, your definition of Pet must be self-referential, because Pet is always a generic type: abstract class Pet <T extends Pet<T>> Secondly, the (T) this cast in setName is … Read more
This pattern is called “Fluent Interfaces” (see Wikipedia) Just return this; from the methods instead of returning nothing. So for example public void makeText(String text) { this.text = text; } would become public Toast makeText(String text) { this.text = text; return this; }
Method chaining is simply being able to add .second_func() to whatever .first_func() returns. It is fairly easily implemented by ensuring that all chainable methods return self. (Note that this has nothing to do with __call()__). class foo(): def __init__(self, kind=None): self.kind = kind def my_print(self): print (self.kind) return self def line(self): self.kind = ‘line’ return … Read more
In PHP 5.4+, the parser’s been modified so you can do something like this (new Foo())->xyz(); Wrap the instantiation in parenthesis, and chain away. Prior to PHP 5.4, when you’re using the new Classname(); syntax, you can’t chain a method call off the instantiation. It’s a limitation of PHP 5.3’s syntax. Once an object is … Read more
What I’d do is have NinjaBuilder keep the operations as a list of delegates, rather than applying them, and only apply them when .Build is called. This would allow you to make them conditional: public class NinjaBuilder { List<Action<Ninja>> builderActions = new List<Action<Ninja>>(); public Ninja Build() { var ninja = new Ninja(); builderActions.ForEach(ba => ba(ninja)); … Read more
I like the solution provided by Camilo above, essentially since all you’re doing is altering the value of a static member, and since you do want chaining (even though it’s only syntatic sugar), then instantiating TestClass is probably the best way to go. I’d suggest a Singleton pattern if you want to restrict instantiation of … Read more