plp/haskell/haskell2.hs

module Haskell2 where

import qualified Data.Map as M
import Control.Monad


--implement player evaluatore (goals/matches)

playerEvaluator :: (RealFloat a) => a -> a -> String
playerEvaluator 0 _ = "Your moment will come kid"
playerEvaluator matches goals
        | performance <= 0.5 = "You should have your feet checked by a god doctor"
        | performance <= 1 = "Not bad kid!"
        | performance > 1 = "Great Result kid!!!"
        where performance = goals / matches

-- implement the quicksot algorithm

quicksort :: (Ord a) => [a] -> [a]
quicksort [] = []
quicksort (x:xs) =
        let smallerSorted = quicksort [a | a <- xs, a <= x]
            biggerSorted = quicksort [a | a <- xs, a > x]
        in smallerSorted ++ [x] ++ biggerSorted

-- implement a binary tree

data Tree a = EmptyTree | Node a (Tree a) (Tree a) deriving (Show, Read, Eq)

-- define a singleton tree (one node with 2 empty leaf)

singleton :: a -> Tree a
singleton x = Node x EmptyTree EmptyTree

-- define insertTree (remember that is a ordered insert)

insertTree :: (Ord a) => a -> Tree a -> Tree a
insertTree x EmptyTree = singleton x
insertTree x (Node a left right)
        | x == a = Node x left right
        | x < a = Node a (insertTree x left) right
        | x > a = Node a left (insertTree x right)

--define a function to check if a element is present in a Tree

treeElem :: (Ord a) => a -> Tree a -> Bool
treeElem _ EmptyTree = False
treeElem x (Node a left right)
        | x == a = True
        | x < a = treeElem x left
        | x > a = treeElem x right

--define treeSum

treeSum :: (Num a) => Tree a -> a
treeSum EmptyTree = 0
treeSum (Node a left right) = (treeSum left) + a + (treeSum right)

-- define treeValues, a function that returns a list containing all the values of a tree

treeValues :: Tree a -> [a]
treeValues EmptyTree = []
treeValues (Node a left right) = treeValues left ++ [a] ++ treeValues right


treeValues2 :: Tree a -> [a]
treeValues2 EmptyTree = []
treeValues2 (Node a left right) = a : ((treeValues left) ++ (treeValues right))

-- define the map function for a tree

treeMap :: (a -> b) -> Tree a -> Tree b
treeMap _ EmptyTree = EmptyTree
treeMap f (Node a left right) = Node (f a) (treeMap f left) (treeMap f right)

-- defin the foldl function for a tree
treeFoldl :: (a -> b -> a) -> a -> Tree b -> a
treeFoldl _ z EmptyTree = z
treeFoldl f z (Node a left right) = treeFoldl f (f (treeFoldl f z left) a) right

-- define the foldr function on a tree

treeFoldr :: (b -> a -> a) -> a -> Tree b -> a
treeFoldr _ z EmptyTree = z
treeFoldr f z (Node a left right) = treeFoldr f (f a (treeFoldr f z right)) left

-- define a filter function on the tree

treeFilter :: (a -> Bool) -> Tree a -> [a]
treeFilter f = treeFoldr (\x acc -> if f x then x:acc else acc) []

-- define the sumTree using treeFoldr

treeSum2 :: (Num a) => Tree a -> a
treeSum2 = treeFoldr (+) 0 

--define a the treeValues function on a tree using the treeFoldr

treeValues3 :: Tree a -> [a]
treeValues3 = treeFoldr (:) []

--define the treeValues unction using the treeFoldl function

treeValues4 :: Tree a -> [a]
treeValues4 t = treeFoldl (++) [] (treeMap (:[]) t)

--define a TrafficLight datatype implementing the equality operations and introducing a (partial) order

data TrafficLight = Red | Yellow | Green

instance Eq TrafficLight where
        Red == Red = True
        Yellow == Yellow = True
        Green == Green = True
        _ == _ = False

instance Show TrafficLight where
        show Red = "The light is red"
        show Yellow = "The light is yellow"
        show Green = "The light is green"