Ivan Čukić

dr Ivan Čukić

Author of "Functional Programming in C++", KDE developer and Free/Libre software enthusiast

For inquiries about KDE projects (requesting features, submitting bugs, asking general questions etc.), you can use:

KDE Community Forum
Bug reporting site
#plasma IRC channel

You need to contact me directly?

KDE related:
ivan.cukic [at] kde.org

Non KDE related things:
ivan [at] this domain

IRC Network: libera.chat
Nick: ivan|home
Channel: #plasma

Projects

Blog categories

Functional Programming in C++

If you like C++, you might be interested in my book. It contains quite a few gems of modern C++ programming.

It is available for purchase at:

Patronage

Qt Functional

Published by Ivan Čukić in the Prog C++ section, on 6 July 2011

Edit: Sorry for bumping this, WordPress seems to think changing a post title should publish it in RSS again**

QfStringList sentence;

sentence << "TZU"
         << "Anticipate"
         << "the"
         << "difficult"
         << "by"
         << "managing"
         << "the"
         << "easy";

sentence
    .foldLeft(Functions::sum);
// "TZUAnticipatethedifficultbymanagingtheeasy"

sentence
    .map(QF_FUNCTION(QString, toUpper()));
// ("TZU", "ANTICIPATE", "THE", "DIFFICULT",
//  "BY", "MANAGING", "THE", "EASY")

sentence
    .map(QF_FUNCTION(QString, length()));
// (3, 10, 3, 9, 2, 8, 3, 4)

sentence
    .map(QF_FUNCTION(QString, length()))
    .foldLeft(Functions::sum);
// 42

Comments:

Ivan Čukić
@<a href="#comment-25855" rel="nofollow">seezer</a>: Yeah, so far only a teaser, but I hope it will get more serious in the near future.
joe
Can you supply a value for the fold's "base case", i.e. when applying it to the empty list? Or does it use the sum function's neutral element? Also, do you employ type checking? Is Functions::sum polymorphic?
Ivan Čukić
@<a href="#comment-25858" rel="nofollow">joe</a>: Yes, naturally. If it isn't specified, it uses the default constructor for the class.
The bug in current fold implementation is that it always uses a starting element, even if not specified.
Everything is template-based so the typing is quite strict. (not that I can get out of the normal C++ type system anyway)
The Functions:: namespace will contain generic functions - the sum function is, essentially just <pre> template <class Type> Type sum(const Type & sum, const Type & item) {
return Type(sum + item);
} </pre>
QF_FUNCTION and QF_OPERATOR (not demoed here) are just macros that construct lambda functions.
All these are there only to provide a nicer syntax, if you want anything special, you just need to pass a lambda or a function pointer.
seezer
Kudos to start a project like this! Being able to use such functional programming style in Qt/C++ would be plain awesome.
Giorogs Tsiapaliwkas
Nice :)
Ivan can you point us out to the source code?
Ivan Čukić
@<a href="#comment-25955" rel="nofollow">Giorogs Tsiapaliwkas</a>: It is a 'teaser' for a couple more weeks. After that I'm going to open the code to the public. That is, announce it properly.
Irrlicht
The last example shows why "strict" functional programming is quite inefficient compared with the prozedural solution:
int n = 0; for (auto w : sentence) { n += w.length(); }
Ivan Čukić
@<a href="#comment-25962" rel="nofollow">Irrlicht</a>: Well, I can't really agree - it might be a bit slower but not much - it is lazy evaluation so the middle map is not created at all.
If you want an equivalent, but faster for both lazy and greedy eval, you could just write:
<pre> sentence
.foldLeft(0,
[] (int sum, QString item) {
return sum + item.length();
}
);
</pre>
Naturally, it would be (again) a bit slower because of the function calls, but not much.
As for the general case of func vs proc, in the <a href="https://days2011.scala-lang.org/sites/days2011/files/ws3-1-Hundt.pdf" rel="nofollow">recently published benchmarks</a> (made by google) scala had beaten java. So, it is more about the compiler and optimizations than about the paradigm the language uses.
Ivan Čukić
Well, I can't go outside of C++, so the limits it has will be the limits of QtF as well... this is not going to be a new functional language, but rather a more pleasant way of using Qt for people who like FnPLs.
The Java vs Scala example was just to show that the different paradigm doesn't need to imply slower execution - and that the paper talks about loops like the example you provided...
Irrlicht
Yes, with lazy evaluation the performance panalty should not be as bad depending on the implementation technique (expression templates vs. thunks). But if you look at the corresponding Haskell code snippet
foldl' (\m s -> m + (length s)) 0 sentence
or my imperative example there is one difference to your foldl version: Polymorphism. One of the nifty feautures of functional languages is type inference, but in C++11 lambdas are not polymorphic.
Java vs. Scala is not really about proc. vs. func. but pure OOP vs. multiparadigm since Scala is by no means a pure functional language.
Jason 'moofang'
Wowow functional programming in C++/Qt. This is simply <3

Write a new comment...