Find next true in a list in Haskell

Question

I have to find a function g : [Bool] -> Integer such that g gives lowest ubication where True is in a list of booleans. For example,

g [False , False , False , False , True , False , True] ==> 5
g [False , True , True , False , False] ==> 2
g [] ==> ***Exception: empty list
g [False , False] ==> ***Exception: There is no True in your list

I am not too interested in cases where the function takes [] or a list where there is no True because I am working on a program where the boolean list is infinite and it's proved that there always exist True. I think a beginning of the definition of the following:

g :: [Bool] -> Integer
g xs | xs == [] = error "empty list"
     | not (and xs) = error "There is no True in your list"
     | otherwise = ...

Can you help me to find ..., please? Thank you very much.

Your second guard look wrong to me, if I understand your requirements properly. Moreover, I don't think you can rule out this case from the start, your function has to just run forever anyway. — Jean-Baptiste Potonnier, Feb 02 '17 at 19:19

Willem Van Onsem · Accepted Answer · 2017-02-02T19:34:10.693

5

Probably the easiest way to do this is using findIndex :: (a -> Bool) -> [a] -> Maybe Int:

import Data.List(findIndex)
import Data.Maybe(fromJust)

g = fromJust . findIndex id

Here you thus use id as "predicate" such that True is accepted and False fails the test. Since in your question you state you know such element always exists, you can use fromJust to "chomp of the Just" so to speak.

In your examples you seem to use "1-indexed" lists, in that case you can define:

-- 1-indexed
import Data.List(findIndex)
import Data.Maybe(fromJust)

g = (1+) . fromJust . findIndex id

In ghci:

Prelude Data.Maybe Data.List> let g = (1+) . fromJust . findIndex id
Prelude Data.Maybe Data.List> g [False , False , False , False , True , False , True]
5
Prelude Data.Maybe Data.List> g [False , True , True , False , False]
2
Prelude Data.Maybe Data.List> g []
*** Exception: Maybe.fromJust: Nothing
Prelude Data.Maybe Data.List> g [False,False]
*** Exception: Maybe.fromJust: Nothing

A final note: it should be:

     | not (or xs) = error "There is no True in your list"

and not

     | not (and xs) = error "There is no True in your list"

since and is only True if all elements are True.

edited Feb 02 '17 at 19:34

answered Feb 02 '17 at 19:11

Willem Van Onsem

443,496
30
428
555

But haskell gives me an error when I define `g`: Not in scope `fromJust` and also with `findIndex`. – joseabp91 Feb 02 '17 at 19:30
@joseabp91: you should `import Data.List` and `import Data.Maybe`. – Willem Van Onsem Feb 02 '17 at 19:32
I have written `import Data.List` and `import Data.Maybe` but why `g` doesn't take any argument in your definition? – joseabp91 Feb 02 '17 at 19:39
1

because of *eta-reduction*. – Willem Van Onsem Feb 02 '17 at 19:42
1

@joseabp91: `f x = g (h x)` is equivalent to: `f = g . h`, – Willem Van Onsem Feb 02 '17 at 19:46
I know but my error is very strange: > Couldn't match expected type `a -> Maybe a1' > against inferred type `Maybe Int' > In the second argument of `(.)', namely `findIndex id xs' > In the expression: fromJust . findIndex id xs > In the definition of `g': > g xs = fromJust . findIndex xs – joseabp91 Feb 02 '17 at 19:47
Is there any more elementary way? – joseabp91 Feb 02 '17 at 19:49
@joseabp91: this is not strange, if you feed the argument explicitly, you either have to use brackets or `$`: `g xs = fromJust (findIndex xs)` or `g xs = fromJust $ findIndex xs`. – Willem Van Onsem Feb 02 '17 at 19:49
@joseabp91: actually using the dots is in my opinion a more elementary way. – Willem Van Onsem Feb 02 '17 at 19:50
My program still does not work. I'll keep trying, thank you very much – joseabp91 Feb 02 '17 at 19:54
@joseabp91: in case you want 1-indexed results, the answer is `g xs = (1+) $ fromJust $ findIndex id xs`. Sorry I forgot (well you forgot) the `id`. – Willem Van Onsem Feb 02 '17 at 21:18
I asked this by this questio I have created: http://stackoverflow.com/questions/42013519/luhn-algorithm-in-haskell – joseabp91 Feb 02 '17 at 23:07

score 3 · Answer 2 · answered Feb 02 '17 at 19:22

3

another approach, without error handling

> fst . head . filter snd . zip [1..]

answered Feb 02 '17 at 19:22

karakfa

66,216
7
41
56

score 2 · Answer 3 · answered Feb 02 '17 at 20:59

2

I'd think that

(1+) . length . takeWhile not

should do that. You can leave out the (1+) if you go for 0 based indexes, that is, indexes that would work with (!!)

answered Feb 02 '17 at 20:59

Ingo

36,037
5
53
100

Find next true in a list in Haskell

3 Answers3