Function operator()

src/fl/stl/function.h:337–572

#endif  // FL_FUNCTION_FULL_VARIANT

    R operator()(Args... args) const FL_NOEXCEPT {
        // Direct dispatch using type checking - efficient and simple
#if FL_FUNCTION_FULL_VARIANT
        if (auto* heap_callable = mStorage.template ptr<fl::shared_ptr<CallableBase>>()) {
            return (*heap_callable)->invoke(args...);
        } else if (auto* free_func = mStorage.template ptr<FreeFunctionCallable>()) {
#else
        if (auto* free_func = mStorage.template ptr<FreeFunctionCallable>()) {
#endif
            return free_func->invoke(args...);
        } else if (auto* inlined_lambda = mStorage.template ptr<InlinedLambda>()) {
            return inlined_lambda->invoke(args...);
#if FL_FUNCTION_FULL_VARIANT
        } else if (auto* nonconst_member = mStorage.template ptr<NonConstMemberCallable>()) {
            return nonconst_member->invoke(args...);
        } else if (auto* const_member = mStorage.template ptr<ConstMemberCallable>()) {
            return const_member->invoke(args...);
#endif
        }
        // This should never happen if the function is properly constructed
        return default_return_helper<R>();
    }
    
    explicit operator bool() const FL_NOEXCEPT {
        return !mStorage.empty();
    }
    
    void clear() FL_NOEXCEPT {
        mStorage = Storage{};  // Reset to empty variant
    }
    
    bool operator==(const function& o) const FL_NOEXCEPT {
        // For simplicity, just check if both are empty or both are non-empty
        // Full equality would require more complex comparison logic
        return mStorage.empty() == o.mStorage.empty();
    }
    
    bool operator!=(const function& o) const FL_NOEXCEPT {
        return !(*this == o);
    }

private:
    // Helper for small lambdas/functors - inline storage
    template <typename F>
    void construct_lambda_or_functor(F f, true_type /* small */) FL_NOEXCEPT {
        mStorage = InlinedLambda(fl::move(f));
    }

#if FL_FUNCTION_FULL_VARIANT
    // Helper for large lambdas/functors - heap storage
    template <typename F>
    void construct_lambda_or_functor(F f, false_type /* large */) FL_NOEXCEPT {
        mStorage = fl::shared_ptr<CallableBase>(fl::make_shared<Callable<F>>(fl::move(f)));
    }
#else
    // Low-memory targets: heap fallback dropped per FastLED #3077 to save flash.
    // Large lambdas (>kInlineLambdaSize) compile but leave the storage empty;
    // operator() returns the default-constructed R. This degrades gracefully