it-swarm-tr.com

(Fonksiyonel) reaktif programlama nedir?

Wikipedia makalesini okudum reaktif programlama . Ayrıca işlevsel reaktif programlama hakkındaki küçük makaleyi de okudum. Açıklamalar oldukça soyut.

  1. İşlevsel reaktif programlama (FRP) pratikte ne anlama geliyor?
  2. Reaktif programlama (reaktif olmayan programlamanın aksine) nelerden oluşur?

Geçmişim zorunlu/OO dillerinde, bu nedenle bu paradigma ile ilgili bir açıklama memnuniyetle karşılanacaktır.

1149
JtR

FRP hakkında bir fikir edinmek istiyorsanız, eski Fran tutorial ile 1998'den başlayabilirsiniz, ki bunlar animasyonlu resimlerdir. Makaleler için, Fonksiyonel Reaktif Animasyon ile başlayın ve ardından ana sayfamdaki yayınlar bağlantısında ve FRPHaskell wiki üzerindeki bağlantı.

Şahsen, nasıl uygulanabileceğini ele almadan önce FRP /ne anlama geldiğini düşünmeyi seviyorum. (Spesifikasyon içermeyen kod, sorgusuz bir cevaptır ve bu nedenle “yanlış bile değildir”.) Bu yüzden FRP'yi temsil/uygulama terimlerinde Thomas K'nın başka bir cevabında yaptığı gibi (grafikler, düğümler, kenarlar, ateşleme, yürütme, vb). Pek çok olası uygulama stili vardır, ancak hiçbir uygulama FRP 'nin ne olduğunu söylemez.

Laurence G'nin FRP'nin “'zaman içinde' değerini temsil eden veri türleri” ile ilgili basit bir tanımına uyuyorum. Geleneksel zorunlu programlama, bu dinamik değerleri yalnızca dolaylı olarak durum ve mutasyonlarla yakalar. Tarihin tamamı (geçmiş, şimdiki zaman, gelecek) birinci sınıf temsil edilmez. Üstelik, zorunlu paradigma geçici olarak ayrık olduğundan, yalnızca gizlice evrimleşendeğerler yakalanabilir (dolaylı olarak). Buna karşılık FRP, bu değişen değerleri doğrudan'da yakalar ve sürekligelişen değerlerle hiçbir zorluk çekmez.

FRP, aynı zamanda zorunlu eşzamanlılığı rahatsız eden teorik ve pragmatik sıçanların yuvasını bozmadan eşzamanlı olması nedeniyle de olağandışıdır. Anlamsal olarak, FRP'nin eşzamanlılığı ince taneli, determinantve süreklişeklindedir. (Uygulamadan değil anlamdan bahsediyorum. Bir uygulama eşzamanlılık veya paralellik içerebilir veya içermeyebilir.) Anlamsal belirsizlik, gerekçeli ve gayrı resmi muhakeme için çok önemlidir. Eşzamanlılık zorunlu programlamaya muazzam bir karmaşıklık katıyor olsa da (klasik olmayan bir araya getirme nedeniyle) FRP'de zahmetsizdir.

