[kccqzy]

My biggest piece of advice for people using lenses is to ditch all the operators. Things like ^. or ^.. or ^? or ^@.. or even <<|>~ are all real operators. Yet they look like line noise. Nobody fully remembers them anyways. Just ditch all operators. Use named functions. The function toListOf is immediately clear what it's doing (that it takes a structure and a fold to convert to a list) but ^.. is not.

In general I avoid all custom operators and only use operators that are in packages preinstalled by the compiler (basically just base and containers).

[chowells]

I strongly recommend using the lens operators. They are uniformly named such that you can trivially identify their behavior based on their lexical construction, and using them reduces mental parsing overhead significantly.

For the former assertion: ^. means "get a single result". ^.. means "get multiple results". ^? means "get zero or one result". ^@.. means "get multiple results, along with their indices". <<|>~ means "modify a value by combining the target with the |> operator from Snoc, then return a tuple of the old target value and the full structure including the combined value". There is a tiny language in the pattern of operator names, and it's worth the 3 minutes of work it takes to learn it.

And as a reward for learning it, you get to write expressions with far fewer parentheses. This is a massive win. Parenthesized expressions introduce a miserable minigame during reading, where you have to properly match each paren to its correct partner keeping a mental stack to handle nesting. By contrast, the lens operators give you the far simpler mental parsing task of separating the optic, the input, and the operation on the input. There's no nesting involved. The process is a simple visual scan that doesn't require keeping a mental stack. It's a lot easier to quickly read and comprehend.

About the only thing you lose is the ability to easily read code out loud. I don't limit myself to thinking in sounds, but I guess for some people it's important to communicate code out loud. For those kinds of pedagogical purposes, I guess it's ok to pass on the operators. But for code I'm going to work with over a long period of time I'd much rather have the readability advantages of the operators.

[kccqzy]

Having fewer parentheses is not a win, it makes more things implicit and forces everyone to remember operator precedence. In my opinion operator precedence is never worth remembering other than plus minus multiply and divide.

I find heavily parenthesized expressions easy to read, just because I tend to break them into multiple lines and the indentation serves as a guide. Don't put too many of them on a single line.

[chowells]

That might be a strong argument in many languages, but in Haskell you really don't need to memorize operator precedence. In nearly every case, the types tell you the precedence. They don't literally, but most expressions only type check in one particular parse tree.

As a result, you just don't think about precedence when reading code. If you assume the code type checked correctly, you know that it all just makes sense. You don't need to create a parse tree. You just trust.

(Actually, this is the huge advantage of Haskell in most every case. You don't need to understand everything. You just trust that it does what makes sense, and you're right. The compiler enforces it.)

[iroddis]

You may want to check out J as a language. It is wonderfully terse and allows for point-free programming, and has all of the advantages you point to above.

[jbggs]

couldn't find/replace be used to swap between operators and readable function names?

[aranchelk]

I disagree. There are many operators that you’ll never use but if you memorize (^.), (.~), and (%~), you’re pretty much set for a lot of real-world software development.

Per Kmett’s original talk/video on the subject, I can confirm my brain shifted pretty quickly to look at them like OOP field accessors. And for the three above, the mnemonics are effective:

“^.” is like an upside down “v” for view.

“.~” looks like a backwards “s” for setters.

“~%” has an tilde so it’s a type of setter and “%” has a circle over a circle, so it’s over.

I’ll also add that my experience in recent versions of PureScript things get even nicer: visible type application lets you define record accessors on the fly like:

foo ^. ln@“bar” <<< ln@“baz”

“.” Is unfortunately a restricted character and is not the composition operator like Haskell, but I alias “<<<“ with “..”

The pretty obvious question with the above is: why don’t you just write “foo.bar.baz”. In my case I use a framework that uses passed lenses for IoC, but I think “%~” is always nicer and less repetitive than the built-in alternative.

[amelius]

Maybe a text-editor should allow the user to look at source code through different "lenses" (pun intended) and show the meanings of symbols whenever the user wants to see them.

[ashton314]

Emacs (of course) has `prettify-symbols-mode` which lets you describe symbols (eg lambda) and replacement characters (eg λ); the effect is purely in the display system—the underlying buffer does not get modified.

[kqr]

I agree strongly with this and take it one step further: I avoid the infix backticks that turn functions `into` operators.

But I'm not a hardliner. I do use backticks sometimes when building joins with Esqueleto and I do use a limited set of lens operators, like ^. and sometimes the %= variants if the situation calls for it.

[agnishom]

I understand where you are coming from, but in a large number of cases this advice does not really make sense.

Sure, a Haskell programmer does write toList when relevant. The lens library also has operators named each or over or _Left.

But let's say I write <$> and you tell me to use fmap. Is that any better? Not particularly. If you didn't know what Functor is, you wouldn't automatically be able to infer it by reading the name `fmap`.

A large number of Haskell concepts simply have no analogue in everyday English.

[kccqzy]

Read more carefully. My advice is to ditch operators in the lens package. I didn't tell anyone to ditch operators in Prelude including <$>.

[agnishom]

My bad.

But I think my point still stands? What is the 'normal' way to write ^. for example?

[kccqzy]

The non-operator way to write ^. is the named function called view. https://hackage-content.haskell.org/package/lens-5.3.5/docs/...

[agnishom]

Thanks. Perhaps you have a point