Pipable functions in C++14 (pfultz2.com)

How is it self-evident?

This is not what one would call 'sane C++'. I think it's more of an exercise than production code. If it is production code, may Knuth have mercy on whoever maintains that codebase.

Except that nobody in their right mind would actually write code like this on a day-to-day basis. All languages allow the writing of insane nonsense. The question is how much nonsense is actually required in everyday work, and on that point I would argue that C++ is moving in the right direction since C++11.

You can't overload the `.` operator. However, something like this would work: `x | (f , g)`.

Well this can help when you have many nested functions that are chained together, for example, like this:

    auto r = select(where(numbers, [](int x) { return x > 2; }), [](int x) { return x * x; });

Because of nesting this can be hard to read(and even write). If we can make the function pipable, the above can be written like this:

    auto r = numbers | where([](int x) { return x > 2; }) | select([](int x) { return x * x; });

Which it is easier to see what this does. So this blogpost goes over how to implement an utility that will take care of the boilerplate involved in writing a function that can be pipable.

It does take advantage of a lot of C++14 features to implement this such as such as vardiac templates, rvalue reference, generic lambdas, and auto type deduction, but those feature actually make it simpler. I have in the past implemented something similar for C++03 and the code looks awful with way too much noise.

> this is madness.

Why do you consider this madness?

Maybe my mind has already been warped by C++.

A more reasonable example of this kind of function composition would be the range adaptors from boost.range.

http://www.boost.org/doc/libs/1_56_0/libs/range/doc/html/ran...

This kind of complexity is only really needed for library writers... e.g. someone writing a package for Boost. Your run-of-the mill application code in C++ will probably stay away from this kind of wizardry.

Taking a huge risk by saying this (I do not use C++ full-time), but every time I look at C++11 and C++14 I get the feeling that I should just stick with Haskell or <insert-popular-fp-lang-here>. It is insanely more natural to do stuff like this in Haskell. Defer to those with more experience in 'modern C++'.

Just because a language allows you to morph its syntax doesn't make it any more powerful. I'm not sure how this is considered an "advanced" thing. It's certainly a convoluted thing, but that's not at all the same.

There are three reasons why a program would look like this:

  1. It is something simple implemented in a complicated way.
  2. It is something complicated implemented in a simple way.
  3. It is something complicated implemented in a complicated way.

