0% found this document useful (0 votes)
110 views30 pages

Haskell Course PDF

This document provides an overview of Jason Barhorst's Haskell programming course. It includes information about Jason's background and experience, an outline of topics that will be covered in the course, system requirements for students, and ways for students to support Jason. The course will cover basic Haskell concepts like types, functions, logic and comparisons over multiple live streaming sessions. Students can participate for free using an online IDE or by installing Haskell on their own computer.

Uploaded by

Quang Đây
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
110 views30 pages

Haskell Course PDF

This document provides an overview of Jason Barhorst's Haskell programming course. It includes information about Jason's background and experience, an outline of topics that will be covered in the course, system requirements for students, and ways for students to support Jason. The course will cover basic Haskell concepts like types, functions, logic and comparisons over multiple live streaming sessions. Students can participate for free using an online IDE or by installing Haskell on their own computer.

Uploaded by

Quang Đây
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 30

Jason Barhorst

1
www.JBarCode.com
About Me
● Started programming in 2005 with C++
● B.S. Electrical Engineering:
○ Minor in Math and Physics
○ Track in Electricity and Magnetism
○ Matlab TA for 3 years
● M.S. Electrical Engineering:
○ Focus in Guidance, Navigation & Control Systems
● Favorite Projects:
○ Building an NFT Launch to Fund Education App (Flutter/Dart, Python)
○ Building an Education App for Android, IOS, and Web (Flutter/Dart, Python, Go?)
○ MTGO Online Trading Bots (C++, SQL)
○ Attitude Determination and Control for a CubeSat (C, Matlab)
○ Auto Pilot & Sensor Integration for Autonomous Vehicles (C, C++, Matlab, Python)
○ Various ML and AI projects
2
About this Course
● #1 Thing: I’m not an expert in Haskell!
○ Terminology and Best Practices will be a little loose at the beginning
○ Learning Haskell to program contracts in Plutus for Cardano (ADA)
○ Teaching Haskell allows me to help others while mastering the material

● Live Streams on Monday & Wednesday at 7pm Est


● First Hour: Lessons on Haskell Programming
● Second Hour: Solving Challenge Problems in Haskell
○ Typically on CodeWars: https://www.codewars.com/

3
Pre-Reqs (what you Need)

● Free Online Environment: ● Git Repository:


○ https://replit.com/~ ○ https://github.com/JBarCode37/haskell-course

● Install Git (optional):


● Local Environment:
○ https://git-scm.com/download
○ https://www.haskell.org/ghc/
○ Windows Install:
■ Directions above
○ Linux Install:
■ Performed on Live Stream Day 1
● Install VS Code (optional)
■ https://www.youtube.com/JBarCode ○ https://code.visualstudio.com/
○ Mac Install:
■ ...when I get my Mini Mac

4
How to Support Me (Free to Not-So-Free)
1) Like and Subscribe on YouTube!
a) https://www.youtube.com/JBarCode

2) Follow on Socials:
a) u/JBarCode on Reddit: https://www.reddit.com/user/JBarCode
b) @JBarCode37 on Twitter: https://twitter.com/JBarCode37

3) Stake ADA with [KNUGS]


a) Used to Support an Education App in Development (Launching Sep 2021)
b) https://pooltool.io/pool/c5c17e9e1e9fb8044b0215ce9b121f1b8a63723dbfa81c14b7a308ba/epochs

4) Straight up send me ADA :)


a) addr1q8hzsl7hzhl64ufhr9hx23cs5wj7hjamye625nmm2474y7w6a2pw5qmntkrpxtt3wcnsjdss7ye5gdmcxn4qhdc6yz9scw48jn

5
Last Stream Recap
● We set up a Haskell Programming environment in Linux
● Using Cabal and GHC based on Cardano Node Installation
○ https://docs.cardano.org/projects/cardano-node/en/latest/getting-started/install.html
○ https://www.haskell.org/cabal/download.html
○ https://www.haskell.org/ghc/

● Don’t Have that Setup? No Problem! Just use repl.it:


○ https://replit.com/~

● gchi
● *.hs haskell script files

6
Basic Types
● Num:
○ Includes types: Double, Float, Int, Integer, many others

● Float, Double:
○ 0.999, 1.3, -3.2, 0.0, etc.
○ sqrt 99 :: Float, sqrt 99 :: Double

● Int, Integer:
○ -99, 23, 0, 99, 1, 838383, etc.
○ 2^63, 2^63 :: Int, 2^63 :: Integer, 9223372036854775808 :: Int (this gives a warning)

● Char:
○ ‘a’, ‘c’, ‘\t’, ‘\n’, ‘\8371’, etc.
○ Unicode: Try running “putStr ['\t', '\8371', '\n']”
7
Basic Types Cont.
● String or [Char]:
○ "Hello World", ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'], etc.

