Partial function composability in C++

First of all, your unary_fn is totally misguided. You're trying to take a C++ object and ask it "What is your first argument type?" C++ doesn't really do that, because we have overloading. See "Perennial impossibilities of C++" (2018-06-12).

auto abs = [](const auto& x) { return (x < 0) ? -x : x; };
unary_fn<decltype(abs)> u;  // oops, does not compile!

However, to avoid reimplementing the (misguided, wobbly) wheel, you could definitely switch to Boost.CallableTraits: boost::callable_traits<decltype(abs)>::args also does not compile, but it takes less hand-written code to achieve that same non-compilation. ;)

template <typename PartialFn1, typename PartialFn2, typename OutType = detail::unary_fn<PartialFn2>::return_type, typename InType = detail::unary_fn<PartialFn1>::arg_type>
concept SingleArgComposable = requires(PartialFn1 pf1, PartialFn2 pf2, InType elem) {
    requires detail::is_optional<typename detail::unary_fn<PartialFn1>::return_type>::value;
    { pf2(*pf1(elem)) } -> std::same_as<OutType>;
    requires detail::is_optional<OutType>::value;
};

This code is pretty impenetrable. Whitespace and newlines would help. So would shorter template parameter names; for example, PartialFn1 and PartialFn2 are only one trailing digit different, which tends to get lost in the noise, whereas F and G are much more distinct names that convey the exact same amount of information: "this thing is a type parameter."

You also don't have to say typename OutType; we know it's a Type because it's a type parameter. Just class Out is good enough. (I prefer class because it's shorter, and doesn't get confused with the other meaning of typename inside complicated templates.)

Finally, some helper aliases would... help. :)

template<class F> using unary_arg_t = detail::unary_fn<F>::arg_type;
template<class F> using unary_return_t = detail::unary_fn<F>::return_type;

template<class F, class G, class Out = unary_return_t<G>, class In = unary_arg_t<F>>
concept SingleArgComposable = requires(F f, G g, In x) {

    requires detail::is_optional<unary_return_t<F>>::value;
    requires detail::is_optional<Out>::value;

    { g(f(x).value()) } -> std::same_as<Out>;
};

At this point it's actually just about as easy to eliminate the In and Out parameters.

template<class F, class G>
concept SingleArgComposable = requires(F f, G g, unary_arg_t<F> x) {

    requires detail::is_optional<unary_return_t<F>>::value;
    requires detail::is_optional<unary_return_t<G>>::value;

    { g(f(x).value()) } -> std::same_as<unary_return_t<G>>;
};

Here's another impenetrable token soup:

template <typename PartialFn1, typename PartialFn2, typename RetType = detail::unary_fn<PartialFn2>::return_type> requires SingleArgComposable<PartialFn1, PartialFn2, RetType>
auto compose(PartialFn1 firstCallable, PartialFn2 secondCallable) {
    return [firstCallable, secondCallable](auto inValue) {
        auto firstResult = firstCallable(inValue);
        if(firstResult) {
            return secondCallable(*firstResult);
        }
        return RetType{};
    };
}

Rewritten to let in some natural light:

template<class F, class G, class R = unary_return_t<G>>
auto compose(F f, G g)
    requires SingleArgComposable<F, G>
{
    return [=](auto x) -> R {
        if (auto fx = f(x)) {
            return g(*fx);
        }
        return std::nullopt;
    };
}

If this were production code, I would change all the by-copy stuff to use move semantics:

template<class F, class G, class R = unary_return_t<G>>
auto compose(F f, G g)
    requires SingleArgComposable<F, G>
{
    return [f = std::move(f), g = std::move(g)]<class X>(X&& x) -> R {
        if (auto fx = f(std::forward<X>(x))) {
            return g(std::move(*fx));
        }
        return std::nullopt;
    };
}

Oh, and about halfway through the code you seem to have forgotten about all that unary_fn stuff you had started out with. Clearly, if you want compose(f,g) to itself be composable, you either have to

• throw out all that unary_fn stuff because it can't handle generic lambdas such as compose(f,g), or

• make compose(f,g) return a non-generic lambda.

For example:

template<class F, class G>
auto compose(F f, G g)
    requires SingleArgComposable<F, G>
{
    return [=](unary_arg_t<F> x) -> unary_return_t<G> {
        if (auto fx = f(x)) {
            return g(*fx);
        }
        return std::nullopt;
    };
}

Now you can do compose(f, compose(g, h)) and so on.