I believe this is an example of case 3, meaning even though it is something advanced, it should not take code that looks insane to express it.

  (defun pipe (val &rest fns)
    (reduce (lambda (acc f)
              (funcall f acc))
            fns :initial-value val))

  (pipe 99 #'1+ #'sqrt #'1-) which evaluates to 9.0

>How would you implement pipe functions in Javascript? And I mean literally using the pipe operator, and not just chained.

>But still, you can do very advanced things.

Why do you think "advanced" means the ability to overload operators? I'd personally define "advanced" to mean something to do with semantics, not syntax.

I've been quite disillusioned with C++ myself as of late. I am currently writing a wrapper class around shared pointers to objects with inheritance (which embed their own private implementations, which also utilize inheritance) so that I can pass them by value and use operator. for method chaining. The SFINAE used for construction from base objects to these shared pointer wrappers is something out of the ninth circle of hell.

    template<typename T> struct Shared : std::shared_ptr<T> {
      template<typename U> struct is_compatible {
        typedef char yes[1], no[0];

        template<typename V> static yes& test1(typename std::enable_if<std::is_base_of<std::shared_ptr<T>, V>::value>::type*);
        template<typename V> static no& test1(...);

        template<typename V> static yes& test2(typename std::enable_if<std::is_base_of<element_type, typename V::element_type>::value>::type*);
        template<typename V> static no& test2(...);

        static constexpr bool value = sizeof(test1<U>(0)) == sizeof(yes) || sizeof(test2<U>(0)) == sizeof(yes);
      };

And from the function binder:

      //value = true if R L::operator()(P...) exists
      template<typename L> struct compatible {
        template<typename T> static constexpr typename std::is_same<R, decltype(std::declval<T>().operator()(std::declval<P>()...))>::type exists(T*);
        template<typename T> static constexpr std::false_type exists(...);
        static constexpr bool value = decltype(exists<L>(0))::value;
      };
      template<typename L> function(const L& object, typename std::enable_if<compatible<L>::value>::type* = nullptr) { callback = new lambda<L>(object); }

And yet ... when actually using the library, it is a thing of beauty.

    struct TextEditor : Window {
      MenuBar menuBar = {this};
        Menu menuFile = {&menuBar, "File"};
          MenuItem menuQuit = {&menuFile, "Quit"};
    
      VerticalLayout layout = {this};
        TextEdit editor = {&layout, Size{~0, ~0}};
    
      TextEditor() {
        StatusBar statusBar{this};
        statusBar.setFont(Font::sans(8, "Bold")).setText("Line 1, Column 1");

        HorizontalLayout findBar(&layout);
        findBar.append(Label(&findBar, "Find:"));
        findBar.append(LineEdit(&findBar).setBackgroundColor(Color::Yellow)
        .onChange([&] { searchFor(text()); }));
        findBar.append(Button(&findBar, "Clear")
        .onActivate([&] { findBar.widget(1).setText(""); }));
    
        menuQuit.onActivate(&Application::quit);
        edit.onChange([&] { updateStatusBar(); });
      }
    };

There is no need for any memory management, or any usage of pointers. We build UIs, and everything gets automatically released safely when nothing is referring to it anymore. We can declare named objects that we can use later, or we can create dynamic objects and pop them right inside of other objects. We can destroy and unparent things whenever we want. And it's deterministic, reference-counted GC. No pauses for a tracer. No dynamic typing anywhere, all errors are at compile-time.

I highly suspect that C++ is unreasonably complicated and that all of this rvalue-reference, variadic template, meta-programming, dynamic-casting polymorphism, is all just voodoo that isn't applicable to general programming. And yet, being able to do it gives me amazing expressive power to write awesome libraries that I could never hope to accomplish in another language.

Until I find a language that's even in the same ballpark as C++ in terms of performance, and offers similar expressiveness, it really doesn't even matter how bad C++ can be for library authors. There's no other viable option right now. D ...

For JavaScript there is this: https://github.com/hij1nx/pipe

Just because you can use some ambiguous syntax construct does not make it good or even clever.

This sort of thing can be done a lot clear with functional constructs like compose and curry.

Common Lisp example (easily done with any language that supports higher order functions): (funcall (compose 'add-one 'add-one) 1)

And you can roll that a number of ways; adding in a curry of the identity of 1 if you just want a nullary function.

(funcall (compose 'add-one 'add-one (curry 'identity 1))

And if you are interested in typing less, maybe you are a dreadful typist...try Haskell.

Interestingly, you can in Powershell, where piping objects works very naturally.

Potentially ambiguous, but I assume worth it?

One rule of thumb I use for code is: Can you step through it in a debugger, at the source level, and have insight into what is going on? Because with really, um, "clever" code, you'll probably need to. And so will your cow-orkers. And if the code doesn't work or has limitations -- quite likely with creeping "clever" machinations like this one -- you'll get Spoken To.

(Yeah, this depends on how good your debugger is. Visual Studio and XCode are pretty decent).

> C++11 certainly introduced very few necessary features

I have to ask whether you've actually done any significant amount of programming in C++, both C++11 and pre-C++11.

> I feel they could have stopped with c++03.

You can still do this kind of horror with C++03. I'd know, I have!

Tests: http://sourceforge.net/p/libindustry/code/HEAD/tree/branches...

Code: http://sourceforge.net/p/libindustry/code/HEAD/tree/branches...

This was written shortly before I decided to stop fighting the language and simply use a better one for all of my hobby projects.