-calculus, có mã hóa cho hay trong khi?

7

Trong -calculus, chúng ta có thể mã hóa số học, số, booleans và thậm chí tính các yếu tố của các số, như được hiển thị ở đây . $\lambda$

Có mã hóa "cho" hoặc "trong khi" không?

lambda-calculus computation-models

— alim
nguồn

6

-tính toán đã hoàn tất, vì vậy, bạn có thể làm điều tương tự một vòng lặp for hoặc while. Tôi sẽ không gọi chúng là mã hóa , vì chúng chỉ là các hàm, giống như mọi thứ trong calcul-

— compus

11

Chắc chắn rồi! Hãy để tôi chỉ cho bạn cách mã hóa FOR bằng cách sử dụng một ví dụ.

Giả sử chúng ta muốn dịch một giai thừa cho chương trình đơn giản

x := 1
for i := 1 to N do
   x := x * i

Chúng tôi viết lại như là

x := 1
i := 1
repeat N times
   x := x*i
   i := i+1

sau đó chúng tôi đặt tất cả các biến chúng tôi sử dụng trong một tuple (một cặp đủ ở đây)

(x,i) := (1,1)
repeat N times
   (x,i) := (x*i, i+1)

Điều này áp dụng hiệu quả chức năng cho cặp ban đầu trong lần. $\lambda\langle x,i \rangle. \langle x*i , i+1 \rangle$ $\langle 1,1 \rangle$ $N$

Vì có thể được biểu diễn dưới dạng số của Giáo hội, chúng tôi nhận được $N$

N (λ ⟨ x, i ⟩ . ⟨ x * i, i + 1 ⟩) ⟨ 1, 1 ⟩

$N (\lambda\langle x,i \rangle. \langle x*i , i+1 \rangle) \langle 1,1 \rangle$

Cú pháp trên sử dụng một vài điều ngoài phép tính lambda đơn giản. Số và số học có thể được thực hiện chính xác bằng cách sử dụng chữ số Church. Các cặp cũng có mã hóa Giáo hội riêng:

⟨ x, y ⟩ \equiv λ k . k x y λ ⟨ x, y ⟩ . M \equiv λ z . M {z T / x, z F / y}

$\langle x,y \rangle \equiv \lambda k.kxy \qquad \lambda \langle x,y \rangle . M \equiv \lambda z. M\{zT/x, zF/y\}$ nơi là một biến tươi, và .

z

$z$

T = λ a b . a

$T = \lambda ab.a$

F = λ a b . b

$F = \lambda ab.b$

Nếu bạn có nhiều hơn hai biến, bạn có thể khái quát mã hóa ở trên thành các bộ dữ liệu hoặc chỉ đơn giản biểu thị các bộ dữ liệu dưới dạng các cặp lồng nhau.

WHILE được xử lý tốt nhất bằng cách sử dụng đệ quy: thay vì

while p(x,i) do
   (x,i) := f(x,i)

trong đó plà một vị ngữ và flà một số hàm (một phần), chúng ta có thể sử dụng một cái gì đó như

def recFun(x,i):
   if p(x,i):
      return recFun(f(x,i))
   else:
      return (x,i)

Trong phép tính lambda, đệ quy thu được bằng cách sử dụng một tổ hợp điểm cố định , ví dụ: Church's hoặc Turing's . Chúng tôi nhận được một cái gì đó như $Y$ $\Theta$

Y (λ r . λ ⟨ x, Tôi ⟩ . Tôi f p x Tôi t h e n r (f ⟨ x, Tôi ⟩) e tôi S e ⟨ x, Tôi ⟩)

$Y (\lambda r . \lambda \langle x,i \rangle . {\sf if}\ p x i\ {\sf then }\ r(f \langle x,i \rangle)\ {\sf else}\ \langle x,i \rangle)$

trong đó giả sử booleans được mã hóa Church. ${\sf if}\ b\ {\sf then }\ t\ {\sf else}\ e \equiv b t e$

Cũng lưu ý rằng WHILE (nghiêm túc) mạnh hơn FOR. Mỗi FOR có thể được mã hóa dưới dạng WHILE, vì vậy kỹ thuật mã hóa này cũng có thể được sử dụng cho FOR.

— chi
nguồn

