Tutorial 2: Functions and types - init by MarekSuchanek · Pull Request #2 · MI-AFP/tutorials

MarekSuchanek · 2018-02-19T07:10:26Z

Second tutorial initial version for this semester (B172) is ready, please review and add/change something if necessary...

roper79 · 2018-03-01T19:12:15Z

+
+### Function declaration
+
+Although type can be in most cases inferred automatically by the compiler, it is good practice to write it down at least in case of functions as part of code documentation. Functions can be complicated and by reading its type signature you know immediately what arguments it expects and what it returns.


... a good practice ...
... as a part of code ...

roper79 · 2018-03-01T19:16:31Z

+
+myAge :: Age
+myAge = Age 20
+```


Here, type String can be replaced by [Char] (it is a mere synonym), so typechecking is not 'perfect' in this sense. In case of newtype, Age is a different type than Int and compiler will check it.

roper79 · 2018-03-01T19:18:36Z

+* `Enum` - for enumerations, allows the use of `..` range list syntax such as `[Blue .. Green]`
+* `Bounded` - for enumerations or other bounded, `minBound` and `maxBound` as the lowest and highest values that the type can take
+
+As it was said, typeclasses are very important in Haskell and will be covered later on. You will also learn how to make new typeclasses, their instances, etc.


... typeclasses are a very important means of abstraction in Haskell ...

roper79 · 2018-03-01T19:21:01Z

+
+## Data types
+
+Haskell has a strong static type system which is one of the things making it so great. As we already saw, every expression in Haskell has some type and the type cannot change during runtime (that is the difference with dynamic typing). As in other programming languages can use predefined data types, get more from some libraries or introduce your own.


... you can ...

roper79 · 2018-03-01T19:23:25Z

+x = MyTypeC1 True 10
+```
+
+Usually, when there is just one data constructor, the name is the same as of the type constructor (but it is not a rule).


This is one another great Haskell feature: Algebraic Data Types (ADT). These are now found in more and more new languages (e.g. 'Rust' and very fresh 'Reason' from Facebook)

roper79 · 2018-03-01T19:24:17Z

+            } deriving Show
+```
+
+Now try to create a type `Pet` which also contains `name` and `age`. You will get an error which is logical, you cannot have two functions with the same name! One option is to rename it to `namePerson` and `namePet`, the second is available to you only if you have GHC 8.0.1 or higher and it is with language extension [DuplicateRecordFields](https://downloads.haskell.org/~ghc/master/users-guide/glasgow_exts.html#duplicate-record-fields):


, however the first option is more common

roper79 · 2018-03-01T19:26:00Z

+olderPet pet = pet { age = (age pet + 1) }
+```
+
+You can also see that there is a shorthand for updating the value of record - creating new edited record from previous. Now you can try some derived behaviour from typeclasses such as `show`, `read`, or `==`:


This is one of the weaker parts of Haskell: it actually does NOT have records (as explained, there is just a syntactic sugar upon tuples). Newer languages from the Haskell family PureScript and Elm elaborated on this and introduced 'proper' records.

roper79 · 2018-03-01T19:27:14Z

+("Hello",7)
+```
+
+Good to know is how it actually works and try to implement own tuples.


roper79 · 2018-03-01T19:28:28Z

+data List a = Empty | NonEmpty a (List a)
+```
+
+That's it! List of type `a` it either `Empty` or `NonEmpty` which means that it has an element and then rest of the list (which can be again `Empty` or `NonEmpty`). Sometimes the following naming is used:


roper79 · 2018-03-01T19:29:09Z

+
+### String
+
+String is really nothing but just list of characters `[Char]`. The only difference is that there are more functions for working especially with `String`s - like `putStr`, `lines`, `words` and more (see [Data.String]). For more efficient working with strings is [text] package providing "a time and space-efficient implementation of Unicode text" with [Data.Text] - two variants: Lazy and Strict. Later on, we will get back to this problem which makes a life of Haskell programmer sometimes little bit uneasy.


a list of characters

roper79 · 2018-03-01T19:29:38Z

+
+## Simple functions
+
+Enough of types and containers, let's do some functions when this is functional programming course!


a functional programming...

roper79 · 2018-03-01T19:29:54Z

