Structural typing is different from dynamic typing. C# supports structural typing in the form of tuples and anonymous types. But you can't return an anonymous type from a method. This is a significant limitation.

As for "free" functions: C# already recognizes the usefulness of this in the "using static" directive. This is useful for a lot more than "hello world".

You can't return an anonymous type, but the syntactic difference between an anon type and a tuple is two characters: parens instead of curly braces.

And the little "new" in front of it. I actually preferred the curly braces version and would have loved for them improve it instead of creating a replacement.

And well, I'd expect them to get it right eventually. It is at least their third evolution of that feature... there was a System.Tuple as well. Wonder if they ever come out and officially deprecate their earlier attempts.

> Wonder if they ever come out and officially deprecate their earlier attempts.

That (mostly) doesn't happen.

I would say that .NET Core was the sole attempt to deprecate a lot of the framework. And most of it came back anyway; see the title of the parent article.

I don't think C# have ever deprecated language features. You can still use the old "delegate{}" syntax even though we have the more concise arrow syntax.

Why are "free" functions useful? What actual real difference does it make compared to putting an extra word in front to call the method?

You don't need to put the extra word in front since "using static" was introduced. But you still need to define a useless static class.

> But that would mean optimising for "hello world" and other small script scenarios, which isn't a goal of the language design.

Fairly complex programs can be written with just plain functions, all of them elegantly starting off column 0 instead of being tabbed for namespaces and classes. It works especially well with directory structure based namespaces. eg: Microsoft's own TypeScript.

> Like "dynamic" in C# 4 ?

No not dynamic, I wouldn't use that very much either. https://en.wikipedia.org/wiki/Structural_type_system

It sounds like you are using the wrong language. F# is what you want to be using.

> No not dynamic

Ok, I see that structural typing is a third type system option.

But honestly, I don't want C# and .NET to contain every feature and paradigm ever created. It would be bloated and hard to use. Already there is significant legacy and different ways of doing the same thing, and it's likely to get even worse.

If the language that you ideally want is built around structurally typed free-floating functions, then it probably isn't C#. It probably exists, it's likely possible on the .NET platform, but it doesn't work and think like C#.

> But that would mean optimising for "hello world" and other small script scenarios, which isn't a goal of the language design.

That's what the Powershell integration is for.

> That's what the Powershell integration is for.

And projects such as scriptcs and cake

http://scriptcs.net/

https://cakebuild.net/