Tab and Shift-Tab smart indent on selected text - haskell

Question

It's standard in most modern editors that you can highlight a piece of code and indent or unindent a tab or however many spaces you're using; how do you do this in emacs?
So, for example I just opened sublime text, highlighted the following piece of code:
variation1 person phoneMap carrierMap addressMap =
case M.lookup person phoneMap of
Nothing -> Nothing
Just number ->
case M.lookup number carrierMap of
Nothing -> Nothing
Just carrier -> M.lookup carrier addressMap
then pressed tab and got
variation1 person phoneMap carrierMap addressMap =
case M.lookup person phoneMap of
Nothing -> Nothing
Just number ->
case M.lookup number carrierMap of
Nothing -> Nothing
Just carrier -> M.lookup carrier addressMap
one shift-tab on that code returns it back to where it was, and if I continuing pressing shift-tab I eventually get the following:
variation1 person phoneMap carrierMap addressMap =
case M.lookup person phoneMap of
Nothing -> Nothing
Just number ->
case M.lookup number carrierMap of
Nothing -> Nothing
Just carrier -> M.lookup carrier addressMap
Quote from another response:
emacs language modes don't really have a notion of 'indent this block
1 tab further'. Instead they're very opinionated and have a notion of
'this is the correct indentation' and that's what you get when you hit
tab in a language mode.
Except when I do that with the following code (haskell mode and ghc mod enabled):
import Monad
import System
import IO
import Random
import Control.Monad.State
type RandomState a = State StdGen a
data CountedRandom = CountedRandom {
crGen :: StdGen
, crCount :: Int
}
type CRState = State CountedRandom
getRandom :: Random a => RandomState a
getRandom =
get >>= \gen ->
let (val, gen') = random gen in
put gen' >>
return val
I get the following:
import Monad
import System
import IO
import Random
import Control.Monad.State
type RandomState a = State StdGen a
data CountedRandom = CountedRandom {
crGen :: StdGen
, crCount :: Int
}
type CRState = State CountedRandom
getRandom :: Random a => RandomState a
getRandom =
get >>= \gen ->
let (val, gen') = random gen in
put gen' >>
return val
when I wanted
import Monad
import System
import IO
import Random
import Control.Monad.State
type RandomState a = State StdGen a
data CountedRandom = CountedRandom {
crGen :: StdGen
, crCount :: Int
}
type CRState = State CountedRandom
getRandom :: Random a => RandomState a
getRandom =
get >>= \gen ->
let (val, gen') = random gen in
put gen' >>
return val
Near enough to a solution from ataylor:
(defcustom tab-shift-width 4
"Sets selected text shift width on tab"
:type 'integer)
(make-variable-buffer-local 'tab-shift-width)
(global-set-key
(kbd "<tab>")
(lambda (start end)
(interactive "r")
(if (use-region-p)
(save-excursion
(let ((deactivate-mark nil))
(indent-rigidly start end tab-shift-width)))
(indent-for-tab-command))))
(global-set-key
(kbd "S-<tab>")
(lambda (start end)
(interactive "r")
(if (use-region-p)
(save-excursion
(let ((deactivate-mark nil))
(indent-rigidly start end (- tab-shift-width))))
(indent-for-tab-command))))
It'd be nice if emacs had support for indent detection (i.e., just grab the value of some variable); the closest thing I found to this was a plugin called dtrt indent but it doesn't work for Haskell.

Answer 1

indent-region will reindent a block of text according to the current mode.
To force an indentation level to be added, you can use string-rectangle, which will prompt you for a string. Here you can provide the string for an indentation level (e.g. a tab, 4 spaces, etc.). The string will be inserted on each line of the currently selected region, in the current column, effectively indenting it. Alternatively, you can get a similar effect from open-rectangle, which will insert whitespace into the rectangle with corners defined by the point and the mark.
Another way to force indentation is to call indent-rigidly (C-x TAB). This overrides the mode specific indentation rules and indents a fixed amount. The numeric argument specifies how much to indent, and a negative argument will unindent. If you want this to be the default behavior when a region is selected, you could do something like this:
(global-set-key
(kbd "<tab>")
(lambda (start end)
(interactive "r")
(if (use-region-p)
(save-excursion
(let ((deactivate-mark nil))
(indent-rigidly start end 4)))
(indent-for-tab-command))))

Answer 2

Haskell code is incredibly difficult to indent correctly, because there are multiple "correct" indentations for a piece of code.
haskell-mode has a very specific line format that it expects you to follow (As in, you have to make line breaks in the right places) and it has a few indentation rules for formatting code that matches that line format. These rules exist to make the automatic indentation results more consistent. The rules are roughly this:
After every keyword that introduces a block, you should make a line break or make sure that the entire block fits into the layout. Otherwise, you get a lot of hanging blocks like in your getRandom example
All blocks are indented exactly two spaces. This includes module blocks; if you do module Bla where, the whole part after that line will be indented. This means that you should keep the default Haskell module file format for the indentation order to work out.
The indentation of a line needs to be as unambiguous as possible; if a line could mean different things depending on its indentation, it will lead to it being indented to the position that haskell-mode thinks makes sense in the context. Fixing this can be impossible in some cases.
Because it is impossible to structure Haskell code so that it meets the requirements of haskell-mode, you cannot indent a while Haskell code file like this. You need to only use automatic indentation locally. This can be done in a number of ways:
When you are on a line, you can indent the current line to the most likely "correct" position with regards to the previous line by pressing TAB. By pressing TAB again, you will bring the line to the "next" indentation level, and continuously cycle through all possible logical indentation steps.
If you select a series of blocks that are found locally (The body of a function etc.) and use M-x indent-region, the result will most likely be correct.
What I usually do in a situation like this is to start on the line that has the "wrong" indentation, press TAB once, and go down line-by-line, pressing TAB one or multiple times on each line until the indentation of that line is correct. The current "logical indentation positions" for the current line are calculated from the preceding code context, so correcting the indentation from the top almost always yields the correct result.

Answer 3

I highlight the area and hit C-M-\. It is indent-region and more fun can be found at the multi-line indent page.

Answer 4

emacs language modes don't really have a notion of 'indent this block 1 tab further'. Instead they're very opinionated and have a notion of 'this is the correct indentation' and that's what you get when you hit tab in a language mode.
Once you get used to it anything else seems weird. In your Haskell code those case statements only really have one indentation that's valid, anything else is a syntax error unless you add braces and semicolons. If you really want to customize what emacs considers the 'right' indentation look at how to customize your mode. A lot of language modes reuse the c-mode variables so here is probably a good place to start (though I'm not sure what Haskell mode does, I've never found a need to customize it).
edit:
I see in your comment that your troubles are from not having Haskell mode installed, got to the github page to get it.