What is a Monad? - Computerphile Computerphile English Turkish

What is a Monad? - ComputerphileYouTube↗ IA↗(long shot)
Education 357.7K views 7.6K likes 1.2K dislikes 24 Nov 2017

Computerphile 2.6M subscribers N/A YouTube↗

Click to Play Video

So, monads are a concept that was invented in mathematics in the 1960s, and

Yani, monads olan bir kavram 1960'lı yıllarda matematikte icat edildi ve

then it was rediscovered in computer science in the 1990s. And what it gives

sonra bilgisayarda yeniden keşfedildi 1990'larda bilim. Ve ne veriyor

you, is a new way of thinking about programming with effects. And for me, this

sen, düşünmenin yeni bir yolu efektlerle programlama. Ve benim için, bu

is one of the most important new ideas in programming languages in the last 25

en önemli fikirlerden biri Son 25 dilde programlama dilinde

years. So that's what we're going to be looking at today - programming with monads.

yıl. Demek olacağımız şey bu günümüze bakıyor - monadlarla programlama.

We're going to come at this using a simple example, and the example that

Bu şeye kullanarak geleceğiz. basit örnek ve örnek

we're going to look at is the idea of writing a function that evaluates simple

biz bakacağız fikri basit değerlendiren bir fonksiyon yazma

expressions. And I'm going to use Haskell for this, but it doesn't matter if you don't

ifade. Ve ben Haskell kullanacağım bunun için, ama yapmaman önemli değil

know anything about Haskell, because we're going to use it in a very simple

Haskell hakkında bir şey biliyorsun, çünkü çok basit bir şekilde kullanacağız

way, and I'm going to explain everything as we're going along. So, what we're going

yol ve ben her şeyi açıklayacağım devam ederken. Peki ne gidiyoruz

to start with, is by defining a simple datatype for the kind of expressions

ile başlamak, basit bir tanımlayarak ifadelerin türüne ilişkin veri türü

that we're going to be evaluating. So, we'll use the data keyword in Haskell,

biz değerlendireceğiz. Yani, Haskell’deki data anahtar sözcüğünü kullanacağız,

which introduces a new data type, and then we're going to define a new data

hangi yeni bir veri türü tanıtır ve o zaman yeni bir veri tanımlayacağız

type for expressions. And then there's two things that an expression can be. It

ifadeler için tür. Ve sonra var Bir ifadenin olabileceği iki şey. O

can either be an integer value, so we'll write that down - we have Val of an Int.

tamsayı bir değer olabilir, öyleyse Bunu yaz - Val'in bir int.

Or, it can be the division of two sub-expressions. So we've got two

Veya, iki bölümü olabilir alt ifadeleri. Yani biz iki tane var

constructors here in our data type - we've got Val,

buradaki inşaatçılar veri türü - elimizde Val,

which builds expressions from integers, and we've got Div, which builds expressions

tam sayılardan ifadeler oluşturan ve İfadeleri oluşturan Div'e sahibiz

from two sub-expressions. So, just to reiterate what what's actually going on

iki alt ifadeden. Yani, sadece gerçekte neler olup bittiğini yineleyin

here, we're declaring a new data type called Expr, and it's got two new

burada yeni bir veri türü ilan ediyoruz Expr adında ve iki yeni

constructors - one called Val, which takes an integer parameter, and one

yapıcılar - Val denilen bir tamsayı parametresi alır ve bir

called Div, which takes two sub-expressions as parameters as well.

Div adlı iki kişi parametrelerin yanı sıra alt ifadeler.

So basically what we're working with is expressions that are built up from

Yani temelde çalıştığımız şey yerleşik ifadeler

integer values using a simple division operator. So, many of you may not be

basit bir bölümü kullanarak tamsayı değerleri Şebeke. Yani, çoğunuz olmayabilir

familiar of this kind of syntax, so let's have a couple of examples of values of

bu tür bir sözdizimine aşina olduğumuza göre birkaç değer örneği var

this data type, so that we make sure everyone's on the same page. So, what I'm

bu veri türünden emin olmamız için herkes aynı sayfada. Peki ben neyim

going to do here, is draw a little table. So, on one side, on the left-hand side, I'm

Burada yapacağım, küçük bir masa çizin. Yani, bir tarafta, sol tarafta, ben

going to have what we would normally write down in mathematics. And then on

normalde yapacağımız şeye sahip olacağız matematiğe yazmak. Ve sonra

the right-hand side, we'll think how would you translate this into a value in

sağ tarafta nasıl düşüneceğimizi düşünelim Bunu bir değere çevirir misiniz

this Haskell data type? So, let's have three simple examples here - we'll have

Bu Haskell veri türü? Öyleyse alalım Burada üç basit örnek - biz

one, and we'll have six divided by two, and

bir, ve biz altı bölü iki, ve

let's do one more example, we'll have six divided by three divided by one. So, these are

hadi bir örnek daha yapalım, altı üçe bölünen bire bölünür. Demek bunlar

simple expressions built up from integers using a division operator. But, we're

tamsayılardan oluşturulan basit ifadeler bir bölme operatörü kullanarak. Ama biz

writing Haskell programs today, so let's think how do these things actually get

Bugün Haskell programlarını yazıyor, hadi bu şeylerin gerçekte nasıl gerçekleştiğini düşünün

represented as values of our expression data type? So, the first one is very

İfademizin değerleri olarak temsil edilir veri tipi? Yani, birincisi çok

simple - if we want to represent the value one, we just need to use the Val tag, so we

basit - eğer değeri temsil etmek istiyorsak Birincisi, sadece Val etiketini kullanmamız gerekiyor.

write Val of one. If we want to have an expression like six divided by two, well it's

Val in birini yaz. Eğer sahip olmak istiyorsak altı gibi ifade ikiye bölünmüş, peki

a division, so we have a Div at the top level, and then we have two values - we

bir bölünme, en üstte bir Div var seviye ve sonra iki değerimiz var - biz

have Val six, and Val two. And actually, I'll leave the last one is a little exercise

Val altı ve Val iki var. Ve aslında, ben sonuncuyu bırak biraz egzersiz

for you here, so you can try this one for yourself - how do you represent this as a

burada senin için, böylece bunun için deneyebilirsin. kendin - bunu nasıl temsil ediyorsun

