Add type-variables and typeclasses

Author: ramesaliyev

02_starting-out/lists.hs

@@ -26,8 +26,8 @@ woot = ['w','o'] ++ ['o','t']
 -- So using cons operator is better which useful for
 -- putting something at the beginning of a list.
 -- : function takes a element and a list.
-smallCat = 'A':" SMALL CAT"
-someNumbers = 5:[1,2,3,4]
+smallCat = 'A' : " SMALL CAT"
+someNumbers = 5 : [1,2,3,4]
 
 -- ++ function takes two lists.
 -- : function takes a element and a list.
@@ -61,7 +61,7 @@ isListEmpty list = areListsEqual list []
 -- > last [...] (returns last element)
 -- > tail [...] (returns everything except first element)
 -- > init [...] (returns everything except last element)
--- > length [...] (returns length of list)
+-- > length [...] (returns length of list as Integral, mostly we convert it to Num with fromIntegral function)
 -- > null [...] (returns True if list is empty, otherwise False) (Use null instead of list==[])
 -- > reverse [...] (returns reversed list)
 -- > take n [...] (returns a list which contains first n element of the list)
@@ -161,4 +161,5 @@ removeNonUppercase st = [ c | c <- st, c `elem` ['A'..'Z']]
 -- Nested list comprehensions are also possible if you're operating on lists that contain lists.
 -- Let's remove all odd numbers without flattening the list.
 multiNumberList = [[1,3,5,2,3,1,2,4,5], [1,2,3,4,5,6,7,8,9], [1,2,4,2,1,6,3,1,3,2,3,6]]
-multiNumberList' = [ [ x | x <- xs, even x ] | xs <- xxs]
+removeOddNumbersFromMultiDList xxs = [ [ x | x <- xs, even x ] | xs <- xxs]
+-- => removeOddNumbersFromMultiDList multiNumberList

02_starting-out/operators.hs

@@ -6,3 +6,13 @@
 -- /= means not equal in haskell
 -- => 5 /= 4
 -- ==> True
+
+-- Pretty much all operators are functions in Haskell.
+-- You can use them infix mode by default.
+-- If a function is comprised only of special characters, it's considered an infix function by default.
+-- But when you want to pass it to another function or call it as a prefix function,
+-- you have to surround it in parentheses
+
+sumTwo a b = (+) a b
+isEqual a b = (==) a b
+

03_types-and-typeclasses/type-variables.hs

@@ -0,0 +1,29 @@
+-- # http://learnyouahaskell.com/types-and-typeclasses#type-variables
+
+-- LOAD THIS FILE WITH ":l type-variables" within repl (ghci)
+-- and reload with ":r"
+
+-- Types are written in capital case.
+-- But type variables are write in lower case.
+
+-- Type variables are like Generics in other languages.
+-- But more  powerful because it allows us to easily write very general functions
+-- if they don't use any specific behavior of the types in them.
+
+-- Functions that have type variables are called polymorphic functions.
+
+-- Type variables can have names longer than one character,
+-- but we usually give them names of a, b, c, d.
+
+-- For example getFirstOfList takes an list of type a, and returns a value of type a.
+-- The "a" is the type variable in type definition.
+getFirstOfList :: [a] -> a
+getFirstOfList list = list !! 0
+
+-- For example fst takes a tuple and returns first element of tuple.
+-- => :t fst
+-- ==> fst :: (a, b) -> a
+-- Because a and b is type variables that taken tuple have and a is the type what it returns.
+-- a and b dont have to be different types.
+-- It just states that the first component's type and the return value's type are the same.
+

03_types-and-typeclasses/typeclasses.hs