● Bool:
○ True, False

● Lists:
○ [1, 2, 3], [True, False, True], [“Hello”, “World”], [[0, 0], [0, 4], [5, 0]]

● Tuples:
○ (1, 2, 3), ([1, 2, 3], “Hello World”, 99, True, (“Red”, False)), yikes!
○ Tuples Create Unique Types (hard to write generic functions for them)

8
Numeric Operations (...some of them)
● (+): addition
● (-): subtraction, negate
● (*): multiplication
● (^): exponentiation
● (/): division (Fractional values)
● div: division (integer division, Integral values)
○ div 4 2, div 5 2, 5 `div` 2 (infix notation using backticks)

● mod: remainder from integer division


● abs
● signum
9
List Operations (...some of them)
● (++): Combine Two List:
○ “Hello ” ++ “ “ ++ “World!”
○ “Hello “ ++ name, assumes name is a String

● concat: Combines several items in a list


○ concat [“Hello”, “ “, “World”]

● reverse:
○ reverse "Hello World", reverse [1, 2, 3, 4, 5]

● head (first item), tail (items after head)


● init (items before last item), last (last item)

10
Basic Comparison Operation ( -> Bool)
● (==): Check for Equality
● (/=): Check for inequality
● (>): Greater Than
● (<): Less Than
● (>=): Greater Than or Equal
● (<=): Less Than or Equal
● :info will give you the priority, but it’s often better to use

11
Basic Tuple Operations
● fst: returns the first item of a pair
○ fst (1, 2)

● snd: returns the second item of a pair


○ snd (1, 2)

● Every tuple is a unique type


○ Check the type of fst and snd
○ They only work for tuples with two items
○ You cannot take the first and second item from other tuples

12
List Operations (...some more of them)
● length: gets the length of a list
● (!!): Retrieve a value (index the list):
○ "Hello World" !! 3

● (:): append an item to the front of a list


● [..]: Create a ranged list
○ [1..5], [1, 3..99], [1..] (use Ctrl-C to interrupt runaway list)

● (<-): List comprehension generator


○ [n^2 | n <- [1..10]]
○ There is a lot more to do here. Revisit after logic operations.

13
Basic Logic Operations Bool -> Bool -> Bool
● (&&): And Operator
○ Only True if both left and right inputs are True
○ Lazy evaluation (if the first input is False, it doesn’t check the second input)

● (||): Or Operator
○ Only False if both values are false
○ Lazy evaluation (if the first input is True, it doesn’t check the second input)

● not: Inverse (Bool -> Bool)


○ True -> False
○ False -> True

14
Revisit List Comprehensions
● Logic Checks
○ [x | x <- [ 1..100], x `mod` 2 == 0]
○ [x | x <- [ 1..100], x `mod` 2 == 0, x < 25]
● Nested List Comprehensions (build a multiplication table)
○ [(x, y, x*y) | x <- [ 1..10], y <- [1..10]]
● When applying a function to a list, it’s often better to use map:
○ map (*2) [1, 2, 3, 4]
○ map (^2) [1, 2, 3, 4]

15
Function Types
● Functions are a Mapping from One Type to Another
● :t not
○ not :: Bool -> Bool

● :t sort
○ sort :: Ord a => [a] -> [a]

● -> is a mapping from one type to another


● => places instance requirements on types. E.g. Type ‘a’ must be an
instance of Ord, valid for ordering operations (<, >, <=, >=, min, max).
More details here:
https://hackage.haskell.org/package/base-4.15.0.0/docs/Data-Ord.html
16
Curried Functions
● Consider the example:
○ add :: Int -> Int -> Int
○ add a b = a + b

● Similar to one function passing a function out:


○ add 3 5

○ add3 = add 3

○ add3 5

● A function can return another function to be evaluated later


○ doubleItems = map (*2)

○ squareItems = map (^2)

○ etc.

17
Polymorphic Types
● Must start with lower case as seen in many examples
○ :t head
○ :t map
○ :t length
○ Etc.

● Related to Overloaded Types


○ :t (+)
■ Addition will add any two items of the same numeric type

18
if statements
● Uses if, then, else format
○ All three parts required
○ if <condition> then <true-value> else <false-value>

● Can be chained together:


○ size x = if x < 1 then "Small" else if x < 3 then "Medium" else "Large"

● This is quite hard to read. Multi lines acceptable:


○ size x = if x < 1 then
"Small"
else if x < 3 then
"Medium"
else
"Large"

● Not much better. Use guards instead.


19
Guarded Equations (Guards)
● Allow for checking multiple conditions
● First match is executed
● otherwise case if no match occurs (similar to else)
size x
| x < 1 = "Small"
| x < 3 = "Medium"
| otherwise = "Large"

