[Haskell-cafe] Do you recognize this type?
david.sorokin at gmail.com
Fri Jun 20 17:13:59 UTC 2014
If I undestand your idea, then it is possible to do with help of continuations wrapped in a monad computation, at least with help of two continuations: (1) the main branch of computation; (2) the immediate cancellation if the result is already known.
The approach is implemented in the F# async workflow (so called the asynchronous computation) and .. in my simulation library Aivika (to model the discontinuous process). Both are monads. Only like the F# developers, I use a plain cancellation without returning the meaningful result, but nothing prevents from returning some data. Also like F# my library supports the third continuation for handling exceptions, namely the IO exceptions in terms of Haskell.
So, the keywords are: canceling the F# asynchronous computation.
20 июня 2014 г., в 16:59, Corentin Dupont <corentin.dupont at gmail.com> написал(а):
> Nobody on that?
> What I really want is: a computation that can be interrupted if enough result is already there.
> I would be surprise if that concept doesn't exist already somewhere :)
> On Thu, Jun 19, 2014 at 5:17 PM, Corentin Dupont <corentin.dupont at gmail.com> wrote:
> Hi guys,
> I am making a DSL for event composition (inspired from digestive-functor & reactive-banana) and I find myself wanting a primitive like that:
> -- given a list of events, evaluate the function on those that have already fired.
> -- returns an event yelding the result when ready.
> ListEvent :: [Event a] -> ([a] -> Maybe b) -> Event b
> Does this type tell you something? Is there a better abstraction that can encompass it?
> My DSL is like that:
> -- | Composable events
> data Event a where
> SumEvent :: Event a -> Event a -> Event a -- The first event to fire will be returned
> AppEvent :: Event (a -> b) -> Event a -> Event b -- Both events should fire, and then the result is returned
> PureEvent :: a -> Event a -- Create a fake event. The result is useable with no delay.
> EmptyEvent :: Event a -- An event that is never fired.
> BaseEvent :: (Typeable a) => Field a -> Event a -- Embed a base event
> It's easy to define instances for Applicative and Alternative.
> But then I have a use case that I cannot solve:
> In the case of votations (which use this DSL), sometime you can end prematuraly the voting, even if not everybody voted yet: for example if the majority is already reached.
> In this case no need to wait for everybody, we can end the vote.
> This does not seem to be possible with Applicative or Monad interfaces: things have to be sequenced in a monad, they cannot be evaluated in parralel.
> For example:
> v1 <- getVote1
> v2 <- getVote2
> v3 <- getVote3
> evalMajority(v1, v2, v3)
> In this example I have to wait for all 3 votes to be completed, but in fact only two would suffice to achieve majority.
> That's why I added "ListEvent" to the DSL above which allow to achieve that but I'm wondering if there is a better/bigger abstraction to put it in.
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the Haskell-Cafe