Czy mógłbyś mi wyjaśnić funciaki OCaml?

Question

Powiel możliwe:
In Functional Programming, what is a functor?

nie wiem zbyt wiele o SML, Uczyłem F # od jakiegoś czasu i bardzo to rozumiem.

Mówią, że F # tęskni za modelem funktora, który jest obecny w OCaml. Próbowałem dowiedzieć się, czym właściwie jest funktor, ale wikipedia i tutoriale mi nie pomogły.

Czy możesz mi wyjaśnić tę tajemnicę? Z góry dzięki :)

EDIT:

Złapałem punkt, thx wszystkim, którzy mi pomogli. Możesz zamknąć pytanie jako dokładny duplikat: In Functional Programming, what is a functor?

Answer 1

Funktory to moduły sparametryzowane przez moduły, tj. Odbicie od modułów do modułów (zwykłą funkcją jest odbicie od wartości do wartości, funkcja polimorficzna jest odbiciem od typów do zwykłych funkcji).

Zobacz także ocaml-tutorial on modules. Pomocne są również

Examples in the manual.

Answer 2

Sprawdź to struktury danych w trakcie SML:

http://www.cs.cornell.edu/Courses/cs3110/2009fa/lecturenotes.asp

wykład funktor: http://www.cs.cornell.edu/Courses/cs3110/2009fa/lectures/lec10.html

i realizacja drzewo splay użyciu funktor: http://www.cs.cornell.edu/Courses/cs3110/2009fa/recitations/rec-splay.html

Answer 3

Jeśli pochodzą z wszechświat OOP, to prawdopodobnie pomaga myśleć o module analogicznym do klasy statycznej. Podobne do klas statycznych .NET, moduł OCaml ma konstruktory; w przeciwieństwie do .NET, moduły OCaml mogą akceptować parametry w swoich konstruktorach. Funktor to przerażająco brzmiąca nazwa obiektu, który przekazujesz do konstruktora modułu.

Więc pomocą kanoniczny przykład binarnego drzewa, my normalnie napisać go w F # tak:

type 'a tree = 
    | Nil 
    | Node of 'a tree * 'a * 'a tree 

module Tree = 
    let rec insert v = function 
     | Nil -> Node(Nil, v, Nil) 
     | Node(l, x, r) -> 
      if v < x then Node(insert v l, x, r) 
      elif v > x then Node(l, x, insert v r) 
      else Node(l, x, r) 

cacy. Ale w jaki sposób F # wie, jak porównać dwa obiekty typu 'a używając operatorów < i >?

Za kulisami jej robi coś takiego:

> let gt x y = x > y;; 

val gt : 'a -> 'a -> bool when 'a : comparison 

Dobrze, dobrze, co jeśli masz obiektu typu Person który nie wykona tego konkretnego interfejsu? Co jeśli chcesz zdefiniować funkcję sortowania w locie?Jednym ze sposobów jest po prostu przejść w comparer następująco:

let rec insert comparer v = function 
     | Nil -> Node(Nil, v, Nil) 
     | Node(l, x, r) -> 
      if comparer v x = 1 then Node(insert v l, x, r) 
      elif comparer v x = -1 then Node(l, x, insert v r) 
      else Node(l, x, r) 

To działa, ale jeśli piszesz moduł do operacji drzewa z wkładką, Lookup, usuwanie, itp, wymagają klienci przechodzą w funkcja zamawiania za każdym razem, gdy wywołują cokolwiek.

Jeżeli F # obsługiwane funktory, jego składnia hipotetyczny może wyglądać następująco:

type 'a Comparer = 
    abstract Gt : 'a -> 'a -> bool 
    abstract Lt : 'a -> 'a -> bool 
    abstract Eq : 'a -> 'a -> bool 

module Tree (comparer : 'a Comparer) = 
    let rec insert v = function 
     | Nil -> Node(Nil, v, Nil) 
     | Node(l, x, r) -> 
      if comparer.Lt v x then Node(insert v l, x, r) 
      elif comparer.Gt v x then Node(l, x, insert v r) 
      else Node(l, x, r) 

Jeszcze w składni hipotetycznej, można by utworzyć moduł jako taki:

module PersonTree = Tree (new Comparer<Person> 
    { 
     member this.Lt x y = x.LastName < y.LastName 
     member this.Gt x y = x.LastName > y.LastName 
     member this.Eq x y = x.LastName = y.LastName 
    }) 

let people = PersonTree.insert 1 Nil 

Niestety, F # nie robi wspierają funktory, więc musicie oprzeć się pewnym nieuporządkowanym obejściom. Dla scenariusza powyżej, ja prawie zawsze przechowywać „funktor” w moim struktury danych z niektórych AUXILLARY funkcji pomocniczych, aby upewnić się, że zostanie skopiowany wokół poprawnie:

type 'a Tree = 
    | Nil of 'a -> 'a -> int 
    | Node of 'a -> 'a -> int * 'a tree * 'a * 'a tree 

module Tree = 
    let comparer = function 
     | Nil(f) -> f 
     | Node(f, _, _, _) -> f 

    let empty f = Nil(f) 

    let make (l, x, r) = 
     let f = comparer l 
     Node(f, l, x, r) 

    let rec insert v = function 
     | Nil(_) -> make(Nil, v, Nil) 
     | Node(f, l, x, r) -> 
      if f v x = -1 then make(insert v l, x, r) 
      elif f v x = 1 then make(l, x, insert v r) 
      else make(l, x, r) 

let people = Tree.empty (function x y -> x.LastName.CompareTo(y.LastName))