Fonksiyonel programlamada bir zaman fonksiyonu nasıl mevcut olabilir?

İtiraf etmeliyim ki fonksiyonel programlama hakkında fazla bir şey bilmiyorum. Buradan ve buradan okudum ve böylece fonksiyonel programlamada, bir fonksiyonun, kaç kez çağrıldığına bakılmaksızın, aynı girdi için aynı çıktıyı döndürdüğünü öğrendim. Tam olarak, fonksiyon ifadesinde yer alan giriş parametrelerinin aynı değeri için aynı çıktıyı değerlendiren matematiksel bir fonksiyon gibidir.

Örneğin, şunu düşünün:

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

Kaç kez kullanırsanız kullanın f(10,4), değeri her zaman olacaktır 104. Bu nedenle, nerede olursanız olun , tüm ifadenin değerini f(10,4)değiştirmeden onu 104değiştirebilirsiniz. Bu özelliğe, bir ifadenin referans şeffaflığı denir .

Wikipedia'nın dediği gibi ( bağlantı ),

Tersine, işlevsel kodda, bir işlevin çıktı değeri yalnızca işleve girilen bağımsız değişkenlere bağlıdır, bu nedenle x işlevinin x bağımsız değişkeni için aynı değerle iki kez çağrılması her iki seferde de aynı sonucu f (x) üretir.

Fonksiyonel programlamada ( şimdiki zamanı döndüren) bir zaman fonksiyonu mevcut olabilir mi?

• Evet ise, o zaman nasıl var olabilir? Fonksiyonel programlama ilkesini ihlal etmiyor mu? Özellikle fonksiyonel programlamanın özelliğinden olan referans şeffaflığı ihlal eder (eğer doğru anlarsam).

• Ya da hayır ise fonksiyonel programlamanın şimdiki zamanını nasıl bilebilirsiniz?

Bunu açıklamanın başka bir yolu şudur: hiçbir işlev geçerli saati alamaz (değişmeye devam ettiğinden), ancak bir eylem geçerli saati alamaz. Bunun , şimdiki zamanı alma eyleminigetClockTime temsil eden sabit (veya isterseniz bir null fonksiyon) olduğunu varsayalım . Bu eylem , ne zaman kullanılırsa kullanılsın aynıdır, bu yüzden gerçek bir sabittir.

Benzer şekilde, printbiraz zaman temsil eden ve onu konsola yazdıran bir işlev olduğunu varsayalım. İşlev çağrıları saf işlevsel bir dilde yan etkilere sahip olamayacağından, bunun yerine zaman damgası alan ve konsola yazdırma eylemini döndüren bir işlev olduğunu hayal ederiz . Yine, bu gerçek bir işlevdir, çünkü aynı zaman damgasını verirseniz, her seferinde yazdırmanın aynı eylemini döndürür .

Şimdi, geçerli saati konsola nasıl yazdırabilirsiniz? İki eylemi birleştirmelisiniz. Peki bunu nasıl yapabiliriz? Biz sadece geçemediği getClockTimeiçin printbaskı bir zaman damgası, değil bir eylem beklediğini beri. Ama biz bir operatör, orada olduğunu hayal edebilirsiniz >>=, birleştirir iki eylemleri bir zaman damgası çeken benim ve argüman ve baskılar o kadar birini alır biri. Bunu daha önce bahsedilen eylemlere uygulamak, sonuç ... tadaaa ... şimdiki zamanı alan ve basan yeni bir eylemdir. Ve bu, Haskell'de tam olarak nasıl yapıldığıdır.

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

Yani, kavramsal olarak, bu şekilde görüntüleyebilirsiniz: Saf işlevsel bir program herhangi bir G / Ç gerçekleştirmez , çalışma zamanı sisteminin yürüttüğü bir eylem tanımlar . Eylem her zaman aynı, ama bunu yürütme sonucu yürütüldüğünde koşullarına bağlıdır.

Bunun diğer açıklamalardan daha açık olup olmadığını bilmiyorum, ancak bazen bu şekilde düşünmeme yardımcı oluyor.

Evet ve hayır.

Farklı fonksiyonel programlama dilleri bunları farklı şekilde çözer.

Haskell'de (çok saf olan) tüm bu şeyler I / O Monad denilen bir şeyde gerçekleşmelidir - buraya bakın .

Bunu, işlevinize (dünya devleti) başka bir girdi (ve çıktı) almak veya değişen zamanı elde etmek gibi "safsızlığın" gerçekleştiği bir yer olarak daha kolay düşünebilirsiniz.

