[GHC] #12541: RFC: Implicit parentheses in GHCi

[GHC]

#12541: RFC: Implicit parentheses in GHCi
-------------------------------------+-------------------------------------
           Reporter:  Iceland_jack   |             Owner:
               Type:  feature        |            Status:  new
  request                            |
           Priority:  normal         |         Milestone:
          Component:  GHCi           |           Version:  8.0.1
           Keywords:                 |  Operating System:  Unknown/Multiple
       Architecture:                 |   Type of failure:  None/Unknown
  Unknown/Multiple                   |
          Test Case:                 |        Blocked By:
           Blocking:                 |   Related Tickets:
Differential Rev(s):                 |         Wiki Page:
-------------------------------------+-------------------------------------
 I've been making a few tickets lately that aren't technical but small
 things that would streamline my interactive experience. Please close if
 this is not the place for it. ''Caveat lector'': long and boring read
 ahead.

 = Code =
 {{{#!hs
 data Op  = Add   | Mul                  deriving Show
 data Exp = Op Op | Lit Int | Exp :$ Exp deriving Show
 infixl :$
 }}}

 = Motivation =
 I often want to see the “progression” of applying an operator to arguments
 one by one. There are several ways of doing this:

 {{{#!hs
 >>> :t (:$)
 >>> :t (Op Add :$)
 >>> :t Op Add :$ Lit 10
 }}}

 {{{#!hs
 >>> :t (:$)
 >>> :t (Op Add :$)
 >>> :t (Op Add :$) (Lit 10)
 }}}

 {{{#!hs
 >>> :t (:$)
 >>> :t (:$) (Op Add)
 >>> :t (:$) (Op Add) (Lit 10)
 }}}

 {{{#!hs
 >>> :t (:$)
 >>> :t (:$) (Op Add)
 >>> :t Op Add :$ Lit 10
 }}}

 Look at all of those parentheses! Every step adds or removes (or requires
 navigation around) parentheses.

 = `tl;dr`: this is annoying to type =

 I'm writing this out in full not just because I get a sick joy out of it
 but to hammer the point home.

 === First example ===
 We wrap `:$` in parentheses, navigate around them to make a section and
 then remove them:

 {{{#!hs
   >>>
   >>> :t (:$)␣
 -- C-m

   >>>
 -- C-p
   >>> :t (:$)␣
 -- C-a
   >>> ␣:t (:$)
 -- C-f, C-f, C-f, C-f
   >>> :t (␣:$)
   >>> :t (Op Add ␣:$)
 -- C-m

   >>>
 -- C-p
   >>> :t (Op Add :$)␣
 -- C-h
   >>> :t (Op Add :$␣
   >>> :t (Op Add :$ Lit 10
 -- C-a
   >>> ␣:t (Op Add :$ Lit 10
 -- C-f, C-f, C-f
   >>> :t ␣(Op Add :$ Lit 10
 -- C-d
   >>> :t ␣Op Add :$ Lit 10
 }}}

 === Second example ===
 We wrap `:$` in parentheses, navigate around them to make a section and
 then wrap the argument in parentheses:
 {{{#!hs
   >>>
   >>> :t (:$)␣
 -- C-m

   >>>
 -- C-p
   >>> :t (:$)␣
 -- C-a
   >>> ␣:t (:$)
 -- C-f, C-f, C-f, C-f
   >>> :t (␣:$)
   >>> :t (Op Add ␣:$)
 -- C-m

   >>>
 -- C-p
   >>> :t (Op Add :$)␣
   >>> :t (Op Add :$) (Lit 10)␣
 }}}

 === Third example ===
 Wrap everything in parentheses, on a good day I will remember that the
 arguments need parentheses:
 {{{#!hs
   >>>
   >>> :t (:$)␣
 -- C-m

   >>>
 -- C-p
   >>> :t (:$)␣
   >>> :t (:$) (Op Add)␣
 -- C-m

   >>>
 -- C-p
   >>> :t (:$) (Op Add)␣
   >>> :t (:$) (Op Add) (Lit 10)␣
 }}}

 ((On every other day I will forget that `Op Add` is an application and
 write..))

 {{{#!hs
   >>> :t (:$)␣
   >>> :t (:$) Add␣
 -- M-b
   >>> :t (:$) ␣Add
   >>> :t (:$) (Op ␣Add
 -- C-e
   >>> :t (:$) (Op Add␣
   >>> :t (:$) (Op Add)␣
 }}}

 === Fourth example ===
 Wrap operator and argument, remove both pairs of parentheses:

 {{{#!hs
   >>>
   >>> :t (:$)␣
 -- C-m

   >>>
 -- C-p
   >>> :t (:$)␣
   >>> :t (:$) (Op Add)␣
 -- C-m

   >>>
 -- C-p
   >>> :t (:$) (Op Add)␣
 -- C-a
   >>> ␣:t (:$) (Op Add)
 -- C-f, C-f, C-f
   >>> :t ␣(:$) (Op Add)
 -- C-d, C-d, ...
   >>> :t ␣Op Add)
 -- C-e
   >>> :t Op Add)␣
 -- C-h
   >>> :t Op Add␣
   >>> :t Op Add :$ Lit 10␣
 }}}

 = Proposal =
 Long story short this involves a lot of manipulation of terms
 (deleting/rewriting, cutting/pasting), jumping around and adding or
 removing parentheses.

 My proposal is to make GHCi a bit smarter in how it accepts operators and
 sections, to a first approximation it would be as if there were implicit
 `'(' ++ cmd ++ ')'` around the command. Let's see how I picture this would
 work:

 {{{#!hs
 >>> :t :$
 >>> :t Op Add :$
 >>> :t Op Add :$ Lit 10
 }}}

 This may feel disconcerting since this is not valid syntax for operators
 or sections, but I think it would be fine. For example both `:info :$` and
 `:info (:$)` work. This would take me a lot less time to write! No
 parentheses and minimal jumping around.

 This would make it very simple to get the right section of an operator:

 {{{#!hs
 >>> :t >>=
 >>> :t >>= id
 }}}

 and could be extended to work with infix functions as well, I would
 probably use `flip` a whole lot less:
 {{{#!hs
 >>> :t `take`
 -- ^ probably shouldn't work, but allows for less skipping

 >>> :t `take` "wabalabadubdub"
 >>> :t 10 `take` "wabalabadubdub"
 }}}

 The reason why I said “to a first approximation” is that `:$) (Op Add`
 should obviously not be valid.

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