อะไรคือทางเลือกในการตั้งโปรแกรมการทำงานของอินเตอร์เฟส?

หากฉันต้องการตั้งโปรแกรมในรูปแบบ "ฟังก์ชั่น" ฉันจะใช้อะไรแทนอินเตอร์เฟสได้บ้าง?

interface IFace
{
   string Name { get; set; }
   int Id { get; }
}
class Foo : IFace { ... }

อาจจะTuple<>?

Tuple<Func<string> /*get_Name*/, Action<String> /*set_Name*/, Func<int> /*get_Id*/> Foo;

เหตุผลเดียวที่ฉันใช้อินเทอร์เฟซตั้งแต่แรกก็เพราะฉันต้องการให้มีคุณสมบัติ / วิธีการบางอย่างอยู่เสมอ

แก้ไข:รายละเอียดเพิ่มเติมบางอย่างเกี่ยวกับสิ่งที่ฉันคิด / พยายาม

บอกว่าฉันมีวิธีที่ใช้สามฟังก์ชั่น:

static class Blarf
{
   public static void DoSomething(Func<string> getName, Action<string> setName, Func<int> getId);
}

ด้วยตัวอย่างของBarฉันสามารถใช้วิธีนี้:

class Bar
{
   public string GetName();
   public void SetName(string value);

   public int GetId();
}
...
var bar = new Bar();
Blarf.DoSomething(bar.GetName, bar.SetName, bar.GetId);

แต่นั่นเป็นความเจ็บปวดเล็กน้อยที่ฉันต้องพูดถึงbarสามครั้งในการโทรครั้งเดียว นอกจากนี้ฉันไม่ได้ตั้งใจให้ผู้โทรจัดหาฟังก์ชั่นจากอินสแตนซ์ที่แตกต่างกัน

Blarf.DoSomething(bar1.GetName, bar2.SetName, bar3.GetId); // NO!

ใน C #, interfaceเป็นวิธีหนึ่งในการจัดการกับสิ่งนี้; แต่ดูเหมือนว่าเป็นวิธีการเชิงวัตถุมาก ฉันสงสัยว่ามีวิธีแก้ปัญหาการทำงานเพิ่มเติม: 1) ผ่านกลุ่มของฟังก์ชั่นร่วมกันและ 2) ให้แน่ใจว่าฟังก์ชั่นที่เกี่ยวข้องกันอย่างถูกต้อง

อย่าใช้การเขียนโปรแกรมที่ใช้งานเป็นแผ่นไม้อัดบาง ๆ มีมากกว่าความแตกต่างของวากยสัมพันธ์

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

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

มีสองสามวิธีในการอนุญาตให้ฟังก์ชันจัดการกับอินพุตหลายอินพุต

ครั้งแรกและที่พบบ่อยที่สุด: Parametric Polymorphism

สิ่งนี้ทำให้ฟังก์ชั่นกระทำกับชนิดใด ๆ :

--Haskell Example
id :: a -> a --Here 'a' is just some arbitrary type
id myRandomThing = myRandomThing

head :: [a] -> a
head (listItem:list) = listItem

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

class Addable a where
   (<+>) :: a -> a -> a
instance Addable Int where
   a <+> b = a + b
instance Addable [a] where
   a <+> b = a ++ b

--Now we can get that do something similar to OO (kinda...)
addStuff :: (Addable a) => [a] -> a
-- Notice how we limit 'a' here to be something Addable
addStuff (x:[]) = x
addStuff (x:xs) = x <+> addStuff xs
-- In better Haskell form
addStuff' = foldl1 <+>

ระหว่างกลไกทั้งสองนี้คุณสามารถแสดงพฤติกรรมที่ซับซ้อนและน่าสนใจทุกประเภทในประเภทของคุณ

กฎพื้นฐานของหัวแม่มือคือในฟังก์ชั่นการเขียนโปรแกรม FP ทำงานเช่นเดียวกับวัตถุที่ทำในการเขียนโปรแกรม OO คุณสามารถเรียกวิธีการของพวกเขา (เช่นกันวิธีการ "เรียก") และพวกเขาตอบสนองตามกฎภายในบางอย่างที่ห่อหุ้มแล้ว โดยเฉพาะอย่างยิ่งภาษา FP ที่เหมาะสมทุกประเภทช่วยให้คุณมี "ตัวแปรอินสแตนซ์" ในการทำงานของคุณด้วยการปิด / กำหนดขอบเขตศัพท์

var make_OO_style_counter = function(){
   return {
      counter: 0
      increment: function(){
          this.counter += 1
          return this.counter;
      }
   }
};

var make_FP_style_counter = function(){
    var counter = 0;
    return fucntion(){
        counter += 1
        return counter;
    }
};

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

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

var my_blarfable = {
 get_name: function(){ ... },
 set_name: function(){ ... },
 get_id:   function(){ ... }
}

do_something(my_blarfable)

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

-- Explicit dictionary version
-- no setters because haskell doesn't like mutable state.
data BlargDict = BlargDict {
    blarg_name :: String,
    blarg_id   :: Integer
}

do_something :: BlargDict -> IO()
do_something blarg_dict = do
   print (blarg_name blarg_dict)
   print (blarg_id   blarg_dict)

-- Typeclass version   
class Blargable a where
   blag_name :: a -> String
   blag_id   :: a -> String

do_something :: Blargable a => a -> IO
do_something blarg = do
   print (blarg_name blarg)
   print (blarg_id   blarg)

สิ่งสำคัญสิ่งหนึ่งที่ควรทราบเกี่ยวกับ typeclasses อย่างไรก็ตามคือพจนานุกรมที่เกี่ยวข้องกับชนิดและไม่ใช่ค่า (เช่นสิ่งที่เกิดขึ้นในพจนานุกรมและรุ่น OO) ซึ่งหมายความว่าระบบประเภทไม่อนุญาตให้คุณผสม "ประเภท" [1] หากคุณต้องการรายการ "blargables" หรือฟังก์ชั่นไบนารีที่ใช้ในการ blargables แล้ว typeclasses จะ จำกัด ทุกอย่างให้เป็นประเภทเดียวกันในขณะที่วิธีการพจนานุกรมจะช่วยให้คุณมีต้นกำเนิดที่แตกต่างกัน (รุ่นที่ดีขึ้นมากในสิ่งที่คุณเป็น ทำ)

[1] มีวิธีการขั้นสูงในการทำ "ประเภทอัตถิภาวนิยม" แต่โดยทั่วไปแล้วจะไม่คุ้มกับปัญหา

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

;; returns a function of the type #'(lambda (x y z &optional a b c)

(defun get-higher-level-method-impl (some-type-of-qualifier) 
    (cond ((eq 'foo) #'the-foo-version)
          ((eq 'bar) #'the-bar-version)))