Thanks a lot for your detailed review and improvement suggestions. I will look into them all one-by-one. Indeed I wish I had more time for practising katas, I've been busy trying to put my lectures together, among other side-projects. I think that the entire community (newcomers to FP) could benefit from this series, since it's proven popular elsewhere - so hopefully I find a way of making it suitable to the CW format.

Thanks for your reply, at least now we can have some dialogue.

I can't help but wonder just how much (or rather, how little) effort the author has put in in authoring such Kata

Actually it has taken me quite a while to work on these, believe it or not. I've added both the JS and the TypeScript versions of the exercices, and the typed versions did not exist in the original series and I had to put it together.

numerous major flaws in the Kata Description, test feedback, etc

I guess part of the problem is that each individual kata doesn't make much sense on its own, but only as part of the series. If you check the originals (http://reactivex.io/learnrx/) you'll see that they make a nice cohesive whole. So maybe codewars is indeed not ideal for such education series. On the other hand, I have seen similar attempts, for instance have a look at the "Learning Typescript" series: this is directly taken from the TypeScript documentation, and exercises are almost identical as the examples given there. And there has not been any banning on these, which are now out of beta. I have actually made use of them for my lecture so I really enjoyed finding such simple fundamental katas on the site. Maybe we would need a more explicit support in the site for what is really "basic" content, or "learn a language" content.

So if I try to address the test feedback issue (it's better on the TypeScript side btw), and expand on the description so that hopefully they can sort of make sense individually, would you be willing to reconsider? I'm not going to put more effort into this if you disagree on the basic premise of porting this education series into the site.

First comment: if you're trying to discourage people for trying their hands at writting katas, way to go. I appreciate the feedback, but not the tone in which it is given. What is this, some kind of place where standard rules of politeness do not apply?

Second comment: this is an education series. It's pretty popular actually, look here https://github.com/ReactiveX/learnrx: 1247 stars. So this might be boring for you, but not for people who never used map(), flatMap(), etc. And I haven't found any sort of equivalent educational katas when looking for "functional programming" and similar keywords. If you know some, I would be grateful for the reference, since writting katas is a lot of work so if I can avoid it all the better. This adaptation to codewars has been done with assent from the authors btw, see my github issue here: https://github.com/ReactiveX/learnrx/issues/167

As a matter of fact, I'm teaching a lecture and this is why I've added this material - it's a nice environment for students to practice in. I understand katas are about a challenge, but this platform is really great for education as well, or is there some clause that this is forbidden?

I will try to address the constructive part of your comments. In exchange, can I ask for reconsideration of your bashing? Btw isn't there to be multiple opinions on who decides to ban what?

how about supporting lodash for this one?

The mixins page from the typescript documentation is actually oudated (https://github.com/Microsoft/TypeScript/issues/17126) and the recommended technique now is to use intersection types. I would therefore replace this kata by an improved one on intersection types, which would cover actual mixin implementation with them (rather than this confusing intersect function).

Sorry but I can't see how the proposed intersect function could be useful in any way - isn't the purpose of mixins to extend the capabilities of an object? How about an exercise about precisely implementing various "traits" (e.g. Loggable, Serializable), and then mixing them into some entities?

how about declaring animal an abstract class with a protected constructor, that might improve the clarity and scope of the exercise. Also, I find the interface doesn't necessarily bring much here.