Personal tools

Indent

From HaskellWiki

(Difference between revisions)
Jump to: navigation, search
(Another solution)
(oh,lambdabot also knows how to ppr)
Line 34: Line 34:
 
 
 
==================== Parser ====================
 
==================== Parser ====================
  +
<haskell>
 
main = do
 
main = do
 
print (f 10)
 
print (f 10)
Line 39: Line 40:
 
print (f 3735928559)
 
print (f 3735928559)
 
f x = sqrt (fromIntegral ((x * 10133123) `mod` 1231111121 :: Int))
 
f x = sqrt (fromIntegral ((x * 10133123) `mod` 1231111121 :: Int))
  +
</haskell>
   
   
Line 44: Line 46:
 
$ ghc -fno-code -ddump-parsed B.hs | sed '/^===/d'
 
$ ghc -fno-code -ddump-parsed B.hs | sed '/^===/d'
   
  +
<haskell>
 
main = do
 
main = do
 
print (f 10)
 
print (f 10)
Line 49: Line 52:
 
print (f 3735928559)
 
print (f 3735928559)
 
f x = sqrt (fromIntegral ((x * 10133123) `mod` 1231111121 :: Int))
 
f x = sqrt (fromIntegral ((x * 10133123) `mod` 1231111121 :: Int))
  +
</haskell>
   
 
Which is a reasonable result.
 
Which is a reasonable result.
Line 54: Line 58:
 
===Use ghc-api===
 
===Use ghc-api===
   
?
+
It may be possible to use ghc-api.
   
 
===Use Language.Haskell===
 
===Use Language.Haskell===
Line 101: Line 105:
 
module Main (main) where
 
module Main (main) where
 
main = let x = 7 in return (x + x)
 
main = let x = 7 in return (x + x)
  +
</haskell>
  +
  +
===Lambdabot===
  +
  +
[[Lambdabot]] has a pretty printing plugin that can be used for similar purposes.
  +
It only takes a single line of input though.
  +
  +
lambdabot> pretty main=let{x=7;y=3;z=4}in case x+y of { _|z<2 -> 1}
  +
<haskell>
  +
main = let x = 7
  +
y = 3
  +
z = 4
  +
in case x + y of
  +
_ | z < 2 -> 1
 
</haskell>
 
</haskell>
   

Revision as of 00:12, 6 April 2006

Contents

1 Indenting Haskell Mechanically

indent(1) is a tool to format C program source. At the time of writing we have no such tool for Haskell in common use -- although this would be fairly easy to write, given the existing parsing and pretty printing libraries.

Here are some other solutions

1.1 Emacs

Emacs has an indent mode. Though it is often considered poor at laying out Haskell code.

1.2 Use GHC

GHC provides a --ddump-parsed flag. It can be used as follows. Note that it will strip comments -- so take care! It will also normalise values -- so 0xdeadbeef becomes a large decimal.

    main = do  {
        ;print (f 10)
                ;      print (f 20)
       ;print (f 0xdeadbeef)       
    }                                                                                                 
    f x = sqrt  ( fromIntegral 
            (x * 10133123 `mod` 
                        1231111121 :: Int ))

Running it through:

$ ghc -fno-code -ddump-parsed B.hs
                                     
==================== Parser ====================
 main = do                                       
          print (f 10)
          print (f 20)
          print (f 3735928559)
 f x = sqrt (fromIntegral ((x * 10133123) `mod` 1231111121 :: Int))


Postprocess:

$ ghc -fno-code -ddump-parsed B.hs | sed '/^===/d'
 main = do
          print (f 10)
          print (f 20)
          print (f 3735928559)
 f x = sqrt (fromIntegral ((x * 10133123) `mod` 1231111121 :: Int))

Which is a reasonable result.

1.3 Use ghc-api

It may be possible to use ghc-api.

1.4 Use Language.Haskell

For Haskell98, this program should do the trick:

import Language.Haskell.Parser
import Language.Haskell.Pretty
 
main = interact $ \s ->
    case parseModule s of
        ParseFailed loc str -> (show loc)      ++ "\n"
        ParseOk m           -> (prettyPrint m) ++ "\n"

For example:

$ ghc -O Ppr.hs -package haskell-src
$ ./a.out < Ppr.hs
module Main (main) where
import Language.Haskell.Parser
import Language.Haskell.Pretty
main
   = interact $
       \ s ->
         case parseModule s of
             ParseFailed loc str -> (show loc) ++ "\n"
             ParseOk m -> (prettyPrint m) ++ "\n"

Or:

 main =  
   let {
       x = 7;
          } in 
 
              return (
                x + x
                        )

Becomes:

 module Main (main) where
 main = let x = 7 in return (x + x)

1.5 Lambdabot

Lambdabot has a pretty printing plugin that can be used for similar purposes. It only takes a single line of input though.

lambdabot> pretty main=let{x=7;y=3;z=4}in case x+y of { _|z<2 -> 1}

 main = let x = 7
            y = 3
            z = 4
        in case x + y of
            _ | z < 2 -> 1