● Any number of conditions allow


● otherwise evaluates to true

20
Function Pattern Matching
● Multiple definitions of a function based on input values
● Priority is from top to bottom
● If no match is found, it will cause an error
○ Try to handle all cases or have a catch all case to handle unexpected values

not' :: Bool -> Bool head' :: [a] -> a fst' :: (a, b) -> a
not' True = False head' [] = error "empty list" fst' (x, _) = x
not' False = True head' (x:_) = x
snd' :: (a, b) -> b
fib :: Int -> Int tail' :: [a] -> [a] snd' (_, x) = x
fib 0 = 0 tail' [] = error "empty list"
fib 1 = 1 tail' (_:xs) = xs
fib n
| n > 0 = fib (n-1) + fib (n-2)
| otherwise = 0

21
Lambda (λ) Expressions
● Anonymous (Nameless) Functions
○ A function has no name

● Begins with backslash (\), list variables, then expression

(\x y z -> x + y + z) 1 2 3

● That’s great, but why?


● Often used with map and other functions for convenience

map (\x -> x^2 + 5) [1..10]

22
Operator Sections
● Haskell is pretty smart about applying functions
● Consider:

(^3) 2 (\x -> x^3) 2

(3^) 2 (\x -> 3^x) 2

map (^3) [1, 2, 3] map (\x -> x^3) [1, 2, 3]

map (3^) [1, 2, 3] map (\x -> 3^x) [1, 2, 3]

23
Zip Lists
● Combine values of two list into tuple pairs:

zip [1, 2, 3] [4, 5, 6]

zip ["John", "Jane", "Rick"] ["Doe", "Smith", "James"]

-- Eyes, Fingers, Toes


zip [2, 10, 11] [True, True, False]

● What happens when the lists are different lengths?

zip [1, 2, 3] [4, 5]

zip ["John", "Rick"] ["Doe", "Smith", "James"]

-- Eyes, Fingers, Toes


zip [2, 10, 11] []

24
ord and chr (import Data.Char)
● ord: Converts Characters to ASCII (Unicode) Value
● chr: Convert ASCII (Unicode) Value to Char
● Ref. http://www.asciitable.com/

ord '4'
ord 'a'
ord 'A'

chr 52
chr 0x61
chr 65

● Challenge: Try Building a Basic Cypher

25
Recursion
● Function that is defined using itself
● Function that calls itself
● len, sum, product, fib, and many other examples already seen.
● Standard format is to have initial definitions or exit conditions

length' :: Integral b => [a] -> b product' :: Num a => [a] -> a
length' [] = 0 product' [] = 1
length' (_:xs) = 1 + length' xs product' (x:xs) = x * product' xs

sum' :: Num a => [a] -> a fib :: Int -> Int


sum' [] = 0 fib 0 = 0
sum' (x:xs) = x + sum' xs fib 1 = 1
fib n = fib (n-1) + fib (n-2)

27
Accumulators
● Another approach to sum
● Similar to loop approaches in other languages
● Initialize total to 0 and add each item to the total.

sum' :: Num a => a -> [a] -> a


sum [1, 2, 3, 4]
sum' total [] = total
sum' 0 [1, 2, 3, 4]
sum' total (x:xs) = sum' (total + x) xs
accumulate (+) 0 [1, 2, 3, 4]

accumulate :: (b -> a -> b) -> b -> [a] -> b


product [1, 2, 3, 4]
accumulate _ acc [] = acc
accumulate (*) 1 [1, 2, 3, 4]
accumulate f acc (x:xs) = accumulate f (f acc
x) xs

28
Folds
● Built in accumulators
● foldl
○ Left to Right, acc / output can be different type than list items

● foldr
○ Right to Left, acc / output can be different type than list items

● foldl1
○ Left to Right, acc / output is same type as list items. First list item is initial acc value

● foldr1
○ Right to Left, acc / output is same type as list items. First list item is initial acc value

29
Why Monads are Hard
● For Monads, you should know:
○ Monoids. Do you know Monoids well?
○ Applicative Functors. Do you know Applicative Functors well?
○ Functors. Do you know Functors well?
○ Data Structures. Do you know Data Structures well?
○ User Defined Types. Do you know User Defined Types well?

...over the next two weeks we’ll focus on working through this

30
Types
● Use the keyword ‘data’
● Point data type for example:

Data Bool = True | False

data Point = Point Double Double deriving (Show)

add :: Point -> Point -> Point


add (Point x1 y1) (Point x2 y2) = Point (x1 + x2) (y1 + y2)

dot :: Point -> Point -> Double


dot (Point x1 y1) (Point x2 y2) = x1*x2 + y1*y2

31

You might also like