เหตุใดจึงมีบางภาษาที่มี 'โอเปอเรเตอร์' ชนิดตัวแปรอยู่?

ฉันหมายความว่าอย่างนี้:

<?php
    $number1 = 5;   // (Type 'Int')
    $operator1 = +; // (Type non-existent 'Operator')
    $number2 = 5;   // (Type 'Int')
    $operator2 = *; // (Type non-existent 'Operator')
    $number3 = 8;   // (Type 'Int')

    $test = $number1 $operator1 $number2 $operator2 $number3; //5 + 5 * 8.

    var_dump($test);
?>

แต่ด้วยวิธีนี้:

<?php
    $number1 = 5;
    $number3 = 9;
    $operator1 = <;

    if ($number1 $operator1 $number3) { //5 < 9 (true)
        echo 'true';
    }
?>

ดูเหมือนจะไม่มีภาษาใด ๆ - มีเหตุผลที่ดีที่ทำไมพวกเขาถึงไม่ทำ?

ผู้ประกอบการเป็นเพียงฟังก์ชั่นภายใต้ชื่อตลก ๆ มีไวยากรณ์พิเศษอยู่รอบตัว

ในหลาย ๆ ภาษาแตกต่างกันไปตาม C ++ และ Python คุณสามารถกำหนดผู้ให้บริการใหม่ได้โดยการแทนที่วิธีพิเศษในชั้นเรียนของคุณ จากนั้นผู้ให้บริการมาตรฐาน (เช่น+) ทำงานตามตรรกะที่คุณจัดหา (เช่นการต่อสตริงหรือเพิ่มเมทริกซ์หรืออะไรก็ตาม)

เนื่องจากฟังก์ชั่นที่กำหนดโดยผู้ประกอบการเป็นเพียงวิธีการคุณจึงสามารถส่งผ่านได้เช่นเดียวกับฟังก์ชัน:

# python
action = int.__add__
result = action(3, 5)
assert result == 8

ภาษาอื่นให้คุณกำหนดผู้ประกอบการใหม่โดยตรงเป็นฟังก์ชั่นและใช้พวกเขาในรูปแบบมัด

-- haskell
plus a b = a + b  -- a normal function
3 `plus` 5 == 8 -- True

(+++) a b = a + b  -- a funny name made of non-letters
3 +++ 5 == 8 -- True

let action = (+)
1 `action` 3 == 4 -- True

น่าเสียดายที่ฉันไม่แน่ใจว่า PHP สนับสนุนอะไรแบบนั้นหรือไม่และถ้าสนับสนุนมันจะเป็นเรื่องดี $foo $operator $barใช้ฟังก์ชั่นธรรมดาก็สามารถอ่านได้มากกว่า

ยังมีอีกหลายภาษาที่อนุญาตให้ใช้ชนิดของบางอย่างจะmetaprogramming โดยเฉพาะอย่างยิ่งฉันประหลาดใจที่ไม่เห็นคำตอบที่พูดถึงตระกูลภาษาLisp

จากวิกิพีเดีย:

Metaprogramming คือการเขียนโปรแกรมคอมพิวเตอร์ที่มีความสามารถในการรักษาโปรแกรมเป็นข้อมูลของพวกเขา

ต่อมาในข้อความ:

เสียงกระเพื่อมอาจเป็นภาษาที่เป็นแก่นสารด้วยเครื่องมืออำนวยความสะดวกด้านเมตาโปรแกรมทั้งเนื่องจากความสำคัญทางประวัติศาสตร์และเนื่องจากความเรียบง่ายและพลังของเมตาโปรแกรม

ภาษาเสียงกระเพื่อม

คำนำที่สร้างขึ้นอย่างรวดเร็วของ Lisp มีดังนี้

วิธีหนึ่งในการดูรหัสคือชุดคำสั่ง: ทำสิ่งนี้จากนั้นทำสิ่งนั้นจากนั้นทำอย่างอื่น ... นี่คือรายการ! รายการสิ่งต่าง ๆ สำหรับโปรแกรมที่ต้องทำ และแน่นอนคุณสามารถมีรายการภายในรายการเพื่อแสดงลูปเป็นต้น ..

ถ้าเราเป็นตัวแทนของรายการที่มีองค์ประกอบ A, B, C, D เช่นนี้ (ABCD) เราได้รับสิ่งที่ดูเหมือนว่าการเรียกฟังก์ชั่นเสียงกระเพื่อมที่aเป็นฟังก์ชั่นและb, c, dมีความขัดแย้ง ถ้าเป็นจริง "Hello World!" ทั่วไป โปรแกรมสามารถเขียนได้เช่น:(println "Hello World!")

