3 ms·

> Ok, but how do you enforce that? If you've got a technique that requires manual review and reasoning at a distance to use safely, then again we're no better o

• lmm 9y ago
  > Failing to constrain may lead to a null reference exception. Just like passing a reference to any method anywhere in C#. But you can adopt a small set of rules that are locally enforceable (and practical to use in an automatic linter) to prevent this happening (just as Haskell is safe even though unsafePerformIO exists, because you can adopt a small set of locally enforceable rules like "never use unsafePerformIO"). Unfortunately one of those rules has to be to never use default(). > That is not the same as returning a dynamic value, which is a type that propagates dynamic dispatch wherever it's passed. A failure to capture a null reference bug means on first usage it will blow up - so you fix the code and everything is type safe. Unfortunately default() isn't fail-fast in all cases - when used with e.g. a struct type containing a reference type, it will create the value in an invalid state (containing a null reference) but you won't necessarily notice until you come to use the value, arbitrarily many compilation units away. So it's just as dangerous as a dynamic value. > All throughout this frankly tedious discussion you have somehow conflated having a bug in an application with having no type system at all. In almost any language you can have polymorphic return values without complete type safety. The feature that Haskell has here isn't that you can have polymorphic return values - it's that you can have polymorphic return values safely. Showing an unsafe implementation of polymorphic return values in some other language is pointless and irrelevant.
  • louthy 9y ago
    > Unfortunately default() isn't fail-fast in all cases It's purely a means of dispatch, if someone wants to put member variables in that are never used - good luck to them. For some reason you think that because C# doesn't protect you from being an idiot you can't do return type polymorphism. Well that's completely incorrect and you know it. The reference of default(A) isn't something that's passed around - yes the method you dispatch to has access to `this`, but what's the point of A: declaring a variable in a 'class instance' and B: using it when it's in an invalid state? It's what a moron would do. I don't call `((string)null).ToString()` because it's fucking stupid. But I assume in your world that means C# can't do method dispatch by reference? Just because somebody can do something stupid doesn't devalue any particular technique that requires you to not do the stupid thing. Otherwise, you may as well delete C# as a language - because it's trivially easy to do stupid things. In fact software engineering wouldn't even have gotten off the ground if that was a pre-requisite. But clearly people do produce software in it - which proves your arguments wrong. > Showing an unsafe implementation of polymorphic return values in some other language is pointless and irrelevant. Show me where it was mentioned in the original comment about safety? Not there is it. You just jumped in with inaccurate claims and went on some tangent about type-system safety, like C# would ever win any type-system safety contests. Leaving asside the fact that all of your arguments about safety are nonsense for the moment... let's do it another way ... public interface Monoid<MA, A> where MA : struct, Monoid<MA, A> { A Empty(); A Append(A x, A y); } public struct MString : Monoid<MString, string> { public string Append(string x, string y) => x + y; public string Empty() => ""; } public struct MList<A> : Monoid<MList<A>, List<A>> { public List<A> Append(List<A> x, List<A> y) => x.Concat(y).ToList(); public List<A> Empty() => new List<A>(); } public static class Monoid { public static A Concat<MA, A>(IEnumerable<A> ma) where MA : struct, Monoid<MA, A> => ma.Fold(default(MA).Empty(), default(MA).Append); } class Program { static void Main(string[] args) { var strs = new[] { "Hello", ",", " ", "World" }; var lists = new[] { List.New(1, 2, 3), List.New(4, 5, 6) }; var str = Monoid.Concat<MString, string>(strs); var list = Monoid.Concat<MList<int>, List<int>>(lists); } } That is now safe in that `Concat` can't be implemented without the `struct` constraint, the code will fail to compile. Also the types that implement `Monoid<MA, A>` must be structs. I'm out of this discussion now - because if you're still going to claim this is unsafe then you're clearly trolling and I haven't really got the motivation to keep feeding you.