Öyleyse, FRP nedir? Kendin icat edebilirdin. Bu fikirlerle başlayın:

  • Dinamik/gelişen değerler (yani, "zaman içinde" değerleri), kendi içinde birinci sınıf değerlerdir. Onları tanımlayabilir ve birleştirebilir, fonksiyonların içine ve dışına aktarabilirsiniz. Bunları "davranış" olarak adlandırdım.

  • Davranışlar, sabit (statik) davranışlar ve zaman (saat gibi) gibi birkaç ilkelden oluşur ve ardından sıralı ve paralel bir kombinasyonla oluşturulur. ndavranışlar n-ary işlevi (statik değerlerde), "nokta-bilge", yani zaman içinde sürekli uygulanarak birleştirilir.

  • Ayrık olayları hesaba katmak için, her biri bir akış akışına (sonlu veya sonsuz) sahip olan başka bir "olay" türü (aile) vardır. Her olayın ilişkili bir zaman ve değeri vardır.

  • Tüm davranış ve olayların kurgulanabileceği kompozisyon sözcüklerini bulmak için bazı örneklerle oynayın. Daha genel/basit olan parçalara ayırmaya devam edin.

  • Böylece sağlam bir zeminde olduğunuzu bildiğiniz için, tüm modele, anlamsal anlambilim tekniğini kullanarak, bir kompozisyonun temelini verin. Bu, sadece (a) her bir tipin karşılık gelen basit ve kesin bir "anlam" tipine sahip olduğu anlamına gelir. b) Her ilkel ve işleç, bileşenlerin anlamlarının bir işlevi olarak basit ve kesin bir anlama sahiptir. Asla, aslauygulama ile ilgili düşünceleri keşif işleminize karıştırmayın. Bu açıklama size saçmasa, (a) Tip sınıf morfizmi ile denotational tasarımına bakın, (b) Push- fonksiyonel reaktif programlama çekin(uygulama bitlerini göz ardı ederek) ve (c) İhbarname AnlambilimiHaskell Vikikitapları sayfası . Sözde anlambilimin, iki kurucusu Christopher Strachey ve Dana Scott'tan iki bölümü olduğunu göz önünde bulundurun: daha kolay ve daha kullanışlı Strachey bölümü ve daha zor ve daha az kullanışlı (yazılım tasarımı için) Scott bölümü.

Bu ilkelere sadık kalırsanız, FRP'nin ruhunda az ya da çok bir şey elde edeceğinizi umuyorum.

Bu ilkeleri nereden buldum? Yazılım tasarımında daima aynı soruyu soruyorum: "Bu ne anlama geliyor?". Sözde anlambilimsel bana bu soru için kesin bir çerçeve sağladı ve estetiğime uygun olanı (her ikisi de beni tatmin etmeyen operasyonel veya aksiyomatik anlambilimcilerin aksine). Ben de kendime davranış nedir diye sordum. Kısa süre önce, zorunlu hesaplamanın geçici olarak ayrık niteliğinin, davranışın kendisinin doğal bir tanımından ziyade, belirli bir makinestiline uyum sağladığını anladım. Aklıma gelen en basit davranış şekli, "sürekli zamanın fonksiyonu" dır, bu yüzden benim modelim. Zevkle, bu model kolaylıkla ve zarafet ile sürekli, deterministic eşzamanlılık işler.

Bu modeli doğru ve verimli bir şekilde uygulamak oldukça zor oldu, ancak bu başka bir hikaye.

932
Conal

Saf fonksiyonel programlamada, yan etkisi yoktur. Pek çok yazılım türü için (örneğin, kullanıcı etkileşimi olan herhangi bir şey), bazı düzeylerde yan etkiler gerekir.

İşlevsel bir stili korurken yan etki gibi davranmanın bir yolu da işlevsel reaktif programlama kullanmaktır. Bu, işlevsel programlama ve reaktif programlamanın birleşimidir. (Bağlandığınız Wikipedia makalesi sonuncusu ile ilgilidir.)

Reaktif programlamanın arkasındaki temel fikir, "zamanla" değerini temsil eden belirli veri tiplerinin olduğudur. Bu zaman içinde değişen değerleri içeren hesapların kendileri zaman içinde değişen değerlere sahip olacaktır.

Örneğin, fare koordinatlarını zamana bağlı bir çift değer olarak temsil edebilirsiniz. Diyelim ki şöyle bir şey yaşadık (bu sözde koddur):

x = <mouse-x>;
y = <mouse-y>;

Herhangi bir anda, x ve y, farenin koordinatlarına sahip olur. Reaktif olmayan programlamanın aksine, bu ödevi yalnızca bir kez yapmamız gerekir ve x ve y değişkenleri otomatik olarak "güncel kalır". Bu nedenle reaktif programlama ve fonksiyonel programlama birlikte çok iyi çalışıyor: reaktif programlama değişken değişkenleri mutasyona bırakma gereksinimini ortadan kaldırırken yine de değişken mutasyonlarla başarabileceğiniz şeyleri yapmanıza izin veriyor.

O zaman buna dayanarak bazı hesaplamalar yaparsak, ortaya çıkan değerler zamanla değişen değerler olacaktır. Örneğin:

