Cette fois, j'écrirai sur la programmation fonctionnelle dans une perspective orientée objet.
Il y a beaucoup de controverse à ce sujet, mais je trouve exact de deviner la traduction de «objet» pour les objets.
Cela signifie que l'objet lui-même est également une valeur. Un exemple simple est présenté ci-dessous en ** Java **.
public class Foo {
private int value;
Foo (v) {
this.value = v;
}
public add_foo (v) {
this.value += v;
}
}
public class Test_Foo {
public static void main (String[] args) {
Foo foo = new Foo(5);
}
}
Foo foo = new Foo(5); Pour expliquer un petit rond-point, Le type de la variable foo est Foo et une instance de Foo est assignée à foo. Ce sera.
Pour être précis, il doit s'agir d'un pointeur et stocke l'instance au point.
Peut-être que je le fais bien en Java. Un exemple est lorsque vous utilisez une chaîne de caractères, La fonction renvoie le résultat directement, mais n'est-il pas possible de gérer les chaînes de manière pratique?
Le sujet est le suivant. Ajoutons une méthode à la valeur 3. Comment puis-je le faire? En Java, héritez de la classe écrite comme suit et ajoutez des méthodes, L'idée est d'utiliser la méthode ajoutée,
public class IFT {
private int v;
IFT (int v) {
this.v = v;
}
public int value () {
return v;
}
}
Avec javascript, vous pouvez écrire comme ça.
class MonoInt {
constructor (v) {
this.v = v;
}
static of (v) {
return new MonoInt(v);
}
get join () {
return this.v;
}
map (f) {
return MonoInt.of(f(this.v));
}
bind (f) {
return this.map(f).join;
}
}
MonoInt.of(3).map(v => v + 3).join; // 6
MonoInt.of(5).bind(v => Monoint.of(v * 8)).join; // 40
Une fonction de flèche, λ (lambda), qui peut être utilisée à partir de Java8, etc. est sortie. À ce stade, MonoInt prend une seule valeur et écrit le code à la condition qu'il ne fasse référence à aucune valeur de l'extérieur et ne l'ajoute pas.
Un objet a une ** valeur ** appelée propriété et est un concept d'implémentation d'une ** transformation naturelle ** appelée méthode. Et si l'objet lui-même est également une valeur, si vous modifiez le code ci-dessus comme suit ...
class Foo {
constructor (v) {
this.value = v;
this.key = "foo";
}
get oo () {
return this.v;
}
set oo (v) {
this.v = v;
}
resetKey (v) {
this.key = "foo" + v;
}
}
class Fix {
constructor (v) {
this.v = v;
}
static of (v) {
return new Fix(v);
}
get join () {
return this.v;
}
map (f) {
return Fix.of(f(this.v));
}
bind (f) {
return this.map(f).join;
}
re (f) {
this.map(f);
return this;
}
assign (o) {
return this.re(v => Object.assign(v, o));
}
}
Fix.of(new Foo(5)).map(foo => foo.oo).map(v => v + 3).join
// 8
Fix.of(new Foo(5)).re(foo => foo.oo += 3).assign(["bar", "baz"])).join
/*
Foo {
"0": "bar",
"1": "baz",
value: 8,
key: "foo"
}
*/
Une fonction qui gère l'objet en masse même lorsque la méthode de l'objet ne renvoie rien J'ai pu mettre en œuvre ** re **. Cela nous permet d'implémenter ** assign **, qui peut déléguer Object.assign.
Si vous ajoutez une méthode qui utilise re, map et bind en interne à l'aide du corps Fix ou d'une classe qui hérite de Fix, vous pouvez exécuter la méthode comme si l'objet l'avait à l'origine. ..
À ce stade, le corps d'objet affecté n'a pas besoin d'avoir cette méthode.
Pour être précis, il semble que les monades qui peuvent effectuer endo (redo) soient dites des monades supplémentaires. C'est pratique, j'aimerais donc l'intégrer de plus en plus.
Si vous avez des corrections ou des suggestions, nous vous répondrons sincèrement. Merci de rester avec nous jusqu'à la fin.
Recommended Posts