value in Haskell? Well, you're gonna need two divisions, you're going to need three

Haskell değeri? Peki, ihtiyacın olacak iki bölüm, üçe ihtiyacın olacak

Val constructors, and then a bunch of brackets. So, this is the basic idea -

Val kurucuları ve sonra bir demet parantez. Yani, bu temel fikir -

we've got simple expressions built up from integers using division, and we want

basit ifadeler oluşturduk bölmeyi kullanan tamsayılardan

to think about how do we write a program to evaluate these expressions? Let's

program yazmayı düşünmek Bu ifadeleri değerlendirmek için? Haydi

write a program to do that. So, we're going to write an evaluator, and it's

Bunu yapmak için bir program yazın. Yani biz bir değerlendirici yazacak ve

going to be a program, or a function in this case, that takes an expression as

bir program veya bir işlev olacak Bu durumda, bu bir ifadeyi alır.

input, and what it's going to give back is the integer value of that expression.

girdi ve geri vereceği şey bu ifadenin tamsayı değeridir.

And there's going to be two cases here, because we have two kinds of expressions.

Ve burada iki dava olacak. çünkü iki tür ifademiz var.

We have a case for values, and we need to figure out what to do with that, which

Değerler için bir vakamız var ve buna ihtiyacımız var. Bununla ne yapacağını çöz.

we'll do in a moment. And then we have a case for division, and we need to think

birazdan yapacağız. Ve sonra biz bir bölünme davası ve düşünmemiz gerek

what to do with that. So, we've got the skeleton here of a program, and then we

bununla ne yapmalı. Yani, biz var Burada bir programın iskeleti ve sonra biz

just need to fill in the details. So, how do you evaluate an integer value? Well,

sadece detayları doldurmanız gerekiyor. Nasıl bir tamsayı değeri değerlendirir misiniz? İyi,

that's very simple, you just give back the number - so if I had Val of one,

bu çok basit, sadece geri verirsin sayı - öyleyse bir Val'im olsaydı,

it's value is just one. And then how do I evaluate a division? Well, these two

bu değer sadece bir tanesidir. Ve sonra ben nasıl yaparım bölümü değerlendirmek? Peki, bu ikisi

expressions here, x and y, these could be as complicated as you wish. So, we need to

Burada ifadeler, x ve y, bunlar olabilir istediğiniz kadar karmaşık. Yani, ihtiyacımız var

evaluate these recursively. So what we would do, is evaluate the first one, x, and

bunları özyinelemeli olarak değerlendirin. Peki biz neyiz yapar, ilkini değerlendirir, x ve

that will give us an integer. And then we'll evaluate the second one, y, and that

Bu bize bir tamsayı verecek. Ve sonra ikincisini değerlendireceğiz, y ve

will give us another integer. And then, all we need to do is divide one by the

bize başka bir tamsayı verecek. Ve sonra, tek yapmamız gereken tek tek bölmek

other. So, this is a nice simple program that evaluates these kind of expressions

diğer. Yani, bu güzel, basit bir program bu tür ifadeleri değerlendiren

built up from integers using division - we just have a simple recursive program, two

bölünmeyi kullanan tamsayılardan - biz sadece basit bir özyinelemeli program var, iki

cases, and everything looks fine. But there's a

davalar ve her şey görünüyor ince. Ama var

problem with this program, and the problem is that it may crash - because if

ve bu programla ilgili sorun sorun çökmesine neden olabilir - çünkü eğer

you divide a number by zero, then that's undefined, so this program will just

bir sayıyı sıfıra bölersen o zaman tanımsız, bu yüzden bu program sadece

crash. So, in particular, if the value of the expression y here was zero, then this

kazasında. Yani, özellikle, eğer değeri Buradaki y ifadesi sıfırdı, sonra bu

division operator would crash, and you get some kind of runtime error. So we

bölüm operatörü çökecek ve sen bir tür çalışma zamanı hatası alıyorum. Yani biz

don't want our programs to crash, so we think, what do we do to fix this problem?

programlarımızın çökmesini istemiyoruz, öyleyse biz düşünüyorum, bu sorunu çözmek için ne yapacağız?

First of all, what we're going to do is we're going to define a safe version of

Her şeyden önce, yapacağımız şey güvenli bir versiyonunu tanımlayacağız

the division operator, which doesn't crash anymore. Because that's basically

olmayan bölme operatörü artık çarpmak. Çünkü bu temelde

the root of the problem here - division by zero gives an undefined result, and the

burada sorunun kökü - bölü sıfır tanımsız bir sonuç verir ve

program is going to crash. So, let's define a safe version of the division

program çökecek. Öyleyse, hadi bölümün güvenli bir sürümünü tanımlayın

operator. We're going to define a function called safediv, and it's going

Şebeke. Tanımlayacağız safediv adı verilen işlev

to take a couple of integers, and it's going to give back Maybe an integer. And

birkaç tamsayı almak için geri vereceğim Belki bir tamsayı. Ve

Maybe is the way that we deal with things that can possibly fail in Haskell.

Belki de başa çıkmamızın yolu budur. Haskell'de muhtemelen başarısız olabilecek şeyler.

So, the type here is not Int to Int to Int, it's Int to Int to Maybe Int, because

Yani, buradaki tür Int'den Int'ye değil, belki int için int, çünkü int

division may fail. And we'll see how this Maybe type works in a moment. So, how do

bölünme başarısız olabilir. Ve bunu nasıl göreceğiz Belki yazı birazdan çalışır. Peki nasıl

we actually define safediv? We take two integers, n and m, and then what we'll do

aslında safediv'i tanımlıyoruz? İki tane alırız tamsayılar, n ve m ve sonra ne yapacağız?

is check - is the second of these zero? Because that's the case when things

kontrol - Bu sıfırı ikinci mi? Çünkü işler böyle olduğunda

would go wrong. So, if m happened to be zero, then we will give back the result

yanlış giderdi. Öyleyse, eğer m olsaydı sıfır, sonra sonucu geri vereceğiz

Nothing. Okay, so Nothing is one of the constructors in the Maybe type. If m is

Hiçbir şey değil. Tamam, yani hiçbir şey Belki türünde yapıcılar. M ise

not zero, what we're going to do is Just give back the result of dividing. So, Just

sıfır değil, yapacağımız şey sadece bölmenin sonucunu geri vermek. Bu yüzden sadece

