Haskell Programming

Functions bind tighter than operations
Click the card to flip 👆
1 / 67
Terms in this set (67)
Functions bind tighter than operations
f a + b = (f a) + b
Left associative
f a b c = ((f a) b) c
GHCi
GHC's (Haskell Compiler) interactive environment, in which Haskell expressions can be interactively evaluated and programs can be interpreted
Implicit Grouping
Avoid explicit syntax to indicate the grouping of definitions - ie the indentation determines how statements are grouped
Strongly Typed
Types are checked at compile time and the compiler will throw a type error if it finds a problem
Compound Types
Types that are built from the basic types using type operators - such as lists, functions and tuples
Type Variables
Represent 'any type' enabling polymorphic functions where we don't know the type that will be passed - normally represented using letters such as a, b, [a]
Type Classes
Eq - Types that support equals comparisons
Ord - Types that support order comparisons (< or min...)
Show - Types that have their own way of pretty printing values
Read -Types that have their own way of parsing values from a string
Num - Types that represent numbers and common operations on them (+ or abs...)
Example: (+) (Num a) => a -> a -> a
Mutual Recursion
When two or more functions recursively call each other
Tail Recursive
When there is no suspended computation built up in the execution stack as the recursion unfolds. As Haskell employs lazy evaluation there isn't a large performance increase for doing this unlike in other languages as it will wait until the last step to actually perform the calculation anyway