This document provides an overview of the Haskell programming language. It discusses that Haskell is a pure, lazy, strongly typed functional language that emphasizes minimizing side effects. It was created in 1990 by combining features from earlier lazy functional languages. Haskell is used widely in academia and for teaching. It has a powerful type system with type inference and supports common data structures like lists. Functions are defined through pattern matching and recursion is fundamental to the language. Notable features include lazy evaluation, monadic I/O, and partial evaluation.
This document provides an overview of the Haskell programming language. It discusses that Haskell is a pure, lazy, strongly typed functional language that emphasizes minimizing side effects. It was created in 1990 by combining features from earlier lazy functional languages. Haskell is used widely in academia and for teaching. It has a powerful type system with type inference and supports common data structures like lists. Functions are defined through pattern matching and recursion is fundamental to the language. Notable features include lazy evaluation, monadic I/O, and partial evaluation.
This document provides an overview of the Haskell programming language. It discusses that Haskell is a pure, lazy, strongly typed functional language that emphasizes minimizing side effects. It was created in 1990 by combining features from earlier lazy functional languages. Haskell is used widely in academia and for teaching. It has a powerful type system with type inference and supports common data structures like lists. Functions are defined through pattern matching and recursion is fundamental to the language. Notable features include lazy evaluation, monadic I/O, and partial evaluation.
This document provides an overview of the Haskell programming language. It discusses that Haskell is a pure, lazy, strongly typed functional language that emphasizes minimizing side effects. It was created in 1990 by combining features from earlier lazy functional languages. Haskell is used widely in academia and for teaching. It has a powerful type system with type inference and supports common data structures like lists. Functions are defined through pattern matching and recursion is fundamental to the language. Notable features include lazy evaluation, monadic I/O, and partial evaluation.
Download as PPT, PDF, TXT or read online from Scribd
Download as ppt, pdf, or txt
You are on page 1/ 33
Haskell
Eric Alzheimer
What is Haskell? Pure Functional Language Powerful, polymorphic, strong and strict type system ... with type inference! Lazily evaluated mathy syntax with significant whitespace (like Python) Emphasizes minimizing side-effects
History 1970s: ML by Robert Milner; Used in academia 1980s: ML had many (~12) pure, lazily evaluated descendents 1990: Committee formed to unify these languages into one creates Haskell. Named after logician Haskell Curry
Who uses it?
Originally popular in academia (math proofs, prog-lang research) Teaching language Functional features in popular dynamic languages (Python, Perl, Ruby) have increased popularity of Haskell as a real-word general purpose language.
Software in Haskell GHC -> Production quality Haskell optimizing compiler and interpreter Pugs -> Perl 6 interpreter (first one, actually) Darcs -> Distributed version control system Bluespec SystemVerilog -> Synthesizable hardware description language.
Language Basics
Functions Everything is a function thisIsTwo = 2 sum x y = x + y foo x y z = z sum x y
>>> foo 1 2 3 --> 0
Data Structures Collections of data Can have multiple internal structures Can be recursive
Data Structures data Point = Point Int Int data Shape = Rect Point Point | Circle Point Int data Colors = Red|Green|Blue type Points = [Point] myCircle = Circle (Point 2 4) 9
Types????? All of the functions a few slides ago are strictly typed ... But we had no type declarations. This is because Haskell has type inference. The compiler/interpreter analyzes your code and automatically assigns the most general possible type. However, it is common to specify the type of top level declarations, to ensure correctness and document functionality
Types!!!!! myNum :: Int myNum = 2
myOtherNum :: Float myOtherNum = 2.0
myFunc :: Int -> Int -> Int
myFunc x y = (2 * x) + x - y
Lists myList = [1, 2, 3]
(define my-list (1 2 3))
longer = 0 : myList
(cons 0 my-list)
head my-list
(car my-list)
tail my-list
(cdr my-list)
[1, 2] ++ [3, 4]
(append (1 2) (3 4))
QWER : [2, 3, 4]
[1, 2] :: [Int]
ERROR
Branching 1. Pattern Matching 2. Guards
Pattern Matching Multiple function definitions Chosen based on value and structure of arguments fib 0 = 1 fib 1 = 1 fib n = fib (n-1) + fib (n-2) isTwo 2 = True isTwo _ = False
Structural pattern matches
The constructors for a type are also their deconstructors, used to get data out of them. data Shape = Rect Int Int | Circle Int area
(Rect w h)
= w * h
area
(Circle r)
= pi * r * r
width (Rect w _)
= w
width (Circle r)
= 2 * r
Guards Like cond in Scheme/Lisp Series of conditional expressions
randomFunction x y | x <= y = (x + y) / 2 | (y 2) > 7 = y x | odd (x + y) = x + y | otherwise = 42
Looping
Recursion As a functional language, recursion is the most basic looping construct.
factorial 0 = 1 factorial n = n * factorial (n 1)
High Order Functions
However, explicit recursion is not good style. High order functions should be used instead. factorial x = product [1..x] sqEv xs = map (\x -> x*x) (filter (\x -> even x) xs)
Local Variables myFunction a b = x y where x = a + b y = a * b myOtherFunction thing = let a = getFoo thing b = getBar thing in a + b
Lazy Evaluation Values arent evaluated until they are forced to be evaluated. In C/Java/Scheme, arguments are evaluated before call. In Haskell, they are only evaluated if used. myIf True x y = x myIf False x y = y >>> myIf (2 == 3) [1..] [1, 2] --> [1, 2]
Monadic IO Monad --> Abstract type used to model sequence, state, and side effects. Do notation getName :: IO String getName = do putStrLn Enter your name: name <- getLine if name == then do putStrLn No name entered... getName - Try again else do return name
Partial Functions sum :: Int -> Int -> Int sum x y = x + y -- sum :: Int -> (Int -> Int) addFive = sum 5 -- What type? addFive :: Int -> Int >>> addFive 3 --> 8
Sample Program Really simple polynomial derivative calculator.
*SimpleDeriv> main Enter a polynomial like "2x^4 + 3x + 7" to get a derivative Enter "q" to exit >>> 2x^9 + 3x + 4x^2 + 6 ==> 18x^8 + 3 + 8x >>> 2 ==> >>> q *SimpleDeriv>
module SimpleDeriv where
-- Import some list utilities from a standard library import Data.List -- Define the data structure for a single term -- It as an algebraic type with two possible forms: -- either constant or term data TermInfo = Constant Integer | Term Integer Integer deriving (Show, Read, Eq) -- A polynomial is just a list of terms type Polynomial = [TermInfo]
