Postfix projections

[ziman]

This is a port of the original PR.

Included changes:

• .proj is now allowed for any identifier proj, not only record projections.
• .(complex expression), which works just like .proj but you can have an arbitrary expression on the RHS. This is feature-gated by %language PostfixProjections.
• The special RF constructor for names of the form .recordField is gone; it does not make much sense anymore with this more general syntax.

Even without %language PostfixProjections enabled, this patch expands the set of accepted programs by allowing non-record-projections in .proj. I'm not sure how to feature-gate this easily but maybe it's okay as it is.

[ziman]

I added a patch that changes the following:

• Bare .proj without a preceding operand is no longer valid syntax, so f $ .proj no longer parses. You have to write f $ (.proj) or f (.proj) or f proj.
• We now support projection sections: (.proj1.proj2 y z) is equivalent to (\x => x.proj1.proj2 y z). This is feature-gated by %language PostfixProjections.

So you can say:

• map (.add 4) [1,2,3]
• map (.oopFoldl 0 (+)) [[1,2,3], [4,5,6]]

[gallais]

Are we happy with this PR? I am happy with it.
Just need a quick rebase & then we can merge it.

[ziman]

I rebased it and fixed the tests. Let's hope the CI agrees, too.

[Russoul]

@ziman expression x .f y .g z parses like (x .f) (y .g) z.
May it be (x .f y) .g z ?

Motivation:

ability to use 'standard', 'scala-like' function application syntax:
suppose:
map : m a -> (a -> b) -> m b
reduce : m a -> (a -> a -> a) -> a
then this would be possible:
list.map(\x => 2 * x).reduce(+) == reduce (map list (\x => 2 * x)) (+)
or
students.target("Peter").update(.expelled) == update (target students "Peter") (\s => expelled s)

but currently it is:
(list.map) ((\x => 2 * x).reduce(+)) == map list (reduce (\x => 2 * x) (+))
or
(students.target) (("Peter").update(.expelled))

[ziman]

I can see where you're coming from but I think that the suggestion goes against the purpose of postfix projections, which is binding tighter than application. (Since you cannot define so tightly binding operators yourself, a change to the syntax was necessary.)

The suggestion would make f x.y p.q interpreted as q (y p (f x)) rather than f (y x) (q p), if I understand correctly, and you'd lose the ability to access record fields in applications, which was the motivation for postfix projections.

I think that what you suggest would be better achieved by borrowing infixl (&) : a -> (a -> b) -> b from Haskell. Then you could write list & map (2 *) & reduce (+). I think this should behave as you suggest, except that you'd write & instead of ..

Alternatively, you can currently write list.(map (2 *)).(reduce (+) 0).

[Russoul]

@ziman yeah, gotcha