minX = x - 16;
minY = y - 16;
maxX = x + 16;
maxY = y + 16;

Bu örnekte, minX her zaman fare işaretçisinin x koordinatından 16 daha az olacaktır. Reaktif bilinçli kütüphanelerle daha sonra şöyle bir şey söyleyebilirsiniz:

rectangle(minX, minY, maxX, maxY)

Fare işaretçisi etrafına 32x32 bir kutu çizilecek ve hareket ettiği her yerde izleyecektir.

İşte oldukça iyi fonksiyonel reaktif programlama üzerine kağıt .

740

Neye benzediği hakkında ilk sezgiye ulaşmanın kolay bir yolu, programınızın bir elektronik tablo olduğunu ve tüm değişkenlerinizin hücre olduğunu hayal etmektir. Bir elektronik tablodaki hücrelerin herhangi biri değişirse, o hücreye başvuran herhangi bir hücre de değişir. FRP ile aynı. Şimdi, hücrelerin bazılarının kendi başlarına değiştiğini (veya dış dünyadan alındığını) hayal edin: GUI durumunda, farenin konumu iyi bir örnek olur.

Bu mutlaka çok özlüyor. Bir FRP sistemi kullandığınızda metafor oldukça hızlı bozulur. Birincisi, genellikle ayrık olayları modelleme girişimleri de vardır (örneğin, tıklanan fare). Buraya sadece neye benzediği hakkında bir fikir vermek için koyuyorum.

144
Bob

Bana göre bu sembol = simgesinin yaklaşık 2 farklı anlamıdır:

  1. x = sin(t) matematiğinde, x öğesinin sin(t) için farklı ad olduğu anlamına gelir. Yani x + y yazmak, sin(t) + y ile aynı şeydir. Fonksiyonel reaktif programlama bu açıdan matematik gibidir: x + y yazarsanız, kullanıldığı zaman t değeri ne olursa olsun hesaplanır.
  2. C-benzeri programlama dillerinde (zorunlu diller) x = sin(t) bir atamadır: x, atama sırasında alınan değerinisin(t) saklar.
131
user712092

Tamam, arkaplan bilgisinden ve işaret ettiğiniz Wikipedia sayfasını okumaktan itibaren, reaktif programlamanın veri akışı hesaplaması gibi bir şey olduğu anlaşılıyor ama belirli bir harici "uyarıcı" ile bir düğüm kümesini ateşlemek ve hesaplamaları yapmak için tetikliyor.

Bu, bir kullanıcı arayüzü kontrolüne dokunmanın (örneğin, bir müzik çalma uygulamasındaki ses kontrolünün) dokunmasının çeşitli görüntü öğelerini ve gerçek ses çıkış hacmini güncellemesi gerekebileceği UI tasarımı için oldukça uygundur. Yönlendirilmiş bir grafikteki bir düğümle ilişkili değerin değiştirilmesine karşılık gelecek olan hacmi (kaydırıcı, diyelim) değiştirdiğinizde.

Bu "hacim değeri" düğümünden kenarları olan çeşitli düğümler otomatik olarak tetiklenecek ve gerekli tüm hesaplamalar ve güncellemeler doğal olarak uygulama boyunca dalgalanacaktır. Uygulama, kullanıcı uyarıcısına "tepki verir". İşlevsel reaktif programlama, bu fikrin işlevsel bir dilde veya genellikle işlevsel bir programlama paradigması içerisinde uygulanması olabilir.

"Dataflow computing" hakkında daha fazla bilgi için Wikipedia'da bu iki kelimeyi arayın veya en sevdiğiniz arama motorunu kullanın. Genel fikir şudur: Program, her biri basit hesaplamalar yapan, yönlendirilmiş bir düğüm grafiğidir. Bu düğümler, bazı düğümlerin çıkışlarını başkalarının girişlerine sağlayan grafik bağlantıları ile birbirine bağlanır.

Bir düğüm ateşlediğinde veya hesaplamasını yaptığında, çıkışlarına bağlı olan düğümler kendilerine karşılık gelen "tetiklenmiş" veya "işaretlenmiş" girişlerine sahiptir. Tüm girişleri tetikleyen/işaretleyen/mevcut olan herhangi bir düğüm otomatik olarak patlar. Grafik, reaktif programlamanın tam olarak nasıl uygulandığına bağlı olarak örtük veya açık olabilir.

