Pony good first issues

The Pony compiler's error messages are confusing when reporting missing methods on lambda types. The compiler uses an internal, uninformative name like '$1$0' instead of a more descriptive type name, making it difficult for users to understand the error. This issue affects explicit lambdas, object literals, and partial applications.

The user is encountering a "can't use an undefined variable in an expression" error in Pony, even though the variable `_x` is assigned a value within a `while true` loop followed by a `break`. This suggests a potential issue with the compiler's ability to correctly infer variable initialization within certain control flow structures.

The `File._pending_writes` function currently mishandles partial writes to disk by treating them the same as critical file descriptor errors. This leads to incorrect disposal of pending writes when only a portion of the data is written, which can occur when writing data larger than `PIPE_BUF`. The issue proposes distinguishing between these two failure types and implementing logic to retry writing the remaining unwritten bytes.

The user is encountering a confusing compiler error "not safe to write right side to left side" when attempting to assign a value to a field of an object within a class, specifically when that assignment happens within a 'fun' context. The error message doesn't clearly indicate that a `fun ref` is required for such operations.

This issue proposes enhancing compiler error messages for type mismatches. Specifically, when a mutation occurs within a function, the compiler should suggest converting the function to a `ref fun` if it detects a simple mutability problem, rather than just reporting generic subtype errors.

This issue requests the creation of new generators for collections within the Ponycheck library. Specifically, it aims to add support for generating `Set` and `Map` types, and potentially persistent collection types.

The compiler provides an unhelpful "unterminated match expression" error when a `let` or `var` keyword is omitted from a variable capture in a Pony match expression. The issue suggests a more informative error message, such as "variable capture requires let or var declaration", to improve developer experience.

The Pony compiler is failing to correctly infer the capture types for lambdas, specifically when dealing with references and boxes. This forces developers to explicitly specify the type of captured variables, which should ideally be inferred automatically by the compiler.

A compiler bug is identified where the `TYPEPARAMREF` modifier (`!`) in a type constraint is not being correctly applied during subtyping checks. This leads to an unsoundness where a type constrained with `!` is treated as a less restrictive type, potentially allowing for incorrect type conversions.

The generated documentation incorrectly includes `= recover` for a default parameter value, which should be a simple expression. This issue appears to stem from how expressions are handled versus simple values in the documentation generation process.

The generated documentation for certain functions, like `Array.slice` and `String.substring`, is incorrectly displaying 'call' as a default value instead of the actual default values such as `USize: -1` or `ISize.max_value()`. This bug is likely located in the `docgen.c` file, which handles documentation generation, and appears to be a boundary-related issue.

This RFC proposes adding an `export` keyword to Pony to generate C ABI-compatible wrapper functions for class methods. These wrappers, along with a header file (generated with a `--export` flag), will enable easier integration with C programs. The implementation requires code, tests, and documentation.

The compiler (ponyc) is reporting a "not reachable" error on a line of code that is actually reachable due to an early return in a function branch. This behavior is inconsistent with a modified version of the code that compiles correctly. A separate but related issue is also reported where `match` incorrectly believes a function body is `None`.

This issue proposes adopting a formal model for viewpoint adaptation, as detailed in George Steed's work. The implementation would involve introducing a new syntax to differentiate between extractive and non-extractive viewpoint types.

The user is encountering a compilation error when trying to make an actor generic over a data structure type. Specifically, they want to pass a reference to a generic `DataStructure` in the constructor, but the language currently disallows this for generic types, forcing it to be an `iso` which breaks the intended behavior.

This issue proposes refactoring the `trace_cap_nominal` function to avoid in-place modification of the Abstract Syntax Tree (AST). The current implementation mutates the AST and relies on careful restoration across all return paths, which has become more complex with recent changes. The suggested solution is to duplicate the AST at the beginning of the function and operate on the copy to prevent unintended side effects.

This issue proposes to fix a discrepancy in how type parameter constraints handle default capabilities. Currently, when a type name is used in a constraint without an explicit capability, the compiler defaults to `#any` or `val` for primitives, ignoring the type's declared default cap. This behavior is inconsistent with other parts of the language and can lead to unexpected errors, as demonstrated by failing `iftype` tests.

Pony programs compiled with Valgrind support on DragonFly BSD hang indefinitely when run under Valgrind's Memcheck. This issue appears to be related to an older version of Valgrind (3.15) shipped with DragonFly, which struggles with the Pony runtime's memory mapping operations. The problem does not occur on Linux with a more recent Valgrind version.