data S = S { name :: String } deriving (Show)
firstname s = (words (name s))!!0
lastname  s = (words (name s))!!1

*Main> let (-->) x f = f x
*Main> let test = S "George Washington"
*Main> test --> firstname
"George"
*Main> test --> lastname
"Washington"

*Main> let flip_concat t s = intercalate t $ reverse.words $ name s
*Main> test --> flip_concat ", "
"Washington, George"
*Main> test --> flip_concat(", ")
"Washington, George"

*Main> [1,2,3] --> length
3
 
class Deref a where
    (-->) :: a -> (a -> b) -> b
    x --> f = f x 
 
instance Deref S
 
*Main> [1,2,3] --> length
 
<interactive>:1:0:
    No instance for (Deref [t])
      arising from a use of `-->' at <interactive>:1:0-17
    Possible fix: add an instance declaration for (Deref [t])
    In the expression: [1, 2, 3] --> length
    In the definition of `it': it = [1, 2, 3] --> length

*Main> let pretty (pre, mid, post) s = pre ++ (firstname s) ++ mid ++ (lastname s) ++ post
*Main> test --> pretty ("<", ", ", ">")
"<George, Washington>"

import qualified Data.Map as Map
import Data.Maybe
import Network.XmlRpc.Client
import Network.XmlRpc.Internals
 
server = "http://yourserver.wordpress.com/xmlrpc.php"
 
-- extract multiple posts from the XML response
extract :: Value -> [Map String Value]
extract xmlresp = 
    let ValueArray rs = xmlresp in
    map (\v -> case v of 
                  ValueStruct vs -> Map.fromList vs
                  _              -> Map.fromList []) rs
 
getRecentPosts :: Int -> [Char] -> [Char] -> Int -> IO Value
getRecentPosts = remote server "metaWeblog.getRecentPosts"
 
-- print out the five most recent posts
main = do result <- getRecentPosts 1 "yourname" "yourpass" 5
          let posts = extract result
          mapM_ (\p -> print $ fromJust $ Map.lookup "title" p) posts

