ฟังก์ชั่นเวลามีอยู่ในการตั้งโปรแกรมการทำงานอย่างไร

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

ตัวอย่างเช่นพิจารณาสิ่งนี้:

f(x,y) = x*x + y; // It is a mathematical function

ไม่ว่าคุณจะใช้ไปกี่ครั้งf(10,4)ก็ตามคุณค่าของมันจะยังคงอยู่ตลอด104ไป ดังนั้นทุกที่ที่คุณเขียนf(10,4)คุณสามารถแทนที่ด้วย104โดยไม่ต้องเปลี่ยนค่าของการแสดงออกทั้งหมด คุณสมบัตินี้เรียกว่าการอ้างอิงโปร่งใสของการแสดงออก

ตามที่ Wikipedia พูดว่า ( ลิงค์ )

ในทางกลับกันในฟังก์ชั่นรหัสค่าเอาท์พุทของฟังก์ชั่นขึ้นอยู่กับอาร์กิวเมนต์ที่ใส่เข้าไปในฟังก์ชั่นเท่านั้นดังนั้นการเรียกใช้ฟังก์ชัน f สองครั้งด้วยค่าเดียวกันสำหรับอาร์กิวเมนต์ x จะให้ผลลัพธ์ที่เหมือนกัน f (x) ทั้งสองครั้ง

ฟังก์ชั่นเวลา (ซึ่งจะคืนค่าเวลาปัจจุบัน ) สามารถมีอยู่ในการตั้งโปรแกรมการทำงานหรือไม่

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

• หรือถ้าไม่, แล้วเราจะรู้เวลาปัจจุบันในการโปรแกรมเชิงฟังก์ชันได้อย่างไร?

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

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

ทีนี้คุณจะพิมพ์เวลาปัจจุบันไปยังคอนโซลได้อย่างไร? คุณต้องรวมการกระทำสองอย่างเข้าด้วยกัน แล้วเราจะทำอย่างไร เราไม่สามารถผ่านgetClockTimeไปprintได้เนื่องจากการพิมพ์คาดว่าจะมีการประทับเวลาไม่ใช่การกระทำ แต่เราสามารถจินตนาการได้ว่ามีโอเปอเรเตอร์>>=ซึ่งรวมสองแอคชั่นหนึ่งอันที่ได้รับการประทับเวลาและอีกอันหนึ่งที่ใช้เวลาหนึ่งเป็นอาร์กิวเมนต์และพิมพ์มัน การนำสิ่งนี้ไปใช้กับการกระทำที่กล่าวถึงก่อนหน้าผลลัพธ์คือ ... tadaaa ... การกระทำใหม่ที่ได้รับเวลาปัจจุบันและพิมพ์ออกมา และนี่คือสิ่งที่บังเอิญทำใน Haskell

Prelude> System.Time.getClockTime >>= print
Fri Sep  2 01:13:23 東京 (標準時) 2011

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

ฉันไม่รู้ว่านี่เป็นคำอธิบายที่ชัดเจนกว่าคำอธิบายอื่น ๆ หรือไม่ แต่บางครั้งมันก็ช่วยให้ฉันคิดได้ด้วยวิธีนี้

ใช่และไม่.

ภาษาโปรแกรมการทำงานที่แตกต่างกันแก้ปัญหาต่างกัน

ใน Haskell (บริสุทธิ์มาก) ทุกสิ่งนี้จะเกิดขึ้นได้ในสิ่งที่เรียกว่าI / O Monad - ดูที่นี่

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

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

ดังที่ Jeffrey Burka พูดถึงในความคิดเห็นของเขา: นี่คือการแนะนำที่ดีสำหรับ I / O Monadตรงจาก Haskell wiki

ใน Haskell เราใช้โครงสร้างที่เรียกว่าmonadเพื่อจัดการกับผลข้างเคียง โดยทั่วไปแล้ว Monad หมายความว่าคุณใส่ค่าลงในคอนเทนเนอร์และมีฟังก์ชั่นบางอย่างเพื่อเชื่อมโยงฟังก์ชันจากค่าไปยังค่าภายในคอนเทนเนอร์ หากคอนเทนเนอร์ของเรามีประเภท:

data IO a = IO (RealWorld -> (a,RealWorld))

เราสามารถใช้การกระทำของ IO ได้อย่างปลอดภัย ประเภทนี้หมายถึง: การกระทำของประเภทIOเป็นฟังก์ชั่นที่ใช้โทเค็นของประเภทRealWorldและส่งกลับโทเค็นใหม่พร้อมกับผล

คิดที่อยู่เบื้องหลังนี้คือการที่แต่ละ IO RealWorldดำเนินการแปรรูปรัฐนอกแสดงโดยโทเค็นที่มีมนต์ขลัง ด้วยการใช้ monads เราสามารถโยงฟังก์ชั่นหลาย ๆ อย่างที่กลายเป็นโลกแห่งความจริงเข้าด้วยกัน หน้าที่ที่สำคัญที่สุดของ monad คือการผูกมัดที่>>=เด่นชัด:

