Understanding Rust Error E0644: Closure Referencing Its Own Type

Introduction

Rust Error E0644 occurs when a closure or generator is constructed in such a way that it references its own type. This is not allowed in Rust, as it can make closure inference problematic. In this article, we will explore the details of this error, why it occurs, and how to fix it.

Error E0644 Example

Let's examine an erroneous code example that triggers Rust Error E0644:

fn fix<F>(f: &F)
  where F: Fn(&F)
{
    f(&f);
}

fn main() {
    fix(&|y| {
        // Here, when `x` is called, the parameter `y` is equal to `x`.
    });
}

In the code above, a closure is passed to the fix function which accepts an argument of reference to its own type (F). This is not allowed in Rust as it could lead to complicated closure inference.

How to Resolve Rust Error E0644

To resolve Rust Error E0644, you can take one of the following approaches:

1. Rewrite your closure into a top-level function or a method.

2. Capture an &Fn() object or fn() pointer referencing the closure itself, and call it via a virtual call, avoiding direct reference to its own type.

Solutions Example

Let's consider the following examples as solutions for the original problematic code:

Solution 1: Top-level function

fn closure_fn(y: &dyn Fn(&dyn Fn())) {
    // Perform the desired action
}

fn fix<F>(f: &F)
  where F: Fn(&F)
{
    closure_fn(&f);
}

fn main() {
    fix(&closure_fn);
}

Solution 2: Capturing an &Fn() object

fn fix<F>(f: &F)
  where F: Fn(&F)
{
    f(&f);
}

fn main() {
    let recursive_closure = |y: &dyn Fn(&dyn Fn())| y(y);
    fix(&recursive_closure);
}

In both the above solutions, the closure and references to its own type have been refactored to avoid Rust Error E0644.