Convert Callback Based Function to Promise Based Function

Convert Callback Based Function to Promise Based Function - Problem

JavaScript Medium

Write a function that accepts another function fn and converts the callback-based function into a promise-based function.

The function fn takes a callback as its first argument, along with any additional arguments args passed as separate inputs. The promisify function returns a new function that should return a promise.

The promise should resolve with the argument passed as the first parameter of the callback when the callback is invoked without error, and reject with the error when the callback is called with an error as the second argument.

Example:

This callback-based function:

function sum(callback, a, b) {
  if (a < 0 || b < 0) {
    const err = Error('a and b must be positive');
    callback(undefined, err);
  } else {
    callback(a + b);
  }
}

Should become equivalent to this promise-based function:

async function sum(a, b) {
  if (a < 0 || b < 0) {
    throw Error('a and b must be positive');
  } else {
    return a + b;
  }
}

Input & Output

Example 1 — Basic Function Conversion

$ Input: fn = function(callback, a, b) { callback(a + b); }

› Output: Returns a function that returns Promise resolving to a + b

💡 Note: The callback-based function is wrapped to return a Promise that resolves with the sum

Example 2 — Error Handling

$ Input: fn = function(callback, a, b) { if (a < 0) callback(undefined, 'Error'); else callback(a + b); }

› Output: Promise rejects with 'Error' if a < 0, otherwise resolves with a + b

💡 Note: Error passed as second parameter to callback becomes Promise rejection

Example 3 — Multiple Arguments

$ Input: fn = function(callback, x, y, z) { callback(x * y * z); }

› Output: Promise resolves to x * y * z

💡 Note: Function with multiple arguments still follows same pattern: callback becomes Promise

Constraints

fn is a valid callback-based function
The callback follows the pattern: callback(result, error)
If error is undefined/null, the operation succeeded
If error is provided, the operation failed

Visualization

Tap to expand

Understanding the Visualization

Input

Callback-based function fn(callback, ...args)

Process

Wrap in Promise constructor with resolve/reject

Output

Promise-based function returning Promise

Key Takeaway

🎯 Key Insight: Wrap callback functions in Promise constructor to modernize async code and enable async/await usage

Asked in

G Google 35 f Facebook 28 a Amazon 22 M Microsoft 18

The key insight is to wrap the callback-based function in a Promise constructor. Create a new function that returns a Promise, where the Promise executor calls the original function with a custom callback that resolves/rejects the promise based on the callback parameters. Best approach uses Promise constructor pattern. Time: O(1), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Modern Promise Pattern	O(1)	O(1)	Use Promise constructor with proper error handling
Promise Constructor Wrapper	O(1)	O(1)	Wrap the callback function in a Promise constructor

Modern Promise Pattern — Algorithm Steps

Return function that creates new Promise
Pass resolve/reject to Promise constructor
Create callback that resolves/rejects based on parameters
Call original function with custom callback

Visualization

Tap to expand

Step-by-Step Walkthrough

Promise Created

New Promise with resolve/reject

Callback Executed

Original function called with custom callback

Result Handled

Success resolves, error rejects

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int has_error;
    int result;
    char error[256];
} CallbackResult;

static CallbackResult global_result;

void promise_callback(int result, const char* error) {
    if (error && strlen(error) > 0) {
        global_result.has_error = 1;
        strncpy(global_result.error, error, 255);
        global_result.error[255] = '\0';
    } else {
        global_result.has_error = 0;
        global_result.result = result;
    }
}

typedef void (*OriginalFunction)(void (*callback)(int, const char*), int, int);

CallbackResult solution_execute(OriginalFunction fn, int a, int b) {
    global_result.has_error = 0;
    global_result.result = 0;
    global_result.error[0] = '\0';
    
    fn(promise_callback, a, b);
    return global_result;
}

int main() {
    char fnName[256];
    if (fgets(fnName, sizeof(fnName), stdin)) {
        fnName[strcspn(fnName, "\n")] = 0;
    }
    
    printf("promisify\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Constant time wrapper creation, actual execution depends on wrapped function

✓ Linear Growth

Space Complexity

O(1)

Only creates promise and callback function, no additional data structures

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Modern Promise Pattern — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler