With the latest patches, this branch builds. There's probably still documentation that doesn't match.

In general, I like this a lot. It feels right and makes a lot of things so much simpler. However, I think we need a better story for constructing Angles. Using Control.Lens.# is completely out of the question, for obvious reasons. And stuff like 30 ^. from deg seems a little clunky. In an ideal world I would like to be able to write something as close to "30 deg" as possible. Obviously that isn't directly possible. But perhaps we could come up with some infix operator of type Double -> Iso' Angle Double -> Angle, so we could write 30 %&%^$ deg? (Obviously we need a better name for the operator...)

As an alternative, we could have deg :: Double -> Angle so we could write 30 # deg. Then the Iso would have to be named something else...

Just brainstorming here. I'm not sure I really like any of the above proposals.

So we need some operator that is not in Lens, not in Diagrams, and not profanity. There must still be a few of those.

Seriously, I agree that this would be better than any of the syntax examples I gave above. Some initial thoughts on names:

• $$ (used in a bunch of parsing contexts)
• @@
• /- (loosely modeled on the angle symbol ∠)
• Turn around the Iso so we can write 30 ^. deg :: Angle and define as = flip review to allow a as deg :: Double

Is there a reason you want Double -> Iso' Angle Double -> Angle rather than the general type b -> Iso' a b -> a? Or I guess the even more general type of flip review :: b -> AReview s t a b -> t?

I'd rather use the Isos than have separate Double -> Angle functions for each unit, if we can find a decent name for the operator.

Yes, I would also rather use the Isos than have separate Double -> Angle functions.

The reason I suggested Double -> Iso' Angle Double -> Angle is to make it easier for users to find. Though of course good documentation, examples, etc. will go a long way here too. b -> Iso' a b -> a might be OK too. I would really rather not have anything with stabs in it.

Turning around the Iso could work too, but I think I'd rather keep them the way they are, since it feels most natural to me. Converting from Angle to radians, degrees, etc. "feels like" a projection much more than constructing an Angle does.

I like @@. 30 @@ deg reads nicely. $$ could work, but it reminds me of function application and that doesn't make sense here: 1/4 $$ turn has nothing to do with applying 1/4 to turn. On the other hand I think $$ is occasionally used for backwards function application so that could be OK. /- looks like some sort of division which might be confusing: (tau / 7) /- rad.

Great. I just added @@ and switched -lib to using it internally. I still have some Haddock changes to make in -lib, and presumably lots of updates to make in -doc.

Cool, looks good to me.

I also meant to ask about precedence for @@. I picked a precedence lower than +, so I can write let a = b + c @@ turn. Are there other interactions we should think about?

Picking operator precedence is a black art. I never really know what the "right" way to approach it is. The precedence you picked for @@ "feels right" to me (for whatever that's worth).

This looks very nice. Definitely preferable to what we had (IMHO).