[GHC] #8751: Show parenthesised output of expressions in ghci

[GHC]

#8751: Show parenthesised output of expressions in ghci
-------------------------------------+-------------------------------------
        Reporter:  Iceland_jack      |                Owner:  (none)
            Type:  feature request   |               Status:  infoneeded
        Priority:  normal            |            Milestone:
       Component:  GHCi              |              Version:  7.6.3
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Old description:

> Operator fixity can be a source of bugs (even for experienced
> users!),[#point1 ¹] [#point2 ²] precedence levels may vary between
> languages and then there are user-defined operators.
>
> Attached is a patch for a ghci command allowing users to quickly
> parenthesise expressions as a sanity check (and as an alternative to
> using :info and parsing the result yourself). The command itself is
> activated with `:paren`:
>
> {{{#!hs
> ghci> :paren 2 + 10 * 4 / 3
> 2 + ((10 * 4) / 3)
> ghci> :paren \a b → a == b || b && a == (b == a) || b
> \ a b -> (a == b) || ((b && (a == (b == a))) || b)
> ghci> :paren 5 + 1 `mod` 2
> 5 + (1 `mod` 2)
> ghci> :paren 5 * 1 `mod` 2
> (5 * 1) `mod` 2
> }}}
>
> A friend of mine also pointed out that this could eventually be
> integrated into `haskell-mode` where the user could temporarily replace
> an expression with a parenthesised version or have different colours
> indicate different levels of logical nesting.
>
> ----
>
> An example that is tricky for me is `calculateBmi w h =  w / h^2`.
>
> [=#point1 ¹] [http://www.knosof.co.uk/cbook/accu06.html Developer beliefs
> about binary operator precedence]
>
> [=#point2 ²]
> [http://ieeexplore.ieee.org/document/7548903/?platform=hootsuite Brace
> Yourself] ([https://twitter.com/ieeesoftware/status/791882437295038464
> tweet])

New description:

 [https://www.reddit.com/r/haskell/comments/605o3b/add_a_describe_command_to_your_ghci_for_figuring/
 reddit thread].

 ----

 Operator fixity can be a source of bugs (even for experienced
 users!),[#point1 ¹] [#point2 ²] precedence levels may vary between
 languages and then there are user-defined operators.

 Attached is a patch for a ghci command allowing users to quickly
 parenthesise expressions as a sanity check (and as an alternative to using
 :info and parsing the result yourself). The command itself is activated
 with `:paren`:

 {{{#!hs
 ghci> :paren 2 + 10 * 4 / 3
 2 + ((10 * 4) / 3)
 ghci> :paren \a b → a == b || b && a == (b == a) || b
 \ a b -> (a == b) || ((b && (a == (b == a))) || b)
 ghci> :paren 5 + 1 `mod` 2
 5 + (1 `mod` 2)
 ghci> :paren 5 * 1 `mod` 2
 (5 * 1) `mod` 2
 }}}

 A friend of mine also pointed out that this could eventually be integrated
 into `haskell-mode` where the user could temporarily replace an expression
 with a parenthesised version or have different colours indicate different
 levels of logical nesting.

 ----

 An example that is tricky for me is `calculateBmi w h =  w / h^2`.

 [=#point1 ¹] [http://www.knosof.co.uk/cbook/accu06.html Developer beliefs
 about binary operator precedence]

 [=#point2 ²]
 [http://ieeexplore.ieee.org/document/7548903/?platform=hootsuite Brace
 Yourself] ([https://twitter.com/ieeesoftware/status/791882437295038464
 tweet])

--

Comment (by Iceland_jack):

 Examples:

 {{{#!hs
 pattern (:=) :: [String] -> [String] -> [String]
 pattern xs:=ys <- (break (== "=") -> (xs, "=":ys))

 splitArgs (words -> fn:args:=rest) = ...
 }}}

 Both `(fn:args):=rest` and `fn:(args:=rest)` parse, to see which one it is
 one either has to know the fixity rules, know `infixr 5 :`, know the
 default fixity (running the command `:info :=` currently does not divulge
 such secrets) or you could think of inputs (or have QuickCheck generate..)
 that give a different result.. neither ideal.

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8751#comment:15>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler