quickcheck VS go-sumtype

Maybe https://github.com/BurntSushi/quickcheck too?

Yeah as other have mentioned, I was using Rust before 1.0.

This is my first public commit: https://github.com/BurntSushi/quickcheck/commit/c9eb2884d6a6...

I didn't write any substantive Rust before that point. So I'm at over 9 years.

The book, Zero To Production In Rust, uses quickcheck:

Hi all! I'm looking for some feedback on my latest crate, reltester. It's a small utility crate that, when paired with property-based testing with e.g. quickcheck makes it very easy to check that your handwritten comparison trait implementations satisfy the necessary constraints (transitivity, reflexivity, and all that stuff). I wrote it our of frustration after finding many subtle bugs in our PartialEq and PartialOrd implementations at $JOB, and hopefully someone else will find it useful.

For what it's worth this would also be a good candidate for property based testing, like with: https://github.com/BurntSushi/quickcheck

I'm aware of Hypothesis and its approach, but the connection between Hypothesis and arbitrary is indeed non-obvious. Even looking over the API docs again, the most I could pick up was this on the docs of Unstructured:

Quickcheck https://github.com/BurntSushi/quickcheck

I'm running into a strange issue while using [quickcheck](https://github.com/BurntSushi/quickcheck) to implement tests and I'm hoping someone here might have an idea. Long story short, I have tests which fail in weird ways when using quickcheck that I can't reproduce otherwise, so I'm not even sure if it's a legitimate issue or not.

I find this implementation to be quite minimal and less clumsy than alternatives. Sure, you don't get nice exhaustive pattern matching. Also, type inference gets in the way when instantiating UserKey (though you can wrap it in constructor functions). But expressing your intent using types still makes your code much more convenient and easier to understand.

The call out to sum types is something I feel. I've been using Rust daily for almost 10 years now, and sum types are absolutely still one of the things I love most about it. It's easily one of the things I miss the most in other languages. I'm usually a proponent of "using languages as they're intended," but I missed exhaustiveness checking so much that I ported a version of it to Go[1] as a sort of lint.

[1]: https://github.com/BurntSushi/go-sumtype

A Google search for golang sum types currently shows my project as a second hit: https://github.com/BurntSushi/go-sumtype

I've been writing Go and Rust nearly daily for about a decade now (Go is more than a decade, Rust is about 8 years). You are not going to teach me anything about the pros and cons of either language in a reddit comment. I do not need to be taught about the "iota mess" when I've written tooling for exhaustiveness checking in Go.

https://github.com/BurntSushi/go-sumtype forces exhaustive type switches for interfaces specifically annotated to need that.

We can fix these two problems by relying on static analyzers such as go-sumtypes

See also https://github.com/BurntSushi/go-sumtype

go-sumtype[0] has completeness checking for sealed interfaces.

[0] https://github.com/BurntSushi/go-sumtype

Pretty easy to achieve outside of the compiler: https://github.com/BurntSushi/go-sumtype