Đây là một câu hỏi cũ nhưng nó thực sự là một câu hỏi hay, vì vậy tôi sẽ trả lời.
Bạn có thể nghĩ các đơn nguyên là các khối mã mà bạn có toàn quyền kiểm soát cách chúng được thực thi: mỗi dòng mã sẽ trả về, liệu việc thực thi có dừng lại tại bất kỳ điểm nào hay không, liệu một số xử lý khác có xảy ra giữa mỗi dòng không.
Tôi sẽ đưa ra một số ví dụ về những điều mà các đơn vị cho phép sẽ khó khăn nếu không. Không có ví dụ nào trong Haskell, chỉ vì kiến thức về Haskell của tôi hơi run rẩy, nhưng chúng đều là những ví dụ về cách Haskell đã truyền cảm hứng cho việc sử dụng các đơn vị.
Trình phân tích cú pháp
Thông thường, nếu bạn muốn viết một trình phân tích cú pháp nào đó, giả sử để thực hiện ngôn ngữ lập trình, bạn sẽ phải đọc đặc tả BNF và viết một loạt mã mã để phân tích cú pháp, hoặc bạn sẽ phải sử dụng trình biên dịch trình biên dịch như Flex, Bison, yacc, v.v. Nhưng với các đơn nguyên, bạn có thể tạo một loại "trình phân tích cú pháp trình biên dịch" ngay trong Haskell.
Trình phân tích cú pháp thực sự không thể được thực hiện mà không có ngôn ngữ đơn nguyên hoặc ngôn ngữ đặc biệt như yacc, bison, v.v.
Chẳng hạn, tôi lấy đặc tả ngôn ngữ BNF cho giao thức IRC :
message = [ ":" prefix SPACE ] command [ params ] crlf
prefix = servername / ( nickname [ [ "!" user ] "@" host ] )
command = 1*letter / 3digit
params = *14( SPACE middle ) [ SPACE ":" trailing ]
=/ 14( SPACE middle ) [ SPACE [ ":" ] trailing ]
nospcrlfcl = %x01-09 / %x0B-0C / %x0E-1F / %x21-39 / %x3B-FF
; any octet except NUL, CR, LF, " " and ":"
middle = nospcrlfcl *( ":" / nospcrlfcl )
trailing = *( ":" / " " / nospcrlfcl )
SPACE = %x20 ; space character
crlf = %x0D %x0A ; "carriage return" "linefeed"
Và giảm xuống còn khoảng 40 dòng mã trong F # (một ngôn ngữ khác hỗ trợ các đơn nguyên):
type UserIdentifier = { Name : string; User: string; Host: string }
type Message = { Prefix : UserIdentifier option; Command : string; Params : string list }
let space = character (char 0x20)
let parameters =
let middle = parser {
let! c = sat <| fun c -> c <> ':' && c <> (char 0x20)
let! cs = many <| sat ((<>)(char 0x20))
return (c::cs)
}
let trailing = many item
let parameter = prefixed space ((prefixed (character ':') trailing) +++ middle)
many parameter
let command = atLeastOne letter +++ (count 3 digit)
let prefix = parser {
let! name = many <| sat (fun c -> c <> '!' && c <> '@' && c <> (char 0x20)) //this is more lenient than RFC2812 2.3.1
let! uh = parser {
let! user = maybe <| prefixed (character '!') (many <| sat (fun c -> c <> '@' && c <> (char 0x20)))
let! host = maybe <| prefixed (character '@') (many <| sat ((<>) ' '))
return (user, host)
}
let nullstr = function | Some([]) -> null | Some(s) -> charsString s | _ -> null
return { Name = charsString name; User = nullstr (fst uh); Host = nullstr (snd uh) }
}
let message = parser {
let! p = maybe (parser {
let! _ = character ':'
let! p = prefix
let! _ = space
return p
})
let! c = command
let! ps = parameters
return { Prefix = p; Command = charsString c; Params = List.map charsString ps }
}
Cú pháp đơn nguyên của F # khá xấu so với Haskell và tôi có thể đã cải thiện điều này khá nhiều - nhưng điểm đáng chú ý là về mặt cấu trúc, mã trình phân tích cú pháp giống hệt với BNF. Điều này không chỉ mất nhiều công sức hơn nếu không có các đơn vị (hoặc trình tạo trình phân tích cú pháp), mà nó gần như không giống với đặc điểm kỹ thuật, và do đó thật tồi tệ khi đọc và duy trì.
Đa nhiệm tùy chỉnh
Thông thường, đa nhiệm được coi là một tính năng của hệ điều hành - nhưng với các đơn nguyên, bạn có thể viết lịch trình của riêng mình để sau mỗi đơn vị hướng dẫn, chương trình sẽ chuyển quyền điều khiển sang trình lập lịch, sau đó sẽ chọn một đơn vị khác để thực thi.
Một anh chàng đã tạo ra một "nhiệm vụ" đơn vị để điều khiển các vòng lặp trò chơi (một lần nữa trong F #), để thay vì phải viết mọi thứ như một máy trạng thái hoạt động trên mỗi Update()cuộc gọi, anh ta chỉ có thể viết tất cả các hướng dẫn như thể chúng là một chức năng duy nhất .
Nói cách khác, thay vì phải làm một cái gì đó như:
class Robot
{
enum State { Walking, Shooting, Stopped }
State state = State.Stopped;
public void Update()
{
switch(state)
{
case State.Stopped:
Walk();
state = State.Walking;
break;
case State.Walking:
if (enemyInSight)
{
Shoot();
state = State.Shooting;
}
break;
}
}
}
Bạn có thể làm một cái gì đó như:
let robotActions = task {
while (not enemyInSight) do
Walk()
while (enemyInSight) do
Shoot()
}
LINQ to SQL
LINQ to SQL thực sự là một ví dụ về một đơn nguyên và chức năng tương tự có thể dễ dàng được thực hiện trong Haskell.
Tôi sẽ không đi vào chi tiết vì tôi không nhớ chính xác tất cả, nhưng Erik Meijer giải thích điều đó khá rõ .