Convert between list-likes in functions like pmap, pfilter, preverse, ...

[Renegatto]

Summary

Do conversion between list representations wherever possible for better efficiency (assuming).

Details

The example of inefficiency of current state against suggested one:
Let's assume:

f :: ClosedTerm (A :--> B)
toImplement :: ClosedTerm (PBuiltinList A :--> PList B)

Now:

toImplement = phoistAcyclic $ plam $ \xs -> pconvertLists #$ pmap # f # xs

Suggested:

toImplement = phoistAcyclic $ pmap # f

This way its one less iteration thru the list.

Implementation

Is mostly straightforward and only need changes in type signatures.
For example, for pmap:

pmap ::
 ( PListLike list
 , PListLike list' -- ADDED
 , PElemConstraint list a
 , PElemConstraint list' b -- CHANGED
 ) =>
 Term s (
   (a :--> b) :-->
   list a :-->
   list' b -- CHANGED
 )

[TotallyNotChase]

This has been suggested before: #416

I only have two concerns about this:

• Type inference. I explain this in a comment in the linked issue; but the gist is that chained list operations become painful with this overloaded impl.
• Script size. Overloaded functions generate a different AST for each unique instantiation. It's not something that'd increase the size of existing code - but it may encourage bad patterns for script size. It's not a big issue though

Since this is really about optimization, the suggestion of simply using a rewrite rule instead seemed better to me at the time. So I never pursued this issue with a quick PR

[L-as]

we could probably allow the user to choose in some way