(>>=) :: IO a -> (a -> IO b) -> IO b

>>=ใช้เวลาหนึ่งการกระทำและฟังก์ชั่นที่ใช้ผลของการกระทำนี้และสร้างการกระทำใหม่ออกมาจากนี้ ชนิดส่งคืนคือการดำเนินการใหม่ ตัวอย่างเช่นสมมติว่ามีฟังก์ชั่นnow :: IO Stringซึ่งจะส่งกลับสตริงที่แสดงเวลาปัจจุบัน เราสามารถโยงมันเข้ากับฟังก์ชั่นputStrLnเพื่อพิมพ์:

now >>= putStrLn

หรือเขียนเป็นdo-Notation ซึ่งเป็นที่คุ้นเคยกับโปรแกรมเมอร์ที่จำเป็น:

do currTime <- now
   putStrLn currTime

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

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

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

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

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

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

ใน C # คุณสามารถใช้มันเช่นนี้:

// Exposes mutable time as immutable time (poorly, to illustrate by example)
// Although the insides are mutable, the exposed surface is immutable.
public class ClockStamp {
    public static readonly ClockStamp ProgramStartTime = new ClockStamp();
    public readonly DateTime Time;
    private ClockStamp _next;

    private ClockStamp() {
        this.Time = DateTime.Now;
    }
    public ClockStamp NextMeasurement() {
        if (this._next == null) this._next = new ClockStamp();
        return this._next;
    }
}

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

คลาส 'ClockStamp' นี้ทำหน้าที่เหมือนรายการเชื่อมโยงที่ไม่เปลี่ยนแปลง แต่จริงๆแล้วโหนดนั้นสร้างขึ้นตามความต้องการเพื่อให้สามารถมีเวลา 'ปัจจุบัน' ได้ ฟังก์ชั่นใด ๆ ที่ต้องการวัดเวลาควรมีพารามิเตอร์ 'clockStamp' และต้องส่งคืนการวัดครั้งสุดท้ายในผลลัพธ์ด้วย (ผู้โทรไม่เห็นการวัดเก่า) เช่นนี้:

// Immutable. A result accompanied by a clockstamp
public struct TimeStampedValue<T> {
    public readonly ClockStamp Time;
    public readonly T Value;
    public TimeStampedValue(ClockStamp time, T value) {
        this.Time = time;
        this.Value = value;
    }
}

// Times an empty loop.
public static TimeStampedValue<TimeSpan> TimeALoop(ClockStamp lastMeasurement) {
    var start = lastMeasurement.NextMeasurement();
    for (var i = 0; i < 10000000; i++) {
    }
    var end = start.NextMeasurement();
    var duration = end.Time - start.Time;
    return new TimeStampedValue<TimeSpan>(end, duration);
}

public static void Main(String[] args) {
    var clock = ClockStamp.ProgramStartTime;
    var r = TimeALoop(clock);
    var duration = r.Value; //the result
    clock = r.Time; //must now use returned clock, to avoid seeing old measurements
}

แน่นอนมันไม่สะดวกที่จะต้องผ่านการวัดครั้งสุดท้ายที่เข้าและออกเข้าและออกเข้าและออก มีหลายวิธีในการซ่อนสำเร็จรูปโดยเฉพาะในระดับการออกแบบภาษา ฉันคิดว่า Haskell ใช้กลอุบายแบบนี้แล้วซ่อนส่วนที่น่าเกลียดโดยใช้ monads

ฉันประหลาดใจที่ไม่มีคำตอบหรือความคิดเห็นที่พูดถึง coalgebras หรือการทำเงิน โดยทั่วไปการบอกกล่าวการทำเงินจะถูกกล่าวถึงเมื่อให้เหตุผลเกี่ยวกับโครงสร้างข้อมูลที่ไม่มีขีด จำกัด แบบจำลองถ่านหินสถานะที่ซ่อนอยู่; และแบบจำลองการตรวจสอบสถานะของรัฐนั้น (โมเดลการเหนี่ยวนำปกติสร้างสถานะ)

นี่เป็นหัวข้อยอดนิยมใน Reactive Functional Programming หากคุณสนใจเนื้อหาประเภทนี้อ่านสิ่งนี้: http://digitalcommons.ohsu.edu/csetech/91/ (28 หน้า)