is another constructor in the Maybe type - Maybe only has two constructors, Nothing,

Belki türünde başka bir kurucu - Belki sadece iki kurucu vardır, Hiçbir şey,

which represents things that have gone wrong, or in our case division by zero,

olan şeyleri temsil eden yanlış veya bizim durumumuzda sıfıra bölünme,

and Just, which represent things that have gone fine. In this case, we actually

ve sadece, bu şeyleri temsil eden iyi gitti. Bu durumda, biz aslında

just get back the result of dividing one number by the other. So, what we have here

Sadece bir bölen sonucu geri almak diğer numara. Peki, burada ne var

now is a safe version of the division operator, which is explicitly checking

şimdi bölümün güvenli bir versiyonu açıkça denetleyen operatör

for the case when the program would have crashed. So this doesn't crash anymore, it

programın ne zaman olacağı çöktü. Yani bu artık çökmeyecek

returns one of two values - either Nothing if things go wrong, or Just of the

iki değerden birini döndürür Eğer işler ters giderse, ya da Sadece

division if things have gone fine. So, what we can do then, with this safe

işler yolunda giderse bölünme. Yani, o zaman ne yapabiliriz, bu kasayla

division operator, is rewrite our little evaluator program to make sure that it

bölüm operatörü, bizim küçük yeniden yazmak Değerlendirici programdan emin olmak için

doesn't crash. So, our new evaluator is going to have a slightly different type

çökmez Yani, yeni değerlendiricimiz biraz farklı bir tür olacak

than before. So before, the original program just took an expression

öncekinden daha. Bundan önce, orijinal program daha yeni ifade aldı

as input, and then it gave back an integer. But that program could crash. The

girdi olarak, ve sonra geri tamsayı. Ancak bu program çökebilir.

new evaluator takes an expression as input as before, but now it Maybe gives

Yeni değerlendirici, ifadesini alır. daha önce olduğu gibi girdi, ama şimdi belki verir

you an integer, because it could fail, it could have division by zero. So, how do we

sen bir tamsayı, çünkü başarısız olabilir, sıfır ile bölme olabilir. Peki nasıl?

rewrite this evaluator? So, we'll do the two cases again - write down the skeleton,

bu değerlendiriciyi yeniden yazmak? Yani biz yapacağız yine iki dava - iskeleti bir yere yaz,

and then we'll fill in the details. So, in the base case, we can't just return n

ve sonra detayları doldururuz. Yani, içinde temel dava, sadece n geri dönemeyiz

this time, because we've got to return a Maybe value. And there's only two things

bu sefer, çünkü geri dönmek zorundayız. Belki değer. Ve sadece iki şey var

we could return, either Nothing or Just, and in this case the right thing to do

geri dönebiliriz, ya hiçbir şey ya da sadece ve bu durumda yapılacak doğru şey

is to return Just of n, because if you evaluate a value that's always going to

Sadece n geri dönmek içindir, çünkü eğer her zaman olacak bir değeri değerlendirmek

succeed, so we use a success tag, which is Just, and then we have the integer

başarılı olun, bu nedenle bir başarı etiketi kullanıyoruz. Sadece, ve sonra tamsayıya sahibiz

value sitting in here. If we have a division, now we need to do a bit more

Burada oturan değer. Eğer bir bölünme, şimdi biraz daha yapmamız gerekiyor

work, because when we evaluate x that may fail, when we evaluate y that may fail,

çalışmak, çünkü x'i değerlendirdiğimizde başarısız, y'yi değerlendirdiğimizde başarısız olabilir,

and then when we do the division that may fail. So, we're going to need to do a

ve sonra bölünme yaptığımızda Başarısız olabilir. Yani yapmamız gerekecek

little bit of checking and management of failure. So, what we're going to do, is

kontrol ve yönetim biraz hatası. Yani, yapacağımız şey,

when we evaluate a division, first of all, we'll do a case analysis on the result

Bir bölümü değerlendirdiğimizde, her şeyden önce, sonuç üzerinde bir vaka analizi yapacağız

of evaluating x. And that could be one of two things - it could either be Nothing, in

Değerlendirmenin x. Ve bu biri olabilir iki şey - bu hiçbiri olabilir, içinde

which case we're going to do something, or we could get Just of some number, in

hangi durumda bir şey yapacağız ya da sadece bir sayı alabiliriz,

which case we're going to do something. So, there's two cases to consider - when we

hangi durumda bir şey yapacağız. Yani, dikkate alınması gereken iki durum var - biz

evaluate the first parameter x, either it succeeds or it fails. So in the failure

ilk parametreyi x değerlendirebilir başarılı veya başarısız. Yani başarısızlıkta

case, if we get back Nothing, the only sensible thing to do is just to say, well

davayı geri alırsak, hiçbir şey, sadece Yapılması gereken mantıklı bir şey sadece demek ki

if evaluation of x fails, the evaluation of the whole division fails. So we'll

x değerlendirmesi başarısız olursa, değerlendirme Tüm bölüm başarısız. Çok iyi

just return Nothing as well. In the Just case, then we need to evaluate the second

Sadece hiçbir şey de döndürmeyin. Sadece durumda, sonra ikinci değerlendirmemiz gerekiyor

parameter y. So, what we're going to do is do another case analysis, we'll do a case

parametre y. Peki, yapacağımız şey başka bir vaka analizi yap, bir dava yapalım

eval of y, and then again there's two possible outcomes which we could have

y 'nin değerlendirmesi ve sonra yine iki tane var. sahip olabileceğimiz olası sonuçlar

here - either we could have Nothing, which means it failed, or we could have Just of m,

burada - ya biz hiçbir şeyimiz olabilirdi ki başarısız olduğu anlamına gelir, yoksa sadece m olabilir.

some other number, in which case we've succeeded. Then again, we need to think

başka bir numara, bu durumda biz başarılı oldu. Sonra tekrar düşünmemiz gerek

what do we do in each of these two cases. So, in the first case, if the evaluation

Bu iki olayın her birinde ne yapıyoruz? Yani, ilk durumda, eğer değerlendirme

of y fails, the only sensible thing to do is say, well, we fail as well. In the

Y başarısız, yapılacak tek mantıklı şey demek ki, biz de başarısızız. İçinde

