Bạn vui lòng giải thích cho các giáo viên của OCaml không?

Question

thể trùng lặp:
In Functional Programming, what is a functor?

Tôi không biết nhiều về OCaml, tôi đã nghiên cứu F # trong một thời gian và khá hiểu nó.

Họ nói rằng F # bỏ qua mô hình functor, hiện diện trong OCaml. Tôi đã cố gắng tìm ra những gì chính xác functor là, nhưng wikipedia và hướng dẫn đã không giúp tôi nhiều.

Bạn có thể làm sáng tỏ bí ẩn đó cho tôi không? Cảm ơn trước :)

CHỈNH SỬA:

Tôi đã hiểu điểm, thx với tất cả những người đã giúp tôi. Bạn có thể đóng câu hỏi là trùng lặp chính xác của: In Functional Programming, what is a functor?

Answer 1

Functors là mô-đun được tham số hóa theo mô-đun, tức là phản ánh từ mô-đun đến mô-đun (hàm bình thường là phản ánh từ giá trị đến giá trị, hàm đa hình phản ánh từ loại này sang hàm bình thường).

Xem thêm ocaml-tutorial on modules.

Examples in the manual cũng hữu ích.

Answer 2

Check-out này cấu trúc dữ liệu trong khóa học ocaml:

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

bài giảng functor: http://www.cs.cornell.edu/Courses/cs3110/2009fa/lectures/lec10.html

và functor thực hiện cây splay sử dụng: http://www.cs.cornell.edu/Courses/cs3110/2009fa/recitations/rec-splay.html

Answer 3

Nếu bạn đến từ một vũ trụ OOP, sau đó nó có thể giúp suy nghĩ của một mô-đun tương tự như một lớp tĩnh. Tương tự như các lớp tĩnh .NET, mô-đun OCaml có các hàm tạo; không giống như .NET, các mô-đun OCaml có thể chấp nhận các tham số trong các hàm tạo của chúng. Một hàm functor là một tên đáng sợ cho đối tượng mà bạn truyền vào trong hàm tạo module.

Vì vậy, sử dụng ví dụ kinh điển của một cây nhị phân, chúng tôi thường viết nó trong F # như thế này:

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) 

Fine và dandy. Nhưng F # biết cách so sánh hai đối tượng thuộc loại 'a bằng cách sử dụng các toán tử < và >?

Đằng sau hậu trường, một cái gì đó làm nó như thế này:

> let gt x y = x > y;; 

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

Alright, cũng những gì nếu bạn có một đối tượng kiểu Person mà không thực hiện mà giao diện cụ thể không? Điều gì sẽ xảy ra nếu bạn muốn xác định chức năng phân loại khi đang di chuyển?Một cách tiếp cận chỉ là để vượt qua trong Comparer như sau:

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) 

Nó làm việc, nhưng nếu bạn đang viết một module cho các hoạt động cây với chèn, tra cứu, di chuyển, vv, bạn yêu cầu khách hàng để vượt qua trong một chức năng đặt hàng mỗi khi họ gọi bất cứ thứ gì.

Nếu functors F # được hỗ trợ, cú pháp giả của nó có thể trông như thế này:

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) 

Vẫn trong cú pháp giả, bạn muốn tạo module của bạn như vậy:

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 

Thật không may, F # doesn 't hỗ trợ functors, vì vậy bạn phải rơi trở lại trên một số cách giải quyết lộn xộn. Đối với kịch bản trên, tôi hầu như luôn luôn lưu trữ "functor" trong cấu trúc dữ liệu của tôi với một số hàm trợ giúp bổ trợ để đảm bảo nó được sao chép chính xác:

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))