ใช่เป็นไปได้ที่ฟังก์ชั่น pure จะส่งคืนเวลาหากได้รับเวลานั้นเป็นพารามิเตอร์ อาร์กิวเมนต์เวลาที่ต่างกันผลลัพธ์เวลาต่างกัน จากนั้นจัดรูปแบบฟังก์ชั่นอื่น ๆ ของเวลาเช่นกันและรวมเข้ากับคำศัพท์ฟังก์ชัน (-of-time) -transforming (ลำดับสูงกว่า) ฟังก์ชั่น ตั้งแต่วิธีการที่เป็นคนไร้สัญชาติเวลาที่นี่สามารถต่อเนื่อง (ความละเอียดอิสระ) มากกว่าที่ไม่ต่อเนื่องมากส่งเสริมต้นแบบ สัญชาตญาณนี้เป็นพื้นฐานของฟังก์ชั่นการเขียนโปรแกรมปฏิกิริยา (FRP)

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

ตามผลลัพธ์ตอนนี้ () อาจดูเหมือนไม่ติดตามความโปร่งใสในการอ้างอิง แต่พฤติกรรมที่แท้จริงของนาฬิการะบบและฟังก์ชั่นด้านบนนั้นเป็นไปตามความโปร่งใสอ้างอิง

ใช่ฟังก์ชั่นการหาเวลาสามารถมีอยู่ในฟังก์ชั่นการเขียนโปรแกรมโดยใช้รุ่นที่แก้ไขเล็กน้อยในการเขียนโปรแกรมฟังก์ชั่นที่เรียกว่าการเขียนโปรแกรมฟังก์ชั่นที่ไม่บริสุทธิ์ (เริ่มต้นหรือหลัก

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

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

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

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

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

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

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

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

-- this is a pure function, written in functional style.
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)

-- This is an impure wrapper around the pure function, written in imperative style
-- It depends on inputs and produces outputs.
main = do
    putStrLn "Please enter the input parameter"
    inputStr <- readLine
    putStrLn "Starting time:"
    getCurrentTime >>= print
    let inputInt = read inputStr    -- this line is pure
    let result = fib inputInt       -- this is also pure
    putStrLn "Result:"
    print result
    putStrLn "Ending time:"
    getCurrentTime >>= print

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

ยกตัวอย่างเช่น Haskell runtime คาดหวังให้ฉันกำหนดการกระทำที่เรียกmainว่าประกอบด้วยการกระทำทั้งหมดที่ประกอบเป็นโปรแกรมของฉัน จากนั้นรันไทม์รันการกระทำนี้ เวลาส่วนใหญ่ในการทำเช่นนั้นมันรันรหัสบริสุทธิ์ ในบางครั้งรันไทม์จะใช้ข้อมูลที่คำนวณได้เพื่อดำเนินการ I / O และดึงข้อมูลกลับเข้าไปในรหัสบริสุทธิ์

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

ตัวอย่าง: clock_t c = time(NULL); printf("%d\n", c + 2);ใน C, vs. main = getCPUTime >>= \c -> print (c + 2*1000*1000*1000*1000)ใน Haskell ผู้ประกอบการ>>=จะใช้ในการเขียนการกระทำผ่านผลการแรกที่ฟังก์ชั่นผลในการดำเนินการที่สอง สิ่งนี้ดูค่อนข้างลึกลับคอมไพเลอร์ Haskell สนับสนุนน้ำตาลประโยคที่ช่วยให้เราสามารถเขียนรหัสหลังดังนี้

type Clock = Integer -- To make it more similar to the C code

-- An action that returns nothing, but might do something
main :: IO ()
main = do
    -- An action that returns an Integer, which we view as CPU Clock values
    c <- getCPUTime :: IO Clock
    -- An action that prints data, but returns nothing
    print (c + 2*1000*1000*1000*1000) :: IO ()

หลังดูมีความจำเป็นมากใช่ไหม?

ถ้าใช่แล้วมันจะมีอยู่ได้อย่างไร? มันไม่ได้ละเมิดหลักการของฟังก์ชั่นการเขียนโปรแกรมหรือไม่? โดยเฉพาะอย่างยิ่งละเมิดความโปร่งใสของการอ้างอิง

มันไม่มีอยู่จริง

หรือถ้าไม่, แล้วเราจะรู้เวลาปัจจุบันในการโปรแกรมเชิงฟังก์ชันได้อย่างไร?

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

สำหรับ Haskell มีแนวคิดของ 'การกระทำของ IO' ซึ่งแสดงถึงประเภทที่สามารถดำเนินการกับกระบวนการ IO บางอย่างได้ ดังนั้นแทนที่จะอ้างอิงtimeค่าเราอ้างอิงIO Timeค่า ทั้งหมดนี้จะทำงานได้อย่างหมดจด เราไม่ได้มีการอ้างอิงถึงtimeแต่สิ่งที่ตามสายของ'อ่านค่าของเวลาที่ลงทะเบียน'

เมื่อเรารันโปรแกรม Haskell จริง ๆ แล้วการกระทำของ IO จะเกิดขึ้นจริง