มีรูปแบบการออกแบบที่เป็นไปได้เฉพาะในภาษาที่พิมพ์แบบไดนามิกเช่น Python หรือไม่?

ฉันอ่านคำถามที่เกี่ยวข้องมีรูปแบบการออกแบบใดที่ไม่จำเป็นในภาษาไดนามิกเช่น Python หรือไม่? และจดจำคำพูดนี้บน Wikiquote.org

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

--- วิทยุวิศวกรรมซอฟต์แวร์ตอนที่ 140: Newspeak และประเภทที่เสียบได้ด้วย Gilad Bracha

ฉันสงสัยว่ามีรูปแบบการออกแบบหรือกลยุทธ์ที่มีประโยชน์โดยใช้สูตรของคำพูด "ไม่ทำงานเป็นประเภท" หรือไม่?

ประเภทเฟิร์สคลาส

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

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

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

ทีนี้เรามาตกลงกันว่าการอนุมานประเภทนั้นเป็นสิ่งที่ดีและฉันต้องการให้มีการตรวจสอบโค้ดก่อนเรียกใช้ อย่างไรก็ตามฉันยังชอบที่จะสามารถสร้างและรวบรวมรหัสที่รันไทม์ และฉันก็ชอบที่จะคำนวณสิ่งต่าง ๆ ในเวลารวบรวมด้วยเช่นกัน ในภาษาที่พิมพ์แบบไดนามิกนี้จะทำด้วยภาษาเดียวกัน ใน OCaml คุณมีระบบประเภทโมดูล / functor ซึ่งแตกต่างจากระบบประเภทหลักซึ่งแตกต่างจากภาษาพรีโปรเซสเซอร์ ใน C ++ คุณมีภาษาแม่แบบซึ่งไม่มีส่วนเกี่ยวข้องกับภาษาหลักซึ่งโดยทั่วไปจะไม่รู้ประเภทระหว่างการดำเนินการ และที่ดีในภาษาเหล่านั้นเพราะพวกเขาไม่ต้องการที่จะให้มากขึ้น

ในท้ายที่สุดที่ไม่เปลี่ยนจริงๆสิ่งที่ชนิดของซอฟต์แวร์ที่คุณสามารถพัฒนา แต่ expressivity การเปลี่ยนแปลงวิธีการที่คุณพัฒนาพวกเขาและไม่ว่าจะเป็นเรื่องยากหรือไม่

รูปแบบ

รูปแบบที่ขึ้นอยู่กับประเภทไดนามิกเป็นรูปแบบที่เกี่ยวข้องกับสภาพแวดล้อมแบบไดนามิก: เปิดชั้นเรียนเยี่ยงอย่างฐานข้อมูลในหน่วยความจำของวัตถุเป็นอันดับ ฯลฯ สิ่งที่ง่ายเช่นภาชนะบรรจุทั่วไปทำงานเพราะเวกเตอร์ไม่ลืมรันไทม์เกี่ยวกับชนิดของวัตถุที่เก็บ (ไม่จำเป็นสำหรับประเภทพารามิเตอร์)

ฉันพยายามที่จะแนะนำวิธีการหลายรหัสมีการประเมินใน Common LISP เช่นเดียวกับตัวอย่างของการวิเคราะห์แบบคงที่ที่เป็นไปได้ (นี่คือ SBCL) ตัวอย่าง sandbox รวบรวมชุดย่อยเล็ก ๆ ของรหัส Lisp ที่ดึงมาจากไฟล์แยกต่างหาก เพื่อความปลอดภัยที่สมเหตุสมผลฉันเปลี่ยน readtable อนุญาตเฉพาะเซ็ตย่อยของสัญลักษณ์มาตรฐานและล้อมสิ่งต่าง ๆ ด้วยการหมดเวลา

;;
;; Fetching systems, installing them, etc. 
;; ASDF and QL provide provide resp. a Make-like facility 
;; and system management inside the runtime: those are
;; not distinct programs.
;; Reflexivity allows to develop dedicated tools: for example,
;; being able to find the transitive reduction of dependencies
;; to parallelize builds. 
;; https://gitlab.common-lisp.net/xcvb/asdf-dependency-grovel
;;
(ql:quickload 'trivial-timeout)

;;
;; Readtables are part of the runtime.
;; See also NAMED-READTABLES.
;;
(defparameter *safe-readtable* (copy-readtable *readtable*))
(set-macro-character #\# nil t *safe-readtable*)
(set-macro-character #\: (lambda (&rest args)
                           (declare (ignore args))
                           (error "Colon character disabled."))
                     nil
                     *safe-readtable*)

;; eval-when is necessary when compiling the whole file.
;; This makes the result of the form available in the compile-time
;; environment. 
(eval-when (:compile-toplevel :load-toplevel :execute)
  (defvar +WHITELISTED-LISP-SYMBOLS+ 
    '(+ - * / lambda labels mod rem expt round 
      truncate floor ceiling values multiple-value-bind)))