@@ -0,0 +1,136 @@
+-- # http://learnyouahaskell.com/types-and-typeclasses#typeclasses-101
+
+-- LOAD THIS FILE WITH ":l typeclasses" within repl (ghci)
+-- and reload with ":r"
+
+-- Typeclasses are like Interfaces that defines some behavior.
+-- If a type is a part of a typeclass, that means that it supports and
+-- implements the behavior the typeclass describes.
+
+-- Lets check type definition of == function/operator.
+-- => :t (==)
+-- ==> (==) :: (Eq a) => a -> a -> Bool
+
+-- Everything before the => symbol is called a class constraint.
+-- So we can read this type definition as;
+-- (==) takes two params of same type and returns a Bool type value,
+-- BUT two params must must be members of the Eq class.
+-- In this case the Eq typeclass provides an interface for testing for equality.
+
+-- All standard Haskell types except for IO and functions are a part of the Eq typeclass.
+
+-- Example;
+-- The elem function has a type of (Eq a) => a -> [a] -> Bool.
+-- Because it uses == operator to check values.
+-- So definition means function will take a type named a,
+-- which implements the behaviors that Eq class describes.
+
+-- We can also see type classes when defining functions without types.
+-- Haskell's type inference will ad Eq for us.
+-- => iseq x y = x == y
+-- => :t iseq
+-- ==> iseq :: Eq a => a -> a -> Bool
+
+-- Some Basic Typeclasses:
+
+-- > Eq
+-- is used for types that support equality testing.
+-- members of it implements == and /=
+-- if a function type definition includes Eq it means function will use == or /=
+-- All the types we mentioned previously except for functions are part of Eq.
+
+-- > Ord
+-- is for types that have an ordering.
+-- covers all the standard comparing functions such as >, <, >= and <=
+-- To be a member of Ord, a type must first be a member of Eq.
+-- All the types we covered so far except for functions are part of Ord.
+-- For example:
+-- compare functions takes two arguments which are members of Ord,
+-- and returns an value of Ordering type.
+-- Ordering is a type that can be GT, LT or EQ, meaning greater than, lesser than and equal.
+
+-- > Show
+-- is for types that can be presented as string.
+-- All the types we covered so far except for functions are part of Show.
+-- Check some functions for example.
+
+-- > Enum
+-- Enum members are sequentially ordered types — they can be enumerated.
+-- We can use them in ranges like;
+-- => ['a'..'e']
+-- ==> "abcde"
+-- We can get them successors and predecesors because they have defined successors and predecesors;
+-- => succ 1
+-- ==> 2
+-- => pred 5
+-- ==> 4
+-- Types in this class: (), Bool, Char, Ordering, Int, Integer, Float and Double.
+
+-- > Bounded
+-- Bounded members have an upper and a lower bound.
+-- Like Int, Char, Bool.
+-- We can get bounds with minBound maxBound functions.
+-- => maxBound Bool
+-- ==> True
+-- => minBound Bool
+-- ==> False
+-- All tuples are also part of Bounded if the components are also in it.
+
+-- > Num
+-- Num is a numeric typeclass. Its members have the property of being able to act like numbers.
+-- Wole numbers are also polymorphic constants. They can act like any type that's a member of the Num typeclass.
+-- => :t 20
+-- ==> (Num t) => t
+-- Int, Integer, Float, Double are types that are in the Num typeclass.
+-- If we examine the type of *, we'll see that it accepts all numbers.
+-- => :t (*)
+-- ==> (*) :: (Num a) => a -> a -> a
+-- To join Num, a type must already be friends with Show and Eq.
+
+-- > Integral
+-- Integral is also a numeric typeclass.
+-- Num includes all numbers, including real numbers and integral numbers,
+-- Integral includes only integral (whole) numbers. In this typeclass are Int and Integer.
+
+-- > Floating
+-- Includes only floating point numbers, so Float and Double.
+
+-- > Read
+-- Takes a string and return a type which is also a member of Read.
+-- Which type of value it should return?
+-- Compiler will told him by infering our usage of value.
+-- For example:
+-- => read "8.2" + "3.8"
+-- ==> 12
+-- => "True" || False
+-- ==> True
+-- => read "[1,2,3,4]" ++ [3]
+-- ==> [1,2,3,4,3]
+-- => read "1" : [2]
+-- ==> [1,2]
+-- As you can see read returns a type which is "a" (type variable) by knowing what we are doing with that value.
+
+-- Explicit Type Annotations
+
+-- Type annotations are a way of explicitly saying what the type of an expression should be.
+-- We do that by adding :: at the end of the expression and then specifying a type.
+-- For example, when we dont using return value from read, compiler cant know what type it should return.
+-- So we have to explicitly told type.
+-- => read "5" :: Int
+-- ==>  5
+-- => read "(3, 'a')" :: (Int, Char)
+-- ==> (3, 'a')
+
+-- Multiple Class Constraints
+
+-- It's totaly ok to have multiple Class Constraits.
+-- For example lets examine function fromIntegral.
+-- It takes an integral number and turns it into a more general number.
+-- => :t fromIntegral
+-- ==> fromIntegral :: (Num b, Integral a) => a -> b
+-- So it takes a Integral and returns a Num.
+
+-- Order of constraits is not importanti constraits mean our function will work with that typeclasses.
+-- Lets swap places of fromIntegral constraits:
+fromIntegral' :: (Integral a, Num b) => a -> b
+fromIntegral' n = fromIntegral n

03_types-and-typeclasses/types.hs

@@ -9,7 +9,10 @@
 -- You can use GHCI to examine the types of an expressions.
 -- You can also check type of functions with :t because Functions are expressions too.
 -- You can also write a function without type and then check which type it gain by compiler with :t
-
+-- for example;
+-- => sumTwo x y = x + y
+-- => :t sumTwo
+-- ==> sumTwo :: Num a => a -> a -> a
 
 -- Explicit types are always denoted with the first letter in capital case. Like "Char".
 

README.md

@@ -13,4 +13,5 @@
    - [conclusion](/02_starting-out/conclusion.hs)
 3. Types and Typeclasses ([Book Page](http://learnyouahaskell.com/types-and-typeclasses))
    - [types](/03_types-and-typeclasses/types.hs)
-   - ...
+   - [type variables](/03_types-and-typeclasses/type-variables.hs)
+   - [typeclasses](/03_types-and-typeclasses/typeclasses.hs)