second case, we've now got to successfully evaluated expressions - x has

ikinci dava, şimdi yapmalıyız. başarıyla değerlendirilen ifadeler - x

given the result n, y has given the result m, and now we can do the safe

n sonucu verilmişse, y sonuç m, ve şimdi güvenli yapabiliriz

division. So, in this case we just do safediv. Now we have a working evaluator.

bölünme. Yani, bu durumda biz sadece safediv. Şimdi çalışan bir değerlendiricimiz var.

We started off with a two-line program, which kind of did the essence of

İki satırlık bir programla başladık, hangi tür özü yaptı

evaluation, but it didn't check for things going wrong - it didn't check for a

değerlendirme, ancak kontrol etmedi yanlış giden şeyler var;

division by zero. Now we've fixed the problem completely, we

sıfıra bölüm. Şimdi biz var sorunu tamamen düzelttik,

have a program which works, this program will never crash, it will always give a

çalışan bir program var, bu program asla çökmeyecek, daima

well-defined result, either Nothing or Just, but there's a bit of a problem with

iyi tanımlanmış sonuç, Hiçbir şey veya Sadece, ama biraz problem var

this program, in that it's a bit too long. It's a bit too verbose, there's

Bu program, bu da biraz uzun. Biraz fazla ayrıntılı, var

quite a lot of noise in here, I can hardly see what's going on anymore,

Burada oldukça fazla gürültü var. artık ne olup bittiğini görmek zor

because it's all of this management of failure. So, we can look at this program,

çünkü bütün bu yönetim hatası. Yani, bu programa bakabiliriz,

and think - how can we make this program better? And how can we make it more like

ve düşünün - bu programı nasıl yapabiliriz daha iyi? Ve nasıl daha fazla hale getirebiliriz

the original program, that didn't work, but still maintain the fact that this

Orijinal program işe yaramadı. ama yine de bu gerçeği korumak

actually does the right thing? And the idea here, is we're going to observe a

aslında doğru olanı yapar mı? Ve Burada fikir, biz bir gözlemlemek için gidiyoruz

common pattern. So, when you look at this program, you can see quite clearly we're

ortak kalıp Yani, buna baktığında programı oldukça açık bir şekilde görebilirsiniz.

doing the same thing twice - we're doing two case analyses. What we're doing, is

aynı şeyi iki kez yapıyorum - yapıyoruz iki vaka analizi. Yaptığımız şey

doing a case analysis on the result of evaluating x, and if it's Nothing we give

sonucu üzerinde bir vaka analizi yapmak x'in değerlendirilmesi ve verdiğimiz bir şey değilse

back Nothing, and if it's Just, we do something with the result. And then we do

geri Hiçbir şey, ve eğer Sadece, yaparız sonucu olan bir şey. Ve sonra yaparız

exactly the same thing with eval of y - we're doing a case analysis on the

y'nin değerlendirmesi ile tamamen aynı şey - hakkında bir vaka analizi yapıyoruz

result of evaluating y, if that gives Nothing we give back Nothing, and if it's

y değerlendirmesinin sonucu, eğer Hiçbir şey geri vermeyiz Hiçbir şey, eğer öyleyse

a Just, we do something with it. So, a very common idea in computing is

Sadece bir şey yapalım. Yani, hesaplamada çok yaygın bir fikir

when you see the same things multiple times, you abstract them out, and have

aynı şeyleri birden çok gördüğünüzde onları soyutlarsın ve

them as a definition. And that's what we're going to do here. So, let's draw a

onları bir tanım olarak. Ve bu ne burada yapacağız. Yani, bir çizelim

little picture first, to capture the pattern which we've seen twice. So, the

ilk küçük resim, yakalamak için iki kere gördüğümüz desen. Böylece

pattern we have here, is we're doing a case analysis on something, so let me

Burada sahip olduğumuz desen, yapıyoruz bir şey üzerinde vaka analizi, o yüzden bırakayım

just draw as a little box - we don't know what's in there, we're doing a case

sadece küçük bir kutu çizin - bilmiyoruz içeride ne var, dava açıyoruz

analysis on something. And, there's two cases - if it's Nothing, we give back

bir şeyin analizi. Ve iki tane var servis talebi - Eğer bir şey değilse geri veriyoruz

Nothing, and if we get Just of some value x, then what we're going to do is we're

Hiçbir şey, ve eğer sadece x değerinden alırsak, o zaman yapacağımız şey biziz

going to process it in some way, we're going to apply some other function to x.

bir şekilde işleyeceğiz, biz başka bir işlevi x'e uygulayacağım.

So, this is the pattern which we've seen twice. In the first case, we had eval of x

Demek gördüğümüz kalıp bu iki defa. İlk durumda, x'in değerlendirmesini yaptık.

sitting here, and in the second case, we had eval of y sitting here, but this is

burada oturuyor ve ikinci durumda, biz Burada oturup y değerlendirmek vardı, ama bu

the same pattern that we see two times in the new evaluator

iki gördüğümüz aynı Yeni Değerlendiricideki Kez

which we've just written. So, what we can do now, is abstract this out as a

ki biz sadece yazdık. Peki biz neyiz şimdi yapabilir, bunu bir

definition. And the idea here, is that we're going to give names to these boxes.

tanım. Ve buradaki fikir şudur: bu kutulara isimler vereceğiz.

So, this box is a Maybe value - it's going to be either Nothing or a Just, so we'll

Yani, bu kutu Belki bir değerdir - gidiyor ya bir hiç ya da adil olmak, öyleyse biz

call it m. And this box is going to be a function, it's going

ona m de Ve bu kutu gidiyor bir işlev olmak için gidiyor

process the result in the case we're successful, so we'll call this f. So, we

sonucu işleme koyarız başarılı, bu yüzden buna f diyeceğiz. Yani biz

can turn this picture here into a definition now, and then we can use it to

bu resmi buraya dönüştürebilir Şimdi tanımı ve sonra bunu kullanabiliriz.

make our program simpler. So, the definition we're going to have is,

programımızı kolaylaştırın. Böylece tanımı biz,

if we have some Maybe value, feeding into, or in sequence with, some function f. So,

Belki bir değerimiz varsa, besleniriz, veya bazı işlevlerle f sırasıyla. Yani,

the operator we're defining here is this funny sequencing symbol, and we'll

