-- Informatics 2D

-- Haskell Refresher Lecture
----------------------------
-- Petros Papapanagiotou


module Lecture where

import Data.Maybe
import Data.List


-- (1) Functions and types

add x y = x + y


add2 :: Integer -> Integer -> Integer
add2 x y = x + y


add3 :: (Num a) => a -> a -> a
add3 x y = x + y


-- (2) Control


-- If-then-else 

abs2 :: Integer -> Integer
abs2 x = if x > 0 then x else (-x)


-- Guards

abs3 :: Integer -> Integer
abs3 x
     | x > 0 = x
     | otherwise = (-x)


grade :: Integer -> String
grade x
      | x > 100 = "Invalid"
      | x > 90 = "A+"
      | x > 80 = "A"
      | x > 70 = "B"
      | x > 60 = "C"
      | x > 50 = "D"
      | x > 40 = "E"
      | x >= 0 = "F"
      | otherwise = "Invalid"


-- Another example

isnonzero :: Integer -> Bool
isnonzero x = if (x == 0) then False else True


isnonzero2 :: Integer -> Bool
isnonzero2 x
      | (x==0) = False
      | otherwise = True


-- Pattern matching

isnonzero3 :: Integer -> Bool
isnonzero3 0 = False
isnonzero3 _ = True 



-- Case split 

isnonzero4 :: Integer -> Bool
isnonzero4 x = case x of 
             0 -> True
             _ -> False


-- (3) 'where' clause

{-

int addabs (int x, int y) {
  return (abs(x) + abs(y));
}

int addabs (int x, int y) {
  int x' = abs(x);
  int y' = abs(y);
  return (x' + y');
}

-}

addabs :: Integer -> Integer -> Integer
addabs x y = abs(x) + abs(y)


addabs2 :: Integer -> Integer -> Integer
addabs2 x y = x' + y'
        where x' = abs x
              y' = abs y


-- (4) Currying

add4 :: (Num a) => a -> a -> a
add4 = (+)


add5 :: Integer -> Integer -> Integer
add5 = add4


add_one :: Integer -> Integer
add_one x = x + 1


add_one2 :: Integer -> Integer
add_one2 = add5 1


-- (5) Composition

-- (f o g) (x) = f( g(x) )

abs_add_one :: Integer -> Integer
abs_add_one x = add_one ( abs(x) )


abs_add_one2 :: Integer -> Integer
abs_add_one2 x = (add_one . abs) x


abs_add_one3 :: Integer -> Integer
abs_add_one3 = add_one . abs


dbl :: Integer -> Integer 
dbl = (*) 2


abs_dbl_add :: Integer -> Integer -> Integer
abs_dbl_add x y = abs( dbl( add x y ))


abs_dbl_add2 :: Integer -> Integer -> Integer
abs_dbl_add2 x y = (abs . dbl) ( add x y )


abs_dbl_add3 :: Integer -> Integer -> Integer
abs_dbl_add3 x y = (abs . dbl . ( add x )) y 


abs_dbl_add4 :: Integer -> Integer -> Integer
abs_dbl_add4 x = (abs . dbl . (add x))


abs_dbl_add5 :: Integer -> Integer -> Integer
abs_dbl_add5 x y = abs $ dbl $ add x y 


-- (6) Lists - Recursion

alist = [1,2,3]

emptylist = []




addl :: [Integer] -> Integer
addl = undefined












addl2 :: [Integer] -> Integer
addl2 x = if (x == []) then 0 else (head x) + (addl2 (tail x))


addl3 :: [Integer] -> Integer
addl3 x
      | x == [] = 0
      | otherwise = (head x) + (addl3 (tail x))




isempty :: [a] -> Bool
isempty [] = True
isempty (x:xs) = False






z = [1,2,0,2,0,3,4,0]

countzeros :: [Integer] -> Integer
countzeros = undefined






















countzeros2 :: [Integer] -> Integer
countzeros2 [] = 0
countzeros2 (x:xs) = (if (x == 0) then 1 else 0) + countzeros xs


countzeros3 :: [Integer] -> Integer
countzeros3 [] = 0
countzeros3 (x:xs) 
            | x == 0 = 1 + tailzeros
            | otherwise = tailzeros
            where tailzeros = countzeros3 xs


countzeros4 :: [Integer] -> Integer
countzeros4 [] = 0
countzeros4 (0:xs) = 1 + countzeros4 xs 
countzeros4 (_:xs) = countzeros4 xs 


sum_dbl :: [Integer] -> Integer
sum_dbl [] = 0
sum_dbl (x:xs) = (dbl x) + (sum_dbl xs)


-- (7) Double recursion (nested loop)

{-
int[] inters (int list1[], int list2[]) {
    int c1 = length(list1);
    int c2 = length(list2);

    int result[];
    int r = 0;

    int i = 0;
    while (i < c1) {
      int j = 0;
      while (j < c2) {
        if (list1[i] == list2[j]) {
          result[r] = list1[i];
          r++;
        }
        j++;
      }
      i++;
    }
    return result;
}


<?php
function inters ($list1, $list2) {
    $i = 0;

    $result = array();

    while (isset($list1[$i])) {
      $j = 0;
      while (isset($list2[$j])) {
        if ($list1[$i] == $list2[$j]) {
          $result[] = $list1[$i];
        }
        $j++;
      }
      $i++;
    }
    return result;
}
?>

-}



isin :: [Integer] -> Integer -> Bool
isin [] _ = False
isin (y:ys) x 
     | x==y = True
     | otherwise = isin ys x


inters :: [Integer] -> [Integer] -> [Integer]
inters _ [] = []
inters l (x:xs) 
       | isin l x = x:tailinters
       | otherwise = tailinters
       where tailinters = inters l xs


-- (8) List functions

-- Map

dbll :: [Integer] -> [Integer]
dbll x = map dbl x


dbll2 :: [Integer] -> [Integer]
dbll2 = map dbl


-- foldr and foldl

addl4 :: [Integer] -> Integer
addl4 x = foldr add 0 x


addl5 :: [Integer] -> Integer
addl5 x = foldl add 0 x


diff_left :: [Integer] -> Integer
diff_left x = foldl (-) 0 x

-- ((0 - 1) - 2) - 3)

diff_right :: [Integer] -> Integer
diff_right x = foldr (-) 0 x

-- (1 - (2 - (3 - 0)))


-- filter 

getnonzeros :: [Integer] -> [Integer]
getnonzeros x = filter isnonzero x


-- filter and currying

inters3 :: [Integer] -> [Integer] -> [Integer]
inters3 l1 l2 = filter (isin l1) l2


-- (9) Pairs

p = (1,2)


-- (10) Maybe monad


search :: Integer -> [Integer] -> Maybe(Integer)
search = undefined




search2 :: Integer -> [Integer] -> Maybe(Integer)
search2 x [] = Nothing
search2 x (y:ys)
       | x == y = Just (0)
       | otherwise = case (tailsearch) of 
                        Nothing -> Nothing
                        Just a -> Just (a + 1)
       where tailsearch = search2 x ys