F # gibi diğer diller sadece bazı safsızlıklara sahiptir ve böylece aynı giriş için farklı değerler döndüren bir işleve sahip olabilirsiniz - tıpkı normal zorunlu diller gibi .

Jeffrey Burka'nın yorumunda belirttiği gibi: İşte doğrudan Haskell wiki'sinden I / O Monad'a güzel bir giriş .

Haskell'de yan etkileri ele almak için monad adlı bir yapı kullanılır . Bir monad, temel olarak değerleri bir kaba kapsüllediğiniz ve işlevleri bir konteyner içindeki değerlerden değerlere zincirlemek için bazı işlevlere sahip olduğunuz anlamına gelir. Konteynerin tipi varsa:

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

ES eylemlerini güvenli bir şekilde uygulayabiliriz. Bu tür şu anlama gelir: Tür eylemi, tür belirteci alan ve sonuçla birlikte yeni bir belirteç döndüren bir IOişlevdir RealWorld.

Bunun arkasındaki fikir, her IO eyleminin büyülü belirteçle temsil edilen dış durumu değiştirmesidir RealWorld. Monadları kullanarak, gerçek dünyayı birlikte değiştiren birden fazla işlevi zincirleyebilirsiniz. Bir monadın en önemli işlevi >>=, belirgin bağlama :

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

>>=bir eylemi ve bu eylemin sonucunu alan bir işlevi alır ve bundan yeni bir eylem oluşturur. Dönüş türü yeni eylemdir. Örneğin, haydi bir işlevi yoktur gibi yapalım now :: IO Stringgeçerli zamanı temsil eden bir dize döndürür. putStrLnYazdırmak için fonksiyonla zincirleyebiliriz :

now >>= putStrLn

Veya dozorunlu bir programcıya daha aşina olan -Notation ile yazılmış :

do currTime <- now
   putStrLn currTime

Bütün bunlar saf, dış dünya ile ilgili mutasyonu ve bilgiyi jetonla eşleştirdik RealWorld. Yani her seferinde bu eylemi çalıştırdığınızda, elbette farklı bir çıktı elde edersiniz, ancak giriş aynı değildir: RealWorldsimge farklıdır.

Çoğu fonksiyonel programlama dili saf değildir, yani fonksiyonların sadece değerlerine bağlı kalmasına izin vermezler. Bu dillerde şimdiki zamanı döndüren bir işleve sahip olmak mükemmel bir şekilde mümkündür. Bu soruyu etiketlediğiniz dillerden Scala ve F # (ve diğer ML modellerinin çoğu ) için geçerlidir.

Saf olan Haskell ve Clean gibi dillerde durum farklıdır. Haskell'de şimdiki zaman bir işlevle değil, Haskell'in yan etkileri kapsülleme yolu olan IO eylemi ile kullanılabilirdi.

Clean'te bir işlev olurdu, ancak işlev argüman olarak bir dünya değerini alacak ve sonuç olarak (şimdiki zamana ek olarak) taze bir dünya değeri döndürecektir. Tür sistemi, her dünya değerinin yalnızca bir kez kullanılabilmesini sağlar (ve dünya değerini tüketen her işlev yeni bir değer üretir). Bu şekilde, zaman fonksiyonunun her seferinde farklı bir argümanla çağrılması gerekir ve böylece her seferinde farklı bir zamana geri dönmesine izin verilir.

"Geçerli saat" bir işlev değildir. Bu bir parametredir. Kodunuz geçerli saate bağlıysa, kodunuzun zamana göre parametrelendirildiği anlamına gelir.

Kesinlikle tamamen işlevsel bir şekilde yapılabilir. Bunu yapmanın birkaç yolu vardır, ancak en basit olanı zaman fonksiyonunun sadece zamanı değil, aynı zamanda bir sonraki zaman ölçümünü almak için aramanız gereken fonksiyonu geri getirmektir .

C # 'da şöyle uygulayabilirsiniz:

// 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;
    }
}

(Bunun basit olması gereken, pratik olmayan bir örnek olduğunu unutmayın. Özellikle, liste düğümleri ProgramStartTime tarafından köklendiği için toplanamaz.)

Bu 'ClockStamp' sınıfı değişmez bir bağlantılı liste gibi davranır, ancak gerçekten düğümler istek üzerine üretilir, böylece 'geçerli' zamanı içerebilirler. Saati ölçmek isteyen herhangi bir fonksiyonun bir 'clockStamp' parametresi olmalı ve aynı zamanda sonuçta son kez ölçümünü döndürmelidir (böylece arayan eski ölçümleri görmez):

