Update tut01 for B232

MarekSuchanek · web-flow · commit 7f38bc500e21 · 2024-02-13T15:07:57.000+01:00
diff --git a/tutorials/01_fp-env.md b/tutorials/01_fp-env.md
@@ -55,7 +55,7 @@ Principles [[jdegoes](https://twitter.com/jdegoes/status/974045822424776704?s=09
 * [Cabal] = system for building and packaging.
 * [Stack] = managing Haskell projects, works with [Cabal] for you.
 
-:point_right: Please, install these (or check if installed already) - you can follow instruction on official websites one by one or (better) install [Haskell Platform], which includes all of those and also most common packages.
+:point_right: Please, install these (or check if installed already) - you can follow instruction on official websites one by one or (recommended and better) install [GHCup], which includes all of those and also most common packages.
 
 ### Editors and IDEs
 
@@ -66,21 +66,6 @@ There are several editors you may use for writing Haskell programs, most probabl
 * [Atom with plugins](https://atom-haskell.github.io/overview/)
 * [Visual Studio Code with plugins](https://medium.com/@dogwith1eye/setting-up-haskell-in-vs-code-with-stack-and-the-ide-engine-81d49eda3ecf)
 
-Most probably you will need following stuff:
-
-* [ghc-mod] = connector to [GHC] API for various stuff, alternatively you can use [HIE](https://github.com/haskell/haskell-ide-engine)
-* [hlint] = source code suggestion
-* [hindent] = indenter, pretty print
-* [stylish-haskell] = code prettifier ("good style")
-
-Install those with [Cabal] (by default it will install just for you to your profile, ensure that you have `~/.cabal/bin` in your `PATH`) or with [Stack]. The installation might take a while - it has a lot of dependencies and needs to build them from Haskell source code. If you want to install something with [Cabal] to all users, use `--global` flag.
-
-```console
-$ cabal update
-$ cabal install hlint stylish-haskell hindent ghc-mod
-$ stack install hlint stylish-haskell hindent ghc-mod
-```
-
 ### Sites for searching
 
 * [Hoogle] = "Google" for Haskell world
@@ -106,19 +91,19 @@ Now you should have [GHC] installed from package or via Stack (and others as wel
 
 ```console
 % ghc --version
-The Glorious Glasgow Haskell Compilation System, version 8.0.2
+The Glorious Glasgow Haskell Compilation System, version 9.4.8
 % stack exec -- ghc --version
-The Glorious Glasgow Haskell Compilation System, version 8.0.2
+The Glorious Glasgow Haskell Compilation System, version 9.4.5
 ```
 
 First, let's try the interactive environment and evaluate some basic expression in Haskell for the first time.
 
 ```
 % ghci
-GHCi, version 8.0.2: http://www.haskell.org/ghc/  :? for help
-Prelude> "Hello, world!"
+GHCi, version 9.4.8: http://www.haskell.org/ghc/  :? for help
+ghci> "Hello, world!"
 "Hello, world!"
-Prelude> putStrLn "Hello, world!"
+ghci> putStrLn "Hello, world!"
 Hello, world!
 ```
 
@@ -129,43 +114,43 @@ In prompt you see (by default) imported modules, in this case just `Prelude` - t
 In Haskell you can use math operators as you are used to.
 
 ```
-Prelude> 5 + 5
+ghci> 5 + 5
 10
-Prelude> 5 + 5 * 3
+ghci> 5 + 5 * 3
 20
-Prelude> (5 + 5) * 3
+ghci> (5 + 5) * 3
 30
-Prelude> 2 ^ 8
+ghci> 2 ^ 8
 256
-Prelude> 2 / 3
+ghci> 2 / 3
 0.6666666666666666
 ```
 
 Integer division and modulo are done by functions. You can call functions in prefix notation (no brackets and no commas):
 
 ```
-Prelude> div 7 2
+ghci> div 7 2
 3
-Prelude> mod 7 2
+ghci> mod 7 2
 1
 ```
 
 Same goes for logic and comparison (you might be used to `!=` or `<>` for not-equal, but `!` and `<>` are used for something else in Haskell we will find out during the course):
 
 ```
-Prelude> 5 > 7
+ghci> 5 > 7
 False
-Prelude> 5 == 7
+ghci> 5 == 7
 False
-Prelude> 5 /= 7
+ghci> 5 /= 7
 True
-Prelude> not (5 /= 7)
+ghci> not (5 /= 7)
 False
-Prelude> False || True
+ghci> False || True
 True
-Prelude> False && True
+ghci> False && True
 False
-Prelude> not False && True
+ghci> not False && True
 True
 ```
 
@@ -174,20 +159,20 @@ True
 A very useful thing in GHCi is that you can check the type of an expression.
 
 ```
-Prelude> :type 2 ^ 8
+ghci> :type 2 ^ 8
 2 ^ 8 :: Num a => a
-Prelude> :type 2 / 3
+ghci> :type 2 / 3
 2 / 3 :: Fractional a => a
 ```
 
 The double semicolon `::` means "is of type" and you can use it for explicitly stating the type of your expressions. But this is not typecasting as you might know, you must conform the restriction, in this case, `Fractional a` (typeclasses will be covered deeply in next lessons).
 
 ```
-Prelude> (2 / 3) :: Double
+ghci> (2 / 3) :: Double
 0.6666666666666666
-Prelude> (2 / 3) :: Float
+ghci> (2 / 3) :: Float
 0.6666667
-Prelude> (2 / 3) :: Int
+ghci> (2 / 3) :: Int
 
 <interactive>:2:2: error:
     • No instance for (Fractional Int) arising from a use of ‘/’
@@ -200,11 +185,11 @@ You can see that error message exactly tells us what is wrong! `Int` is not an i
 If you need to change type, find a suitable function. Some of them are in `Prelude`: `toInteger`, `fromInteger`, `toRational`, etc. Another quite important is `show` for showing anything as `String`. How these work will be covered later on in more detail as we get to typeclasses and polymorphism!
 
 ```
-Prelude> :t toInteger (7::Int)
+ghci> :t toInteger (7::Int)
 toInteger (7::Int) :: Integer
-Prelude> show (2/3)
+ghci> show (2/3)
 "0.6666666666666666"
-Prelude> toRational (2/16)
+ghci> toRational (2/16)
 1 % 8
 ```
 
@@ -213,13 +198,13 @@ Similarly you can do such thing with functions, because we are in functional lan
 The type signature is very math-like... Instance (type) of `Num` is for example `Integer` and you know functions from math which have type `Integer -> Integer` (domain and co-domain).
 
 ```
-Prelude> :type abs
+ghci> :type abs
 abs :: Num a => a -> a
-Prelude> abs (-5)
+ghci> abs (-5)
 5
-Prelude> abs (-10.65)
+ghci> abs (-10.65)
 10.65
-Prelude> abs "z"
+ghci> abs "z"
 
 <interactive>:26:1: error:
     • No instance for (Num [Char]) arising from a use of ‘abs’
@@ -230,20 +215,20 @@ Prelude> abs "z"
 The operators are functions as well - Haskell is functional language. All you need to do is put it in brackets. Plus takes two numbers and returns a number. You can then use `(+)` as a function in prefix notation and not infix.
 
 ```
-Prelude> :type (+)
+ghci> :type (+)
 (+) :: Num a => a -> a -> a
-Prelude> (+) 5 4
+ghci> (+) 5 4
 9
 ```
 
 On the other hand you might want to use some functions in infix to improve readability and you need `` ` `` for that.
 
 ```
-Prelude> :t div
+ghci> :t div
 div :: Integral a => a -> a -> a
-Prelude> 5 `div` 3
+ghci> 5 `div` 3
 1
-Prelude> 5 `mod` 3
+ghci> 5 `mod` 3
 2
 ```
 
@@ -252,21 +237,21 @@ Prelude> 5 `mod` 3
 In GHCi you can name an expression with `let` and assignment.
 
 ```
-Prelude> let x = 5
-Prelude> :type x
+ghci> let x = 5
+ghci> :type x
 x :: Num t => t
-Prelude> let x = 5 :: Integer
-Prelude> :type x
+ghci> let x = 5 :: Integer
+ghci> :type x
 x :: Integer
 ```
 
 You can create functions as well. Notice that the type is automatically inferred. It happens every time when possible and you don't explicitly state the type.
 
 ```
-Prelude> let myFunc x y = 2 * x + y
-Prelude> :t myFunc
+ghci> let myFunc x y = 2 * x + y
+ghci> :t myFunc
 myFunc :: Num a => a -> a -> a
-Prelude> myFunc 5 3
+ghci> myFunc 5 3
 13
 ```
 
@@ -297,7 +282,7 @@ isTriangle a b c = (a + b > c) && (a + c > b) && (b + c > a)
 Now we can load it with `:load` to GHCi:
 
 ```
-Prelude> :load FPCourse/files/01_test_haskell.hs
+ghci> :load FPCourse/files/01_test_haskell.hs
 [1 of 1] Compiling Main             ( 01_test_haskell.hs, interpreted )
 Ok, modules loaded: Main.
 ```
@@ -423,7 +408,7 @@ Let's do the *Hello, world!* app with [Stack]. First, verify that you have it in
 
 ```console
 % stack --version
-Version 1.9.3, Git revision 40cf7b37526b86d1676da82167ea8758a854953b (6211 commits) x86_64 hpack-0.31.1
+Version 2.13.1, Git revision 8102bb8afce90fc954f48efae38b87f37cabc988 (9949 commits) aarch64 hpack-0.36.0
 ```
 
 Then you can create a new project with default template:
@@ -459,10 +444,10 @@ Using cabal packages:
 
 Selecting the best among 15 snapshots...
 
-* Matches lts-13.8
+* Matches lts-21.25
 
-Selected resolver: lts-13.8
-Initialising configuration using resolver: lts-13.8
+Selected resolver: lts-21.25
+Initialising configuration using resolver: lts-21.25
 Total number of user packages considered: 1
 Writing configuration to file: HelloWorld/stack.yaml
 All done.
@@ -497,7 +482,7 @@ Now you don't use GHC directly, but call it via `stack build`:
 
 ```console
 % stack build
-No compiler found, expected minor version match with ghc-8.0.2 (x86_64) (based on resolver setting in /home/user/.stack/global-project/stack.yaml).
+No compiler found, expected minor version match with ghc-9.4.8 (x86_64) (based on resolver setting in /home/user/.stack/global-project/stack.yaml).
 To install the correct GHC into /home/user/.stack/programs/x86_64-linux/, try running "stack setup" or use the "--install-ghc" flag. To use your system GHC installation, run "stack config set system-ghc --global true", or use the "--system-ghc" flag.
 ```
 
@@ -507,7 +492,7 @@ As you see `stack` doesn't want to use system-wide installation of `ghc` but loc
 % stack setup
 Preparing to install GHC to an isolated location.
 This will not interfere with any system-level installation.
-Downloaded ghc-8.0.2.
+Downloaded ghc-9.4.8.
 Installed GHC.
 stack will use a sandboxed GHC it installed
 For more information on paths, see 'stack path' and 'stack exec env'
@@ -521,10 +506,10 @@ Using cabal packages:
 
 Selecting the best among 11 snapshots...
 
-* Matches lts-13.8
+* Matches lts-21.25
 
-Selected resolver: lts-13.8
-Initialising configuration using resolver: lts-9.11
+Selected resolver: lts-21.25
+Initialising configuration using resolver: lts-21.25
 Total number of user packages considered: 1
 Writing configuration to file: stack.yaml
 All done.
@@ -544,8 +529,8 @@ Building executable 'HelloWorld-exe' for HelloWorld-0.1.0.0..
 [2 of 2] Compiling Paths_HelloWorld ( .stack-work/dist/x86_64-linux-tinfo6/Cabal-2.4.0.1/build/HelloWorld-exe/autogen/Paths_HelloWorld.hs, .stack-work/dist/x86_64-linux-tinfo6/Cabal-2.4.0.1/build/HelloWorld-exe/HelloWorld-exe-tmp/Paths_HelloWorld.o )
 Linking .stack-work/dist/x86_64-linux-tinfo6/Cabal-2.4.0.1/build/HelloWorld-exe/HelloWorld-exe ...
 HelloWorld-0.1.0.0: copy/register
-Installing library in /home/user/Projects/MI-AFP/tests/HelloWorld/.stack-work/install/x86_64-linux-tinfo6/lts-13.8/8.6.3/lib/x86_64-linux-ghc-8.6.3/HelloWorld-0.1.0.0-8b39YCi0nmn4QsoDKix2j8
-Installing executable HelloWorld-exe in /home/user/Projects/MI-AFP/tests/HelloWorld/.stack-work/install/x86_64-linux-tinfo6/lts-13.8/8.6.3/bin
+Installing library in /home/user/Projects/MI-AFP/tests/HelloWorld/.stack-work/install/x86_64-linux-tinfo6/lts-21.25/9.4.8/lib/x86_64-linux-ghc-8.6.3/HelloWorld-0.1.0.0-8b39YCi0nmn4QsoDKix2j8
+Installing executable HelloWorld-exe in /home/user/Projects/MI-AFP/tests/HelloWorld/.stack-work/install/x86_64-linux-tinfo6/lts-21.25/9.4.8/bin
 Registering library for HelloWorld-0.1.0.0..
 stack build  6.16s user 0.94s system 96% cpu 7.329 total
 ```
@@ -647,13 +632,12 @@ For your first assignment, visit [MI-AFP/hw01](https://github.com/MI-AFP/hw01).
 [Cabal]: https://www.haskell.org/cabal/
 [Elm]: http://elm-lang.org
 [GHC]: https://www.haskell.org/ghc/
-[ghc-mod]: https://github.com/DanielG/ghc-mod
 [GHCJS]: https://github.com/ghcjs/ghcjs
+[GHCup]: https://www.haskell.org/ghcup/
 [GitHub]: https://github.com
 [Hackage]: https://hackage.haskell.org
 [Haskell]: https://www.haskell.org
 [Haskell 2010]: https://www.haskell.org/onlinereport/haskell2010/
-[Haskell Platform]: https://www.haskell.org/platform/
 [Haste]: https://haste-lang.org
 [hindent]: https://github.com/commercialhaskell/hindent
 [hlint]: https://hackage.haskell.org/package/hlint
