Functional Reactive Programming en Java

**CyaNnOrangehead** · 09/10/2013, 00h28

Rien que ça !!!!

Après mon petit article sur le pattern Foncteur en java (ICI) il y a une idée qui me trotte dans la tête depuis quelques jours.
Le functional reactive programming, comment ça marche ? Et surtout, cela peu-t-il fonctionner en Java ?

Du coup, je me suis décidé à lancer mon petit IDE préféré et zou, j'ai tenté l'aventure. J'ai écrit ma petite librairie et voici comment l'utiliser :

Voici un exemple qui fait la chose suivante : Une évènement sur le mouvement et le click de la souris mais qui ce déclenchent que toutes les 250 milli secondes. Je veux également que cet évènement prenne fin au bout de 2 secondes. (rien que l'énoncé, avec les évènements traditionnels, ça fait pâlir).

Voici concrètement ce que cela donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
final React myReact = new MouseReact()
	.move()
	.merge(new MouseReact().click())
	.filter(new Function<Boolean, Arguments1<React>>() {
 
		@Override
		public Boolean invoke(Arguments1<React> arguments) {
			React r = arguments.getArgument1();
			return (r.getTimeElapsed() > 250L);
		}
	})
	.onReact(new Procedure<Arguments1<React>>() {
 
		@Override
		public void invoke(Arguments1<React> arguments) {
			MouseReact r = (MouseReact) arguments.getArgument1();
			log("REACT move & click every 250 milli ! " + r.count() + " " + r.getTimeElapsedFromStart());
		}
	});
 
new React().once(2000L).onReact(new Procedure<Arguments1<React>>() {
 
	@Override
	public void invoke(Arguments1<React> arguments) {
                log("REACT until 2 seconds ");
		myReact.dispose();
	}
});

Voilà comment utiliser la dite librairie. Pas mal non ?
Il faut voir cela comme un map/filter/reduce, mais appliqué aux évènements et aux threads (ce qu'il y a dans la librairie en réalité), le tout architecturé sur des monades (encore un truc issu du fonctionnel).

Maintenant, j'aimerai vos avis sur la chose, vos idées.
Je suis en train de me demander si je ne ferai pas un article sur la FRP en java dans la même veine que sur les foncteurs....

Voilà, toute idée est la bienvenue.

**adiGuba** · 09/10/2013, 09h01

Salut,

J'ai survolé l'article vite fait et cela a l'air très complet

J'essayerais de prendre le temps de m'y attarder un peu plus

Au passage ce type d'API vont sûrement fleurir avec Java 8 et les lambdas, qui permettront d'éviter toutes les lourdeurs des classes anonymes.

Le bout de code que tu donnes pourra s'utiliser comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
final React myReact = new MouseReact()
	.move()
	.merge(new MouseReact().click())
	.filter( (arguments) -> arguments.getArgument1().getTimeElapsed() > 250L )
	.onReact( (arguments) -> {
		MouseReact r = (MouseReact) arguments.getArgument1();
		log("REACT move & click every 250 milli ! " + r.count() + " " + r.getTimeElapsedFromStart());
	});
 
 
new React().once(2000L).onReact( (arguments) -> {
	log("REACT until 2 seconds ");
	myReact.dispose();
});

De plus l'API standard adoptera un "map-filter-reduce" via l'API des Streams

a++

**tchize_** · 09/10/2013, 10h31

Envoyé par adiGuba

Le bout de code que tu donnes pourra s'utiliser comme ceci :

Ha? Moi je verrais plutôt ceci dans la logique des lambdas:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
final React myReact = new MouseReact()
	.move()
	.merge(new MouseReact().click())
	.filter( (it) -> it.getTimeElapsed() > 250L )
	.onReact( (r) -> {
		log("REACT move & click every 250 milli ! " + r.count() + " " + r.getTimeElapsedFromStart());
	});
 
 
new React().once(2000L).onReact(it -> {
	log("REACT until 2 seconds ");
	myReact.dispose();
});

Ben oui, sa classse "Arguments" devient inutile ^^

**adiGuba** · 09/10/2013, 12h23

Envoyé par tchize_

Ha? Moi je verrais plutôt ceci dans la logique des lambdas:

Ben oui, sa classse "Arguments" devient inutile ^^

Le code que je donnais devrait fonctionner sans modification dans le code de son API

(c'est aussi une force des lambdas de pouvoir s'adapter aux codes existants)

@CyaNnOrangehead : Je n'ai pas trouvé le code de ta classe React, mais je suppose qu'il faut la paramétrer (un peu comme pour l'API Stream de Java 8 justement).

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
interface Predicate<T> {
	public boolean accept(T value);
}
 
interface Function<T> {
	public void invoke(T value);
}
 
class React<T> {
 
	public React<T> filter(Predicate<T> predicate) {
		...
	}
 
	public void onReact(Function<T> function) {
		...
	}
 
}

Et fait de chaque implémentation une version spécifique (MouseReact sera un React<MouseEvent> par exemple)

a++

a++

**CyaNnOrangehead** · 09/10/2013, 14h18

Envoyé par adiGuba

Et fait de chaque implémentation une version spécifique (MouseReact sera un React<MouseEvent> par exemple)

Oui je pensais faire un truc dans ce genre.
J'ai un peu regardé hier soir, mais je n'ai pas eu le temps de tout faire, ce n'est qu'un premier jet écrit en 2h ! Pour ça que je n'ai pas fournis les sources de la librairie pour le moment qui ne ressemblent à rien ^_^.

Je regarde en fin de semaine pour refactorer un peu tout ça et résoudre ce problème de type.
Je pense passer par une classe abstraite React et des classes concrètes ReactTime, ReactMouse etc....
Un template method devrait me permettre de faire de la factory par type (pour le chaînage)....

**CyaNnOrangehead** · 10/10/2013, 00h14

Bon voilà après un petit refactoring de la chose, ce que ça donne :

L'utilisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
final React react = TimeReact.tick(500L).<TimeReact>filter(new Predicate1<TimeReact>() {
 
	@Override
	public boolean invoke(TimeReact react) {
		if (react.getIteration() % 3 == 0) {
			return true;
		} else {
			return false;
		}
	}
}).combine(TimeReact.tick(250L)).onReact(new Procedure1<TimeReact>() {
 
	@Override
	public void invoke(TimeReact react) {
		System.out.println("TICK ! " + react.getTimeFromStart());
	}
}).onPause(new Procedure1() {
 
	@Override
	public void invoke(Object arg1) {
		System.out.println("PAUSED !");
	}
}).onResume(new Procedure1() {
 
	@Override
	public void invoke(Object arg1) {
		System.out.println("RESUME !");
	}
}).onDispose(new Procedure1() {
 
	@Override
	public void invoke(Object arg1) {
		System.out.println("DISPOSE !");
	}
});
 
TimeReact.once(3200L).onReact(new Procedure1<TimeReact>() {
 
	@Override
	public void invoke(TimeReact arg1) {
		react.pause();
	}
});
 
TimeReact.once(5000L).onReact(new Procedure1<TimeReact>() {
 
	@Override
	public void invoke(TimeReact arg1) {
		react.resume();
	}
});
 
TimeReact.once(7500L).onReact(new Procedure1<TimeReact>() {
 
	@Override
	public void invoke(TimeReact arg1) {
		react.dispose();
	}
});

L'interface React (avec des génériques c'est mieux) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
public interface React<R extends React> {
 
	int getIteration();
 
	long getTimeFromStart();
 
	long getTimeFromLast();
 
	void fireOnReact();
 
	/**
        Call function automatically in case of event occured
        @param function function to call by react
        @return returm this
         */
	React onReact(Procedure1<R> function);
	React onPause(Procedure1<R> function);
	React onResume(Procedure1<R> function);
	React onDispose(Procedure1<R> function);
 
	/**
        Merge reactor with another one and couple the events between
        @param <R2> the second react type
        @param react the second react
        @return return this
         */
	 <R2 extends React> R combine(final R2 react);
 
	/**
        Filter events according predicate criteria.
        @param predicate return true if event should be active, else not
        @return return this
         */
	 <R0 extends React> React filter(Predicate1<R0> predicate);
 
	/**
        Pause the react execution
         */
	void pause();
 
	/**
        Resume the react execution
         */
	void resume();
 
	/**
        Dispose all react and dependents ones
        Terminate all events
         */
	void dispose();
}

La classe abstraite qui mutualise pas mal de comportements :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
 
public abstract class ReactBase<R extends React> implements React<R> {
 
	// event
	private List<Procedure1<R>> onReactFunctions;
	private List<Procedure1<R>> onPauseFunctions;
	private List<Procedure1<R>> onResumeFunctions;
	private List<Procedure1<R>> onDisposeFunctions;
	// chain
	private React parent;
	private List<React> children;
	// attributes
	private int iteration = 0;
	private long startTime = System.currentTimeMillis();
	private long lastTime = System.currentTimeMillis();
 
	protected ReactBase() {
		onReactFunctions = new ArrayList<Procedure1<R>>();
		onPauseFunctions = new ArrayList<Procedure1<R>>();
		onResumeFunctions = new ArrayList<Procedure1<R>>();
		onDisposeFunctions = new ArrayList<Procedure1<R>>();
		this.parent = null;
	}
 
	protected ReactBase(React parent) {
		this();
		this.parent = parent;
	}
 
	public abstract R getInstance(React parent);
 
	private void addChild(React react) {
		if (children == null) {
			children = new ArrayList<React>();
		}
		children.add(react);
	}
 
	private void fireEvent (List<Procedure1<R>> functions) {
		for (Procedure1<R> function : functions) {
			function.invoke((R) this);
		}
	}
 
	@Override
	public void fireOnReact() {
		iteration++;
		fireEvent(onReactFunctions);
		lastTime = System.currentTimeMillis();
	}
 
	@Override
	public int getIteration() {
		return iteration;
	}
 
	@Override
	public long getTimeFromStart() {
		return System.currentTimeMillis() - startTime;
	}
 
	@Override
	public long getTimeFromLast() {
		return System.currentTimeMillis() - lastTime;
	}
 
	@Override
	public React onReact(Procedure1<R> function) {
		onReactFunctions.add(function);
		return this;
	}
 
	@Override
	public React onPause(Procedure1<R> function) {
		onPauseFunctions.add(function);
		return this;
	}
 
	@Override
	public React onResume(Procedure1<R> function) {
		onResumeFunctions.add(function);
		return this;
	}
 
	@Override
	public React onDispose(Procedure1<R> function) {
		onDisposeFunctions.add(function);
		return this;
	}
 
	@Override
	public <R2 extends React> R combine(R2 react) {
		addChild(react);
 
		react.onReact(new Procedure1<R2>() {
 
			@Override
			public void invoke(R2 arg1) {
				ReactBase.this.fireOnReact();
			}
		});
		return (R) this;
	}
 
	@Override
	public <R0 extends React> React filter(final Predicate1<R0> predicate) {
		final R react = getInstance(this);
 
		this.onReact(new Procedure1<R>() {
 
			@Override
			public void invoke(R arg1) {
 
				if (predicate.invoke((R0) ReactBase.this)) {
					react.fireOnReact();
				}
 
			}
		});
 
		return react;
	}
 
	abstract protected void applyPause();
 
	@Override
	public void pause() {
		fireEvent(onPauseFunctions);
 
		if (parent != null) {
			parent.pause();
		}
		if (children != null) {
			for (React child : children) {
				child.pause();
			}
		}
		applyPause();
	}
 
	abstract protected void applyResume();
 
	@Override
	public void resume() {
		fireEvent(onResumeFunctions);
 
		if (parent != null) {
			parent.resume();
		}
		if (children != null) {
			for (React child : children) {
				child.resume();
			}
		}
		applyResume();
	}
 
	abstract protected void applyDispose();
 
	@Override
	public void dispose() {
		fireEvent(onDisposeFunctions);
 
		if (parent != null) {
			parent.dispose();
		}
		if (children != null) {
			for (React child : children) {
				child.dispose();
			}
		}
 
		// empty lists
		if (onReactFunctions != null) {
			onReactFunctions.clear();
		}
 
		applyDispose();
	}
}

(du coup, je me demande si c'est vraiment util d'avoir une interface + une classe abstraite)

Et enfin une classe concrète (TimeReact) qui gère le temps, threads tout ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
public class TimeReact extends ReactBase<TimeReact> {
 
	private Thread thread;
 
	public TimeReact() {
	}
 
	public TimeReact(React parent) {
		super(parent);
	}
 
	@Override
	public final TimeReact getInstance(React parent) {
		return new TimeReact(parent);
	}
 
	@Override
	protected final void applyPause() {
		if (thread != null) {
			synchronized (thread) {
				thread.suspend();
			}
		}
	}
 
	@Override
	protected final void applyResume() {
		if (thread != null) {
			synchronized (thread) {
				thread.resume();
			}
		}
	}
 
	@Override
	protected void applyDispose() {
		if (thread != null) {
			thread.interrupt();
			thread = null;
		}
	}
 
	public static TimeReact tick(final long timeout) {
		final TimeReact react = new TimeReact();
 
		react.thread = new Thread() {
 
			@Override
			public void run() {
				try {
 
					while (!isInterrupted()) {
						Thread.sleep(timeout);
 
						react.fireOnReact();
					}
				} catch (InterruptedException ex) {
 
					// do nothing
				}
 
			}
		};
 
		react.thread.start();
 
		return react;
	}
 
	public static TimeReact once(final long timeout) {
		final TimeReact react = new TimeReact();
 
		react.thread = new Thread() {
 
			@Override
			public void run() {
				try {
 
					Thread.sleep(timeout);
 
					react.fireOnReact();
				} catch (InterruptedException ex) {
					// do nothing
				}
 
			}
		};
 
		react.thread.start();
 
		return react;
	}
 
}

En gros cette dernière présente des factories (tick, once etc...) d'elle même.

**CyaNnOrangehead** · 09/10/2013, 09h35

Oui tout à fait adiGuba. Vivement le jdk8.
Seulement, d'après ce que j'ai compris, il n'est pas prêt de voir le jour.

Effectivement les lambdas simplifient grandement la lecture. Je pensais aussi créer des interface spécifiques qui éviteraient cette bataille avec les arguments.

En fait ce que je suis en train d'essayer de faire, en plus de fair joujou avec java, c'est de l'implémenter dans mon langage AL (www.algoid,net)
Si je parviens à écrir une librairie correcte en java, je pourrai la porter en AL facilement.
Quand je voie ce qu'offre un tel idiom de programmation, ça me démange de l'implémenter.... lol

J'ai vu que ça existait aussi en Scala et en c#. Je vais my pencher pour m'en inspirer dés que j'ai 5mn.

**adiGuba** · 09/10/2013, 09h45

Envoyé par CyaNnOrangehead

Oui tout à fait adiGuba. Vivement le jdk8.
Seulement, d'après ce que j'ai compris, il n'est pas prêt de voir le jour.

La "developer-preview" est déjà disponible depuis quelques temps... et la version finale est prévu pour mars 2014 soit dans moins de 6 mois

a++

**thierryler** · 09/10/2013, 09h53

Ca a l'air pas mal ;-) je vais lire ça à tête reposée.

**CyaNnOrangehead** · 09/10/2013, 10h15

J'ai encore ce vilain problème de cast :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
public void invoke(Arguments1<React> arguments) {
			MouseReact r = (MouseReact) arguments.getArgument1();

J'ai un sur type React, un sous type MouseReact.
React contient une liste de React qui m'oblige à caster le type en sortie....
Je ne sais pas encore comment solutioner ce problème. (aime pas les casts)

**tchize_** · 09/10/2013, 10h34

Envoyé par CyaNnOrangehead

J'ai encore ce vilain problème de cast :

Tu ne pourra pas te passer du cast dans ce cas là, puisque Arguments se base sur des Reacts et, dans ton code, tu suppose que ce sont des MouseReact. Rien ne te le garantis du point de vue de la compilation.

Functional Reactive Programming en Java

Langage Java

Vue hybride

Discussions similaires

Partager

Partager