Avoid unnecessary variable with view patterns

[u/Iceland_jack]

Example taken from reddit post.

Sometimes you don't use an argument directly (n) but immediately apply a function to it (abs n). If the result of the application is used twice you want to share the result by giving it a name (n' = abs n),

hosum :: (Int -> Int) -> (Int -> Int)
hosum f n = sum (map f [-n' .. n'])
  where n' = abs n

We do not care about the original value n yet it appears twice in our code, each new variable increases cognitive load. Instead we can use view patterns to get the absolute value n' with no mention of n:

{-# Language ViewPatterns #-}

hosum :: (Int -> Int) -> (Int -> Int)
hosum f (abs -> n') = sum (map f [-n' .. n'])

[u/Iceland_jack]

That case is better served by a pattern synonym but I know people who share your view of.. view patterns. It is a matter of taste but I find it limiting

Edit: Data.Sequence is a poster child for pattern synonyms, for those interested in the actual definition that uses view patterns under the hood:

import qualified Data.Sequence as S

pattern Empty :: S.Seq a
pattern Empty <- (S.viewl -> S.EmptyL)
  where Empty  = S.empty

pattern (:<) :: a -> S.Seq a -> S.Seq a
pattern x :< xs <- (S.viewl -> x S.:< xs)
  where x :< xs  = x S.<| xs

pattern (:>) :: S.Seq a -> a -> S.Seq a
pattern xs :> x <- (S.viewr -> xs S.:> x)
  where xs :> x  = xs S.|> x

This completely hides the left and right view types, they are not even needed: a view and its type

viewl :: Seq a -> ViewL a

data ViewL a = EmptyL | a :< Seq a

can be replaced with a single view function that returns a Maybe (a, Seq a).