The effect of generics on me is a personal remark. I was not born a programmer as my brothers were (since they were 5 or so). I dabbled in assembly and C but didn’t start going full at it until I was using Delphi. In Delphi 5.0 at the time (early 2000s), there weren’t generics yet. They may have existed in other languages. So in my building of my multi-threaded transcription program (I was typing neurologic transcription at the time and thus developing/dogfooding it for myself), I remember having to explicitly write out many list classes, events, etc., that were to enable strongly typing things. This carried over in the earliest version of C#. When generics were introduced, they significantly improved the expressive power of the language and allowed me to cull my code greatly - especially in combination with reflection (runtime introspective programming).
As for compared to other languages, I’ve looked a little into the OCaml functors here, and I have to say that it seems to be a strange (broad?) comparison when comparing generics in an OOP language like C# to Functors in an FP language such as OCaml. From what I can grok there, it appears that the modules are like interfaces and that the functors are used to “build up” complex dynamic functions, much like a compound currying mechanism. This behavior in C# would like be implemented using base classes which implement interfaces. Then, using generics, you could pass around strongly-typed references via the interface/class. You can also declare constraints on the generics when doing this as well.
So for the simpler Increment example, you can actually pass around generic anonymous functions, such as Func<int, int>, but to represent a function that takes a single int argument and returns an int, such as (oh goodness, from C# memory…it’s been a couple years now!): var inc = x => return x + 1;. To do a closure around an anonymous lambda function I believe would just be to set a variable before the declaration:
var y = 2;
var inc2 = x => return y + 1;
But my memory is hazy on the scoping rules for them. It would be unwieldy to pass around more curry-like functions, such as a Func<Func<int, int>, int> (but I have done it).
Also, from reading through that page, it mentions the required explicit module type attribution. My gut feeling is that this has to do with covariance and contravariance? (oh we’re digging deep for vocab now). Generics didn’t initially have this capability, but at some point it was introduced and allowed for even more powerful type inference in the compiler. This makes me want to search for an example in the old ibgib codebase, because I’m sure I used it. I had built the entire codebase on a single interface (going against standard C# naming conventions unfortunately, but I had to do it): Task<ib> gib(ib gib). As I’ve learned more about FP, it turns out I was just about trying to shove FP into C# and I didn’t realize it at the time! 
EDIT: Looking at the mathematical functors on the all-knowing wikipedia, it does indeed look like that is why co/contravariance was introduced to generics in C#. I always would get confused on which one is which, but the practical side was that you could define generic types using the keywords in and out, depending on how a type was being used.
to your knowledge on that one! 