什么是scalaz filterM方法？

Question

this scalaz tutorial provides an example of using the filterM method, but it does not explain it.

List(1, 2, 3) filterM { x => List(true, false) }
res19: List[List[Int]] = List(List(1, 2, 3), List(1, 2), List(1, 3), List(1), List(2, 3), List(2), List(3), List())

I see that I can pass it a boolean list of any size. what is this filterM method?

also, is there a book/tutorial of scalaz with a bit more explanations?

Answer 1

According to implementation, you need to pass the function A => F[Boolean] , such as F: Applicative . filterM goes over list, filters elements, for which predicate passed ( returned F[true] ), and in the end put this List into F .

A bit simpler example:

List(1, 2, 3).filterM[Option](_.some.map(_ % 2 == 0)) // Some(List(2))

Note, that this gives you additional degree of freedom, to not only consider true or false , but as well None . You may try it for different Applicatives to grasp the concept.

In the example you put in, the List is the Applicative as well. So that, what happens (because it is recursive, it easier to go from the end):
1) when you are at the end of the list - you just get an empty list
2) you have a list 3 :: Nil . Applying a predicate to 3 gives you List(true, false) . So, you are taking the whole List(3) and the tail List() .
3) next comes 2 . 2 -> true :: false which maps to head :: head :: tail which is List(2) :: List(2, 3) . Appending it to what you had before, you are getting List(List(2, 3), List(2), List(3), List())
4) now comes the last step, where you get one. The same way you prepend 1 to each of the list for the true and take the rest for the false .

List(List(1, 2, 3), List(1, 2), List(1, 3), List(1), List(2, 3), List(2), List(3), List())

I added some logging, to make clear what happens:

current list: List(1, 2, 3)
current list: List(2, 3)
current list: List(3)
current list: List()
filtered value: List(List())
taking head and tail :   List(3)
taking tail: List()
filtered value: List(List(3), List())
taking head and tail :   List(2, 3)
taking head and tail :   List(2)
taking tail: List(3)
taking tail: List()
filtered value: List(List(2, 3), List(2), List(3), List())
taking head and tail :   List(1, 2, 3)
taking head and tail :   List(1, 2)
taking head and tail :   List(1, 3)
taking head and tail :   List(1)
taking tail: List(2, 3)
taking tail: List(2)
taking tail: List(3)
taking tail: List()
List(List(1, 2, 3), List(1, 2), List(1, 3), List(1), List(2, 3), List(2), List(3), List())

Answer 2

I'm not entirely sure whats going on but the result is just a truth table. It seems like filterM just combines two applicatives , one of which is an applicative of Boolean so basically the result is an applicative for every combination that results in true .

1,2,3   (true, true ,true)
1,2     (true, true, false)
2,3     (false, true, true)
1,3     (true, false, true)
1       (true, false, false)
2       (false, true, false)
3       (false, false, true)
()      (false, false, false)

Answer 3

This is a pretty old question. I'll just answer just in case anyone else was wondering.

You can find a pretty good explanation from Learn You a Haskell for Good! . Search for filterM in the link I referenced.

In the book, it says the following (you can kind of make out the haskell syntax):

The filter function is pretty much the bread of Haskell programming (map being the butter). It takes a predicate and a list to filter out and then returns a new list where only the elements that satisfy the predicate are kept. Its type is this:

filter :: (a -> Bool) -> [a] -> [a]

The predicate takes an element of the list and returns a Bool value. Now, what if the Bool value that it returned was actually a monadic value? Whoa! That is, what if it came with a context? Could that work? For instance, what if every True or a False value that the predicate produced also had an accompanying monoid value, like ["Accepted the number 5"] or ["3 is too small"]? That sounds like it could work. If that were the case, we'd expect the resulting list to also come with a log of all the log values that were produced along the way. So if the Bool that the predicate returned came with a context, we'd expect the final resulting list to have some context attached as well, otherwise the context that each Bool came with would be lost.

filterM :: (Monad m) => (a -> m Bool) -> [a] -> m [a]

The predicate returns a monadic value whose result is a Bool, but because it's a monadic value, its context can be anything from a possible failure to non-determinism and more! To ensure that the context is reflected in the final result, the result is also a monadic value.

As for a good book for reference, I would read the following Scalaz for a brief tutorial: Learning Scalaz . If you need further in depth explanation, I would go back to the learn you a haskell book.

Still doesn't make sense for me what filterM does in the Scalaz example. From the explanation in the Haskell book it makes complete sense.

Edit: clarified what didn't make sense.