Unterstützt Dart funktionale Programmierung?

Question

Ermöglicht die Google Dart-Sprache eine funktionale Programmierung? Werden insbesondere die folgenden Funktionen unterstützt?

• Funktionen als Variablen gespeichert (Referenzen),
• funktionelle currying,
• lazy Parameter

Weitere Merkmale der funktionalen Programmierung?

Es sieht aus wie Dart nicht unveränderliche Daten unterstützt.

Answer 1

Dart verfügt über erstklassige Funktionen und unterstützt viele funktionale Programmierkonstrukte. Hier sind einige Beispiele von Funktionen auf Variablen und eine curried Funktion zuweisen:

main() { 
    f1(x) => x * 2;   // Define the function f1 
    var f2 = f1;   // Assign f1 to the variable f2 
    print(f2(7));   // Feel free to call f2 like any other function 

    add(a) => (b) => a + b; // Curried addition 
    print(add(3)(4));  // Calling curried addition 

    var add3 = add(3);  // Combining the 
    print(add3(2));   // concepts 
} 

Wie erwartet, dies erzeugt:

 
14 
7 
5 

Ich glaube nicht, faul Parameter möglich sind und Sie bereits festgestellt, dass es gibt eindeutig veränderbare Daten.

Answer 2

Hängt davon ab, was Sie unter "funktionale Programmierung" verstehen. Funktionen sind erstklassige Objekte, die Punkt 1 umfasst, gibt es Function.apply, die Sie selbst currying implementieren können, so dass Punkt 2 umfasst, aber anders als das ist Dart nicht sehr funktional (Unveränderlichkeit - nein, referentielle Transparenz - nein , faule Auswertung - nein, was hast du sonst - wahrscheinlich auch nicht.

Answer 3

Ein Paket, das https://code.google.com/p/dart/issues/detail?id=29

Answer 4

Kleines Beispiel über Unveränderlichkeit Erfahrung Dart FP weiter https://github.com/vsavkin/fpdart

Eine offene Frage über Endrekursion verbessert: mit der

class Point { 
    Point(this.x, this.y); 
    int x,y; 
    int get sum => x + y; 
} 
class ImmutablePoint{ 
    final int x,y, sum; 
    const ImmutablePoint(x,y) : 
    this.x = x,this.y = y,this.sum = x + y; 
} 

class SemiImmutablePoint { 
    int _x, _y; // _ -like private but not access protected by the VM. 
    SemiImmutablePoint(this._x, this._y); 
    int get x => _x; 
    int get y => _y; 
} 

void main() { 
    List<int> li = [1,2,3,4,5]; 
    final List<int> immutableLi = const [1,2,3,4,5]; 
    li[1] = 10; //ok 
    li = [6,7,8]; //ok 
    immutableLi[1] = 10; //error because const 
    immutableLi = [6,7,8]; //error because final 
    var p = new Point(5,10); 
    p.x = 10; //ok 
    p.sum = 10; // error can't be directly mutated 
    var p2 = const ImmutablePoint(5,10); // compile-time constant 
    p2.x = 10; //error 
} 

Sie können FP verwenden Dart oder sogar Sprachen ohne Typen oder Unveränderlichkeit wie JS. Es ist nur ein Stil, es erfordert keine native Implementierung in der Sprache.

Mit den Sprachen wie Scala werden FP-Paradigmen normalerweise mit dem Typsystem implementiert, so dass es restriktiver und schwerer ist unbeabsichtigt zu brechen. Aber zur gleichen Zeit verlangen Sie vom lib Benutzer spezielles Wissen von wirklich komplexem Typsystem, manchmal Kategorientheorie - andernfalls ist es wirklich schwer davon zu profitieren zu wissen, dass dieses Ding "Monade" oder "Monoid" oder was auch immer ist. Ich kann Listen verwenden, ohne zu wissen, dass das Monaden oder wirklich nützliches Konzept von "Zukunft" in Dart sind. Wenn Sie FP ohne "type magic" implementieren, ist es oft klarer und zugänglicher für einen durchschnittlichen Entwickler. Aber zur gleichen Zeit mit leistungsfähigen Typ System kann Compiler führen erweiterte Code-Optimierungen und ermöglichen bessere statische Code-Analyse.

Category theory for JavaScript programmers - Sehenswert.

hinzugefügt: Jetzt haben Sammlungen UnmodifiableListViewUnmodifiableMapBaseUnmodifiableMapView

Answer 5

Um Ihren letzten Punkt, Unveränderlichkeit, siehe:

• https://github.com/google/built_collection.dart
• https://github.com/google/built_value.dart

die l liefern Unterstützung von Bibliotheken und Codegen für unveränderbare Sammlungen und "Werttypen". Diese helfen, die Lücke zwischen OO und der funktionalen Programmierung, zum Beispiel ermöglicht inline „Updates“ auf unveränderliche Werte:

var node = new Node((b) => b 
    ..left.left.left.right.left.right.label = 'I’m a leaf!' 
    ..left.left.right.right.label = 'I’m also a leaf!'); 
var updatedNode = node.rebuild((b) => b 
    ..left.left.right.right.label = 'I’m not a leaf any more!' 
    ..left.left.right.right.right.label = 'I’m the leaf now!'); 

Wo „Knoten“ und „updatedNode“ sind beide unveränderlich. Mehr Details in diesem Artikel: built_value for Immutable Object Models.