Create a guide for authoring in Haskell

[Steffan153]

Create an article similar to https://docs.codewars.com/languages/python/authoring/ but for Haskell.
Would also be nice to have a separate tutorial on how to create custom Gens for QuickCheck.

Maybe @JohanWiltink would like to help on this?

[hobovsky]

I would love to see a generator which accepts [(Gen s, Int)] and uses a set of generators, generates n inputs from each of them, shuffles them, and uses the inputs to feed test cases.

For example, for "Is a number prime?" kata, I'd like to have a composite generator built like compositeGen([(genPrimes, 100), (genOddComposites, 100), (genNegativePrime, 10), (genSquareOfAPrime, 20)]) or something like this, and it would run test cases over 230 shuffled inputs.

Bonus points if such generator were able to generate not only Int, but also (Int, Bool) (input + expected answer) or even (Int, Bool, String) (input, expected answer, and assertion message).

[Steffan153]

For example, for "Is a number prime?" kata, I'd like to have a composite generator built like compositeGen([(genPrimes, 100), (genOddComposites, 100), (genNegativePrime, 10), (genSquareOfAPrime, 20)]) or something like this, and it would run test cases over 230 shuffled inputs.

That's not quite how it works... You would make all of those different generators run on a different forAll, at the easiest. But it wouldn't work quite like that.

But I'll make something to make you happy :P

[JohanWiltink]

I appreciate the vote of confidence in my technical ability. Writing documentation is not my strong point, and I don't have a perspective of all available documentation, so I might have difficulty not doing double work, linking to relevant portions elsewhere instead.

Ideally, someone would interview me on Haskell-specific techniques, ideas and pitfalls, but I have no ambition to write a Haskell authoring tutorial by myself. If I were to write a QuickCheck Generator Tutorial, it would probably be rather technical, not really a simple HowTo useful for a beginner, more of a reference guide ( which would mostly duplicate already available Hackage documentation ).

Also, I tend to lose myself in details and write overly lengthy documents, explaining too much. Editing anything I write by someone else would be a good idea.

[JohanWiltink]

That's not quite how it works

That can work just fine. Have a look at oneof

[JohanWiltink]

( and there are other constructs to do this within a single it-header )

[Steffan153]

I know that, but I meant that you can't specify specifically, "Oh, this generator should be included 20 times, this one 15, this one 30, etc." That's what he mentioned. However, if you do each gen in a different it block and specify how many tests to run, it would work. If you want, you could even loop through that list and run the tests for every one individually.

If I were to write a QuickCheck Generator Tutorial, it would probably be rather technical, not really a simple HowTo useful for a beginner, more of a reference guide ( which would mostly duplicate already available Hackage documentation ).

For that, kinda same for me, I'd explain how Gen is a monad and etc :P Then again, custom generators aren't really a noob thing anyway, so...

[hobovsky]

I meant that you can't specify specifically, "Oh, this generator should be included 20 times, this one 15, this one 30, etc."

Really? is it not possible to create such generator? It wouldn't be the first time when my misunderstanding of Haskell and related mechanism would make me expect things which cannot be done (in a feasible way), but, uh... I would expect such combining generator to be possible to create ;) I might be wrong though (I am not a Haskell guy), but I will definitely try to prove one of us two right :)

@JohanWiltink if you do not mind being nagged on gitter from time to time, Steffan or me can create some stub, and ask you for some help with technical details, if you don't mind?

[JohanWiltink]

You could do that, but it wouldn't be a forAll, it'd be a for_ over a shuffled list of cases. I've done that in specific instances.

Generally, I would randomise the counts by using frequency rather than generating a list and shuffle it, but that's mostly because I like more randomness better than less. Assumptions in generators have a way of turning on you and biting. If you want exactly ( or at least ) 20 squares of primes, do it in a separate withMaxSuccess 20 $ forAll with fully random primes, but that might generate the same 20 primes anyway. So just run a big enough test that it'll even out.

[JohanWiltink]

I guess it's the difference between random tests and randomised fixed tests. Ideally, do both.

[hobovsky]

You could do that, but it wouldn't be a forAll, it'd be a for_ over a shuffled list of cases. I've done that in specific instances.

Could you share a link to such tests?

[Steffan153]

https://www.codewars.com/kumite/5fee0ce19e5d0b001cf33d6b?sel=5fee0ce19e5d0b001cf33d6b

The last shouldBe 1 1 is just to keep the return type of the do block correct.

[Steffan153]

And here's what you were kind of thinking of in the first comment: https://www.codewars.com/kumite/5fee0f2e575c0b0021ace67d/?sel=5fee0f2e575c0b0021ace67d

It's a bit different, but similar.