burada tanımladığımız operatör Bu komik sıralama sembolü ve biz

back to that in a second. What we're going to do, is a case analysis - we're

bir saniyede buna geri dönelim. Biz neyiz yapacağım, bir vaka analizi - biz

going to look at what the Maybe value is - if it's Nothing,

Belki neye bakacağım değer - eğer bir şey değilse,

we'll give back Nothing, and if it's Just of x, we'll apply the function to it. Okay,

biz hiçbir şey vermeyeceğiz, ve eğer sadece x işlevini uygulayacağız. Tamam,

so we'll just captured the pattern, which we've seen twice, by a definition now. So,

bu yüzden sadece deseni yakalayacağız. Şimdi bir tanım gereği iki kere gördük. Yani,

we have some Maybe value, then, or in sequence with, some function f, and all

O zaman veya içinde Belki değerimiz var bazı işlevler f ve diğerleri

we're going to do is look at what the value of the Maybe is - if it's failed,

ne yapacağız bakalım ne olacak Belki değeri - eğer başarısız olursa,

we'll fail, if it succeeds, we pass the result to the function f. It's just the

Başarısız olacağız, eğer başarılı olursa, f fonksiyonunun sonucu. Sadece

idea of abstracting out a common pattern as a definition. So, now we can use this

ortak bir kalıptan soyutlama fikri tanım olarak. Yani şimdi bunu kullanabiliriz

definition to make our program simpler. So, let's rewrite our evaluator once

programımızı basitleştirecek tanım. Öyleyse, bir zamanlar değerlendiricimizi tekrar yazalım

again. The type will remain the same - it takes in an expression as input, and

tekrar. Tip aynı kalacak - bir ifadeyi girdi olarak alır ve

it's going to give back a Maybe value, as before. But the definition is going

Belki bir değer geri verecek eskisi gibi. Ama tanımı gidiyor

to be a bit simpler this time. So, let's write down the skeleton. So, if we

Bu sefer biraz daha basit olmak. Öyleyse, hadi iskeleti yaz. Öyleyse, eğer biz

evaluate a value, we're going to do something. If we evaluate a division,

bir değeri değerlendir, yapacağız şey. Bir bölümü değerlendirirsek,

we're going to do something. So, what do we write in the base case? Well, I could

bir şeyler yapacağız. Bu yüzden ne yapmalıyım temel duruma yazalım mı? Ben yapabilirim

write Just of n here, but actually I'm going to abstract that as well - rather

Sadece n'yi buraya yaz, ama aslında ben Bunu da soyutlayacağım - daha doğrusu

than writing Just of n, I'm going to write return of n, so really what I'm

Sadece n yazmadan, ben gidiyorum n 'nin iadesini yaz, gerçekten ne olduğumu

making is a little kind of side definition, that says return of x is the

yapma biraz yan tanımı, x'in iadesi

same as Just of x. And then, what are we doing in the division case? Well, we're

Sadece x ile aynı. Ve sonra biz neyiz? bölme durumunda mı? Peki, biz

going to do an evaluation first - we're going to evaluate x, and then if that's

önce bir değerlendirme yapacağız - biz x'i değerlendirecek ve eğer öyleyse

successful, using our little sequencing operator, we're going to feed the result

Başarılı, küçük dizimizi kullanarak operatör, sonucu besleyeceğiz

into a function. So that function is going to take the result, n, that comes

bir fonksiyona. Yani bu fonksiyon sonuç alacak, n geliyor

from evaluating that, and then it's going to evaluate y. So, if we do eval of y, if

Bunu değerlendirmekten sonra gidiyor y'yi değerlendirmek. Yani, eğer y'nin değerlendirmesini yaparsak,

that's successful, we're going to feed that result into a function. And here

bu başarılı, besleneceğiz bu bir işleve dönüşür. Ve burada

again, I'm using the lambda notation, which we did a video about previously,

tekrar, lambda gösterimini kullanıyorum hakkında daha önce bir video yaptık,

you can have a look back at that. So, if these two things are both successful,

Şuna bir bakabilirsin. Öyleyse, eğer bu iki şeyin ikisi de başarılı

we'll have two values, n and m, and then all we do is call safediv with them,

n ve m olmak üzere iki değere sahip olacağız ve sonra tek yaptığımız onlarla safediv'i aramak.

then close the brackets. So, this program here is equivalent to the program which

sonra braketleri kapatın. Yani bu program Burada program eşdeğerdir hangi

we wrote, which had all the nested case analyses. But, that's all been abstracted

İç içe geçmiş tüm davaları yazdık. analiz eder. Ama hepsi bu soyutlandı.

away now - it's all been kind of abstracted into return, and the

uzakta şimdi - her şey biraz oldu dönüş içine soyutlanmış ve

sequencing, and safediv. So, this is a nicer program now, but still I'm not

sıralama ve safediv. Yani bu bir şimdi güzel program, ama ben hala değilim

entirely happy with this. There's still some complexity in there - we're

Bundan tamamen memnunum. Orada hala orada biraz karmaşıklık - biz

still using the funny lambda notation, we're still using this funny symbol,

hala komik lambda gösterimini kullanıyor, Hala bu komik sembolü kullanıyoruz.

which we've introduced. Maybe I can make it even simpler? So, what a language like

Hangisini tanıttık? Belki yapabilirim daha da basit? Peki, nasıl bir dil

Haskell gives you, is a special notation for writing programs which have this

Haskell size verir, özel bir gösterimdir buna sahip programlar yazmak için

kind of form. And this is called the do notation. So let me write this in do

bir çeşit form. Ve bu yapmak denir notasyonu. Bu yüzden bunu yazayım

notation, and then we'll come back to what this has all got to do with monads.

gösterimde, sonra geri döneceğiz Tüm bunların monad'larla ne ilgisi var.

So, let's write this program in an even more simple form, and this will be our

Yani, bu programı bile yazalım daha basit bir form ve bu bizim olacak

final program. We take an expression as input, and it's going to Maybe deliver

son program Olarak bir ifade alırız giriş ve belki teslim edecek

us an integer. And the base case will not change, so we'll get return of n. But the

bize bir tamsayı. Ve temel dava olmaz değişim, yani n'nin karşılığını alacağız. Fakat

recursive case is going to become a bit simpler, because we use the do notation

