Problem Description

This problem asks you to create a function that returns a special object with "infinite methods". This object has a unique property: you can call any method name on it (even methods that don't exist), and it will always return the name of the method you called as a string.

The key characteristics of this infinite-method object are:

• It accepts any method call, regardless of whether that method was previously defined
• When any method is called, it returns the method's name as a string
• The method names can be anything - they don't need to be predefined

For example:

• If you call obj.abc123(), it returns the string "abc123"
• If you call obj.hello(), it returns the string "hello"
• If you call obj.anyRandomName(), it returns the string "anyRandomName"

The solution uses JavaScript's Proxy object to intercept property access. When any property is accessed on the proxy object, it returns a function. When that function is called, it returns the property name as a string. The get trap in the proxy handler intercepts all property accesses and returns a function that, when executed, returns the property name converted to a string.

This creates the illusion of an object with infinite methods, where each "method" simply returns its own name.

Intuition

When we need an object that can respond to any method call that doesn't actually exist, we need to think about how JavaScript handles property access and method calls. In JavaScript, calling a method like obj.abc123() happens in two steps:

1. First, the property abc123 is accessed from obj
2. Then, the result is called as a function with ()

Since we can't possibly define every possible method name ahead of time (there are infinite possibilities), we need a way to dynamically intercept these property accesses and return something callable.

This is where JavaScript's Proxy comes in. A Proxy allows us to intercept and customize operations performed on objects, including property access. When we create a proxy with a get trap, we can control what happens whenever any property is accessed on our object.

The clever part is realizing that when the get trap is triggered, we receive the property name as a parameter (prop). Instead of returning a value or undefined, we return a function. This function, when called, simply returns the property name that was originally accessed.

So the flow works like this:

• obj.abc123() triggers the get trap with prop = "abc123"
• The get trap returns a function: () => "abc123"
• The () immediately calls this returned function
• The function executes and returns "abc123"

By returning a function from the get trap that closes over the property name, we create the illusion that every possible method exists on our object, and each one knows its own name.

Solution Approach

The implementation uses JavaScript's Proxy object to create the infinite-method object. Here's how the solution works step by step:

1. Create a Proxy with an empty target object: The function starts by creating a new Proxy with an empty object {} as the target. The target doesn't need any properties since we're intercepting all property access anyway.

2. Define the handler with a get trap: The second argument to Proxy is a handler object that defines which operations to intercept. We only need the get trap, which intercepts property access operations.

3. The get trap implementation:

   get: (_, prop) => () => prop.toString()

   • The get trap receives three parameters, but we only use prop (the property name being accessed)
   • The underscore _ represents the target object, which we don't need
   • Instead of returning a value directly, it returns an arrow function () => prop.toString()
   • This returned function, when called, converts the property name to a string and returns it

4. Property access flow: When someone accesses a property like obj.abc123:

   • The proxy intercepts this access
   • The get trap is triggered with prop = "abc123"
   • It returns a function that remembers "abc123" through closure
   • When this function is immediately called with (), it returns "abc123"

5. Type definition: The function returns Record<string, () => string>, indicating an object where:

   • Keys are strings (any property name)
   • Values are functions that return strings

This pattern leverages JavaScript's dynamic nature and the Proxy's ability to intercept operations, creating an object that appears to have infinite methods without actually defining any of them explicitly.

Example Walkthrough

Let's walk through how the infinite-method object works with a concrete example:

// Create the infinite-method object
const obj = createInfiniteObject();

// Call obj.greeting()

When we call obj.greeting(), here's what happens step by step:

1. Property Access Phase: JavaScript first tries to access the property greeting from obj

   • This triggers the Proxy's get trap
   • The get trap receives prop = "greeting"
   • Instead of returning undefined (since greeting doesn't exist), the trap returns a function: () => "greeting"

2. Function Execution Phase: The parentheses () immediately invoke the returned function

   • The function executes and returns the string "greeting"
   • Result: obj.greeting() returns "greeting"

Let's trace through another example with multiple calls:

const obj = createInfiniteObject();

console.log(obj.foo());        // "foo"
console.log(obj.bar());        // "bar"
console.log(obj.test123());    // "test123"

For each call:

• obj.foo():
  • Get trap intercepts "foo" → returns () => "foo" → executes → returns "foo"
• obj.bar():
  • Get trap intercepts "bar" → returns () => "bar" → executes → returns "bar"
• obj.test123():
  • Get trap intercepts "test123" → returns () => "test123" → executes → returns "test123"

The key insight is that the Proxy dynamically generates a new function for each property access, and that function captures the property name through closure. This creates the illusion that the object has infinite pre-defined methods, when in reality, each "method" is created on-the-fly during property access.

Solution Implementation

Time and Space Complexity

Time Complexity: O(1)

The createInfiniteObject() function creates and returns a Proxy object, which is a constant-time operation. The Proxy's get trap handler executes in O(1) time when any property is accessed, as it simply returns a function that converts the property name to a string using prop.toString(). When the returned function is invoked, the toString() operation on the property name is also O(1) for typical property access scenarios.

Space Complexity: O(1)

The space complexity is constant because:

• The Proxy object itself takes a fixed amount of memory regardless of how many properties are accessed
• The empty object {} used as the target takes constant space
• Each property access creates a new function closure, but these are created on-demand and not stored permanently in the object
• The Proxy doesn't actually store any properties - it dynamically generates responses through the get trap
• Memory usage doesn't grow with the number of different properties accessed, as no actual properties are being stored in the underlying object

Common Pitfalls

1. Confusion Between Property Access and Method Call

A frequent mistake is forgetting that the returned value is a function that needs to be called. Developers often try to access the property without calling it as a method:

Incorrect:

obj = create_infinite_object()
result = obj.abc123  # This returns a function object, not "abc123"
print(result)  # Output: <function InfiniteObject.__getattr__.<locals>.<lambda> at 0x...>

Correct:

obj = create_infinite_object()
result = obj.abc123()  # Note the parentheses - calling the function
print(result)  # Output: "abc123"

2. Attempting to Access Built-in Methods

The __getattr__ method only intercepts attributes that don't exist. Python's built-in methods and attributes might not behave as expected:

Problem:

obj = create_infinite_object()
# These might not return what you expect:
obj.__class__()  # Won't return "__class__" - this is a real attribute
obj.__dict__()   # Won't return "__dict__" - this is a real attribute

Solution: Override specific magic methods if you need consistent behavior:

class InfiniteObject:
    def __getattr__(self, prop):
        return lambda: str(prop)
  
    def __getattribute__(self, prop):
        # Intercept ALL attribute access, not just missing ones
        if prop.startswith('_'):
            # Allow access to special methods for Python internals
            return object.__getattribute__(self, prop)
        return lambda: str(prop)

3. Type Checking and IDE Autocomplete Issues

Static type checkers and IDEs won't recognize dynamically generated methods, leading to warnings and lack of autocomplete:

Problem:

obj = create_infinite_object()
obj.my_method()  # IDE shows warning: "Unresolved attribute reference"

Solution: Add type hints to help with static analysis:

from typing import Callable, Any

class InfiniteObject:
    def __getattr__(self, prop: str) -> Callable[[], str]:
        return lambda: str(prop)
  
    # For better IDE support, you could add a __call__ pattern:
    def __call__(self, method_name: str) -> str:
        return method_name

4. Nested Property Access Attempts

Developers might expect chaining or nested property access to work:

Problem:

obj = create_infinite_object()
# This won't work as expected:
result = obj.parent.child()  # Error: 'function' object has no attribute 'child'

Solution: If chaining is needed, modify the implementation to return another infinite object:

class InfiniteObject:
    def __getattr__(self, prop):
        def method(*args, **kwargs):
            if args or kwargs:
                # If called with arguments, return the property name
                return str(prop)
            # If called without arguments, return property name
            return str(prop)
      
        # Also add the ability to chain
        method.__getattr__ = lambda nested_prop: InfiniteObject().__getattr__(f"{prop}.{nested_prop}")
        return method

5. Memory Considerations with Closure

Each property access creates a new lambda function, which could lead to memory overhead if many properties are accessed:

Solution: Cache frequently accessed methods or use a single method with parameters:

from functools import lru_cache

class InfiniteObject:
    @lru_cache(maxsize=128)
    def __getattr__(self, prop):
        return lambda: str(prop)