// 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
}

Tabii ki, bu son ölçümü içeri ve dışarı, içeri ve dışarı, içeri ve dışarı geçirmek zorunda kalmak biraz sakıncalıdır. Isıtıcı plakayı, özellikle dil tasarımı düzeyinde gizlemenin birçok yolu vardır. Bence Haskell bu tür bir numara kullanıyor ve sonra çirkin kısımları monad kullanarak gizliyor.

Cevapların veya yorumların hiçbirinin kömürge veya koindüksiyondan bahsetmediğine şaşırdım. Genellikle, sonsuz veri yapıları hakkında akıl yürütmede koindüksiyondan bahsedilir, ancak aynı zamanda bir CPU üzerindeki zaman kaydı gibi sonsuz bir gözlem akışı için de geçerlidir. Bir kömürgebra gizli devleti modeller; ve bu durumu gözlemleyen coinduction modelleri . (Normal indüksiyon modelleri inşa devlet.)

Bu, Reaktif Fonksiyonel Programlama'da gündemde olan bir konudur. Bu tür şeylerle ilgileniyorsanız, şunu okuyun: http://digitalcommons.ohsu.edu/csetech/91/ (28 s.)

Evet, saf bir işlevin parametre olarak verildiği takdirde zamanı döndürmesi mümkündür. Farklı zaman argümanı, farklı zaman sonucu. Daha sonra zamanın diğer fonksiyonlarını da oluşturun ve basit bir fonksiyon (-of-zaman) -transforming (yüksek dereceli) fonksiyon kelime dağarcığı ile birleştirin. Yaklaşım vatansız olduğundan, buradaki zaman ayrık olmaktan ziyade sürekli (çözünürlükten bağımsız) olabilir ve modülerliği büyük ölçüde artırır . Bu sezgi Fonksiyonel Reaktif Programlamanın (FRP) temelidir.

Evet! Haklısın! Now () veya CurrentTime () veya bu tür bir aromanın herhangi bir yöntem imzası, bir şekilde referans şeffaflığı göstermemektedir. Ancak derleyiciye talimat vererek bir sistem saat girişi tarafından parametrelendirilir.

Çıktı olarak, Now () referans şeffaflığını takip etmiyor gibi görünebilir. Ancak sistem saatinin gerçek davranışı ve üstündeki işlev referans şeffaflığına bağlıdır.

Evet, fonksiyonel programlamada saf olmayan fonksiyonel programlama olarak bilinen biraz değiştirilmiş bir sürüm kullanılarak fonksiyonel programlamada bir alma süresi fonksiyonu bulunabilir (varsayılan veya ana işlev saf fonksiyonel programlamadır).

Zamanın alınması (veya dosya okunması veya füze fırlatılması) durumunda, işin yapılabilmesi için kodun dış dünya ile etkileşime girmesi gerekir ve bu dış dünya işlevsel programlamanın saf temellerine dayanmaz. Saf bir fonksiyonel programlama dünyasının bu saf olmayan dünyayla etkileşime girmesine izin vermek için, insanlar saf olmayan fonksiyonel programlama başlattı. Sonuçta, dış dünya ile etkileşime girmeyen yazılımlar, bazı matematiksel hesaplamalar yapmaktan başka yararlı değildir.

