Czy program Dart obsługuje funkcjonalne programowanie?

Question

Czy język Google Dart pozwala na funkcjonalne programowanie? W szczególności obsługiwane są następujące funkcje?

• funkcje przechowywane jako zmienne (referencje),
• currying funkcjonalny,
• leniwe parametry

Inne cechy funkcjonalne programowania?

Wygląda na to, że Dart nie obsługuje niezmiennych danych.

Answer 1

Dart ma pierwszorzędne funkcje i obsługuje wiele funkcjonalnych konstrukcji programistycznych. Oto niektóre przykłady przypisywania funkcji do zmiennych i funkcji z curry:

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 
} 

Zgodnie z oczekiwaniami, to produkuje:

 
14 
7 
5 

Nie wierzę leniwe parametry są możliwe, a ty już zauważyć, że istnieją wyraźnie zmienne dane.

Answer 2

Zależy od tego, co rozumiesz przez "programowanie funkcjonalne". Funkcje są pierwszorzędnymi obiektami, które obejmują punkt 1, jest Function.apply, który pozwala zaimplementować currying siebie, tak że obejmuje punkt 2, ale poza tym, Dart nie jest bardzo funkcjonalny (niezmienność - nie, referencyjna przezroczystość - nie , leniwe oceny - nie, co jeszcze masz - prawdopodobnie też nie).

Answer 3

pakiet, który poprawia Dart FP doświadczenie dalsze https://github.com/vsavkin/fpdart

kwestią otwartą o rekursji ogonowej https://code.google.com/p/dart/issues/detail?id=29

Answer 4

mały przykład o niezmienności:

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 
} 

Można wykorzystać FP z Dart, a nawet języki bez typów lub niezmienności, takie jak JS. to tylko styl, nie wymaga natywnej implementacji w języku.

W takich językach jak Scala FP paradygmaty są zwykle wdrażane w systemie typu, więc jest bardziej restrykcyjne i trudniejsze do niezamierzonego naruszenia. Ale jednocześnie potrzebujesz od użytkownika biblioteki specjalistycznej wiedzy na temat naprawdę skomplikowanego systemu, czasami teorii kategorii - w przeciwnym razie naprawdę trudno jest czerpać korzyści z tego, że jest to "monada" lub "monoid" czy cokolwiek innego. Mogę używać list nie wiedząc, że są to monady lub naprawdę użyteczna koncepcja "przyszłości" w Dart. Kiedy wdrażasz FP bez "magii typu", jest to często bardziej przejrzyste i łatwiejsze do uchwycenia przez przeciętnego programistę. Ale jednocześnie posiadający potężny system typów może pomóc kompilatorowi wykonać zaawansowane optymalizacje kodu i umożliwić lepszą analizę kodu statycznego.

Category theory for JavaScript programmers - Warto obejrzeć.

dodania: Teraz zbiory mają UnmodifiableListViewUnmodifiableMapBaseUnmodifiableMapView

Answer 5

Do ostatniego punktu, niezmienność, patrz:

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

które zapewniają l ibrary i codegen wsparcie dla niezmiennych kolekcji i "typów wartości". Są pomaga wypełnić lukę pomiędzy oo oraz programowania funkcyjnego, na przykład umożliwiając inline „nowości” do wartości niezmiennych:

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!'); 

Gdzie „węzeł” i „updatedNode” są zarówno niezmienne. Więcej szczegółów w tym artykule: built_value for Immutable Object Models.