แน่นอนb, cหรือdอาจจะเป็นรายการที่ประเมินสิ่งที่เป็นความดี ต่อไปนี้: (println "I can add :" (+ 1 3) )จากนั้นพิมพ์ "" ฉันสามารถเพิ่มได้: 4 "

ดังนั้นโปรแกรมเป็นชุดของรายการที่ซ้อนกันและองค์ประกอบแรกคือฟังก์ชั่น ข่าวดีก็คือเราสามารถจัดการรายชื่อ! ดังนั้นเราสามารถจัดการภาษาการเขียนโปรแกรม

ข้อดีของเสียงกระเพื่อม

Lisps ไม่ได้เป็นภาษาการเขียนโปรแกรมมากเท่าเครื่องมือสำหรับการสร้างภาษาโปรแกรม ภาษาโปรแกรมที่ตั้งโปรแกรมได้

สิ่งนี้ไม่เพียง แต่ง่ายขึ้นใน Lisps ในการสร้างโอเปอเรเตอร์ใหม่ แต่ยังเป็นไปไม่ได้ที่จะเขียนโอเปอเรเตอร์บางภาษาในภาษาอื่น ๆ

ตัวอย่างเช่นในภาษา C เช่นสมมติว่าคุณต้องการเขียนifโอเปอเรเตอร์ด้วยตัวเองเช่น:

my-if(condition, if-true, if-false)

my-if(false, print("I should not be printed"), print("I should be printed"))

ในกรณีนี้อาร์กิวเมนต์ทั้งสองจะได้รับการประเมินและพิมพ์ตามลำดับของการประเมินผลของอาร์กิวเมนต์

ใน Lisps การเขียนโอเปอเรเตอร์ (เราเรียกมันว่าแมโคร) และการเขียนฟังก์ชั่นนั้นเกี่ยวกับสิ่งเดียวกันและใช้ในวิธีเดียวกัน ความแตกต่างที่สำคัญคือการที่พารามิเตอร์ของแมโครไม่ได้รับการประเมินก่อนที่จะถูกส่งเป็นอาร์กิวเมนต์ไปยังแมโคร นี่เป็นสิ่งสำคัญที่จะสามารถเขียนโอเปอเรเตอร์บางอย่างเช่นifด้านบน

ภาษาในโลกแห่งความจริง

แสดงให้เห็นว่าขอบเขตออกไปเล็กน้อย แต่ฉันขอแนะนำให้คุณลองเขียนโปรแกรมด้วยเสียงกระเพื่อมหนึ่งเพื่อเรียนรู้เพิ่มเติม ตัวอย่างเช่นคุณสามารถดู:

• Scheme , Lisp เก่า "ค่อนข้างบริสุทธิ์" ที่มีแกนกลางขนาดเล็ก
• Common Lisp, Lisp ที่ใหญ่กว่าพร้อมระบบอ็อบเจกต์ที่รวมเข้าด้วยกันและการใช้งานมากมาย (เป็นมาตรฐาน ANSI)
• แร็กเกต Lisp ที่พิมพ์
• Clojure ที่ฉันชอบตัวอย่างข้างต้นคือรหัส Clojure เสียงกระเพื่อมที่ทันสมัยทำงานบน JVM มีตัวอย่างบางส่วนของมาโคร Clojure บนSOด้วย (แต่นี่ไม่ใช่จุดเริ่มต้นที่ถูกต้องฉันจะดู4clojure , braveclojureหรือclojure koansในตอนแรก)

โอ้และโดยวิธีการกระเพื่อมหมายถึง LISt กำลังประมวลผล

เกี่ยวกับตัวอย่างของคุณ

ฉันจะยกตัวอย่างโดยใช้ Clojure ด้านล่าง:

หากคุณสามารถเขียนaddฟังก์ชั่นใน Clojure (defn add [a b] ...your-implementation-here... )คุณสามารถตั้งชื่อชอบดังนั้น+ (defn + [a b] ...your-implementation-here... )นี่คือความจริงสิ่งที่เกิดขึ้นในการนำไปใช้จริง (เนื้อหาของฟังก์ชั่นนั้นมีส่วนเกี่ยวข้องมากกว่า แต่ความหมายนั้นเหมือนกับที่ผมเขียนไว้ด้านบน)

