Lang comparison

Lang comparison.kt

ECMA Script 6:

const applier = (rules, reactions) => {
	const apply = (state, events) => {
		return R.reduce((state, event) => {
			const reaction = reactions(state, event);
			const next = rules(state, event);

			return apply(next, reaction);
		}, state, events);
	};

	return apply;
};

===============

Java:

public class SignalApplier<T, S> implements BiFunction<State<T, S>, Stream<S>, State<T, S>> {

	private final BiFunction<T, S, T> applier;
	private final BiFunction<T, S, Stream<S>> reactor;

	public SignalApplier(BiFunction<T, S, T> applier, BiFunction<T, S, Stream<S>> reactor) {
		this.applier = applier;
		this.reactor = reactor;
	}

	@Override
	public State<T, S> apply(State<T, S> initialState, Stream<S> signals) {
		return signals.reduce(initialState, (currentState, signal) -> {
			Stream<S> reaction = reactor.apply(currentState.getData(), signal);
			State<T, S> nextState = currentState.affectedWith(applier.apply(currentState.getData(), signal), signal);

			return apply(nextState, reaction);
		}, (oldState, newState) -> newState);
	}

}

===============

Haskell:

apply :: (state -> signal -> state) -> (state -> signal -> [signal]) -> state -> [signal] -> state
apply _ _ inititialState [] = inititialState
apply applier reactor inititialState signals = foldl (\ state signal -> apply applier reactor (applier state signal) (reactor state signal)) inititialState signals

===============

Rust (not sure if it works):

fn apply<T, S, A, R> (applier: A, reactor: R, initial_state: T, signals: Vec<S>) -> T where
	A: Fn(&T, &S) -> T,
	R: Fn(&T, &S) -> Vec<S> {
	return signals
		.iter()
		.fold(initial_state, |state, signal| {
			let reaction = reactor(&state, &signal);
			let next_state = applier(&state, &signal);

			return apply(applier, reactor, next_state, reaction);
		});
}


===============