Q: thoughts on takeSome and takeMany

[safareli]

Recently I used List.Lazy and my expectation was that parser take 2 (many (char '0')) Will try to match character 0 maximum 2 times. But it's actually trying to match 0 until it fails. So if input to parser is 0000000 it will consume all of 0-s and result will be list of two 0-s.

To solve this issue I have implemented takeSome and takeMany for normal List:

-- | Attempt a computation `n` times, requiring at least one success.
-- |
-- | The `Lazy` constraint is used to generate the result lazily, to ensure
-- | termination.
takeSome :: forall f a. Alternative f => Lazy (f (List  a)) => Int -> f a -> f (List  a)
takeSome 0 _ = pure Nil
takeSome n v = Cons <$> v <*> defer (\_ -> takeMany (n - 1) v)

-- | Attempt a computation `n` times, returning as many successful results
-- | as possible (possibly zero).
-- |
-- | The `Lazy` constraint is used to generate the result lazily, to ensure
-- | termination.
takeMany :: forall f a. Alternative f => Lazy (f (List a)) => Int -> f a -> f (List a)
takeMany 0 _ = pure Nil
takeMany n v = takeSome n v <|> pure Nil

If Infinity was member of Int then:

some = takeSome Infinity
many = takeMany Infinity

This issue is not strictly related to Parser but i think it could be useful for parsers.
What you think if we define this functions for List/Array/....

We can have on internal definition take{Some,Many} which are taking Number (to allow use of Infinity) and define some, many, takeSome and takeMany in terms of them.

takeSome = toNumber >>> takeSome_ 
some = takeSome_ Infinity
takeMeny = toNumber >>> takeMeny_ 
meny = takeMeny_ Infinity

[safareli]

Or maybe instead of defer of the f, LazyList's Internal Lazy should be used somehow?

[paf31]

How does this relate to replicateA?

[safareli]

It's somewhat related but it has no some/many semantics. like takeMeny will try parser n times, but if at some it fails, it will return staff it has already collected.

[safareli]

takeMany n will try parser up to n times and result could possibly contain zero elements
takeSome n will try parser up to n times and result must contain at least one success

[safareli]

I think we should define takeSome and takeMany on List and Array as there is no other thing with semantics described above. the only way to fulfill the need I had, was to implement this functions as no other existing functions can help. I think it could be useful to others too

[safareli]

what you think on takeSome and takeMany ? do you want to see PR for List/Array?

[paf31]

Seems like this be implemented using many and guard.

[safareli]

Hm, If you use guard them you might need Monad instance, even if monad instance I can't think of such implementation :/

[jamesdbrock]

replicateA repeats a pattern exactly n times. Regular expressions have first-class quantifier syntax for repeating a pattern at least n or a most m times. It's a common pattern. Would be nice to have API support for this, or at least documentation which explains how to accomplish it.