สิ่งที่เกี่ยวกับสัญกรณ์มัด Clojure ใช้prefixสัญกรณ์ (หรือโปแลนด์) ดังนั้นเราสามารถสร้างinfix-to-prefixแมโครที่จะเปลี่ยนรหัสนำหน้าเป็นรหัส Clojure ซึ่งอันที่จริงแล้วเป็นเรื่องง่ายอย่างน่าประหลาดใจ (จริงๆแล้วมันเป็นหนึ่งในแบบฝึกหัดแมโครใน koans ปิดบัง)! นอกจากนี้ยังสามารถมองเห็นได้ในป่าเช่นดูIncanter$=แมโคร

นี่เป็นเวอร์ชั่นที่ง่ายที่สุดจาก koans ที่อธิบาย:

(defmacro infix [form]
  (list (second form) (first form) (nth form 2)))

;; takes a form (ie. some code) as parameter
;; and returns a list (ie. some other code)
;; where the first element is the second element from the original form
;; and the second element is the first element from the original form
;; and the third element is the third element from the original form (indexes start at 0)
;; example :
;; (infix (9 + 1))
;; will become (+ 9 1) which is valid Clojure code and will be executed to give 10 as a result

เพื่อผลักดันให้จุดยิ่งขึ้นบางคำพูดเสียงกระเพื่อม :

“ ส่วนหนึ่งของสิ่งที่ทำให้ Lisp โดดเด่นคือมันถูกออกแบบมาเพื่อพัฒนา คุณสามารถใช้ Lisp เพื่อกำหนดตัวดำเนินการ Lisp ใหม่ เมื่อ abstractions ใหม่กลายเป็นที่นิยม (เช่นการเขียนโปรแกรมเชิงวัตถุ) มันจะกลายเป็นเรื่องง่ายที่จะนำไปใช้ใน Lisp เช่นเดียวกับ DNA ภาษาดังกล่าวไม่ได้มีสไตล์ "

- Paul Graham, ANSI Common Lisp

“ การเขียนโปรแกรมใน Lisp เหมือนกับการเล่นกับกองกำลังดั้งเดิมของจักรวาล รู้สึกเหมือนสายฟ้าอยู่ระหว่างปลายนิ้วของคุณ ไม่มีภาษาอื่นแม้แต่รู้สึกใกล้ชิด "

- Glenn Ehrlich, Road to Lisp

$test = $number1 $operator1 $number2 $operator2 $number3;

การใช้งานภาษาส่วนใหญ่มีขั้นตอนที่ตัวแยกวิเคราะห์วิเคราะห์รหัสของคุณและสร้างต้นไม้จากมัน ตัวอย่างเช่นการแสดงออก5 + 5 * 8จะได้รับการแยกวิเคราะห์เป็น

  +
 / \
5   *
   / \
  8   8

ต้องขอบคุณความรู้ของผู้รวบรวมเกี่ยวกับลำดับความสำคัญ หากคุณป้อนตัวแปรแทนที่ตัวดำเนินการจะไม่ทราบลำดับการดำเนินการที่เหมาะสมก่อนที่จะเรียกใช้รหัส สำหรับการใช้งานส่วนใหญ่ที่จะเป็นปัญหาร้ายแรงดังนั้นภาษาส่วนใหญ่จึงไม่อนุญาต

แน่นอนคุณสามารถเข้าใจภาษาที่ parser แยกวิเคราะห์ข้างต้นเป็นลำดับของนิพจน์และโอเปอเรเตอร์เพื่อเรียงลำดับและประเมินผลที่รันไทม์ สมมุติว่ามีแอปพลิเคชันไม่มากนักสำหรับเรื่องนี้

ภาษาสคริปต์จำนวนมากอนุญาตให้ประเมินนิพจน์โดยพลการ (หรืออย่างน้อยนิพจน์ทางคณิตศาสตร์ตามอำเภอใจเช่นในกรณีของexpr) ที่รันไทม์ ที่นั่นคุณสามารถรวมตัวเลขและตัวดำเนินการของคุณเป็นนิพจน์เดียวแล้วปล่อยให้ภาษาประเมินสิ่งนั้น ใน PHP (และอื่น ๆ อีกมากมาย) evalฟังก์ชั่นที่เรียกว่า

$test = eval("$number1 $operator1 $number2 $operator2 $number3");

นอกจากนี้ยังมีภาษาที่อนุญาตให้สร้างรหัสในเวลารวบรวม การแสดงออกของ mixin ใน Dมาถึงใจของฉันซึ่งฉันเชื่อว่าคุณสามารถเขียนบางอย่างเช่น

