Warning

types, definitions of functions, pattern matching, lists, basic built-in functions and operators: :load, :type (:t)

fact :: Integer -> Integer
fact n = if n == 0 then 1 else n*(fact (n-1))

fact1 n | n==0 = 1
| otherwise = n*(fact1 (n-1))

fact'' 0 = 1
fact'' n = n*(fact'' (n-1))
data MyColor = Red | Green | Blue

-- some sort of list of MyColor
data MyListColor = CCons MyColor MyListColor | EmptyListColor

data MyList a = Cons a (MyList a) | EmptyList
[1..100]     -- list of numbers from 1 to 100 with step 1.
[1,3..100]   -- list of odd numbers from  1 to 100 (with step 2)
[2,4..100]   -- list of even numbers from  2 to 100 (with step 2)
[1..]        -- list of all numbers from 1 with step 1
[1,3..]      -- list of all odd numbers from 1 (with step 2)
-- QuickSort in Haskell:
quicksort [] = []
quicksort (e:ls) = (quicksort [x|x<-ls,x<e]) ++ [e] ++ (quicksort [x|x<-ls,x>=e])

lambda terms, curryfication, graphical syntax, @, let, where, type classes (class, instance, deriving), basic built-in type classes (Eq, Ord, Num, Show), :info (:i), lazy evaluation

-- Example of lambda term
Main> map (\ x -> -x) [1..10]
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]

-- Example of curryfication of -
Main> map ((-) 0) [1..10]
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]

-- Example of curryfication of infix -
Main> map (0-) [1..10]
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]

-- Example of let
Main> let minus = (0-) in map minus [1..10]
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]

-- Example of let
Main> let {minus = (0-); ls = [1..10]} in map minus ls
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]

-- Example of where
Main> map minus ls where {minus = (0-); ls = [1..10]}
[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]

msort [] = []
msort [x] = [x]
msort ls = merge sas sbs where
(xs,ys) = split ls where
split [] = ([],[])
split [x] = ([x],[])
split (x:y:ls) = ((x:xs),(y:ys)) where
(xs,ys) = split ls
sas = msort xs
sbs = msort ys
merge [] ls = ls
merge ls [] = ls
merge ws@(x:xs) zs@(y:ys) | (x<=y) = (x : merge xs zs)
| otherwise = merge zs ws

-- Example:
Main> :t msort
msort :: Ord a => [a] -> [a]

Main> msort [6,4,1,3]
[1,3,4,6]

-- automated instantiation of Eq, Ord, and Show class for NTree type using: deriving
data NaryTree a = NaryNode a [NaryTree a] | NaryLeaf a deriving (Eq,Ord,Show)

-- Example:
Main> :t NaryNode 1 [NaryLeaf 2]
NaryNode 1 [NaryLeaf 2] :: Num a => NaryTree a

Main> NaryNode 2 [NaryLeaf 2] == NaryNode 1 [NaryLeaf 2]
False

Main> NaryNode 2 [NaryNode 2] <= NaryNode 1 [NaryLeaf 2]
False

Main> NaryNode 1 [NaryLeaf 2]
NaryNode 1 [NaryLeaf 2]

data NaryTree a = NaryNode a [NaryTree a] | NaryLeaf a

numberLeafs (NaryLeaf _) = 1
numberLeafs (NaryNode _ ls) = sum [numberLeafs x| x <- ls]

-- custom instantiation of Eq, Ord, and Show class for NaryTree type using: instance
instance (Eq a) => Eq (NaryTree a) where
x == y = numberLeafs x == numberLeafs y

instance (Ord a) => Ord (NaryTree a) where
x <= y = numberLeafs x <= numberLeafs y

instance (Show a) => Show (NaryTree a) where
show (NaryLeaf x) = "<" ++ (show x) ++ ">"
show (NaryNode x ls) = "{" ++ (show x) ++ ":" ++ (show ls) ++ "}"

-- Example:
Main> :t NaryNode 1 [NaryLeaf 2]
NaryNode 1 [NaryLeaf 2] :: Num a => NaryTree a

Main> NaryNode 2 [NaryLeaf 2] == NaryNode 1 [NaryLeaf 2]
True

Main> NaryNode 2 [NaryNode 2] <= NaryNode 1 [NaryLeaf 2]]
True

Main> NaryNode 1 [NaryLeaf 2]
{1:[<2>]}

-- custom definition of some class W with one function w
class W a where
w :: a -> Bool

-- instantiation of class W for type NTree a
instance W (NaryTree a) where
w (NaryLeaf _) = True
w _ = False 