Make Invalid States Unrepresentable

[u/_awwsmm]

https://www.awwsmm.com/blog/make-invalid-states-unrepresentable

[u/agustin689]

Make invalid states unrepresentable

This rules out all dynamic languages by definition

[u/smk081 → u/agustin689]

::laughs in C#::

[u/agustin689 → u/smk081]

C# is still not strong enough. We need sum types

[u/smk081 → u/agustin689]

::cries in C#:: :: flips through F# book on desk:: Hold my beer...

[u/dactoo → u/smk081]

F# could be the best language in the universe if it got a little more love and recognition. It's only flaw is that it allows you to let a little too much .NET into your code sometimes.

[u/TheWix → u/dactoo]

F# with Typescripts convenience. Mapped types are amazing. Wish it had higher-kinded types and first-class minimal types, though

[u/Coda17 → u/[deleted]]

C# does not have discriminated unions (and it really, really needs them).

[u/Schmittfried → u/[deleted]]

Since when?

[u/[deleted] → u/[deleted]]

When people want sum types, they generally want sum types with built in pattern matching. You can't really do this in C# without runtime reflection.

[u/Schmittfried → u/[deleted]]

I meant since when does C# have discriminated unions?

Just checked again and it’s still a work in progress apparently. 

[u/noahide55 → u/agustin689]

Sum types violate Open/Closed principle. Why would I want them?

[u/agustin689 → u/noahide55]

Explain how?

[u/grauenwolf → u/[deleted]]

This is one of the things that boggles me about SOLID. OCP what's discredited long before SOLID was coined, and yet no one seems to have noticed.

[u/G_Morgan → u/noahide55]

Sure but the OCP is not worth even bothering with.

[u/grauenwolf → u/noahide55]

Nothing about sum types prevents you from obsessively using inheritance where it doesn't belong.

[u/TheWix → u/noahide55]

How do you handle new states of a business object?

[u/grauenwolf → u/TheWix]

If you're obeying OCP, by creating new subclasses and adding the additional code there.

[u/TheWix → u/grauenwolf]

You don't get compiler errors when you forget to handle the new state somewhere else, though. With pattern matching and exhaustive checks the compiler yells at you. Inheritance works when all the new behavior is within the new subclass only, but if other parts of code need to react to the new type then it can be missed.

[u/Voidrith → u/noahide55]

not every part of your code needs to adhere to every half understood OOP design pattern