test = mixin("number1 " + operator1 + " number2 " + operator2 + "number3");

ที่นี่operator1และoperator2จะต้องเป็นค่าคงที่สตริงซึ่งเป็นที่รู้จักกันในเวลารวบรวมเช่นพารามิเตอร์แม่แบบ number1, number2และnumber3ถูกทิ้งไว้เป็นตัวแปรรันไทม์ปกติ

คำตอบอื่น ๆ ได้กล่าวถึงวิธีการต่าง ๆ ที่ผู้ดำเนินการและฟังก์ชั่นนั้นมีความเหมือนกันมากหรือน้อยขึ้นอยู่กับภาษา แต่มักจะมีความแตกต่างระหว่างประโยคสัญลักษณ์ประกอบ builtin มัดชอบและชื่อเหมือน+ callable operator1ฉันจะให้รายละเอียดกับคำตอบอื่น ๆ เหล่านั้น

อัลกอล 68 มีคุณสมบัติตรงตามนั้น ตัวอย่างของคุณใน Algol 68 จะมีลักษณะเช่นนี้:

int number1 = 5;                              ¢ (ชนิด 'Int') ¢
op operator1 = int ( int , ข ) + ข ; ¢ (พิมพ์ไม่มี 'ผู้ดำเนินการ') ¢ prio โอเปอเรเตอร์ 1 = 4; int number2 = 5;                              ¢ (ชนิด 'Int') ¢ op operator2 = int ( int , ข ) * ข ;  ¢


(พิมพ์ไม่มีอยู่ 'ผู้ดำเนินการ') ¢
prio โอเปอเรเตอร์ 2 = 5;
int number3 = 8;                              ¢ (พิมพ์ 'Int') ¢

int test = number1 operator1 number2 operator2 number3 ; ¢ 5 + 5 * 8. ¢

var_dump ( ทดสอบ );

ตัวอย่างที่สองของคุณจะเป็นดังนี้:

int number4 = 9;
op operator3 = bool ( int a , b ) a < b ; ตัวดำเนินการ
prio3 = 3; ถ้าnumber1 $ operator3 number4 ดังนั้น¢ 5 <9 (จริง) ¢ พิมพ์ ( จริง ) fi

คุณจะสังเกตเห็นว่าสัญลักษณ์ของโอเปอเรเตอร์ถูกกำหนดและกำหนดเนื้อหาวิธีการที่มีการดำเนินการที่ต้องการ ผู้ประกอบการและตัวถูกดำเนินการของพวกเขาทั้งหมดพิมพ์และผู้ประกอบการสามารถกำหนดลำดับความสำคัญเพื่อให้การประเมินผลจะเกิดขึ้นในลำดับที่ถูกต้อง คุณอาจสังเกตเห็นว่ามีความแตกต่างเล็กน้อยในการฟอนท์ระหว่างสัญลักษณ์ของโอเปอเรเตอร์และสัญลักษณ์ของตัวแปร

อันที่จริงแม้ภาษาที่เขียนโดยใช้ fonting, เครื่องของวันที่ไม่สามารถจัดการแบบอักษร (เทปกระดาษและบัตรเจาะ) และstroppingถูกนำมาใช้ โปรแกรมอาจจะถูกป้อนเป็น:

'INT' NUMBER4 = 9;
'OP' 'OPERATOR3' = 'BOOL' ('INT' A,B) A < B;
'PRIO' 'OPERATOR3' = 3;
'IF' NUMBER1 'OPERATOR3' NUMBER4 'THEN' 'C' 5 < 9 'C'
PRINT('TRUE')
'FI'

นอกจากนี้คุณยังสามารถเล่นเกมที่น่าสนใจด้วยภาษาเมื่อคุณสามารถกำหนดสัญลักษณ์ของคุณเองสำหรับผู้ให้บริการซึ่งฉันใช้ประโยชน์เมื่อหลายปีก่อน ... [2]

_{อ้างอิง:}

[1] บทนำเป็นทางการเพื่อ Algol 68โดย CHLindsey และรถตู้ SG der Meulen, นอร์ทฮอลแลนด์ 1971

[2] Algol 68 วลี, เครื่องมือในการเขียนการช่วยเหลือของคอมไพเลอร์ใน Algol 68 , BC Tompsett การประชุมนานาชาติเกี่ยวกับการประยุกต์ใช้ Algol 68, ที่ University of East Anglia, Norwich, สหราชอาณาจักรปี 1976