özyinelemeli dava biraz olacak daha basit, çünkü notasyonu kullanıyoruz.

as a shorthand for using the sequencing operator which we've introduced. So, I can

sıralamayı kullanmak için bir kısa yol olarak biz tanıttığımız operatör. Bu yüzden yapabilirim

say, if I evaluate a division, what I'm going to do, and this is the keyword,

diyelim ki, bir bölümü değerlendirirsem ne olurum yapacağım ve bu anahtar kelime,

which just gives you a shorthand for exactly what we've just written, it's

bu sadece size bir steno tam olarak ne yazdık, o

not anything special, it's just shorthand, just syntactic sugar. What we're going to

özel bir şey değil, sadece steno Sadece sözdizimsel şeker. Ne yapacağız

do, is take the result n, from the result of evaluating x, if it's successful. Then,

yapmak, sonucu almak n, sonuçtan Başarılı olursa, x değerlendirmesinin. Sonra,

we'll take the result m, from the result of evaluating y, if that's successful. And

sonucu m alacağız, sonuçtan Başarılı olursa, değerlendirme y. Ve

then, we will call safediv. And this is our final program, and I'm much happier

o zaman safediv'i arayacağız. Ve bu son programımız ve ben daha mutluyum

with this one. I mean, it looks kind of similar to the original program, a

Bununla birlikte. Yani, biraz benziyor orijinal programa benzer

similar level of complexity, but all the failure management is now handled for us

benzer düzeyde karmaşıklık başarısızlık yönetimi artık bizim için ele alınıyor

automatically. The failure is happening behind the

otomatik olarak. Başarısızlık arkasında oluyor

scenes with the do notation, and with safediv, but we don't need to see that

do notasyonuna sahip sahneler ve safediv, ama bunu görmemize gerek yok

when we're reading this program. This is a much nicer program than the last one,

Bu programı okurken. Bu sonuncusundan daha güzel bir program,

because we've kind of abstracted away from a lot of the detail. So, you can look

çünkü bir nevi soyutlanmış durumdayız ayrıntıdan çok. Yani bakabilirsin

at a program like this, and I've hardly mentioned the word monads in the last

Böyle bir programda ve ben pek Sonunda monads kelimesinden bahsetti.

ten minutes, you can say what's this actually got to do with monads? Well, what

on dakika, bunun ne olduğunu söyleyebilirsin Aslında monads ile ilgisi var? Peki ne

we've actually done, is we've rediscovered what's

aslında yaptık ne olduğunu yeniden keşfettik mi

known as the Maybe monad. The Maybe monad is three things -

Belki monad olarak bilinir. Belki monad üç şeydir -

it's the Maybe type, or really the Maybe type constructor, because it takes a

belki türü, ya da gerçekten belki yapıcı yazın, çünkü bir

parameter. So you can have Maybe of an integer, or maybe of a Boolean, or maybe of

parametre. Yani belki bir olabilir tamsayı, ya da belki bir Boole

whatever you like. And then it's two functions - it's the function called

her ne seversen. Ve sonra iki fonksiyonlar - adı verilen fonksiyon

return, and it's the sequencing operator which we introduced. And we can think

return ve sıralama operatörü hangi biz tanıtıldı. Ve düşünebiliriz

about what are the types of these things? So what return does, is it takes a thing

Bu tür şeyler nelerdir? Öyleyse ne işe yarıyor?

of any old type, a - could be an integer, could be a Boolean, could be whatever you

herhangi bir eski tipte, a - bir tamsayı olabilir, Boolean olabilir, ne olursa olsun

like. And it converts it into a Maybe value. So, in our case, this just took an

sevmek. Ve onu Belki'ye dönüştürüyor. değer. Yani, bizim durumumuzda, bu sadece bir aldı

integer like five, and we return Just of five. Okay, so that's all the return was

beş gibi bir tamsayı, ve biz sadece döndük beş. Tamam, tüm dönüş buydu

doing, it's basically just applying Just. And what it gives you, is a bridge

yapıyor, basitçe sadece Just'a başvuruyor. Ve sana verdiği şey, bir köprü

between the pure world of values here, and the impure world of things that

Buradaki değerlerin saf dünyası arasında, ve şeylerin saf dünyası

could go wrong - so it's a bridge from pure to impure, if you like. And what

yanlış gidebilir - yani bu bir köprü İsterseniz, saf olmayan saf. Ve ne

sequencing does, is it gives you a way of sequencing things - so you give it

sıralama yapar, size bir yol sunar mı işleri sıralamak - böylece ver

something which can fail, a Maybe a, and then you give it a function that tells

başarısız olabilecek bir şey, Belki bir, ve o zaman ona söyleyen bir işlev verirsin

you what to do with that a, if you succeed - so an a to Maybe b. And then,

eğer onunla ne yapmalı başarılı - yani a a Belki b. Ve sonra,

finally, what you're going to get back is a Maybe b. Okay, and this is all that

Sonunda geri alacağın şey bir Belki b. Tamam, hepsi bu

a monad is essentially - a monad is some kind of type constructor, like Maybe, or

bir monad esasında - bir monad biraz Belki türden bir tür kurucu

List, or something else, as there's many other examples, together with two functions

Liste, ya da başka bir çok şey olduğu gibi iki fonksiyonla birlikte diğer örnekler

that have these types here. So, what we've essentially done is rediscovered what's

Burada bu tür var. Peki, neyimiz var aslında yapılan şey yeniden keşfedilir

called the Maybe monad. What's the point of all of this? I mean, what's the point?

Belki monad çağırdı. Amaç ne bunların hepsinden? Demek istediğim, nokta ne?

We seem to have gone through quite a lot of steps, to write in the end quite a

Çok şey yaşadık gibi görünüyor. Sonunda yazmak için adımların bir

simple program. What was the actual point here? So there's four points which I

basit bir program. Asıl nokta neydi İşte? Demek ki dört puan var

would like to emphasize here. So, the first point, is that the same idea we've

burada vurgulamak istiyorum. Böylece ilk nokta, aynı fikirde olduğumuz mu

seen works for other effects as well - it's not specific to Maybe, which

diğer etkiler için de görülen eserler - belki, belirli değil

captures failure. The same idea captures other kinds, or you can use with, other

başarısızlığı yakalar. Aynı fikir yakalar diğer çeşitlerle veya diğerleriyle birlikte kullanabilirsiniz.

