6

I find a lot of things I jigger together on my own that seem at all useful actually have a standard implementation that I just didn't know about, so was curious if anybody could say they've seen this type of thing used before:

It takes a monadic function and will fold it until a predicate is chosen by alternative then it returns the result of the predicate:

until :: (Monad m, Alternative m) => (a -> m a) -> (a -> m c) -> a -> m c
f `until` p = \a -> (f >=> (p `altF` (until f p))) a
  where f1 `altF` f2 = \a -> f1 a <|> f2 a

I realize the name is a prelude collision, I'll probably name it something else but thought I'd first see if there's already a similar piece of functionality in a standard library I just don't know about..

Also I guess I'm curious if the compositional alternative I wrote is defined elsewhere or if any of this bit of functionality seems misguided to begin with. But the crux of my question is, is this implemented elsewhere or is something very similar implemented elsewhere perhaps

duplode
  • 33,731
  • 7
  • 79
  • 150
Jimmy Hoffa
  • 5,909
  • 30
  • 53
  • You might want to use `MonadPlus` rather than the combined `Monad` and `Alternative` constraints. – Tom Crockett Mar 06 '13 at 05:10
  • @pelotom You can define Alternative in terms of MonadPlus? I was unaware, I just took my signature straight from GHCi – Jimmy Hoffa Mar 06 '13 at 05:19
  • 1
    They define different APIs but perform similar roles... `Alternative`:`Applicative`::`MonadPlus`:`Monad`. – Tom Crockett Mar 06 '13 at 05:47
  • Does it work as you want it to? From the name I'd expect that `p` is a predicate - but it doesn't produce a Bool instead it produces the final answer. Looking at the implementation, I'd have to work out on paper when `p` actually fires and produces an answer - this worries me somewhat as I do like combinators to be intuitive if possible. If I wrote it myself I'd want a separate predicate to test for stopping and a "flusher" to produce the final value. – stephen tetley Mar 06 '13 at 18:23

1 Answers1

7

There is a surprisingly large number of convenience functions that aren’t in the Prelude or standard libraries, but perhaps should be. I wouldn’t fret too much over reimplementing a few if you find them useful.

Noting that altF is equivalent to liftA2 (<|>), you might write it more like this:

till :: (Monad m, Alternative m) => (a -> m a) -> (a -> m b) -> a -> m b

-- To do f till p is to first do f; then either p, or f till p.
f `till` p = f >=> (<|>) <$> p <*> f `till` p

And noting that (Monad m, Alternative m) is much the same as MonadPlus m, you can simplify the type a bit:

till :: MonadPlus m => (a -> m a) -> (a -> m b) -> a -> m b
f `till` p = f >=> mplus <$> p <*> f `till` p

There is a similar function called untilM in Control.Monad.Loops which uses a Bool predicate, and a LoopT transformer exists for arbitrary looping in Control.Monad.Trans.Loop. But no, this particular function doesn’t seem to be famous yet.

Jon Purdy
  • 53,300
  • 8
  • 96
  • 166