Implementación de zipE :: Evento t a -> Evento t b -> Evento t (a, b)

Question

Soy nuevo en banana reactiva y FRP en general, así que me disculpo si me falta algo obvio.

Para my project (a GDB/MI front-end) Estoy usando reactive banana (versión 0.6.0.0) tanto para la interfaz gráfica de usuario como para los módulos lógicos frontales. El primero funciona muy bien, pero para este último aparentemente necesito otros combinadores.

Uno de ellos es zipE :: Event t a -> Event t b -> Event t (a, b). Por desgracia, todo lo que podía llegar a es una solución en la mónada NetworkDescription que utiliza changes y no es genérica en los tipos de eventos:

zipE :: Event t Int -> Event t String -> NetworkDescription t (Event t (Int, String)) 
zipE ea eb = changes $ (,) <$> stepper 0 ea <*> stepper "" eb 

Por supuesto, no estoy satisfecho con esto. Por lo tanto, quería preguntar cómo implementar una función zipE genérica sin usar changes (que se desaconseja su uso para fines no relacionados con la GUI).

Otros intentos han fallado, p.

zipE :: Num a => Event t a -> Event t b -> Event t (a,b) 
zipE ea eb = apply (stepper (0,) ((,) <$> ea)) eb 

resultados en los primeros elementos de las tuplas se cambiaron por uno - supongo que debido a la "ligero retraso" introducido por stepper. Pero no veo cómo obtener un comportamiento de un evento sin stepper (o accumB para el caso) y no veo cómo aplicar una función a un evento sin un comportamiento. Y, en general, no veo cómo proporcionar un valor inicial a Stepper en el caso de un tipo genérico.

Answer 1

Tiene dificultades para definir zipE porque no tiene sentido semántico. Si se tiene en cuenta las definiciones semánticas

Event a == [(Time, a)] 
Event b == [(Time, b)] 

no hay una forma natural de la cremallera, porque, en general, cada evento será en un momento diferente.

Es posible comprimirlos utilizando una suma en lugar de un producto.

zipE :: Event a -> Event b -> Event (Either a b) 
zipE aE bE = (Left <$> aE) `mappend` (Right <$> bE) 

Si realmente necesita tener tanto a y b al mismo tiempo, la solución apropiada es crear un Behavior que se acumula con el uno o el otro, o la fusionado Either corriente que el anterior.

editar: un ejemplo de una forma de acumularse sobre la secuencia combinada (no comprobada). Otras implementaciones también son posibles. Esto no hace que ambos eventos ocurran al mismo tiempo, sino que le permite combinar el estado actual con los estados pasados ​​para que siempre tenga los últimos disponibles tanto de Left como de Right.

currentAandB :: a -> b -> Event a -> Event b -> Event (a,b) 
currentAandB a0 b0 aE bE = accumE (a0,b0) (mergefn <$> zipE aE bE) 
    where 
     mergefn (Left a) (_,b) = (a,b) 
     mergefn (Right b) (a,_) = (a,b) 

Todavía es necesario proporcionar valores iniciales para ambas corrientes Event. Piénselo de esta manera: si solo ha tenido eventos de Event a, ¿qué valor debería tener la segunda parte de la tupla?