Düğümler paralel olarak ateşlenir gibi bakılabilir, ancak çoğu zaman seri olarak veya sınırlı paralellik ile yürütülürler (örneğin, bunları yürüten birkaç iş parçacığı olabilir). Ünlü bir örnek Manchester Dataflow Machine idi; (IIRC), bir veya daha fazla yürütme birimi aracılığıyla grafikteki düğümlerin yürütülmesini planlamak için etiketli bir veri mimarisini kullandı. Dataflow hesaplama, hesaplamaları asenkron olarak tetikleyen hesaplamaların kaskadlara neden olduğu durumlarda, uygulamanın bir saat (veya saatler) tarafından yönetilmeye çalışılmasından daha iyi çalıştığı durumlar için oldukça uygundur.

Reaktif programlama bu "yürütme çağrısı" fikrini ithal eder ve programı veri akışı benzeri bir şekilde düşünür, ancak bazı düğümlerin "dış dünyaya" bağlı olması ve yürütme çağrısı bu duyusal olarak tetiklendiğinde şart koşar. benzeri düğümler değişir. Program yürütme daha sonra karmaşık bir refleks arkına benzer bir şeye benzeyecektir. Program uyaranlar arasında temel olarak sapsız olabilir veya olmayabilir ya da uyaranlar arasında temel olarak sapsız bir duruma yerleşebilir.

"reaktif olmayan" programlama, yürütme akışını ve dış girdilerle ilişkisini çok farklı bir şekilde gösteren bir programlama olacaktır. Bazı sübjektif olması muhtemeldir, çünkü insanlar dış girdilere cevap veren herhangi bir şeyi kendilerine "tepki verir" diyecekler. Ancak olayın ruhuna bakıldığında, bir olay sırasını sabit bir aralıkta yoklayan ve işlevlerde (veya iş parçacıklarında) bulunan olayları gönderen bir program daha az reaktifdir (çünkü yalnızca belirli bir aralıktaki kullanıcı girdisine katılır). Yine, buradaki şeyin özüdür: Bir kişi çok hızlı bir oylama aralığına sahip bir yoklama uygulamasının çok düşük bir seviyeye koyduğunu ve bunun üzerine reaktif bir şekilde program yaptığını hayal edebilir.

71
Thomas Kammeyer

FRP hakkında birçok sayfa okuduktan sonra nihayet rastladım this FRP hakkında aydınlatıcı yazılar, FRP'nin gerçekte neyle ilgili olduğunu anlamamı sağladı.

Heinrich Apfelmus (reaktif muzun yazarı) altından alıntı yapıyorum.

Fonksiyonel reaktif programlamanın özü nedir?

Yaygın bir cevap, “FRP'nin, bir sistemi değişken durum yerine zamanla değişen fonksiyonlar açısından tanımlamakla ilgili” olduğu ve bunun kesinlikle yanlış olmayacağı şeklinde olacaktır. Bu anlamsal bakış açısı. Ancak benim görüşüme göre, daha derin, daha tatmin edici bir cevap aşağıdaki tamamen sözdizimsel kriter tarafından verilmektedir:

İşlevsel reaktif programlamanın özü, bildirim sırasında bir değerin tamamen dinamik davranışını belirtmektir.

Örneğin, bir sayaç örneği alın: sayacı artırmak veya azaltmak için kullanılabilecek “Yukarı” ve “Aşağı” etiketli iki düğmeniz vardır. Zorunlu olarak, ilk önce bir başlangıç ​​değeri belirler ve daha sonra bir düğmeye basıldığında onu değiştirirsiniz; böyle bir şey:

counter := 0                               -- initial value
on buttonUp   = (counter := counter + 1)   -- change it later
on buttonDown = (counter := counter - 1)

Mesele şu ki, ilan sırasında sayaç için sadece ilk değer belirtildi; Sayacın dinamik davranışı, program metninin geri kalan kısmında gizlidir. Buna karşılık, işlevsel reaktif programlama, bildirim sırasındaki tüm dinamik davranışı şöyle belirtir:

