nested-generics

I'm prototyping some highly declarative code, and the type inference and safety that comes with Kotlin helps a lot. One of the goals is making extensions (subclasses) of the primary types stupidly easy to implement. In order to maintain rich type inference and expressiveness, I've found some success in defining generic extension functions projected against subclasses. All the type information of subclass methods with none of the extra subclass implementation, it's great. So I'm trying to write a rich generic function that maintains as much type information as possible. The issue creeps up with

I wrote this extension method (which compiles): public static IEnumerable<J> Flatten<T, J>(this IEnumerable<T> @this) where T : IEnumerable<J> { foreach (T t in @this) foreach (J j in t) yield return j; } The code below causes a compile time error (no suitable method found), why? : IEnumerable<IEnumerable<int>> foo = new int[2][]; var bar = foo.Flatten(); If I implement the extension like below, I get no compile time error: public static IEnumerable<J> Flatten<J>(this IEnumerable<IEnumerable<J>> @this) { foreach (IEnumerable<J> js in @this) foreach (J j in js) yield return j; } Edit(2) : This

I was playing around with a hobby project when I came across a type-inference error I didn't understand. I have simplified it to the following trivial example. I have the following classes and functions: class Foo { } class Bar { } class Baz { } static T2 F<T1, T2>(Func<T1, T2> f) { return default(T2); } static T3 G<T1, T2, T3>(Func<T1, Func<T2, T3>> f) { return default(T3); } Now consider the following examples: // 1. F with explicit type arguments - Fine F<Foo, Bar>(x => new Bar()); // 2. F with implicit type arguments - Also fine, compiler infers <Foo, Bar> F((Foo x) => new Bar()); // 3. G

This question already has an answer here: Java - Generics with lists 5 answers So how can I do the following in Java? List<String> strings = new ArrayList<String>(); JAXBElement<List<String>> jax = new JAXBElement<List<String>>(new QName("strings"), List<String>.class, strings); The issue specifically occurs at List.class and the error returned is: Multiple markers at this line - List cannot be resolved to a variable - String cannot be resolved to a variable - Syntax error on token ">", void expected after this token You can't. The closest approximation to what you want is to use (Class<List

So I'm trying to get a reasonably complicated system working. Here's the basics of what I'm attempting. Rules: abstract class Rule { // stuff } class ExampleRule extends Rule { // stuff } Handlers: abstract class RuleHandler<T extends Rule> { Class<T> clazz; RuleHandler(Class<T> forClass) { this.clazz = forClass; } abstract void doStuff(T rule); } class ExampleRuleHandler extends RuleHandler<ExampleRule> { ExampleRuleHandler() { super(ExampleRule.class); } void doStuff(ExampleRule rule) { // stuff } } And tying them together: class HandlerDispatcher { Map<Class<? extends Rule>, RuleHandler<?