C# developer here, with a long history of OCaml development (and I&#x27;m still using OCaml knowledge as a filter for recruiting C# developers).<p>First-class functions in C# are nice, nearly as good as those in OCaml. The main annoyance is the incompatibility between Action&lt;&gt; and Func&lt;&gt; (and, in general, the fact that C# uses void rather than unit).<p>--<p>Immutability: for every mutable class in our code base, there are three or four immutable classes, and `readonly` is likely the most frequent keyword. Among these, we have an entire hierarchy of dozens of classes that are entirely immutable (and make heavy use of immutable containers from Microsoft) because it&#x27;s still the easiest way to implement a multi-reader, single-writer thread-safe data structure. You can survive without immutable-by-default, you can survive without OCaml&#x27;s<p><pre><code>    { record with  a = b ; c = d }
</code></pre>
syntax, but it gets very, very annoying to work without<p><pre><code>    {&lt; self with a = b ; c = d &gt;} 
</code></pre>
in an object-oriented language.<p>Algebraic data-types: I&#x27;m mostly writing compilers (yes, in C#, don&#x27;t ask), and instead of writing a simple<p><pre><code>    | SetLineOp of param * param * index
</code></pre>
I have to define a new class, three readonly fields, a constructor to set them, equality operators (R# helps, but still...), and five or six lines of visitor pattern boilerplate in order to get the &quot;you missed a case&quot; warning in pattern matching. This gets very annoying very quick, and there is no practical benefit to having all those classes here.<p>--<p>Type inference: C# does manage to be fairly clever, although not as clever as OCaml. I have seldom found it to be lacking in general use, aside from the ability to define local functions (var f = a =&gt; { ... } does not work, you have to spell out the type of f). There have been a handful of times when I was trying to do something very clever and found myself limited by the type system, and had to write annotations myself.<p>And one time, I had to reimplement GADTs with generics and reflection. It was painful, but it works.<p>However, with a few minor tweaks (e.g. an option type), I would rather have the C# type inference than the OCaml one. The reason is that, if I want to do something very clever, I will not find myself limited to code that I can actually prove to the OCaml compiler as correct: I have, time and time again, resorted to reflection and code generation to work around such situations. In other words C#&#x27;s Obj.magic is a lot more powerful (and safe, and expressive) than OCaml&#x27;s.<p>A fairly good example is Eliom&#x27;s way of expressing the parameters of a service. In C# you would write in a PageController class<p><pre><code>    public Details Update(PageId id, UserId user, [PostBody] Details body) 
</code></pre>
and have your web framework automatically bind this to POST &#x2F;page&#x2F;update&#x2F;{id}?user={user} with the appropriate serialization for PageId and UserId. And writing such a framework is easy: a couple hundred lines of code, with run-time type safety.<p>In OCaml you have to understand the entire Eliom_parameter framework: <a href="https:&#x2F;&#x2F;ocsigen.org&#x2F;eliom&#x2F;4.2&#x2F;api&#x2F;server&#x2F;Eliom_parameter" rel="nofollow">https:&#x2F;&#x2F;ocsigen.org&#x2F;eliom&#x2F;4.2&#x2F;api&#x2F;server&#x2F;Eliom_parameter</a>
Just think of the mental firepower needed to create that framework in the first place!