counter :: Behavior Int
counter = accumulate ($) 0
            (fmap (+1) eventUp
             `union` fmap (subtract 1) eventDown)

Ne zaman sayaç dinamiklerini anlamak istediğinizde, sadece tanımına bakmak zorundasınız. Başına gelebilecek her şey sağ tarafta görünecektir. Bu, sonraki bildirimlerin daha önce bildirilen değerlerin dinamik davranışını değiştirebileceği zorunlu yaklaşımın aksinedir.

Yani, 'de anladığım kadarıyla bir FRP programı bir denklem kümesidir: enter image description here

jayrık: 1,2,3,4 ...

ft'e bağlıdır, bu yüzden dış uyaranları modelleme olanağını içerir.

programın tüm durumu x_i değişkenleriyle kapsüllenir

FRP kütüphanesi ilerleme zamanını, başka bir deyişle jj+1 'a alarak önemser.

Bu denklemleri this videoda çok daha ayrıntılı olarak açıklıyorum.

DÜZENLEME:

Orijinal cevabın yaklaşık 2 yıl sonra, geçenlerde FRP uygulamalarının başka önemli bir yönü olduğu sonucuna vardım. Önemli bir pratik problemi çözmeleri gerekir (ve genellikle yaparlar): önbellek geçersiz kılma .

x_i- s'nin denklemleri bir bağımlılık grafiğini açıklar. x_i öğelerinin bazıları jzamanında değiştiğinde, x_i' adresindeki diğer tüm j+1 değerlerinin güncellenmesi gerekmez, bu nedenle bazı bağımlılıkların yeniden hesaplanması gerekmeyebilir, çünkü bazı x_i'x_i öğesinden bağımsız olabilir.

Ayrıca, değişiklik yapan x_i- s'ler adım adım güncellenebilir. Örneğin, Scala'da f=g.map(_+1) bir harita işlemini ele alalım; burada fve gListname__, Intsname__'dir. Burada fx_i(t_j) işlevine karşılık gelir ve gx_j(t_j) işlevidir. Şimdi eğer bir elemanı g'e hazırlarsam, o zaman mapname__' daki tüm elemanlar için gişlemini yapmak israf olur. Bazı FRP uygulamaları (örneğin reflex-frp ) bu sorunu çözmeyi amaçlamaktadır. Bu problem aynı zamanda artımlı hesaplama. olarak da bilinir.

Başka bir deyişle, FRP'deki davranışlar (x_i- s) önbellek hesaplamaları olarak düşünülebilir. x_i- s'nin bir kısmı değişirse, bu cache-s'leri (f_i- s) etkin şekilde geçersiz kılmak ve yeniden hesaplamak FRP motorunun görevidir.

65
jhegedus

Feragatname: Cevabım Javascript için 'reaktif bir programlama' kütüphanesi olan rx.js bağlamında.

İşlevsel programlamada, koleksiyondaki her bir öğeyi yinelemek yerine, koleksiyonun kendisine daha yüksek dereceli işlevler (HoF'ler) uygularsınız. Öyleyse, FRP'nin ardındaki fikir, her bir olayı işlemek yerine, bir olaylar akışı (gözlemlenebilir * ile uygulanmış) oluşturmak ve bunun yerine HoF'leri uygulamaktır. Bu şekilde, sistemi yayıncıları abonelere bağlayan veri hatları olarak görselleştirebilirsiniz.

Bir gözlemlenebilir kullanmanın en büyük avantajları şunlardır:
i) durumunuzu kodunuzdan çıkartır, örneğin, olay işleyicisinin yalnızca her bir 'olayda' kovulmasını veya ilk 'n' olaylarından sonra ateş etmeyi durdurmak veya yalnızca ateşlemeye başlamak istiyorsanız İlk 'n' olaylarından sonra, sayaçları ayarlamak, güncellemek ve kontrol etmek yerine HoF'leri (filtre, sırasıyla TakeUntil, atla) kullanabilirsiniz.
ii) kodun yerini iyileştirir - bir bileşenin durumunu değiştiren 5 farklı olay işleyiciniz varsa, bunların gözlemlenebilir niteliklerini birleştirebilir ve birleştirilen gözlemlenebilir üzerinde tek bir olay işleyici tanımlayabilir, bunun yerine 5 olay işleyicisini etkin bir şekilde 1 Bu, tüm sisteminizdeki hangi olayların bir bileşeni etkileyebileceğini düşünmeyi çok kolaylaştırır, çünkü hepsi tek bir işleyicide mevcuttur.

  • Gözlenebilir, yinelenebilir olanın ikilisidir.

