Functional programming in C++

C++ enables you to do nearly everything with every possible paradigm. I actually consider it as a huge mess or maybe I’m the one that can not comprehend that much stuff. Considering C++ is made by people smarter than me, probably the latter is true.

So trying to use C++ as a purely functional programming language is probably possible but pointless in all cases except having some fun. More acceptable strategy may be using it as functional but not so pure language like Scala(or something like that). But then the question arises, why not use a language that is designed for that from scratch? Many answers can be given to this question but the most obvious ones goes like this:

  1. You hate C++ but you need to write some C++.
  2. You love C++ and looking for better paradigms to use in your programming.
  3. You are neutral towards C++ and too lazy to learn another language from scratch, so you decided to go with C++. But you are not that lazy to learn a new paradigm.
  4. Other combinations involving love-hate relationship with C++.

There are a lot of tutorials on this subject but they sometimes go too extreme or they are too specific. I’ll try to give you a general idea about how functional programming can be done using C++. These things generally dependent on new C++ features so I’ll put an indicator to everything that shows which feature aims which version of C++. Of course it’s probably possible to implement some of those features for earlier versions but I’ll just stick with the easiest and most recent implementations. And if some feature takes too much to implement, I’m not even going to mention it. Also, I’m not advocating usage of persistent (immutable) data structures because it’s either cumbersome to use them or they are inefficient. At the end of the day we are using C++ and lets keep it multi-paradigm. Think this tutorial as “zero-cost paradigm changes that you can apply to your daily C++ programming”.

First things

1. Use auto at all costs C++11

auto is just great. It makes your code faster and shorter. Consider this example (I probably took this example from Effective Modern C++ by Scott Meyers):