+
+### Basic list functions
+
+Since list is very simple and widely used data structure, it is a good time to learn useful functions to work with lists. You can find a complete list in [Data.List] documentation. Try following examples and examine the type of functions if needed. Also, try to run some unclear cases like `head` of the empty list and see what happens...


a very simple and widely used

roper79 · 2018-03-01T19:30:39Z

+False
+```
+
+The last one is left fold, there is also right fold (depends on associativity), we will cover this in more detail later while explaining so-called catamorphism. Now you can just see that it is a generalization of `sum`, `and`, `or`, and many others.


roper79 · 2018-03-01T19:30:56Z

+
+The last one is left fold, there is also right fold (depends on associativity), we will cover this in more detail later while explaining so-called catamorphism. Now you can just see that it is a generalization of `sum`, `and`, `or`, and many others.
+
+It is very good practice to try to implement some of these functions to understand them and their complexity. You may worry that using list is always very inefficient, luckily GHC can do some optimizations (although still in some cases you should prefer [Data.Sequence] or other [containers] - we will get back to this during the course).


a very good practice

roper79 · 2018-03-01T19:32:44Z

+factorial n = n * factorial n-1
+```
+
+During any call of subroutine (function, procedure, or other action), it is needed to store information to the [call stack]. Such information consist of where was the call initiated, what was the state and where it should return the value when poping from this stack. For example, with calling `res = factorial 3` call stack could look like this (top on the left):


MarekSuchanek and others added 7 commits January 27, 2018 19:54

Init from MarekSuchanek/FPCourse

21a2fcd

(Tail) recursion explained briefly

7e20bf7

Homework info added

6b32222

Text of patterns, list funcs, string

5694d0f

List funcs and patterns examples

09b253a

Deriving typeclass intro

8c531ea

Play with deriving typeclass

22def0a

MarekSuchanek requested a review from roper79 February 19, 2018 07:10

MarekSuchanek changed the title ~~Tutorial 2: Functions and types, init~~ Tutorial 2: Functions and types - init Feb 19, 2018

Grammar fix with Grammarly

ad6cb1d

roper79 reviewed Mar 1, 2018

View reviewed changes

Fixs after Robert's review

1895a81

MarekSuchanek merged commit 7939797 into master Mar 2, 2018

MarekSuchanek deleted the 02_functions-types branch March 2, 2018 07:24


		### Function declaration

		Although type can be in most cases inferred automatically by the compiler, it is good practice to write it down at least in case of functions as part of code documentation. Functions can be complicated and by reading its type signature you know immediately what arguments it expects and what it returns.


		## Data types

		Haskell has a strong static type system which is one of the things making it so great. As we already saw, every expression in Haskell has some type and the type cannot change during runtime (that is the difference with dynamic typing). As in other programming languages can use predefined data types, get more from some libraries or introduce your own.


		### String

		String is really nothing but just list of characters `[Char]`. The only difference is that there are more functions for working especially with `String`s - like `putStr`, `lines`, `words` and more (see [Data.String]). For more efficient working with strings is [text] package providing "a time and space-efficient implementation of Unicode text" with [Data.Text] - two variants: Lazy and Strict. Later on, we will get back to this problem which makes a life of Haskell programmer sometimes little bit uneasy.


		## Simple functions

		Enough of types and containers, let's do some functions when this is functional programming course!


		### Basic list functions

		Since list is very simple and widely used data structure, it is a good time to learn useful functions to work with lists. You can find a complete list in [Data.List] documentation. Try following examples and examine the type of functions if needed. Also, try to run some unclear cases like `head` of the empty list and see what happens...


		The last one is left fold, there is also right fold (depends on associativity), we will cover this in more detail later while explaining so-called catamorphism. Now you can just see that it is a generalization of `sum`, `and`, `or`, and many others.

		It is very good practice to try to implement some of these functions to understand them and their complexity. You may worry that using list is always very inefficient, luckily GHC can do some optimizations (although still in some cases you should prefer [Data.Sequence] or other [containers] - we will get back to this during the course).

Conversation

MarekSuchanek commented Feb 19, 2018

Uh oh!

roper79 Mar 1, 2018 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

roper79 Mar 1, 2018 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

roper79 Mar 1, 2018 •

edited

Loading

roper79 Mar 1, 2018 •

edited

Loading