;;
;; Read-time evaluation #.+WHITELISTED-LISP-SYMBOLS+
;; The same language is used to control the reader.
;;
(defpackage :sandbox
  (:import-from
   :common-lisp . #.+WHITELISTED-LISP-SYMBOLS+)
  (:export . #.+WHITELISTED-LISP-SYMBOLS+))

(declaim (inline read-sandbox))

(defun read-sandbox (stream &key (timeout 3))
  (declare (type (integer 0 10) timeout))
  (trivial-timeout:with-timeout (timeout)
    (let ((*read-eval* nil)
          (*readtable* *safe-readtable*)
          ;;
          ;; Packages are first-class: no possible name collision.
          ;;
          (package (make-package (gensym "SANDBOX") :use '(:sandbox))))
      (unwind-protect
           (let ((*package* package))
             (loop
                with stop = (gensym)
                for read = (read stream nil stop)
                until (eq read stop)
                ;;
                ;; Eval at runtime
                ;;
                for value = (eval read)
                ;;
                ;; Type checking
                ;;
                unless (functionp value)
                do (error "Not a function")
                ;; 
                ;; Compile at run-time
                ;;
                collect (compile nil value)))
        (delete-package package)))))

;;
;; Static type checking.
;; warning: Constant 50 conflicts with its asserted type (MOD 11)
;;
(defun read-sandbox-file (file)
  (with-open-file (in file)
    (read-sandbox in :timeout 50)))

;; get it right, this time
(defun read-sandbox-file (file)
  (with-open-file (in file)
    (read-sandbox in)))

#| /tmp/plugin.lisp
(lambda (x) (+ (* 3 x) 100))
(lambda (a b c) (* a b))
|#

(read-sandbox-file #P"/tmp/plugin.lisp")

;; 
;; caught COMMON-LISP:STYLE-WARNING:
;;   The variable C is defined but never used.
;;

(#<FUNCTION (LAMBDA (#:X)) {10068B008B}>
 #<FUNCTION (LAMBDA (#:A #:B #:C)) {10068D484B}>)

ไม่มีสิ่งใดที่เป็นไปไม่ได้ที่จะทำกับภาษาอื่น วิธีการปลั๊กอินใน Blender ในซอฟต์แวร์เพลงหรือ IDE สำหรับภาษาที่รวบรวมแบบคงที่ซึ่งทำการคอมไพล์แบบออนไลน์ ฯลฯ แทนที่จะใช้เครื่องมือภายนอกภาษาแบบไดนามิกจะใช้เครื่องมือที่ใช้ข้อมูลที่มีอยู่แล้ว ผู้โทรที่รู้จักทั้งหมดของ FOO หรือไม่ คลาสย่อยทั้งหมดของ BAR หรือไม่ วิธีการทั้งหมดที่มีความเชี่ยวชาญโดยชั้น ZOT? นี่เป็นข้อมูลภายใน ประเภทเป็นอีกแง่มุมหนึ่งของสิ่งนี้

(ดูเพิ่มเติมที่: CFFI )

คำตอบสั้น ๆ : ไม่เพราะทัวริงเทียบเท่า

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

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

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

ผู้ชายจากเครื่องหมายคำพูดนั้นถูกต้องว่าประเภทคงที่จะ จำกัด สิ่งที่คุณทำได้ แต่นั่นเป็นคุณสมบัติที่สำคัญไม่ใช่ปัญหา บรรทัดบนถนน จำกัด สิ่งที่คุณสามารถทำได้ในรถของคุณ แต่คุณคิดว่ามันเข้มงวดหรือมีประโยชน์หรือไม่? (ฉันรู้ว่าฉันไม่ต้องการขับรถบนถนนที่วุ่นวายและซับซ้อนซึ่งไม่มีอะไรบอกให้รถวิ่งไปในทิศทางตรงกันข้ามเพื่อไปทางด้านข้างและไม่มาที่ที่ฉันขับรถ!) โดยการตั้งค่ากฎที่อธิบายสิ่งที่ชัดเจน ถือว่าเป็นพฤติกรรมที่ไม่ถูกต้องและทำให้มั่นใจได้ว่ามันจะไม่เกิดขึ้นคุณลดโอกาสที่จะเกิดความผิดพลาดอย่างมาก

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

ก่อนอื่นเพราะรหัสที่ไม่มีคำอธิบายประกอบประเภทอ่านยาก พิจารณา Python ต่อไปนี้:

def sendData(self, value):
   self.connection.send(serialize(value.someProperty))

คุณคาดหวังว่าข้อมูลจะดูเหมือนว่าระบบที่ปลายอีกด้านหนึ่งของการเชื่อมต่อได้รับอะไร และถ้ามันได้รับบางสิ่งที่ดูผิดปกติคุณจะรู้ได้อย่างไรว่าเกิดอะไรขึ้น?

value.somePropertyทั้งหมดขึ้นอยู่กับโครงสร้างของ แต่มันดูเหมือนอะไร? คำถามที่ดี! สิ่งที่เรียกเป็นsendData()? มันกำลังผ่านอะไร ตัวแปรนั้นมีลักษณะอย่างไร มันมาจากไหน ถ้าไม่ใช่ในพื้นที่คุณต้องติดตามประวัติทั้งหมดของvalueการติดตามสิ่งที่เกิดขึ้น บางทีคุณกำลังส่งผ่านสิ่งอื่นที่มีsomePropertyคุณสมบัติ แต่มันไม่ได้ทำในสิ่งที่คุณคิด

ตอนนี้เรามาดูด้วยคำอธิบายประกอบแบบที่คุณอาจเห็นในภาษา Boo ซึ่งใช้ไวยากรณ์ที่คล้ายกันมาก แต่พิมพ์แบบคงที่:

def SendData(value as MyDataType):
   self.Connection.Send(Serialize(value.SomeProperty))

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

เหตุผลที่สองสร้างขึ้นในครั้งแรก: ในโครงการขนาดใหญ่และซับซ้อนคุณน่าจะมีผู้สนับสนุนหลายคน (และถ้าไม่คุณกำลังสร้างมันขึ้นมาเองเป็นเวลานานซึ่งเป็นสิ่งเดียวกันลองอ่านโค้ดที่คุณเขียนเมื่อ 3 ปีก่อนถ้าคุณไม่เชื่อฉัน!) ซึ่งหมายความว่าคุณไม่รู้ว่าเกิดอะไรขึ้น ผ่านหัวของบุคคลที่เขียนเกือบทุกส่วนของรหัสในเวลาที่พวกเขาเขียนเพราะคุณไม่ได้อยู่ที่นั่นหรือจำไม่ได้ว่ามันเป็นรหัสของคุณเมื่อนานมาแล้ว การมีการประกาศประเภทจริงๆช่วยให้คุณเข้าใจว่าเจตนาของรหัสคืออะไร!

คนที่ชอบผู้ชายในคำพูดมักจะใช้ประโยชน์จากการพิมพ์แบบคงที่บ่อยๆว่า "ช่วยคอมไพเลอร์" หรือ "หมดประสิทธิภาพ" ในโลกที่ทรัพยากรฮาร์ดแวร์แทบไม่ จำกัด ทำให้สิ่งนี้มีความเกี่ยวข้องน้อยลงในแต่ละปีที่ผ่านมา แต่อย่างที่ฉันได้แสดงให้เห็นในขณะที่ประโยชน์เหล่านั้นมีอยู่จริงประโยชน์หลักอยู่ในปัจจัยมนุษย์โดยเฉพาะอย่างยิ่งการอ่านรหัสและการบำรุงรักษา (ประสิทธิภาพที่เพิ่มขึ้นเป็นโบนัสที่ดีอย่างแน่นอน!)

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

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

doc.header.status.text()

และคุณมีเนื้อหาของเส้นทางนั้นมาจากวัตถุ XML แยกวิเคราะห์ เรียบร้อยและเป็นระเบียบเรียบร้อย IMO และถ้าไม่มีโหนดใหญ่ก็แค่คืนค่าวัตถุจำลองที่ไม่มีอะไรเลยนอกจากวัตถุจำลอง (เต่าลงมาจนสุด) ไม่มีทางที่จะทำเช่นนั้นจริง ๆ ได้ Java คุณต้องรวบรวมคลาสล่วงหน้าตามความรู้เกี่ยวกับโครงสร้างของ XML ทิ้งไว้ไม่ว่าจะเป็นความคิดที่ดีสิ่งนี้จะเปลี่ยนวิธีการแก้ปัญหาของคุณในภาษาไดนามิก ฉันไม่ได้บอกว่ามันจะเปลี่ยนไปในทางที่ดีกว่าเสมอไป มีค่าใช้จ่ายที่แน่นอนสำหรับวิธีการแบบไดนามิกและคำตอบของเมสันให้ภาพรวมที่ดี ไม่ว่าพวกเขาจะเป็นทางเลือกที่ดีหรือไม่นั้นขึ้นอยู่กับหลายปัจจัย

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

คำพูดนั้นถูกต้อง แต่ก็ไม่ตรงตามความเป็นจริง มาแยกกันดูกันว่าทำไม:

สิ่งมหัศจรรย์เกี่ยวกับการพิมพ์แบบไดนามิกคือช่วยให้คุณสามารถแสดงสิ่งที่คำนวณได้

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

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

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

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

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

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

มีบางสิ่งที่คุณสามารถทำได้ในภาษาที่พิมพ์แบบไดนามิกเท่านั้น แต่พวกเขาไม่จำเป็นต้องมีการออกแบบที่ดี

คุณอาจกำหนดจำนวนเต็ม 5 ก่อนจากนั้นสตริง'five'หรือCatวัตถุให้กับตัวแปรเดียวกัน แต่คุณจะทำให้มันยากขึ้นสำหรับผู้อ่านรหัสของคุณที่จะคิดออกว่าเกิดอะไรขึ้นวัตถุประสงค์ของตัวแปรทุกตัวคืออะไร

คุณอาจเพิ่มวิธีการใหม่ในไลบรารีคลาส Ruby และเข้าถึงฟิลด์ส่วนตัว อาจมีบางกรณีที่แฮ็คนั้นมีประโยชน์ แต่นี่อาจเป็นการละเมิดการห่อหุ้ม (ฉันไม่รังเกียจการเพิ่มเมธอดที่อาศัยอินเทอร์เฟซสาธารณะเท่านั้น แต่นั่นไม่ใช่สิ่งที่วิธีการขยาย C # แบบคงที่ไม่สามารถทำได้)

คุณอาจเพิ่มเขตข้อมูลใหม่ลงในวัตถุของคลาสของคนอื่นเพื่อส่งข้อมูลพิเศษรอบ ๆ แต่มันเป็นการออกแบบที่ดีกว่าเพียงแค่สร้างโครงสร้างใหม่หรือขยายชนิดดั้งเดิม

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

ภาษาแบบไดนามิกที่ดีคือน้ำตาลประโยค ตัวอย่างเช่นเมื่ออ่านวัตถุ JSON deserialized คุณอาจจะหมายถึงค่าที่ซ้อนกันเป็นเพียงobj.data.article[0].content- neater obj.getJSONObject("data").getJSONArray("article").getJSONObject(0).getString("content")กว่าพูด

นักพัฒนาทับทิมโดยเฉพาะสามารถพูดคุยเกี่ยวกับเวทมนตร์ที่สามารถทำได้โดยการใช้method_missingซึ่งเป็นวิธีที่ช่วยให้คุณสามารถจัดการกับการโทรที่พยายามไปยังวิธีที่ไม่ได้ประกาศ ตัวอย่างเช่น ActiveRecord ORM ใช้เพื่อให้คุณสามารถโทรออกUser.find_by_email('joe@example.com')โดยไม่ต้องประกาศfind_by_emailวิธีการ แน่นอนว่ามันไม่มีอะไรที่ไม่สามารถเข้าใจได้เหมือนUserRepository.FindBy("email", "joe@example.com")ในภาษาที่พิมพ์แบบคงที่ แต่คุณไม่สามารถปฏิเสธได้ว่ามันเรียบร้อย

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

class Proxy(object):
    def __init__(self, obj):
        self.__target = obj

    def __getattr__(self, attr):
        return getattr(self.__target, attr)

ใช้นี้สร้างวัตถุใหม่ที่มีลักษณะการทำงานเช่นเดียวกับProxy(someObject) someObjectเห็นได้ชัดว่าคุณต้องการเพิ่มฟังก์ชันการทำงานเพิ่มเติม แต่อย่างใดนี่เป็นพื้นฐานที่มีประโยชน์สำหรับการเริ่มต้น ในภาษาสแตติกที่สมบูรณ์คุณจะต้องเขียนคลาสพร็อกซีหนึ่งคลาสต่อประเภทที่คุณต้องการใช้พร็อกซีหรือใช้การสร้างรหัสแบบไดนามิก (ซึ่งเป็นที่ยอมรับรวมอยู่ในไลบรารีมาตรฐานของภาษาแบบคงที่หลายแห่ง ปัญหาที่ไม่สามารถทำได้ด้วยสาเหตุนี้)

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

ใช่มีหลายรูปแบบและเทคนิคที่เป็นไปได้เฉพาะในภาษาที่พิมพ์แบบไดนามิก

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

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

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

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

คำตอบอื่น ๆ ที่ถกเถียงกันว่าทัวริงเทียบเท่าหมายความว่าอะไรเป็นไปได้ในหนึ่งภาษาเป็นไปได้ในทุกภาษา แต่สิ่งนี้ไม่ปฏิบัติตาม เพื่อสนับสนุนบางอย่างเช่นการปะของลิงในภาษาแบบคงที่คุณจะต้องใช้ภาษาย่อยแบบไดนามิกภายในภาษาแบบคงที่ เป็นไปได้แน่นอน แต่ฉันจะโต้แย้งว่าคุณกำลังเขียนโปรแกรมในภาษาไดนามิกฝังตัวเนื่องจากคุณสูญเสียการตรวจสอบประเภทคงที่ซึ่งมีอยู่ในภาษาโฮสต์

C # เนื่องจากรุ่น 4 รองรับวัตถุที่พิมพ์แบบไดนามิก เห็นได้ชัดว่านักออกแบบภาษาเห็นประโยชน์ในการพิมพ์ทั้งสองชนิด แต่มันก็แสดงให้เห็นว่าคุณไม่สามารถมีเค้กและกินฉันได้เช่นกัน: เมื่อคุณใช้วัตถุแบบไดนามิกใน C # คุณจะได้รับความสามารถในการทำสิ่งต่าง ๆ เช่นการปะลิง แต่คุณก็สูญเสียการตรวจสอบชนิดคงที่สำหรับการโต้ตอบกับวัตถุเหล่านี้

ฉันสงสัยว่ามีรูปแบบการออกแบบหรือกลยุทธ์ที่มีประโยชน์โดยใช้สูตรของคำพูด "ไม่ทำงานเป็นประเภท" หรือไม่?

ใช่และไม่.

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

ให้ฉันแสดงตัวอย่างของสิ่งนี้:

Map<Class<?>, Function<?, String>> someMap;
someMap.get(object.getClass()).apply(object);

ฉันรู้ว่าsomeMap.get(T.class)จะกลับมาFunction<T, String>เพราะฉันสร้างบางแผนที่ แต่ Java มั่นใจว่าฉันมีฟังก์ชั่นเท่านั้น

ตัวอย่างอื่น:

data = parseJSON(someJson)
validate(data, someJsonSchema);
print(data.properties.rowCount);

ฉันรู้ว่า data.properties.rowCount จะเป็นการอ้างอิงที่ถูกต้องและจำนวนเต็มเพราะฉันตรวจสอบข้อมูลกับสคีมาแล้ว หากฟิลด์นั้นหายไปจะมีการโยนข้อยกเว้น แต่คอมไพเลอร์จะรู้ว่าเป็นการโยนข้อยกเว้นหรือคืนค่า JSONValue ทั่วไปบางประเภท

ตัวอย่างอื่น:

x, y, z = struct.unpack("II6s", data)

"II6s" กำหนดวิธีการเข้ารหัสข้อมูลตัวแปรสามตัว เนื่องจากฉันระบุรูปแบบฉันจึงทราบว่าจะส่งคืนประเภทใด คอมไพเลอร์จะรู้ว่ามันส่งคืน tuple เท่านั้น

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

นั่นคือสิ่งที่ต้นฉบับพูดถึงที่:

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

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

อย่างไรก็ตามหากต้องการกลับไปที่คำถามของคุณ:

ฉันสงสัยว่ามีรูปแบบการออกแบบหรือกลยุทธ์ที่มีประโยชน์โดยใช้สูตรของคำพูด "ไม่ทำงานเป็นประเภท" หรือไม่?

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

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

นี่คือตัวอย่างบางส่วนจาก Objective-C (พิมพ์แบบไดนามิก) ซึ่งเป็นไปไม่ได้ใน C ++ (พิมพ์แบบคงที่):

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

• การขยายคลาสโดยไม่มีคลาสย่อย
  ใน Objective-C, NSStringคุณสามารถกำหนดฟังก์ชั่นสมาชิกใหม่สำหรับชั้นเรียนที่มีอยู่รวมทั้งคนที่ภาษาที่กำหนดไว้เช่น ตัวอย่างเช่นคุณสามารถเพิ่มวิธีการstripPrefixIfPresent:เพื่อให้คุณสามารถพูดได้[@"foo/bar/baz" stripPrefixIfPresent:@"foo/"](สังเกตการใช้NSSringตัวอักษร@"")

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