std::unordered_map<std::string, int> m;
// ...
for (const std::pair<std::string, int>& p : m) {
   // ...

Continue reading →

Programming AVR microcontrollers in Linux (Specifically ATMega)

The Windows way of doing that is just using ATMEL Studio but we don’t have it in Linux. As a customization freak, I’ll just write the steps of how to compile and flash your program to an AVR microcontroller and leave the rest for you. So integrating this steps into your favorite IDE, if you are using one, is your job.
Continue reading →

KDE – Dolphin ile Türkçe kodlanmış altyazıları UTF-8’e çevirme

Malumunuzdur, indirdiğiniz altyazılar genellikle Windows-1254 ile kodlanmış oluyor. GNU/Linux ortamındaki birçok oynatıcının da öntanımlı olarak UTF8 kullandığı göz önünde bulundurulduğunda oynatıcının altyazıları garip göstermesi beklenen bir davranış. Elbette oynatıcının ayarlarından kodlama türünü değiştirip bu sorunu çözebiliriz fakat bu sefer her indirdiğimiz farklı kodlamaya sahip altyazı dosyası için ayar değiştirmemiz gerekecek. Böyle yapmak yerine dolphin için bir servis menüsü hazırlayıp kullanmak en pratik çözüm.

Bu şekilde altyazı dosyasına sağ tıklayıp anında çeviri işlemini yapabilirsiniz. Aksiyonu menüye eklemek için yapmanız gereken ise şu aşağıdaki dosyayı ~/.local/share/kservices5/ServiceMenus/ içine kopyalamanız:

Kotlin Function Application

I often write some code like this:

val result = someData.split(...)
        .map { ... }
        .filter { ... }
        .reduce { ... }


As you can see last line of the code is breaking the beautiful flow of chained functions. One can rewrite this as:

        .map { ... }
        .filter { ... }
        .reduce { ... }

Which seems better to me but not as good as this:

        .map { ... }
        .filter { ... }
        .reduce { ... }

I don’t know if there is a standard way of doing this but here is my solution:

infix fun <T, R> T.apply(func: (T) -> R): R = func(this)

So this extension function applies its object to the function that it took as an argument and returns the result of application. You can use it as an infix operator, if you want to:

        .map { ... }
        .filter { ... }
        .reduce { ... }
        .... apply ::someFunction

You can even chain function applications:

        .map { ... }
        .filter { ... }
        .reduce { ... }
        .apply { fun4(it) }

Which is same as:

        .map { ... }
        .filter { ... }
        .reduce { ... }
        .... apply ::fun1 apply ::fun2 apply ::fun3 apply { fun4(it) }

This code is equivalent of this one:

val result = someData.split(...)
        .map { ... }
        .filter { ... }
        .reduce { ... }


Median cut Algorithm in Qt/C++

I needed a simple color quantization algorithm for my project. I didn’t want to use any other program/library for this simple job. So I implemented median cut with Qt. I just used the explanation of the algorithm in Wikipedia, I didn’t make any other research, so the code is not well optimized but it just works. I’ll try to explain step by step:

We have an image with an arbitrary number of pixels and want to generate a palette of X colors. The very first thing we need to is putting all the pixels in a list. By pixels, I mean their Rgb data. Then we need to find the color channel(red, green, blue) that has the most wide range. Let’s implement this:

QString filePath = "some_image.png";
int color_count = 256; // The color count that we want to reduce our image.

QList<QRgb> pixels;
QImage img(filePath);

// For finding color channel that has the most wide range,
// we need to keep their lower and upper bound.
int lower_red   = qRed(img.pixel(0, 0)),
    lower_green = qGreen(img.pixel(0, 0)),
    lower_blue  = qBlue(img.pixel(0, 0));
int upper_red   = 0,
    upper_green = 0,
    upper_blue  = 0;

// Just loop trough all the pixels
for (int x = 0; x < img.width(); ++x) {
    for (int y = 0; y < img.height(); ++y) {
        QRgb rgb = img.pixel(x, y);         // Get rgb data of a particular pixel
        if (!pixels.contains(rgb)) {        // If we have the same pixel, we don't need it twice or more
            lower_red = std::min(lower_red, qRed(rgb));
            lower_green = std::min(lower_green, qGreen(rgb));
            lower_blue = std::min(lower_blue, qBlue(rgb));

            upper_red = std::max(upper_red, qRed(rgb));
            upper_green = std::max(upper_green, qGreen(rgb));
            upper_blue = std::max(upper_blue, qBlue(rgb));

We have upper bounds and lower bounds of the color channels, so just find out the one that has widest range:

int red = upper_red - lower_red;
int green = upper_green - lower_green;
int blue = upper_blue - lower_blue;
int max = std::max(std::max(red, green), blue);

Then we need to short our pixels list according to the channel we just found out. For example, if the blue channel has the greatest range, then a pixel with an RGB value of (32, 8, 16) is less than a pixel with an RGB value of (1, 2, 24), because 16 < 24.

qSort(pixels.begin(), pixels.end(), [max,red,green,blue](const QRgb& rgb1, const QRgb& rgb2){
    if (max == red)  // if red is our color that has the widest range
        return qRed(rgb1) < qRed(rgb2); // just compare their red channel
    else if (max == green) //...
        return qGreen(rgb1) < qRed(rgb2);
    else /*if (max == blue)*/
        return qBlue(rgb1) < qBlue(rgb2);
// We just used qSort here.
// As comparison function, we sent a lambda function
// that compares two rgb color according to our selected color channel.

After sorting our list, we need to move the upper half of the list to another list, then we have two list. For these two list, we will do the same thing until we get X lists (So if we want to reduce our color palette to 16 colors, we need to repeat this step until we get 16 lists.).

QList<QList<QRgb>> lists;
int list_size = pixels.size() / color_count; 

for (int i = 0; i < color_count; ++i) {
    QList<QRgb> list;
    for (int j = list_size * i; j < (list_size * i) + list_size; ++j) {

We got our lists. After that, we can get the average of each list and we can build our X colored palette or we can just get the median of each list. I didn’t observe so much difference, so I’m going with the easy one.

QVector<QRgb> palette;
for (QList<QRgb> list: lists) {
    palette.append( / 2));

We build up our X color palette. The next thing I am going to do is convert our original image color palette to our new palette. Actually there is a Qt function for that but it has a bug.(I’ll explain it later) So we need to implement this.

QVector<QRgb> palette;
for (QList<QRgb> list: lists) {
    palette.append( / 2));

QImage out(img.width(), img.height(), QImage::Format_ARGB32);
for (int x = 0; x < img.width(); ++x) {
    for (int y = 0; y < img.height(); ++y) {
        out.setPixel(x,y, palette[closestMatch(img.pixel(x, y), palette)]);

In this piece of code, we just create a QImage that has same size of our original image and format. Then we loop through all the pixels in our original image and find the closest color from our new palette then set that color to corresponding pixel of our new QImage object. And that’s it.

There is one function that needs explanation in this code, closestMatch. I just took it from the Qt source code. Actually, QImage has a function named convertToFormat. You can use this function to change the format of your image and also it lets you to change color palette of your image. The function definition goes like this: QImage QImage::convertToFormat(Format format, const QVector<QRgb> &colorTable, Qt::ImageConversionFlags flags = Qt::AutoColor) const and it’s definition says:

Returns a copy of the image converted to the given format, using the specified colorTable. Conversion from 32 bit to 8 bit indexed is a slow operation and will use a straightforward nearest color approach, with no dithering.

So we can simply use this function to convert any image using our palette. But there is a one problem, if you don’t want to change your image format(so your source and output image has the same format), it just simply returns the image itself without converting to our palette. So I extracted the part that it finds the closest color to given color from a vector:

static inline int pixel_distance(QRgb p1, QRgb p2) {
    int r1 = qRed(p1);
    int g1 = qGreen(p1);
    int b1 = qBlue(p1);
    int a1 = qAlpha(p1);

    int r2 = qRed(p2);
    int g2 = qGreen(p2);
    int b2 = qBlue(p2);
    int a2 = qAlpha(p2);

    return abs(r1 - r2) + abs(g1 - g2) + abs(b1 - b2) + abs(a1 - a2);

static inline int closestMatch(QRgb pixel, const QVector<QRgb> &clut) {
    int idx = 0;
    int current_distance = INT_MAX;
    for (int i=0; i<clut.size(); ++i) {
    int dist = pixel_distance(pixel,;
        if (dist < current_distance) {
            current_distance = dist;
            idx = i;
    return idx;

Haskell Notları – 3 (Listeler)

Haskell’in en güzel yönlerinden birisi olan listelere bakacağız şimdi.


Prelude> [1,2,3,4]
Prelude> ["eleman", "eleman 2"]
["eleman","eleman 2"]
Prelude> [True, True, False, True]

Aklınıza gelebilecek her şeyi bir listenin içine koyabiliyoruz. Burada dikkat edilmesi gereken nokta, listenin bütün elemanlarının aynı türden olması gereklilliği. Yani şöyle bir şey hata verecektir:

Prelude> [1,"iki",3]

<interactive>:6:2: error:
    • No instance for (Num [Char]) arising from the literal ‘1’

Birden fazla boyutlu listeler de oluşturabiliriz. Yine aynı şekilde, alt-listeler yine aynı türden elemanları içermeli, fakat içerdiği eleman sayısı değişebilir.

Prelude> [[1,2,3], [4,5], [22]]
Prelude> [[], ["deneme"]]

Liste Oluşturma

Yukarıda kullandığımız liste notasyonu, örneğin [1,2,3,4], aslında 1:2:3:4:[] gösteriminin bir sözdizimsel şekeri (syntactic sugar). Bu gösterimi incelemekte yarar var, çünkü ilerde oldukça işimizi kolaylaştıracak.

: operatörü, cons olarak okunuyor ve yaptığı şey elemanları alıp tek tek bir listeye sevk etmek. Elimizde bir liste var ve başına eleman eklemek istiyorsak şöyle bir şey işimizi görecektir:

Prelude> 1:[2,3,4]

Birden fazla elemanı da bu şekilde ekleyebilirim:

Prelude> 1:2:3:[4,5,6,7]

Hatta elimde, listelerden oluşan bir liste varsa, yine bu notasyon ile listenin başına ekleme yapabilirim:

Prelude> [1,2,3]:[[4,5,6], [7,8,9]]

Bir önceki yazıdan hazırlayacağınız ++ operatörü ile de aynı işlemi yapabilirim aslında:

Prelude> [[1,2,3]] ++ [[4,5,6], [7,8,9]]

Fark ettiyseniz, ++ operatörü iki tane aynı türden listeyi alıp birleştiriyor. : ise gelen elemanları bir listenin başına ekliyor. Böyle durumlarda elinizden geldiğince : operatörünü tercih edin, çünkü bu operatör sabit bir zamanda çalışıyor fakat ++ $latex O(n)$ karmaşıklığına sahip.

Durumu özetleyecek olursak, notasyon şöyle:

liste ++ liste

Kullanım örnekleri:

Prelude> 'h':'a':'s':'k':'e':'l':'l':[]
Prelude> 'h':'a':"skell"
Prelude> "has" ++ "kell"
Prelude> 'h':'a':'s':'k':'e':'l':'l':[] == "haskell"

Karakterleri belirtirken ' kullanırken String‘ler için " kullanıyoruz, gözden kaçırılmaması gereken bir nokta da bu. Dolayısıyla "h":"a":"s":[] gibi bir ifade "has" değil, ["h","a","s"] gibi bir listeye dönüşecektir. Çünkü " işaretini kullandığımız için derleyici her bir harfi String olarak görüyor dolayısıyla bunları bir String listesine([String] diğer bir deyişle [[Char]]) dönüştürüyor.
Bir diğer dikkat edilmesi gereken nokta ise 1:2:3 gibi bir gösterimin hiçbir şey ifade etmemesi. Çünkü böyle bir konumda : operatörü için gereken listeyi sağlamamış oluyoruz. Fakat 1:2:3:[] ise tamamen doğru bir şekilde [1,2,3] listesini oluşturan bir ifade.

Temel liste fonksiyonları

Haskell’de bir listeyi şu şekilde görmek mümkün:

head    tail
[1, 2, 3, 4, 5]
    init    last

Bu çizimde anlatmaya çalıştığım şey, headin listenin ilk elemanını, lastın listenin son elemanını, initin listenin son elemanı hariç bütün elemanlarını, tailin ise listenin ilk elemanı hariç bütün elemanlarını ifade ettiği. Aynı zamanda bunlar bir fonksiyon olduğu için şöyle kullanabilirsiniz:

Prelude> head [5,4,3,2,1]  

Prelude> tail [5,4,3,2,1]  

Prelude> last [5,4,3,2,1]  

Prelude> init [5,4,3,2,1]  

Haskell’in belkemiği olan recursive(özyinelemeli) fonksiyonlar için oldukça kullanışlı fonksiyonlar olacaklar. İleriki yazılarda nu fonksiyonların kullanımı da değineceğim. Burada bu yazıyı da kısa kesip, bir sonrakinde list comprehension kavramından bahsetmeye çalışacağım.

Haskell Notları – 2 (Tipler)

Bir önceki yazının sonunda bir listenin neye benzediğini görmüştük. Listelere geçmeden önce Haskell’deki tip(type) sisteminden bahsedelim, sonra da listelere giriş yapalım.


Diğer dillerden alışık olduğumuz tipleri Haskell’de de görüyoruz. Örnek vermek gerekirse, "deneme" bir String, True bir Bool tipine sahip. GHCI üzerinde, bir şeyin tipini merak ettiğinizde yapmanız gereken :t komutunu kullanmak, şöyle ki:

Prelude> :t True
True :: Bool
Prelude> :t "deneme"
"deneme" :: [Char]
Prelude> :t (3 < 2)
(3 < 2) :: Bool

Yukarıda "deneme"nin bir String olduğunu söylemiştim fakat GHCI bize "deneme"nin bir [Char] olduğunu söylüyor.

Prelude> : 'A'
'A' :: Char

Char tipi tek bir harfi ifade eder. [Char] ise görüntüsünden de anlaşılacağı üzere Char‘lardan oluşan bir listeyi ifade eder. Dolayısıyla String dediğimiz şey aslında Char‘lardan oluşan bir listeye verilen takma addır.

Yukarıda da gördüğünüz üzere :: sembolü tip notasyonunu ifade etmek için kullanılıyor.

Prelude> "deneme" :: [Char]

Burada yaptığımız şey "deneme"nin türünü kendi elimizle belirtmek oldu. Normalde GHCI "deneme"nin ne olduğunu kendisi anlayabiliyor. Fakat anlaşılmaz durumları çözmek, fonksiyonları daha okunabilir kılmak için bu notasyonu da kullanacağız. Az önce String‘in [Char] için bir takma ad olduğunu söylemiştim, dolayısıyla "deneme" :: String yazmak da "deneme"yi tanımlamak için geçerli bir yöntem ve daha okunaklı.

Prelude> "deneme" :: String

Şu ana kadar Bool, Char ve String tiplerini gördük. Haskell’in sayılar için biraz daha karışık bir tip sistemi var ve ondan daha sonra bahsedeceğiz. Şimdilik sayılar için Int, Double, Float gibi tipler olduğunu bilmemiz yeterli.

Fonksiyon tiplerini anlamak için not fonksiyonuna bir göz atalım.

Prelude> not True
Prelude> not (False && True)

Fonksiyonun ne yaptığı gayet açık. Peki fonksiyonun tipine bakmak istersek:

not :: Bool -> Bool

Karşımıza çıkan şey, not fonksiyonunun bir Bool parametresi alıp, sonuç olarak bir Bool değeri döndürdüğünü gösteriyor. Şimdi kendimiz bir fonksiyon tanımlayıp, tipinin ne olduğuna bakalım:

Prelude> let concatenate s1 s2 = s1 ++ s2
Prelude> :t concatenate 
concatenate :: [a] -> [a] -> [a]

Burada yeni bir çok şey var, sırayla neler olduğunu açıklayayım. Öncelikle let anahtar kelimesini GHCI üzerinde bir şeyler tanımlamak için kullanıyoruz. Aslında daha farklı kullanımları da var fakat şimdilik bu kullanımı bilmek yetecektir. İsterseniz concatenate fonksiyonumuzu let kelimesini kullanmadan bir dosyaya kaydedip bu dosyayı GHCI’ye yükleyebiliriz, bir önceki yazıda yaptığımız gibi. (:l dosyaAdı.hs)

++ fonksiyonu ise bir listeyi diğerinin arkasına eklemek için kullanılan bir fonksiyon. Listeler kısmında daha ayrıntılı göreceğiz.

a ise bir tip değişkeni. a’yı “herhangi bir tip” diye okuyabiliriz. O zaman [a]‘yı ise “herhangi bir şeyin listesi” diye okuyabiliriz. Dolayısıyla bizim fonksiyonumuz iki listeyi alıp, birleştiren bir fonksiyon ve listelerin içinde bulundurduğu tipler önemli değil, sadece fonksiyona gönderilen listelerinin ikisinin de aynı tipleri içeriyor olması gerekmekte.

Prelude> concatenate [1,2,3] [4,5,6,7]
Prelude> concatenate "has" "kell"
Prelude> concatenate [True] [False, False]
Prelude> concatenate [True] "haskell"

<interactive>:54:20: error:
    • Couldn't match type ‘Char’ with ‘Bool’

Zaten fonksiyon tanımına baktığımız zaman, GHCI bize parametrelerin [a] ve [a] olduğunu söylüyor. Yani a bir Char ise parametrelerimiz [Char] ve [Char] olacaktır, [Char] ve [Bool] olması mümkün değil. Bir de fark ettiyseniz, parametreler ve döndürülen değer için ayrı bir gösterim yok. Yani [a] -> [a] -> [a] ifadesinde baştaki iki [a] parametreleri belirtirken, sondaki [a] ise döndürülen değeri ifade ediyor.

Yazdığımız fonksiyon belirttiğim gibi herhangi bir tipten iki listeyi birleştiriyor. Peki biz sadece iki String’i birleştiren bir fonksiyon yazmak isteseydik? O zaman bir Haskell dosyası açalım ve içine bunları yazıp dosyayı GHCI’ye yükleyelim:

concatenate :: String -> String -> String
concatenate s1 s2 = s1 ++ s2

Gördüğünüz üzere fonksiyon tanımını biz yapmış olduk. Dolayısıyla bu fonksiyon artık sadece String’leri birleştirecek, başka tipten bir parametre verilmesi halinde hata verecektir. Fonksiyonları yazarken tanımlarını yapmak iyi bir alışkanlık, tam olarak ne yazacağınızı da bilmiyorsanız :t komutundan yardım almaktan da çekinmeyin.

Haskell Notları – 1 (Değişkenler ve Fonksiyonlar)

Haskell üzerine fazla Türkçe kaynak olmamasından ve en iyi öğrenme biçiminin de öğrenirken not tutmaktan geçmesi beni bu yazı dizisini başlatmaya iten sebepler. Haskell, fonksiyonel programlama geçmişi olmayanlar için oldukça oldukça ilginç ve zor kavranan bir dil. Dolayısıyla temel kavramları Türkçe bir kaynaktan öğrenmek sizler için de öğrenim hızını birazcık da olsa arttıracaktır. Bu yazılar programlamaya yeni başlayanlar için değil, daha önceden programlamayla ilgilenmiş fakat fonksiyonel programlamaya tamamen/kısmen yeni olan kişiler için. Bu bilgiyi de verdikten sonra kurulum işlemleri ile başlayalım:


Haskell’in bir çok derleyici implementasyonu bulunmakta. GHC bunlar arasında de facto lider konumunda ve ben de onu kullanacağım. Bu derleyici dertsiz tasasız kullanmanın en güzel yolu ise Haskell Platform. GHC hiçbir ekstra gereksinime ihtiyaç duymayan çalıştırılabilir dosyalar üretebiliyor. Oldukça yenetekli bir derleyici olan ghc’nin aynı zamanda interaktif bir arayüzü de bulunmakta. Sürekli derle/çalıştır yapmak yerine bu arayüz üzerinden çalışacağız.

Terminale ghci komutunu girerek interaktif arayüzümüze ulaşıyoruz. :? komutu ile ghci üzerinde kullanabileceğiniz diğer komutları görebilirsiniz. Şu an için bilmeniz gereken en önemli komut :q, çıkış yapmanızı sağlıyor.


Bu yazıyı yazarken kullandığım kaynaklar şöyle, burada genel bilgiyi aldıktan sonra daha ayrıntılı inceleme için bu kaynaklara bakabilirsiniz:



ghci’yi çalıştırdıktan sonra beni şöyle bir şey karşılıyor ve muhtemelen sizi de:

GHCi, version 8.0.1:  :? for help

Artık komutlarımızı buraya yazacağız. Klasik başlangıcımızı yapalım:

Prelude> 3 + 5
Prelude> 22 / 7
Prelude> 3 * 2

Neler döndüğü oldukça açık gibi. Biraz da şunlara bakalım:

Prelude> True == True
Prelude> "Haskell" == "haskell"
Prelude> 3 /= 4

Burada da her şey tanıdık gelmiş olmalı. Tek farklı olabilecek notasyon /=. Diğer dillerden alışık olduğunuz != operatörü ile aynı şey aslında. Matematikten aşina olduğumuz eşit değil (≠) işareti ile olan benzerliği fark etmişsinizdir. Matematik ile bir sürü anoloji yapacağız ilerde, hazırlıklı olun.

Öcelikle Haskell’de değişken diye bir şey yok (Fonksiyonlara gönderilen parametreler lambda calculus’deki değişken tanımına uyar fakat konumuz bu değil). Peki biz nasıl programlama yapacağız? Önce gelin C benzeri dillerdeki bir değişken tanımına bakalım:

int main() {
    int i;  // i diye bir değişken tanımladık
    i = 2;  // i'nin tuttuğu değeri 2 yaptık.
    i = 5;  // i'nin değerini 5 olarak değiştirdik.

Şimdi Haskell’de buna benzer bir şey yapmaya çalışalım:

a = 2
a = 5

Bunun sonucunda alacağınız hata şudur:

Multiple declarations of 'a'.

Hatanın size demek istediği şey a’yı bir kere tanımladığınızda bir daha değiştiremeyeceğiniz. Matematiğe dönelim yeniden, bir problem içerisinde Pi diye bir değer olduğunu düşünelim. Aynı problem içinde Pi’in değeri değişebilir mi? Hayır. Aynı mantık Haskell’de de bulunmakta. Bir bakıma Haskell’in değişkenleri için immutable diyebiliriz. Ama bundan daha iyi bir tanım var:

Haskell’in bize sunduğu hazır fonksiyonlardan iki tanesi şöyle:

Prelude> succ 3
Prelude> pred 4
Prelude> pred 'b'

succ fonksiyonu aldığı parametrenin tanımlanmış varisini döndüren bir fonksiyon, successor’ün kısaltması. pred ise ise kendinden önce geleni döndüren bir fonksiyon. Şimdi notasyona bir bakalım. Fonksiyona parametre gönderirken parametre ayracı görevini ” “(boşluk) görüyor. yani succ yazdıktan sonra bir boşluk bırakıp parametremizi gönderiyoruz.

Prelude> succ 3 * 5

Burada olan şey ise şu. succ fonksiyonu kendisine parametre olarak gelen 3’ü alıyor ve varisini bulup döndürüyor. Yani artık elimizde 4 * 5 var ve sonuç 20 olarak hesaplanıyor. Peki 3 * 5’in yani 15’in varisini bulmak isteseydik ne yapacaktık?

Prelude> succ (3 * 5)

Şimdi de mod fonksiyonuna bakalım, her şey daha açık olacaktır. mod fonksiyonu iki parametre alır, bir sayı ve bölen sayı, sonuç olarak da kalanı döndürür.

Prelude> mod 15 2

Bunun imperatif bir dildeki karşılığını mod(15, 2) olarak düşünebilirsiniz. Haskell’de yazdığımız pred (mod (3 * 5) 2) fonksiyonun karşılığı ise pred(mod(3*5, 2)) olacaktır. Aynı şekilde foo 3 (baz “aha”) ise foo(3, baz(“aha”)) olacaktır.

Gördüğünüz gibi fonksiyonlar prefix gösterim biçiminde. Fakat mod işlemini mod 5 2 şeklinde yazmak çok okunaklı olmayabilir, infix gösterim biçimiyle daha anlamlı hale gelebilir. Fonksiyonları infix biçimde yazmak için yapmanız gereken şey, fonksiyonu ` işaretleri arasına almak. Yani:

Prelude> mod 15 2
Prelude> 15 `mod` 2

Şimdi biz Haskell’de bir fonksiyon tanımlayalım:

a = 2

Herhangi bir parametre almayan ve sonuç olarak 2 değerini döndüren bir fonksiyon. Yukarıda değişken tanımlamaya çalışırken de aynısı yapmıştık ve bunun aslında bir fonksiyon olduğunu gördük. Peki ta parametre alan bir fonksiyon nasıl olurdu?

triple x = x * 3

Burada durup sizden yeni bir dosya oluşturmanızı ve adını first.hs (ya da içinizden ne geliyorsa) koymanızı istiyorum. Şimdi dosyayı açıp içine yukarıdaki fonksiyon tanımımızı yazıp kaydedebiliriz. Daha sonra bu dosyanın bulunduğu dizinde terminali açıp ghci’yi çalıştırın.

Prelude> :load first.hs
[1 of 1] Compiling Main             ( first.hs, interpreted )
Ok, modules loaded: Main.

:load komutu ile ghci’nin first.hs dosyasını yüklemesini sağladık. Artık bu dosya içinde bulunan fonksiyonları rahatlıkla çağırabileceğiz.

*Main> triple 4
*Main> triple (triple 4)

Yeniden dosyayı açıp içine şu fonksiyonları ekleyebiliriz:

areaCircle r = pi * r * r
areaRect w h = w * h

Yeni fonksiyonları ghci’de görebilmek adına dosyayı yeniden yüklememiz gerekli, bunun için :reload komutunu veriyoruz. Bu arada :load’ın kısaltması :l, :reload‘ın kısaltması ise :r.

*Main> :reload
[1 of 1] Compiling Main             ( first.hs, interpreted )
Ok, modules loaded: Main.
*Main> areaCircle 3
*Main> areaCircle 3 - areaRect 4 5

İki çemberin alanları farkını bulan bir fonksiyon yazmak isteseydik şunu yapabilirdik:

diffCircles r1 r2 = areaCircle r1 - areaCircle r2

areaCircle fonksiyonunu programın başka bir yerinde kullanmıyorsak açık bir tanım yapmamıza gerek yok, o yüzden diffCircles fonksiyonunu şu şekilde yazabiliriz:

diffCircles r1 r2 = (pi * r1 * r1) - (pi * r2 * r2)

Fakat burada da gördüğünüz üzere tekrara düştük ve hoş bir kod olmadı. Yardımımıza ise where ifadesi koşuyor bu konumda. where sayesinde yerel tanımlamalar yapabiliyoruz, şöyle ki:

diffCircles r1 r2 = area r1 - area r2 where area r = pi * r * r

Aynı zamanda bu fonksiyonu daha okunaklı yazabiliriz:

diffCircles r1 r2 = area r1 - area r2 
        where area r = pi * r * r

Bunu da dosyamıza kaydedelim ve:

*Main> :r
[1 of 1] Compiling Main             ( first.hs, interpreted )
Ok, modules loaded: Main.
*Main> diffCircles 4 2

İkinci dereceden bir denklemin köklerini bulan bir fonksiyonu yazmaya çalışalım şimdi: $latex ax^2+bx+c=0 $ denklemimiz olsun. Denklemin diskriminantı ise $latex \Delta = b^2 – 4ac $. Diskriminantın pozitif olduğu durumlarda ise denklemin kökleri $latex \frac{-b + \sqrt {\Delta}}{2a} \quad\text{ve}\quad \frac{-b – \sqrt {\Delta}}{2a}, $. Bu durumda denklemin köklerini döndüren fonksiyonumuz şu şekilde olacak:

roots a b c = [root1, root2]
                    delta = (b * b) - (4 * a * c)
                    root1 = (-b - sqrt delta) / (2 * a)
                    root2 = (-b + sqrt delta) / (2 * a)

Bunu dosyamıza kaydedip ghci’de yeniden yüklediğimiz zaman:

*Main> :r
[1 of 1] Compiling Main             ( first.hs, interpreted )
Ok, modules loaded: Main.
*Main> roots 1 (-3) 2

Fonksiyon görüldüğü üzere üç parametre alıyor. where ifadesinin yardımıyla yerel tanımlamalar ile iki kökü hesaplıyor ve daha sonra bu kökleri bir listenin içine sırayla koyup döndürüyor. Bir sonraki yazıda da listelerden uzun uzun bahsedeceğim.

Everyday Terminal Commands and Applications

Using terminal for your everyday jobs makes everything faster. For example, I was using Thunderbird as my main mail client. Recently, I switched to mutt which is a commandline application that takes care of your e-mails. Mutt is far more faster and simple. Because mutt doesnt have a heavy GUI. For me there is probably nothing that you cant do in mutt but in Thunderbird. I’m just using it for checking my mails and everything seems faster with mutt.

All the commands and applications that I’ll mention will be simple and easy to use. I really have a bad memory, I cant memorize the parameters and stuff. So this will be a simple guide for simple jobs.

Before beginning  you should find a good terminal for you. I’m currently using Guake which is fastest to use. It is a drop-down terminal for GTK environments. Its invoked by a single key, and hidden by pressing the same key again. Using a drop-down terminal is really easy and fast. Also if you are using KDE, you should consider Yakuake.

Very Basic Commands

  • ls – Displays a list of files in the current working directory
  • cd directory – change directories
  • pwd – display present working directory
  • cat textfile – throws content of textfile on the screen
  • cp source dest– copy files and directories
  • mv source dest – move or rename files and directories
  • rm file – remove files and directories. With -r parameter you can remove folders recursively.
  • mkdir dirname – create directories

Some Key Combinations For Terminal

  • Ctrl+C – End a running program and return the prompt.
  • Ctrl+D – Log out of the current shell session, equal to typing exit or logout.
  • Ctrl+R – Search command history.
  • Ctrl+Z – Suspend a program. When you suspend a program, it waits or runs in background. fg command brings the most recent program to foreground.
  • Tab – Command or file name completion.
  • Tab Tab – Shows file or command completion possibilities.

Task Managing

  • killall process_name – kills the process. Using it with -SIGTERM parameter will terminate the process. So use it with that parameter when a process freezes.
  • top or htop – task managers. htop is a better choice but its not installed by default, just install it from your package manager and there you have a fully featured easy to use task manager.
  • free – shows memory and swap usage. using it with -h or –human parameter can be good for your eyes.
  • which app_name – shows the path of the application. Like, which firefox returns /usr/bin/firefox.

File Operations

  • command > output.txt – prints the output of the command to output.txt. This works for nearly all commands.
  • cat file.txt – prints content of file.txt to screen.
  • touch file.txt – creates file.txt
  • chmod – changes permissions of file.
    • owner/group/others
    • 4 – (r)ead. 2 – (w)rite. 1 – e(x)ecute.
    • chmod 777 file will give read write and execute permissions for everyone.
    • chmod +x file will give execute permission to user. Other permissions wont changes.

Other Useful Commands

  • uptime – shows uptime of system. Using with –pretty parameter can be more useful.
  • cal – shows a calendar.
  • date – show the date.

Useful Terminal Applications

  • htop – as I mentioned above, an improved version of top which is a task manager.
  • mutt – an email client. Check here for usage.
  • cmus – a music player. Check here for usage.
  • wget – a download manager.
  • alsamixer – you can adjust nearly everything about sound from here.
  • cowsay and cmatrix are worth checking out.


Installing LAMP Server, phpMyAdmin And Enabling Userdir in Ubuntu 15.10

There are a lot of tutorials covering this subject but most of them not saying all things to you. There are a few things to do more than just installing them, not a big deal but you need to do them to get working. So we are starting with just installing things:

1- Install apache2

sudo apt-get install apache2

2- Install mysql

sudo apt-get install mysql-server mysql-client

3- Install php

sudo apt-get install php5 php5-mysql libapache2-mod-php5

4- Install phpMyAdmin

sudo apt-get install phpmyadmin

Get phpMyAdmin Working

If the page http://localhost/phpmyadmin works, you are fine. If not, do the following:

Open th Continue reading →