Yinelemeler tembel olarak tüketilen bir sekanstır - her öğe kullanmak istediği zaman yineleyici tarafından çekilir ve bu nedenle sayım tüketici tarafından belirlenir.

Gözlenebilir bir tembel olarak üretilen bir sekanstır - sekansa her eklendiğinde gözlemciye her öğe itilir ve bu nedenle sayım üretici tarafından sürülür.

29
tldr

Conal Elliott ( direkt PDF , 233 KB) tarafından yazılan Basitçe verimli işlevsel reaktivite oldukça iyi bir giriş. İlgili kütüphane de çalışır.

Kağıt şimdi başka bir kağıt tarafından üstlenildi, Çekmeli işlevsel reaktif programlama ( doğrudan PDF , 286 KB).

29
scvalex

Ahbap, bu çok garip bir fikir! 1998'de neden bunu bulamadım? Her neyse, işte benim yorumum Fran eğitimim. Öneriler çok açığız, buna dayalı bir oyun motorunu çalıştırmayı düşünüyorum.

import pygame
from pygame.surface import Surface
from pygame.Sprite import Sprite, Group
from pygame.locals import *
from time import time as Epoch_delta
from math import sin, pi
from copy import copy

pygame.init()
screen = pygame.display.set_mode((600,400))
pygame.display.set_caption('Functional Reactive System Demo')

class Time:
    def __float__(self):
        return Epoch_delta()
time = Time()

class Function:
    def __init__(self, var, func, phase = 0., scale = 1., offset = 0.):
        self.var = var
        self.func = func
        self.phase = phase
        self.scale = scale
        self.offset = offset
    def copy(self):
        return copy(self)
    def __float__(self):
        return self.func(float(self.var) + float(self.phase)) * float(self.scale) + float(self.offset)
    def __int__(self):
        return int(float(self))
    def __add__(self, n):
        result = self.copy()
        result.offset += n
        return result
    def __mul__(self, n):
        result = self.copy()
        result.scale += n
        return result
    def __inv__(self):
        result = self.copy()
        result.scale *= -1.
        return result
    def __abs__(self):
        return Function(self, abs)

def FuncTime(func, phase = 0., scale = 1., offset = 0.):
    global time
    return Function(time, func, phase, scale, offset)

def SinTime(phase = 0., scale = 1., offset = 0.):
    return FuncTime(sin, phase, scale, offset)
sin_time = SinTime()

def CosTime(phase = 0., scale = 1., offset = 0.):
    phase += pi / 2.
    return SinTime(phase, scale, offset)
cos_time = CosTime()

class Circle:
    def __init__(self, x, y, radius):
        self.x = x
        self.y = y
        self.radius = radius
    @property
    def size(self):
        return [self.radius * 2] * 2
circle = Circle(
        x = cos_time * 200 + 250,
        y = abs(sin_time) * 200 + 50,
        radius = 50)

class CircleView(Sprite):
    def __init__(self, model, color = (255, 0, 0)):
        Sprite.__init__(self)
        self.color = color
        self.model = model
        self.image = Surface([model.radius * 2] * 2).convert_alpha()
        self.rect = self.image.get_rect()
        pygame.draw.ellipse(self.image, self.color, self.rect)
    def update(self):
        self.rect[:] = int(self.model.x), int(self.model.y), self.model.radius * 2, self.model.radius * 2
circle_view = CircleView(circle)

sprites = Group(circle_view)
running = True
while running:
    for event in pygame.event.get():
        if event.type == QUIT:
            running = False
        if event.type == KEYDOWN and event.key == K_ESCAPE:
            running = False
    screen.fill((0, 0, 0))
    sprites.update()
    sprites.draw(screen)
    pygame.display.flip()
pygame.quit()

