Subset generation

module Main where

main = print (subset "abcd")

subset :: [Char] -> [[Char]]
subset [] = [[]]

subset (x:xs) = subset(xs) ++ [x:l | l <- subset(xs)]

Just for the record, worked like a charm after I got around some pesky type issues. So satisfying!

module Main where

main = print (permute "abcd")

permute :: [Char] -> [[Char]]
permute [] = [[]]
permute (l) = [a:x | a <- l, x <- permute(filter (/= a) l)]

Another toy program to traverse a binary tree in depth-first order.

module Main where

main = traverse((Tree (Node 'a') (Tree (Node 'c') (Node 'b'))))

data Tree = Node Char | Tree Tree Tree

traverse :: Tree -> IO ()
traverse (Node n) = print n
traverse (Tree l r) = do traverse l
                         traverse r

Here is a toy evaluator of integer expressions:

module Main where

data Expr = Const Int | Add Expr Expr | Sub Expr Expr | Mul Expr Expr | Div Expr Expr

main = print (eval (Div (Const 20) (Add (Const 1) (Sub (Const 10) (Const 2)))))

eval :: Expr -> Int
eval (Const k) = k
eval (Add x y) = eval x + eval y
eval (Sub x y) = eval x - eval y
eval (Mul x y) = eval x * eval y
eval (Div x y) = eval x `div` eval y

Counting lines

module Main where

main = print . length . lines =<< getContents

=<< is the sequencing operator being used here in lieu of do. "." is the function composition operator.

This can also be written as:

module Main where

main = do lns <- getContents
          let lns' = lines lns
          print (length lns')

Reading files

module Main where

import IO

main = do h <- openFile "p3.hs" ReadMode
          contents <- hGetContents h
          putStr contents
          hClose h

Hello, You!

module Main where

main = do putStr "Name?"
          n <- getLine
          putStrLn ("Hello, " ++ n)

Hello, World! - the Haskell way

module Main where
main = putStrLn "Hello, World!"