{-# OPTIONS -XBangPatterns #-}
import IO
import System
import Data.Word
import Data.Array.Unboxed
import Control.Monad.ST
import Data.Array.ST
import qualified Data.ByteString as B
import qualified Data.ByteString.Internal as BI
import qualified Data.ByteString.Char8 as C
 
counts' !line = do arr <- newArray (0,255) 0 :: ST s (STUArray s Word8 Int)
                   -- collate character counts here
                   return arr
counts !line = runSTUArray (counts' line)
 
hit !line = let freq = counts line in freq!65 == 10
 
main =
    do args <- getArgs
       f <- openFile "wordlist" ReadMode
       text <- B.hGetContents f
       print $ length $ filter hit (C.lines text)

-- version 1 : 9.5 seconds
counts' !line = do arr <- newArray (0,255) 0 :: ST s (STUArray s Word8 Int)
                   readArray arr (B.head line) >>= \v -> writeArray arr (B.head line) (v+1)
                   return arr
counts !line = runSTUArray (counts' line)

-- version 2 : 0.07 seconds
counts' !line = do arr <- newArray (0,255) 0 :: ST s (STUArray s Word8 Int)
                   readArray arr 0 >>= \v -> writeArray arr 0 (v+1)
                   return arr

-- version 3
-- compile with: ghc -package bytestring stuarray.hs -prof -auto-all -O2 -o stuarray.out
-- run with: ./stuarray.out +RTS -p 
initial_array = do arr <- newArray (0,255) 0 :: ST s (STUArray s Word8 Int)
                   return arr
 
counts' !line = do arr <- initial_array
                   let ix = B.head line
                   readArray arr ix >>= \v -> writeArray arr ix (v+1)
                   return arr
counts !line = runSTUArray (counts' line)

-- version 4: 0.11 seconds
initial_array = listArray (0,255) (repeat 0) :: UArray Word8 Int
 
counts' !line = do arr <- thaw initial_array
                   let ix = B.head line
                   readArray arr ix >>= \v -> writeArray arr ix (v+1)
                   return arr
counts !line = runSTUArray (counts' line)

import IO
import System
import qualified Data.ByteString as B
import qualified Data.ByteString.Internal as BI
import qualified Data.ByteString.Char8 as C
 
main = do args <- getArgs
          let searchfor = C.pack $ head args
          f <- openFile "wordlist" ReadMode
          text <- B.hGetContents f 
          print $ length $ filter ((==) searchfor) (C.lines text)

import IO
import System
import Data.Char
import qualified Data.ByteString as B
import qualified Data.ByteString.Internal as BI
import qualified Data.ByteString.Char8 as C
 
main = do args <- getArgs
          let searchfor = C.pack $ head args
          f <- openFile "wordlist" ReadMode
          text <- B.hGetContents f 
          print $ length $ filter (\x -> (C.map toLower x) == searchfor) (C.lines text)

import IO
import System
import Data.Char
import Data.Word
import Data.Array.Unboxed
import qualified Data.ByteString as B
import qualified Data.ByteString.Internal as BI
import qualified Data.ByteString.Char8 as C
 
ctype_lower = listArray (0,255) (map (BI.c2w . toLower) ['\0'..'\255']) :: UArray Word8 Word8
lowercase = B.map (\x -> ctype_lower!x)
 
main = do args <- getArgs
          let searchfor = C.pack $ head args
          f <- openFile "wordlist" ReadMode
          text <- B.hGetContents f 
          print $ length $ filter (\x -> (lowercase x) == searchfor) (C.lines text)

import Distribution.PackageDescription
import Distribution.PackageDescription.Parse  -- added this line
import Distribution.Simple

# :m Python.Interpreter Python.Objects Python.Utils Python.Exceptions
# py_initialize
# pyRun_SimpleString "print 'hello'"
hello

-- add 1 and 2 in Python
-- can also use Py_file_input or Py_single_input for different handling of the context
addem = pyRun_String "1+2" Py_eval_input [] >>= fromPyObject :: IO Integer

callByName :: String            -- ^ Object\/function name
           -> [PyObject]        -- ^ List of non-keyword parameters
           -> [(String, PyObject)] -- ^ List of keyword parameters
           -> IO PyObject
 
pyObject_Call :: PyObject       -- ^ Object to call
              -> [PyObject]     -- ^ List of non-keyword parameters (may be empty)
              -> [(String, PyObject)] -- ^ List of keyword parameters (may be empty)
              -> IO PyObject    -- ^ Return value
 
-- example 1: create an IMAP instance
imap <- callByName "imaplib.IMAP4_SSL" [imap_hostname] []
 
-- call "foo.bar(p1,p2)"
bar <- getattr foo "bar"
result <- pyObject_Call bar [p1,p2] []

# g <- pyRun_String "(1,2,'hello')" Py_eval_input []
# showPyObject g
"<type 'tuple'>: (1, 2, 'hello')"
# reprOf g
"(1, 2, 'hello')"
# strOf g
"(1, 2, 'hello')"
# dirPyObject g
["__add__","__class__","__contains__","__delattr__","__doc__","__eq__","__ge__",
"__getattribute__","__getitem__","__getnewargs__","__getslice__","__gt__",
"__hash__","__init__","__iter__","__le__","__len__","__lt__","__mul__","__ne__",
"__new__","__reduce__","__reduce_ex__","__repr__","__rmul__","__setattr__","__str__"]

# a
[1,2]
# b <- toPyObject a
# reprOf b
"[1L, 2L]"
# pyList_AsTuple b >>= reprOf
"(1L, 2L)"
 
-- get "True," "False," and "None"
none <- pyRun_String "None" Py_eval_input []
pyTrue <- pyRun_String "True" Py_eval_input []
pyFalse <- pyRun_String "False" Py_eval_input []
 
-- try it out
# r <- pyRun_String "1==1" Py_eval_input []
# r == pyTrue
True

addem = handlePy exc2ioerror $ 
           do r <- pyRun_String "1/0" Py_eval_input []
              fromPyObject r :: IO Integer
 
# addem
*** Exception: user error (Python <type 'exceptions.ZeroDivisionError'>: integer division or modulo by zero)

-- Python:  ",".join(lst)
-- either...
import Data.List
intercalate "," lst
-- or...
import Data.List
concat (intersperse "," lst)

-- a.split(ss)
-- You might need to get Data.List.Split from Cabal
import Data.List.Split
splitOn ss a 
-- using regexes
import Text.Regex
splitRegex (mkRegex ss) a

-- Python: a.startswith(b)
import Data.List
isPrefixOf b a
-- ByteString
import Data.ByteString
isPrefixOf b a

-- Python: a.endswith(b)
import Data.List
isSuffixOf b a
-- ByteString
import Data.ByteString
isSuffixOf b a

-- Python: a.find(b) != -1
import Data.List
isInfixOf b a
-- ByteString
import Data.ByteString
isInfixOf b a 
-- ByteString
import Data.ByteString
findSubstring b a -- returns Just int or Nothing

-- Python: a[::-1]
reverse a
-- ByteString
import Data.ByteString
reverse bs

-- Python: a[pos]
a !! pos    -- slow O(n)
-- ByteString
import Data.ByteString
index a pos

-- Python: a.find(b)
import Data.ByteString
findSubstring a b

-- Python: b = a.replace(src,dest)
import Text.Regex
b = subRegex (mkRegex src) a dest

-- Python: b = re.sub("[0-9]+", lambda x: str(int(x.group(0)) + 1), a)
import Text.Regex (matchRegexAll, mkRegex)
 
subRegexFn fn re s = concat $ reverse $ sub s []
    where sub s accum = case matchRegexAll re s of
                            Nothing -> s:accum
                            Just (pre, mid, post, _) -> sub post $ (fn mid):pre:accum 
 
b = subRegexFn (read . (+ 1) . show) "[0-9]+" a

-- Python: a.strip()
import Data.Char (isSpace)
trim      :: String -> String
trim      = f . f
   where f = reverse . dropWhile isSpace

-- Python:  loop through every line in stdin, applying a function
-- for line in sys.stdin:
--      print fn(line)
let main = interact (unlines . map fn . lines) 
-- or...
let main = do { a <- stdin; mapM_ print (map fn (lines a)); }