Kısacası: Her bileşen bir sayı gibi ele alınabilirse, tüm sistem bir matematik denklemi gibi ele alınabilir, değil mi?

18
Dan Ross

Paul Hudak'ın kitabı Haskell İfade Okul , Haskell’e sadece iyi bir giriş değil, aynı zamanda FRP’de de oldukça fazla zaman harcıyor. Eğer FRP'ye yeni başlayan biriyseniz, size FRP'nin nasıl çalıştığı hakkında bir fikir vermenizi tavsiye ederim.

Ayrıca bu kitabın yeni bir tekrarı gibi görünen de var (2011, 2014 yayınlandı), Haskell Müzik Okul .

14
Curt J. Sampson

Önceki cevaplara göre, matematiksel olarak, sadece daha yüksek bir sırada düşündüğümüz anlaşılıyor. Bir değer düşünmek yerine x türüne sahip X, bir işlev düşünürüz x: TX, burada T zamanın türüdür, doğal sayılar, tam sayılar veya süreklilik olabilir. Şimdi --- y: = x + 1'i programlama dilinde yazdığımızda, aslında y (t denklemini kastediyoruz. =) = x (t) + 1.

10
Yuning

Belirtildiği gibi bir elektronik tablo gibi davranır. Genellikle olaya dayalı bir çerçeveye dayanır.

Tüm "paradigmalarda" olduğu gibi, yeniliği de tartışmalıdır.

Aktörlerin dağıtılmış akış ağları deneyimimden kolayca, av ağları arasında düğümler ağı genel bir devlet tutarlılığı problemine, yani tuhaf döngülerde çok fazla salınım ve tuzağa düşme ihtimaline kolayca düşebilir.

Bazı anlambilim, referans döngüler veya yayın anlamına geldiğinden ve aktörler ağı öngörülemeyen bir durum üzerinde birleştiğinde (ya da olmadığında) oldukça karmakarışık olabileceğinden, bu durumdan kaçınmak zordur.

Benzer şekilde, iyi tanımlanmış kenarlara sahip olmasına rağmen bazı devletlere ulaşılamayabilir, çünkü küresel devlet çözümden uzaklaşıyor. 2 + 2 oluncaya ve bu şekilde kaldıklarına bağlı olarak 2 + 2 4 olabilir veya olmayabilir. Elektronik sayfalarda senkron saatler ve döngü algılama bulunur. Dağıtılmış aktörler genellikle yoktur.

Hepsi iyi eğlenceler :).

9
emperorz

Clojure subreddit'inde FRP ile ilgili bu Nice videosunu buldum. Clojure'u tanımıyor olsanız bile anlamak oldukça kolaydır.

İşte video: http://www.youtube.com/watch?v=nket0K1RXU4

Videonun 2. yarıda ifade ettiği kaynak: https://github.com/Cicayda/yolk-examples/blob/master/src/yolk_examples/client/autocomplete.cljs

8
Daniel Kaplan

Bu makale Andre Staltz tarafından şu ana kadar gördüğüm en iyi ve en net açıklama.

Makaleden bazı alıntılar:

Reaktif programlama, asenkron veri akışlarıyla programlamadır.

Bunun da ötesinde, bu akışların herhangi birini birleştirmek, oluşturmak ve filtrelemek için inanılmaz bir işlev kutusu kutusu verilir.

İşte makalenin bir parçası olan fantastik diyagramlara bir örnek:

Click event stream diagram

7
GreenGiant

Zaman içindeki matematiksel veri dönüşümleriyle ilgilidir (veya zamanı yok sayarak).

Kodda bu, fonksiyonel saflık ve bildirimsel programlama anlamına gelir.

Devlet böcekleri standart zorunluluk paradigmasında büyük bir problemdir. Çeşitli kod parçaları, programların yürütülmesinde farklı "zamanlarda" bazı paylaşılan durumları değiştirebilir. Başa çıkmak zor.

FRP'de (bildirimsel programlamada olduğu gibi) verilerin bir durumdan diğerine nasıl dönüştüğünü ve neyin tetiklendiğini açıklarsınız. Bu, zamanı görmezden gelmenizi sağlar, çünkü fonksiyonunuz sadece girdilerine tepki verir ve mevcut değerleri yeni bir tane oluşturmak için kullanır. Bu, durumun, dönüşüm düğümlerinin grafiğinde (veya ağacında) bulunduğu ve işlevsel olarak saf olduğu anlamına gelir.

