lorenzo bolla's blog

I had to tinker quite a bit before finding a decent configuration for vim to edit Haskell files.

Here are the packages and config files I use:

• Haskell mode: interaction with Haddock, compiler integration, and other general settings.
• Indentation: proper source code indentation.
• More configs to enforce good style (no tabs, tabstops, etc.): 

  " Add to .vimrc
  " Need to have .vim/compiler/ghc.vim
  
  augroup HSK
          au Bufenter *.hs compiler ghc
          autocmd FileType haskell setlocal formatoptions+=t
          autocmd FileType haskell let b:ghc_staticoptions = '-Wall -Werror'
  augroup END
  
  

  view raw haskell-.vimrc.vim This Gist brought to you by GitHub.

  " Add to .vim/ftplugin/haskell.vim
  
  " From Good Haskell Style http://urchin.earth.li/~ian/style/haskell.html
  setlocal expandtab
  setlocal tabstop=8
  setlocal shiftwidth=8
  setlocal textwidth=79

  view raw haskell-ftplugin.vim This Gist brought to you by GitHub.

  " Add to .vim/syntax/haskell.vim
  
  " From Good Haskell Style http://urchin.earth.li/~ian/style/haskell.html
  
  syn cluster hsRegions add=hsImport,hsLineComment,hsBlockComment,hsPragma
  syn cluster hsRegions add=cPreCondit,cCppOut,cCppOut2,cCppSkip
  syn cluster hsRegions add=cIncluded,cDefine,cPreProc,cComment,cCppString
  
  syn match tab display "\t" containedin=@hsRegions
  hi link tab Error
  syn match trailingWhite display "[[:space:]]\+$" containedin=@hsRegions
  hi link trailingWhite Error

  view raw haskell-syntax.vim This Gist brought to you by GitHub.

You can also have them bundled all together.

To try to make sense of this, I decided to write a “simple” http client in Haskell in as many styles as I could think of:

import Network.HTTP
import Control.Applicative

url = "http://www.haskell.org/haskellwiki/Haskell"

--  Imperative style
fetch_1 = do
	rsp <- Network.HTTP.simpleHTTP (getRequest url)
	body <- getResponseBody rsp
	return (take 1000 body)

--  With Functors' fmap
fetch_2 = do
	rsp <- Network.HTTP.simpleHTTP (getRequest url)
	fmap (take 1000) (getResponseBody rsp)

--  With Applicative's >>=
fetch_3 = fmap (take 1000) (Network.HTTP.simpleHTTP (getRequest url) >>= getResponseBody)

--  "fmap f x" is the same as "pure f <*> x" (Applicative's law)
fetch_4 = pure (take 1000) <*> (Network.HTTP.simpleHTTP (getRequest url) >>= getResponseBody)

--  "pure f <*> x" is the same as "f <$> x"
fetch_5 = (take 1000) <$> (Network.HTTP.simpleHTTP (getRequest url) >>= getResponseBody)

it’s a long time since I found so many new concepts while studying a new programming language…

If you are interested to know if the myth about MD5 being faster than SHA1 holds for Python, here is the result I got on my box:

In [1]: import hashlib

In [2]: %timeit hashlib.md5('text text text').hexdigest()
1000000 loops, best of 3: 1.29 us per loop

In [3]: %timeit hashlib.sha1('text text text').hexdigest()
1000000 loops, best of 3: 1.4 us per loop

Result is: MD5 is faster, but only just, in Python 2.7.2. Considering that MD5 is broken, I think I’ll use SHA1…

10/10

better go before I break it…