kinds of effects like input/output, like mutable state, like reading from

giriş / çıkış gibi etki türleri değiştirilebilir durum

environments, like writing to log files, non-determinism. All sorts of other

günlük dosyalarına yazma gibi ortamlar, deterministik olmayan. Diğer her türlü

things which you think of as being effects in programming languages fit

varlık olarak düşündüğün şeyler dil uyumunda etkileri

exactly the same pattern. So, monads kind of give you a uniform framework for

tam olarak aynı desen. Yani, monads tür size tek tip bir çerçeve vermek

thinking about programming with effects. Another important point is that it supports

Etkileri olan programlama hakkında düşünme. Bir diğer önemli nokta, desteklediği.

pure programming with effects. I mean, Haskell is a pure

efektli saf programlama. Yani, Haskell saf

language - functions just take inputs, and produce outputs, they don't have any kind

dil - fonksiyonlar sadece girişleri alır ve çıktı üretmek, herhangi bir çeşidi yoktur

of side effects at all. But you need to have side effects to write real

yan etkileri hiç. Ama ihtiyacın var gerçek yazmak için yan etkileri var

programs. So, what monads give you is a way of doing impure things, like proper

programları. Yani monadların sana verdiği şey uygun olmayan şeyleri yapmanın yolu

side effects, like input/output, in a pure programming language like Haskell. Another

giriş / çıkış gibi yan etkiler saf Haskell gibi bir programlama dili. Bir diğeri

important point here, is that the use of the effects is explicit in the types.

Burada önemli nokta, kullanımı etkileri türlerinde açıktır.

When I wrote the evaluator which didn't fail,

Yazdığımda başarısız olan değerlendirici,

it took an expression as input, and it delivered Maybe of an integer. So, the

girdi olarak bir ifade aldı ve Belki bir tamsayı. Böylece

Maybe in the type is telling me that this program may fail. So, this is the

Belki de tipte bana bunu söylüyor bu program başarısız olabilir. Yani, bu

idea of being explicit about what kind of effects, or side effects, that your

ne tür hakkında açık olma fikri etkileri veya yan etkileri

programs can have in the types. And this is a very, very powerful idea. And the

program türleri olabilir. Ve bu çok, çok güçlü bir fikir. Ve

last thing is, it's a little bit strange, but it's particularly interesting, it's

Son şey, biraz garip, ama özellikle ilginç, bu

the idea of writing functions that work for any effect - we might call this kind of

İşe yarayan fonksiyonlar yazma fikri herhangi bir sonuç için - bu tür

effect polymorphism. So, a simple example of this would be maybe you have a

etki polimorfizmi. Yani basit bir örnek Bunun olabilir belki bir

sequence of things, which can have some effects, and you want to run them all one

bazı olabilir bazı şeylerin, efektleri ve hepsini çalıştırmak

after the other. You could write a generic function, in a language like

diğerinden sonra. Bir yazabilirsin genel bir işlev, gibi bir dilde

Haskell which supports monads, which would take a sequence of effects of any

Monadları destekleyen Haskell herhangi bir etkisi bir dizi alırdı

kind, any monadic type, and it would run them for you. So this is a very, very

tür, herhangi bir monadik tür ve çalışacak onlar senin için. Yani bu çok, çok

powerful idea, and languages like Haskell have libraries of kind of generic effect

güçlü bir fikir ve Haskell gibi diller Kütüphanelerde tür etkisi

functions, which are very useful. So, that's basically all I want to say. Just

çok kullanışlı olan fonksiyonlar. Yani, temelde söylemek istediğim buydu. Sadece

going back to the start, I think the idea of programming with monads is one of the

Başa dönüyorum, bence fikir monad'larla programlama

most important developments in programming languages in the last 25

en önemli gelişmeler son 25 dilde programlama dili

years - I find this particularly fascinating. We've only really touched on

yıl - özellikle bunu buldum büyüleyici. Biz sadece gerçekten dokunduk

the surface here, and if you want to know a little bit more, I can do a bit of a

Buradaki yüzey ve bilmek istiyorsanız biraz daha, biraz yapabilirim

plug - I have a new book which came out fairly recently, Programming in Haskell,

fiş - çıktığım yeni bir kitabım var oldukça yakın zamanda, Haskell'de Programlama,

and this has got a chapter specifically about this, which goes into much more

ve bunun özellikle bir bölümü var Bu konuda, daha çok içine girer

detail. I've only really touched on the surface, there's lots of things I didn't

detay. Ben sadece gerçekten dokundum yüzey, yapmadığım birçok şey var

say, which maybe you need to know to write real programs using this stuff. So,

söyle, belki de bilmen gereken bu şeyleri kullanarak gerçek programlar yaz. Yani,

you could have a look in the book to find out more about that. This is an

kitapta bir göz atabilirsin Bunun hakkında daha fazla bilgi edinin. Bu bir

interesting point, it causes quite quite some problems for people learning

ilginç nokta, oldukça oldukça öğrenen insanlar için bazı problemler

languages like Haskell, because Haskell people tend to use the proper

Haskell gibi diller, çünkü Haskell insanlar doğru kullanma eğilimindedir

mathematical terms for things, and those terms are often quite foreign to

şeyler için matematiksel terimler ve bunlar terimler genellikle oldukça yabancı

programmers. And it does cause quite a lot of difficulty - so there's some people

programcılar. Ve oldukça bir neden olur çok fazla zorluk - yani bazı insanlar var

have the view that we shouldn't actually have used the term monad, maybe we

aslında yapmamamız gereken görüşe sahip monad terimini kullandık, belki biz

should have called them effects, or something like that. So, just use the more

onlara etki denmeli ya da bunun gibi bir şey. Yani, sadece daha fazlasını kullanın.

kind of human, or a familiar term. But it is an issue. But I'm actually of

bir tür insan ya da tanıdık bir terim. Fakat bu bir konudur. Ama ben aslında

the point of view that, if we know the proper term for something, we should call

bakış açısını, eğer biliyorsak Bir şey için uygun terim, aramalıyız

it that something, and the people who are using it should just learn that term.

bu bir şey ve kim kullanıyorsanız sadece bu terimi öğrenmelisiniz.

I mean, it's what it is, it's a monad, and we should kind of pay homage to

