Ayaz Hafiz a53da2bc24 Make sure late specializations of opaques inherit Inspect as needed ... A "late specialization" of a type is an ability specialization that is not visible or needed until after type-specialization; i.e. during monomorphization. The `Inspect.toInspector` ability is special-cased for opaques that do not claim or explicitly implement `Inspect`. In such cases, they are treated as structural types, and given the immediate specialization of `Inpect.inspectOpaque`. However, prior to this commit, that special-casing would only be applied during early specialiation (i.e. specializations visible during generalized type inference). This commit applies the special case to late specialization as well - the specialization decision for an opaque type is always the specialization of the opaque type in the late case, but now, when we go to look up the ambient lambda set of the specialization, if it does not exist and corresponds to `Inspect.toInspector`, we fall back to the immediate. One concern I have here is that in a case like ``` Op := {} x = dbg (@Op {}) ``` the specialization of `Inspect.toInspector` for `Op` should be known early. Indeed, the program ``` Op := {} x = Inspect.toInspector (@Op {}) |> Inspect.apply (Inspect.init {}) |> Inspect.toDbgStr ``` Compiles fine without this change. This makes me suspect there is an issue with the implementation of `dbg`'s desugaring. If possible, this should be addressed sooner rather than later. Closes #6127		2023-11-30 22:25:08 -06:00
..
docs	Add language to all fenced code blocks	2022-09-09 01:12:31 -06:00
src	Make sure late specializations of opaques inherit Inspect as needed	2023-11-30 22:25:08 -06:00
tests	make dropFirst and dropLast drop n elements	2023-10-29 13:23:33 -05:00
Cargo.toml	roc_solve shouldn't depend on itself	2023-11-10 16:04:06 -05:00