Bu, karmaşıklığı ve hata ayıklama süresini büyük ölçüde azaltır.

Bir programda matematik A = B + C ve A = B + C arasındaki farkı düşünün. Matematikte asla değişmeyecek bir ilişkiyi tarif ediyorsun. Bir programda "Şu anda" A'nın B + C olduğu yazıyor. Ancak bir sonraki komut B ++ olabilir; bu durumda A, B + C'ye eşit değildir. Matematik veya bildirimsel programlamada, A'daki zamanın hangi noktasında olursa olsun, her zaman B + C'ye eşit olacaktır.

Böylece paylaşılan durumun karmaşıklığını ortadan kaldırarak ve zaman içinde değerleri değiştirerek. Programın sebebi çok daha kolaydır.

Bir EventStream, bir EventStream + bazı dönüşüm işlevidir.

Davranış bir EventStream + Bellekteki bir değerdir.

Olay başladığında, dönüşüm işlevi çalıştırılarak değer güncellenir. Bunun ürettiği değer davranış hafızasında saklanır.

Davranışlar, diğer N davranışlarında dönüşüm olan yeni davranışlar üretmek için oluşturulabilir. Bu oluşan değer, girdi olayları (davranışlar) ateşlendikçe yeniden hesaplanacaktır.

“Gözlemciler vatansız olduklarından, çoğu zaman sürükleyici örnekte olduğu gibi bir durum makinesini simüle etmek için çoğuna ihtiyacımız var. Yukarıdaki değişken yoldaki gibi tüm ilgili gözlemciler için erişilebilir olduğu durumu kaydetmeliyiz.”

Alıntı - Gözlemci Şablonunun Kaldırılması http://infoscience.epfl.ch/record/148043/files/DeprecatingObserversTR2010.pdf

5
Jay Shepherd

Reaktif Programlama ile ilgili kısa ve net açıklama Cyclejs - Reaktif Programlama üzerinde görünür ve basit ve görsel örnekler kullanır.

Bir [modül/Bileşen/nesne] reaktifdir , harici olaylara tepki vererek kendi durumunu yönetmekten tamamen sorumlu olduğu anlamına gelir.

Bu yaklaşımın faydası nedir? Kontrol Tersine Çevirme , çünkü esas olarak [modül/Bileşen/nesne] kendisinden sorumludur ve halka açık olanlara karşı özel yöntemler kullanarak enkapsülasyonu iyileştirir.

İyi bir başlangıç ​​noktasıdır, tam bir bilgi kaynağı değildir. Oradan daha karmaşık ve derin kağıtlara atlayabilirsiniz.

2
pdorgambide

FRP, İşlevsel programlama (herşeyin fikri üzerine kurulu programlama paradigması bir işlevdir) ve reaktif programlama paradigması (her şeyin bir akış olduğu fikri üzerine kurulu (gözlemci ve gözlemlenebilir felsefe) birleşimidir. Dünyanın en iyisi olması gerekiyordu.

Başlamak için reaktif programlama üzerine Andre Staltz gönderisine bakın.

0
kg11

.NET için Rx, Reactive Extensions'a göz atın. IEnumerable ile temelde bir akıştan 'çekdiğinizi' işaret ederler. IQueryable/IEnumerable ile ilgili Linq sorguları, kümenin sonuçlarını 'emen' işlemlerdir. Ancak, IObservable üzerindeki aynı operatörlerle, 'tepki' veren Linq sorguları yazabilirsiniz.

Örneğin, gibi bir Linq sorgusu yazabilirsiniz (m'de MyObservableSetOfMouseMovements öğesindeki m'den m.X <100 ve m.Y <100'ün yeni Nokta seçtiği (m.X, m.Y)).

ve Rx uzantılarıyla, işte bu: Fare hareketlerinin gelen akışına tepki gösteren ve 100.100 kutudayken çizdiğiniz UI kodunuz var ...

0
Sentinel