Birkaç fonksiyonel programlama programlama dili, içlerinde hangi safsızlık ve hangisinin saf olduğunu (F #, vb.) Ayırmak kolay olmayacak şekilde bu safsızlık özelliğine sahiptir ve bazı fonksiyonel programlama dilleri, bazı saf olmayan şeyler yaptığınızda bu kod, Haskell gibi saf kodla karşılaştırıldığında açıkça göze çarpıyor.

Bunu görmenin bir başka ilginç yolu, fonksiyonel programlamada zaman alma fonksiyonunuzun, zaman, dünyada yaşayan insan sayısı vb. Gibi dünyanın mevcut durumuna sahip bir "dünya" nesnesini almasıdır. nesne her zaman saf olurdu yani her zaman aynı zaman alacak aynı dünya devleti geçmek.

Sorunuz bir bilgisayar dilinin ilgili iki ölçümünü kapsamaktadır: işlevsel / zorunlu ve saf / saf olmayan.

İşlevsel bir dil, işlevlerin giriş ve çıkışları arasındaki ilişkileri tanımlar ve zorunlu bir dil, belirli işlemleri gerçekleştirilecek belirli bir sırayla tanımlar.

Saf bir dil yan etkilere neden olmaz veya yan etkilere bağlı değildir ve saf olmayan bir dil bunları baştan sona kullanır.

Yüzde yüz saf program temelde işe yaramaz. İlginç bir hesaplama yapabilirler, ancak yan etkileri olmadığı için girdi veya çıktıları yoktur, böylece ne hesapladıklarını asla bilemezsiniz.

Hiç faydalı olmak için, bir program en azından keskin bir safsızlık olmalıdır. Saf bir programı kullanışlı hale getirmenin bir yolu, onu ince bir saf olmayan sargıya koymaktır. Bu denenmemiş Haskell programı gibi:

-- 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

Fonksiyonel programlamada çok önemli bir konuyu, yani G / Ç işlemini gerçekleştiriyorsunuz. Pek çok saf dilin gidişatı, gömülü alana özgü diller kullanmaktır, örneğin, görevi eylemleri kodlamak olan bir alt dil olabilecek olan ve sonuçları olabilen .

Örneğin Haskell çalışma zamanı, şöyle bir eylem tanımlamamı bekliyor: main programımı oluşturan tüm eylemlerden oluşan . Çalışma zamanı daha sonra bu eylemi yürütür. Çoğu zaman, bunu yaparken saf kod yürütür. Çalışma zamanı zaman zaman G / Ç gerçekleştirmek için hesaplanan verileri kullanır ve verileri tekrar saf koda geri gönderir.

Bunun hile gibi göründüğünden şikayet edebilirsiniz ve bir şekilde: eylemleri tanımlayarak ve çalışma zamanının bunları yürütmesini bekleyerek, programcı normal bir programın yapabileceği her şeyi yapabilir. Ancak Haskell'in güçlü tip sistemi, programın saf ve "saf olmayan" parçaları arasında güçlü bir bariyer oluşturur: mevcut CPU saatine iki saniye ekleyemezsiniz, diyelim ki yazdırabilirsiniz, akımla sonuçlanan bir eylem tanımlamanız gerekir. CPU zamanını seçin ve sonucu iki saniye ekleyen ve sonucu basan başka bir eyleme geçirin. Bir programın çok fazla yazılması kötü bir stil olarak kabul edilir, çünkü bize her şeyi anlatan Haskell türlerine kıyasla hangi etkilerin neden olduğunu ortaya çıkarmayı zorlaştırır bir değerin ne olduğu hakkında bildiğimiz .

Örnek: clock_t c = time(NULL); printf("%d\n", c + 2);C'de, main = getCPUTime >>= \c -> print (c + 2*1000*1000*1000*1000)Haskell'de. Operatör >>=, ilk işlemin sonucunu ikinci eylemle sonuçlanan bir işleve geçirerek eylemler oluşturmak için kullanılır. Bu oldukça gizemli görünen Haskell derleyicileri, ikinci kodu aşağıdaki gibi yazmamızı sağlayan sözdizimsel şekeri destekler:

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 ()

İkincisi oldukça zorunlu görünüyor, değil mi?

Evet ise, o zaman nasıl var olabilir? Fonksiyonel programlama ilkesini ihlal etmiyor mu? Özellikle referans şeffaflığını ihlal ediyor

Tamamen işlevsel bir anlamda mevcut değildir.

Ya da hayır ise fonksiyonel programlamanın şimdiki zamanını nasıl bilebilirsiniz?

İlk olarak bir bilgisayarda zamanın nasıl alındığını bilmek faydalı olabilir. Esasen, zamanı takip eden yerleşik devre vardır (bu, bir bilgisayarın genellikle küçük bir hücreli pile ihtiyaç duymasının sebebidir). Sonra belirli bir bellek kaydında zamanın değerini ayarlayan bazı dahili işlemler olabilir. Hangi aslında CPU tarafından alınabilecek bir değere kaynar.

Haskell için, bazı IO sürecini gerçekleştirmek için yapılabilecek bir türü temsil eden bir 'IO eylemi' kavramı vardır. Dolayısıyla bir timedeğere başvurmak yerine bir değere başvuruyoruz IO Time. Bütün bunlar tamamen işlevsel olacaktır. Referans vermiyoruz, timeancak 'zaman kaydının değerini okuyun' çizgisinde bir şey var .

Haskell programını gerçekten yürüttüğümüzde, aslında ES eylemi gerçekleşecekti.