Yani, olan bu, bir monad, ve buna saygı göstermeliyiz

the mathematicians for discovering this idea first, and not kind of reappropriate it as

Bu fikri keşfettiği için matematikçiler ilk önce

if it was discovered independently - the mathematicians discovered this, they should get

bağımsız olarak keşfedildiyse - matematikçiler bunu keşfetti, almalılar

credit for that, and so I'm quite happy with the word monad. But, it does cause

Bunun için kredi, ve ben çok mutluyum monad kelimesiyle. Ancak, neden olur

some problems when people are learning programming languages, because it does

insanlar öğrenirken bazı sorunlar programlama dilleri, çünkü

sound a bit scary, and there's lots more scary terms like this in programming as

biraz korkutucu ses ve çok daha fazlası var gibi programlama gibi korkunç terimler

well. This is all built into languages like Haskell. So, there's

iyi. Bunların hepsi yerleşik. Haskell gibi diller. Yani var

lots of libraries for programming with monadic things - you

programlama için birçok kütüphane monadik şeylerle - siz

don't need to define a lot of the infrastructure, like Maybe, and return, and

birçoğunu tanımlamanıza gerek yok Belki gibi bir altyapı ve geri dönüş, ve

the sequencing, for yourself - this is kind of built in as libraries. You can

sıralama, kendiniz için - bu Kütüphaneler gibi yerleşik. Yapabilirsin

define your own ones if you want to, but there's maybe kind of fifteen or twenty

istersen kendininkileri tanımla belki on beş ya da yirmi var

monads which are just lying around waiting for people to use. And if you

sadece etrafta yatan monadlar insanların kullanmasını bekliyorum. Ve eğer sen

want to use multiple different monads in your programs, maybe you need two

birden fazla farklı monad kullanmak istiyorum programlarında belki iki tane gerekir

different kinds of effects, maybe you need things that can fail, and you need some

değişik etki türleri, belki ihtiyacınız olabilir başarısız olabilecek şeyler ve biraz

state, there's ways of coping with that kind of stuff as well. So, you don't need

devlet, bununla baş etmenin yolları var Bir çeşit şey. Yani ihtiyacın yok

to do all yourself, it's mostly built in for you.

Kendini yapmak için çoğunlukla sizin için inşa edilmiştir.

Similar videos:

Essentials: Functional Programming's Y Combinator - Computerphile
Computerphile
172.7K views 3.6K likes 258 dislikes 16 Aug 201773% match

Program Correctness - Computerphile
Computerphile
48.8K views 2K likes 253 dislikes 27 Nov 202056% match

Why C is so Influential - Computerphile
Computerphile
1.6M views 22.5K likes 1.6K dislikes 25 Aug 201743% match

What is Bootstrapping? - Computerphile
Computerphile
375.1K views 5.5K likes 287 dislikes 19 Mar 201443% match

Programming in PostScript - Computerphile
Computerphile
181.1K views 3.5K likes 42 dislikes 11 Apr 201443% match

Where HTML beats C? - Computerphile
Computerphile
551.2K views 11K likes 1.3K dislikes 27 May 201642% match

Lambda Calculus - Computerphile
Computerphile
803.9K views 19.5K likes 567 dislikes 27 Jan 201742% match

PDF, What is it FOR? - Computerphile
Computerphile
409K views 12K likes 144 dislikes 16 Sep 201638% match

Fibonacci Programming - Computerphile
Computerphile
198.8K views 3.3K likes 52 dislikes 17 Jun 201438% match

Mac or PC? - Computerphile
Computerphile
587.9K views 9.7K likes 314 dislikes 21 May 201438% match

What on Earth is Recursion? - Computerphile
Computerphile
565.8K views 16.8K likes 123 dislikes 16 May 201438% match

ALGOL 60 at 60 - Computerphile
Computerphile
73.7K views 3.1K likes 20 dislikes 04 Jun 202038% match

Functional Programming & Haskell - Computerphile
Computerphile
493.3K views 12.2K likes 144 dislikes 30 Nov 201637% match

Computing Limit - Computerphile
Computerphile
358.4K views 11.3K likes 443 dislikes 03 Nov 201735% match

Parsing Explained - Computerphile
Computerphile
134.2K views 3.6K likes 45 dislikes 13 Nov 201933% match

Reflections on Trusting Trust - Computerphile
Computerphile
66K views 3.7K likes -1 dislikes 23 Mar 202132% match

Programming Loops vs Recursion - Computerphile
Computerphile
1.1M views 26.6K likes 417 dislikes 22 Sep 201731% match

Secrets Hidden in Images (Steganography) - Computerphile
Computerphile
1.1M views 22K likes 242 dislikes 04 Aug 201531% match

P vs NP on TV - Computerphile
Computerphile
527.4K views 7.8K likes 537 dislikes 08 Feb 201430% match

Where GREP Came From - Computerphile
Computerphile
644.1K views 23.4K likes 152 dislikes 06 Jul 201830% match

Fuzzy Logic - Computerphile
Computerphile
335.5K views 5.5K likes 185 dislikes 11 Jun 201430% match

Essentials: Pointer Power! - Computerphile
Computerphile
326.4K views 8.5K likes 203 dislikes 18 Aug 201730% match

50 Years of Computer Science: Professor Brailsford Q&A - Computerphile
Computerphile
81.3K views 3K likes 17 dislikes 22 Apr 202030% match

Internationalis(z)ing Code - Computerphile
Computerphile
911.6K views 32.5K likes 495 dislikes 04 Aug 201429% match

Password Cracking - Computerphile
Computerphile
3M views 60.3K likes 1K dislikes 13 Jul 201629% match

Unicorn AI - Computerphile
Computerphile
339.5K views 7.8K likes 189 dislikes 04 Jul 201929% match

Deep Learning - Computerphile
Computerphile
392.2K views 6.1K likes 280 dislikes 19 Apr 201629% match

The Perfect Code - Computerphile
Computerphile
491.4K views 10.6K likes 196 dislikes 08 Mar 201729% match

How to Choose a Password - Computerphile
Computerphile
1M views 21.1K likes 235 dislikes 20 Jul 201628% match

Entropy in Compression - Computerphile
Computerphile
332.2K views 7.1K likes 69 dislikes 02 Jul 201328% match

Settings Privacy About Contact Donate