1

Lets say there is a list of all possible things

all3PStrategies :: [Strategy3P]
all3PStrategies = [strategyA, strategyB, strategyC, strategyD]  //could be longer, maybe even infinite, but this is good enough for demonstrating

Now we have another function that takes an integer N and two strategies, and uses the first strategy for N times, and then uses the second strategy for N times and continues to repeat for as long as needed.
What happens if the N is 0, I want to return a random strategy, since it breaks the purpose of the function, but it must ultimatley apply a particular strategy.

rotatingStrategy [] [] _ = chooseRandom all3PStrategies
rotatingStrategy strategy3P1 strategy3P2 N =
  | … // other code for what really happens

So I am trying to get a rondom strategy from the list. I Think this will do it:

chooseRandom :: [a] -> RVar a

But how do I test it using Haddock/doctest?

--  >>> chooseRandom all3PStrategies
--      // What goes here since I cant gurauntee what will be returned...?

I think random functions kind of goes against the Haskell idea of functional, but I also am likely mistaken. In imperative languages the random function uses various parameters (like Time in Java) to determine the random number, so can't I just plug in a/the particular parameters to ensure which random number I will get?

chris Frisina
  • 19,086
  • 22
  • 87
  • 167
  • Well, you can guarantee that the rvar isn't undefined, and that its value is in `all3PStrategies`. However, I doubt that `chooseRandom` will have your type. – Zeta Sep 17 '14 at 14:32
  • Any IO/stateful operations is against the functional idea, but they exist because without IO any program is useless. – Mephy Sep 17 '14 at 14:34
  • @Zeta Could I rewrite `chooseRandom` to `chooseRandom :: [Strategy3P] -> RVar Strategy3P` ? – chris Frisina Sep 17 '14 at 14:36
  • Why not have the function take a non empty list of strategies instead? Like `replicate 20 strategyA ++ replicate 20 strategyB` or something similar for Data.List.NonEmpty? – monocell Sep 17 '14 at 14:37
  • @monocell I am unsure of what you mean. The list `all3PStrategies` is already non empty. I am trying to get/return a random one, since the input of `rotatingStrategy` failed to meet the specification, however, a result of type `Strategy3p` still must occur/return, and I can't/don't want to define which one explicitly. – chris Frisina Sep 17 '14 at 14:43
  • I think your description of what `rotatingStrategy` should do is fishy. Can you give the type of that function? It looks like it takes two lists and some integer, so a strategy is a list? Otherwise, how can it take two strategies? Furthermore, you wrote that for `n /= 0`, the function should "apply" (?) each given strategy `n` times. For `n == 0`, the function should ignore the given strategies but pick a random one and then apply that... how often? – Frerich Raabe Sep 30 '14 at 13:50
  • `rotatingStrategy :: Strategy3P -> Strategy3P -> Int -> History -> History -> History -> Choice`. I dont say `n /= 0` I am pattern matching the inputs, `N` is the last input, and the next line is the pipe `|` to designate the first pattern. – chris Frisina Sep 30 '14 at 21:59

2 Answers2

2

If you do this: chooseRandom :: [a] -> RVar a, then you won't be able to use IO. You need to be able to include the IO monad throughout the type declaration, including the test cases.

Said more plainly, as soon as you use the IO monad, all return types must include the type of the IO monad, which is not likely to be included in the list that you want returned, unless you edit the structure of the list to accommodate items that have the IO Type included.

chris Frisina
  • 19,086
  • 22
  • 87
  • 167
Adrianne Williams
  • 56
  • 1
  • 5
1

There are several ways to implement chooseRandom. If you use a version that returns RVar Strategy3P, you will still need to sample the RVar using runRVar to get a Strategy3P that you can actually execute.

You can also solve the problem using the IO monad, which is really no different: instead of thinking of chooseRandom as a function that returns a probability distribution that we can sample as necessary, we can think of it as a function that returns a computation that we can evaluate as necessary. Depending on your perspective, this might make things more or less confusing, but at least it avoids the need to install the rvar package. One implementation of chooseRandom using IO is the pick function from this blog post:

import Random (randomRIO)

pick :: [a] -> IO a
pick xs = randomRIO (0, (length xs - 1)) >>= return . (xs !!)

This code is arguably buggy: it crashes at runtime when you give it the empty list. If you're worried about that, you can detect the error at compile time by wrapping the result in Maybe, but if you know that your strategy list will never be empty (for example, because it's hard-coded) then it's probably not worth bothering.

It probably follows that it's not worth testing either, but there are a number of solutions to the fundamental problem, which is how to test monadic functions. In other words, given a monadic value m a, how can we interrogate it in our testing framework (ideally by reusing functions that work on the raw value a)? This is a complex problem addressed in the QuickCheck library and associated research paper, Testing Monadic Code with QuickCheck).

However, it doesn't look like it would be easy to integrate QuickCheck with doctest, and the problem is really too simple to justify investing in a whole new testing framework! Given that you just need some quick-and-dirty testing code (that won't actually be part of your application), it's probably OK to use unsafePerformIO here, even though many Haskellers would consider it a code smell:

{-|
>>> let xs = ["cat", "dog", "fish"]
>>> elem (unsafePerformIO $ pick xs) xs
True
-}
pick :: [a] -> IO a

Just make sure you understand why using unsafePerformIO is "unsafe" (it's non-deterministic in general), and why it doesn't really matter for this case in particular (because failure of the standard RNG isn't really a big enough risk, for this application, to justify the extra work we'd require to capture it in the type system).

sjy
  • 2,702
  • 1
  • 21
  • 22