Added additional definitions from Yampa to BearRiver as discussed in …

[thalerjonathan]

…in #40: never, now, once and >--

[ivanperez-keera]

never = constant NoEvent

In general it's best not to use internal constructors if possible.

Using the API, as opposed to the internal constructors, facilitates changing the library internally without affecting uses/users. This is part of the reason for an API in the first place.

While this often creates some (small) performance loss, it's worth it when libraries grow big, since you can change the internals quickly. For example, if you choose to use GADTs to improve performance, and implement constant using that optimisation, you'll only get a gain if you stuck to the API. For another example, if you choose to add another field or change the order of the elements in the tuple, you won't have to change everything.

[thalerjonathan]

Yes, I understand.
Saw that you use the internal MSF constructor a couple of times and assumed it is OK in such cases. But of course when a function can be implemented using the existing API then it should always go that way - but sometimes it is not clear for me to see that but thanks for the help.

[ivanperez-keera]

This could be factorized:

replaceOnce :: a -> MSF a a
replaceOnce x = MSF $ \_ -> return (x, id)

(-->) :: Monad m => b -> SF m a b -> SF m a b 
b0 --> sf = sf >>> replaceOnce b0

(>--) :: Monad m => a -> SF m a b -> SF m a b 
a0 >-- sf = replaceOnce a0 >>> sf

The question is: can one write replaceOnce without using unMSF? It's possible, using switching :)

EDIT: the implementation of replaceOnce was incorrect. I've fixed it.

[ivanperez-keera]

@turion You've implemented a new exception-handling mechanism. What's the current way of writing \x -> dSwitch (constant (x, Event)) (\_ -> id) using that API?

[thalerjonathan]

Awesome :)
Shouldn't replaceOnce look like:

replaceOnce :: Monad m => a -> MSF m a a
replaceOnce x = MSF $ \_ -> return (x, arr id)

[thalerjonathan]

And here without using the internal MSF constructor:

replaceOnce :: Monad m => a -> SF m a a
replaceOnce a = dSwitch (arr $ const (a, Event ())) (const $ arr id)

[ivanperez-keera]

replaceOnce :: Monad m => a -> SF m a a
replaceOnce a = dSwitch (constant (a, Event ())) (const $ arr id)

?

[thalerjonathan]

Yeah obviously ;)