9

Có các mã hóa các vòng lặp, nhưng chúng không hoạt động chính xác như các vòng lặp mà bạn đã từng sử dụng, vì phép tính lambda không phải là một ngôn ngữ bắt buộc. Tính toán lambda không có tác dụng phụ (đó là ngôn ngữ hoàn toàn chức năng ), do đó, tương đương chính xác của một vòng lặp sẽ là vô ích.

Trạng thái rõ ràng

Một chương trình bắt buộc có thể được dịch sang một ngôn ngữ chức năng thuần túy bằng cách chuyển tất cả trạng thái xung quanh một cách rõ ràng như một biến trong chương trình. Tôi sẽ sử dụng cú pháp Python cho mã giả bắt buộc; nó phải gần như trong suốt, với dấu hiệu (a, b) = f(…)có nghĩa là lệnh gọi hàm ftrả về một cặp avà bđược gán thành phần thứ nhất và thứ hai của cặp tương ứng. Xem xét một vòng lặp

while test_condition():
    do_stuff()

Hãy làm cho nhà nước rõ ràng.

state = initial_state
(state, cond) = test_condition(state)
while cond:
    (state, cond) = test_condition(do_stuff(state))

Chúng ta có thể dịch nó thành một cuộc gọi đệ quy. def loop(state):định nghĩa một hàm gọi là loop.

def loop(state):
    (state, cond) = test_condition(state)
    if cond: return loop(do_stuff(state))
    else: return state
state = loop(initial_state)

Điều này chỉ sử dụng các khái niệm sau, tất cả đều có thể được biểu thị dễ dàng trong phép tính lambda:

Chức năng gọi: khái niệm bản địa
Các phép gán biến cục bộ mà không cần gán lại: truyền giá trị cho hàm phụ trợ
Cặp: Cặp nhà thờ
Booleans: Booleans nhà thờ
Đệ quy: tổ hợp điểm cố định

Và do đó chúng ta có thể định nghĩa một whilehàm cho một điều kiện $C$ ( test_condition) và một cơ thể $B$ ( do_stuff):

w h Tôi tôi e : = λ C . λ B . f Tôi x (λ f . λ S . (λ p . THÂN HÌNH (f Tôi r S t p) (S e c o n d p)) (C S)) nơi CƠ THỂ = = λ S^{'} . λ c . Tôi f c (f (B S^{'})) S^{'}

$\mathsf{while} := \lambda C. \lambda B. \mathsf{fix} (\lambda f. \lambda s. (\lambda p. \text{BODY} (\mathsf{first}\, p) (\mathsf{second}\, p)) (C \, s)) \\ \text{where BODY} = \lambda s'. \lambda c. \mathsf{if} \, c \, (f \, (B \, s')) \, s'$

Đối với các vòng lặp khác nhau tùy thuộc vào ngôn ngữ lập trình, nhưng chúng luôn là trường hợp đặc biệt của các vòng lặp trong khi chúng có thể được mã hóa theo cùng một cách. Nếu ngôn ngữ nguồn giới hạn tính biểu cảm của các vòng lặp, có thể có các bảng mã đơn giản hơn. Ví dụ, lặp lại $n$ thời gian đơn giản là thành phần chức năng $n$ lần, trong đó hàm là phép biến đổi trạng thái cấu thành phần thân của vòng lặp và nếu $n$ là một con số của Giáo hội, điều đó chỉ đơn giản là áp dụng $n$ chính nó để các chức năng cơ thể vòng lặp.

Thêm trạng thái vào ngôn ngữ

Một cách tiếp cận khác với trạng thái là mở rộng phép tính lambda với các nguyên hàm thao tác trạng thái. Nếu bạn làm điều đó, thứ tự đánh giá trở nên quan trọng. Trong trường hợp đó, một vòng lặp while có thể được biểu thị trực tiếp bằng đệ quy.

{w h Tôi tôi e}_{mệnh lệnh} : = λ C . λ B . f Tôi x (λ f . Tôi f C (B; f) ())

$\mathsf{while}_{\text{imperative}} := \lambda C. \lambda B. \mathsf{fix} (\lambda f. \mathsf{if} \, C \, (B; f) \, ())$

— Gilles 'SO- ngừng là ác'
nguồn