Take the 2-minute tour ×
Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. It's 100% free, no registration required.

Most functional programming languages (e.g. Common Lisp, Scheme / Racket, Clojure, Haskell, Scala, Ocaml, SML) support some common higher-order functions on lists, such as map, filter, takeWhile, dropWhile, foldl, foldr (see e.g. Common Lisp, Scheme / Racket, Clojure side-by-side reference sheet, the Haskell, Scala, OCaml, and the SML documentation.)

Does C++11 have equivalent standard methods or functions on lists? For example, consider the following Haskell snippet:

let xs = [1, 2, 3, 4, 5]
let ys = map (\x -> x * x) xs

How can I express the second expression in modern standard C++?

std::list<int> xs = ... // Initialize the list in some way.
std::list<int> ys = ??? // How to translate the Haskell expression?

What about the other higher-order functions mentioned above? Can they be directly expressed in C++?

share|improve this question
    
Yes, but they operate on more general concepts than that specific implementation of a doubly linked list. As do Python's operations in this area. I much prefer that to being tied to a specific data structure. Ever tried to do these operations on, say, a Data.Sequence in Haskell? It's comparatively ugly. –  delnan Oct 18 '12 at 20:17
    
"It's comparatively ugly.": Compared to what? –  Giorgio Oct 18 '12 at 20:19
    
Compared to the same operation on [a]. You either have to hide the prelude function, hack around prelude, or choose a different and less intuitive name. –  delnan Oct 18 '12 at 20:21
    
Maybe you are right, but the topic of this question is how to express common list higher-order functions in C++, not how to implement analogous functions on Data.Sequence in Haskell. –  Giorgio Oct 18 '12 at 20:23
    
I know. My point is that you don't want those operations implemented for lists specifically, not in C++ and not anywhere else. That's far too restrictive. –  delnan Oct 18 '12 at 20:24
show 1 more comment

1 Answer 1

up vote 7 down vote accepted

Even more, C++ have such functions, take a look to algorithm (or with C++11 additions) header:

std::transform
std::for_each
std::remove_copy_if

They can be easily used with any container.

For example your code can be expressed like this (with C++11 lambdas for easy coding):

std::vector<int> x = {1, 2, 3, 4, 5};
std::vector<int> y;
std::transform(x.begin(), x.end(), std::back_inserter(y), [](int elem){ return elem * elem; });

Less intuitive, but you can easily wrap the std::transform call into function which would return new container (with move semantics for better perfomance).

share|improve this answer
    
Thanks. I'd like to simplify some code I wrote a few days ago and this could really help make it much shorter. Just one small question: why do you need to pass x.begin() and x.end()? Wouldn't be sufficient to just pass the vector x? –  Giorgio Oct 18 '12 at 20:40
    
std::transform takes two iterators, so, you can take a slice of a container (remember that you have iterators arithmetics). –  m0nhawk Oct 18 '12 at 20:47
    
So you have two operations in one: taking a slice, and applying a transformation. –  Giorgio Oct 18 '12 at 20:48
    
Formerly you have two iterators and applying transform to elements between them. Iterators not a common in functional programming. –  m0nhawk Oct 18 '12 at 20:49
1  
I haven't met such libraries, in C++ the iterator-based algorithm much useful. You can make a wrapper of, in your case, std::transform like: Y<U> map(T<U>, std::function<Y(U)>). –  m0nhawk Nov 21 '12 at 11:44
show 6 more comments

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.