JPP1920

Haskell

Lab 1a (24.02)

1. codewars.com
2. excercism.io
3. Learn You a Haskell for Great Good!
4. Przykładowe rozwiązania i testy do zadań z Moodla

Lab 1b (28.02)

1. Zadania na foldy

Lab 2a (02.03)

1. Zadania 5,6,8 z Moodla -- Lab1 (zadanie 9 zrobimy w piątek)
2. Ćwiczymy Data.Set i Data.Map (SetsAndMaps.hs w Lab2a)
3. Ćwiczymy funktory (Functors.hs w Lab2a)

Lab 2b (06.03)

1. Na początku ćwiczymy razem leniwość
   1. W pliku Laziness.hs w Lab2b można znaleźć dwa przykłady nieskończonych list
   2. Do pomyślenia:
      1. Zrobić listę wszystkich liczb pierwszych
      2. Zrobić listę wszystkich liczb Fibbonacciego
      3. (rozwiązania w Lab2b/LazinessSolutions.hs )
2. W ramach ćwiczenia leniwości można rozwiązać zadanie Functional streams z codewars.com
3. Ćwiczymy funkcję interact :: (String -> String) -> IO ()
   1. Napisać program Hello World w Haskellu.
   2. Napisać program, który wypisuje długość wejścia
   3. Napisać program, który wypisuje swój input
   4. Napisać program który odwraca swój input (porównać "interaktywność" 3 i 4)
   5. Napisać program który odwraca każde słowo na wejściu (potem tak samo z każdą linią)
   6. * Tak samo jak 3, ale żeby wszystko wypisało się dopiero na koniec
   7. ** Tak samo jak 3, ale żeby wyjście wypisywało się co dwie linijki
   8. Zadanie 9 z moodla (ignorując newline'y na wejściu)
   9. Zadanie 9 z moodla respektująć newline'y na wejściu -- dzielimy tylko długie linijki
   10. (Rozwiązania w Lab2b/Interact.hs)

Lab 3a (09.03)

1. Robimy zadanie z moodla o BST (Zadanie 3), ale jescze z funkcją remove :: (Ord a) => BST a -> BST a
   1. Implementujemy funckje:
      1. insert
      2. fromList
      3. toList (można zapoznać się z Data.DList)
      4. remove
      5. (testy można znaleźć w Lab3a/BSTTests.hs)
   2. Implementujemy instajce Show, Eq i Functor.
2. Robimy zadanie z moodla o wyrażeniach (Zadanie 4), na razie bez ELet
   1. Dla chętnych zadanie o liczeniu pochodniej na codewars (raczej pracochłonne)
3. Debugowanie Haskella: Debug.Trace

f :: Int -> Int -> Int

f x y =

| traceShow (x, y) False = undefined

| otherwise = {-- definicja f --}

Dzięki temu, wypiszą się wszystkie argumenty z którymi wywoływane jest F.

Lab 3b (13.03)

1. Zajęcia odbywają się zdalnie (wszystkie informacje będzie można znaleźć na Slacku).
2. Czytamy rozdział Input and Output z "Learn You a Haskell for Great Good!"
   1. Można pominąć sekcje Bytestrings i randomness (nie dlatego, że są nieciekawe, tylko dlatego że są trochę mniej w temacie).
3. Robimy zadania na IO:
   1. Napisać program, który odpyta użytkownika z tabliczki mnożenia.
      1. Podstawowa wersja powinna wyglądać jak tu: mnozenie.txt (tu może przydać się funkcja readMaybe z Text.Read)
      2. Można dodać wypisywanie na koniec liczby zdobytych punktów. (Podpowiedź: nie trzeba do tego używać IO zmiennych).
      3. Można dodać pytanie "do skutku" -- komputer będzie pytał się o podpowiedź tak długo jak nie dostanie poprawnej odpowiedzi (tutaj pomocna może być funkcja whileM_, czytając jej typ trzeba zamieniać m na IO)
      4. Dla chętnych: można urozmaicić program używając losowości.
      5. Rozwiązanie w wersji 2 można znaleźć w pliku Lab3b/mnożenie_rozwiązanie.hs
   2. Napisać program, który wczyta od użytkownika nazwę pliku (np. foo) a następnie liczbę naturalną k (np. 3), a następnie utworzy k pustych plików (o nazwach foo1.txt, foo2.txt, foo3.txt).

Lab 4a (16.03)

1. Zajęcia dalej odbywają się zdalnie. Dzisiaj ćwiczmy monady: głównie Maybe i Either.
2. Na początku wspólnie przechodzimy przez Lab4a/MaybeEitherDemoEmpty.hs (rozwiązanie w Lab4a/MaybeEitherDemo.hs).
3. Zadanie: Lab4a/ManyOperations.hs
4. Zadanie: Lab4a/MonadicOperations.hs
5. Dodatkowo: można przeczytać pierwszy rozdział o monadach z Learn You a Haskell tylko, że on zakłada znajomość poprzedniej sekcji o Funktorach, Aplicative i Monoidach. Sekcję o monoidach można pominąć (nie przydaje się do monad), ale sama w sobie jest bardzo ciekawa.

Lab 4b (19.03)

1. Dzisiaj ćwiczymy monadę state (laby odbywają się poprzez slack i meets).
2. Na początku wspólnie przechodzimy przez Lab4b/StateDemo.hs (rozwiązanie w StateDemoSolved.hs).
3. Zadanie: napisać numerowanie wierzchołków drzewa in-order i pre-order (w stylu StateDemo.hs)
4. Jeśli ktoś nie skończył zadań z zeszłego tygodnia, to teraz jest na to dobry czas.
5. Trudniejsze: Zadanie The most imperative functional language? z Codewars.
6. Można przeczytać fragment z Learn You a Haskell o monadzie State (rozdział For a few monads more).

Lab 5a (23.03)

1. Dzisiaj ćwiczymy monadę reader (laby odbywają się poprzez slack i meets).
2. Na początku wspólnie przechodziimy przez Lab5a/StateDemo.hs (rozwiązanie w Lab5a/StateDemoFilled.hs)
3. Robimy zadanie 2b z Moodla (Lab Monady 2), o interpretowaniu wyrażeń.
4. Robimy zadanie 3b z Moodla o interpretowaniu programu imperatywnego, ale jeszcze nie 3c.
5. Można przeczytać fragment z Learn You a Haskell o monadzie Reader.

Lab 5b (26.03)

1. Dzisiaj ćwiczymy transformatory monad.
2. Na początku wspólnie przechodzimy przez Lab5b/TransformersDemo.hs (rozwiązanie w TransformersDemoFilled.hs).
3. Potem do zrobienia jest zadanie (częściowo z Moodla) Lab5b/SmallInterpreter.hs
4. Można przeczytać wpis o transformatorach monad (zwłaszcza warto zapoznać się z ExceptT -- eleganckiej wersji EitherT).

Lab 6a (30.03)

1. Dzisiaj zaczynamy parsery.
2. Zaczynamy od BNFC (w szczególności: krótszy i dłuższy tutorial)
3. Tworzymy razem gramatykę do prostych wyrażeń, i programów.
4. Zadanie na dzisiaj to stworzenie gramatyki i podpięcie jej do interpretera z zeszłego tygodnia -- Lab5b lub Lab5a. (Mogą się trochę nie zgadzać typy tworzone przez BNFC, trzeba będzie albo trochę zmodyfikować interpreter, albo napisać prosty konwerter).
5. Przy pracy z bnfc trzeba pamiętać o:
   1. bnfc -m -haskell <nazwa_pliku>
   2. Umieszczamy pliki wytworzone przez bnfc w podkatalogu (może być ten sam co gramatyka), inaczej zrobi się zamieszanie.
   3. Jeśli gramatyka nazywa się exp.bnfc, to składnia abstrakcyjna znajduje się w AbsExp.hs, a wyrażenie można sparsować za pomocą pExp (myLexer s) pExp i myLexer są w parExp.hs (tworzonego automatyczne z parExp.hs)

Lab 6b (03.04)

1. Kontynuujemy parsery.
2. Dzisiaj zajmujemy się modułem Parsec (Text.Parsec, Text.ParsecChar, Text.ParsecToken)
3. Najpierw przeglądamy razem pliki ParsecSimple.hs i ProgramParser.hs z Lab6b (rozwiązania odpowiednio w plikach *Done.hs).
4. Piszemy parser dla języka z tygodnia 5.
5. Dla chętnych: tutorial z parseca na Real World Haskell
6. (trudniejsze) Dla chętnych: Zadanie z codewars: Writing applicative parsers from scratch

Lab 7a (06.04)

1. Testowanie w Haskellu: Hspec + QuickCheck
2. Piszemy testy do rozwiązań zadań z pierwszego labu:
   1. Przechodzimy razem przez Lab7a Solutions.hs is SolutionsSpec.hs
   2. Dopisujemy więcej testów w Lab7a SolutionsSpec.hs
3. Pełną listę oczekiwań (jak shouldBe albo shouldThrow) można znaleźć w Test.Hspec.Expectations
4. Hint: Monadę IO można testować używając shouldReturn i capture

Lab 8a (17.04)

1. Dzisiaj zajmiemy się typowaniem (zadanie z moodla), pliki można znaleźć w Lab8a
2. Na początku przechodzimy razem przez TypeChecker.hs (rozwiązanie w TypeCheckerDone.hs)
   1. Muismy otypować rachunek lambda z anotacjami: (\x:int -> f:(int -> int) ->f x)
   2. Typy to funkcje i inty
3. Do zrobienia samemu jest zadanie TypeCheckerString.hs
   1. mamy dwa typy Int i String i przeciążone operatory + i *
4. Dla chętnych: TypeChecker (bez Stringów) tylko, że bez anotacji (\x -> \f -> f x), trzeba samemu domyślać się typów (tu przydazą się zmienne typowe i unfikacja).
5. Dla chętnych: j. w tylko, że z polimorficznym let (szczegóły na Moodlu).

Lab 9a (20.04)

1. Dzisiaj ostanie zajęcia z Haskella.
2. Przeglądamy razem grę snake: https://github.com/ravst/HGE2D
3. Do zrobienia samemu jest jakaś modyfikacja tej gry:
   1. Wyświetlanie wyniku
   2. Przechodzenie przez ściany (i wychodzenie z drugiej strony)
   3. Zwiększający się poziom trudności (wąż rusza się coraz szybciej)
   4. ...
4. Można też napisać swoją grę

Lab 9b (23.04)

1. Instalujemy SWI-Prolog.
2. Przechodzimy razem przez plik family.pl w Lab9b
3. Robimy ćwiczenia z pliku family.pl

Lab 10a (27.04)

1. Ćwiczymy listy i liczby naturalne (na razie jako termy 0, s(0), s(s(0)), ...).
2. Przechodzimy razem przez pliki nat.pl i list.pl w Lab10a
3. Rozwiązania w plikach nat_filled.pl i list_filled.pl
4. Kolejne zajęcia 04.05 (poniedziałek) wyjątkowo o 12:30

Lab 11a (04.05)

1. Ćwiczymy arytmetykę (arithmetics.pl w Lab11a).
2. Przykład: Kanibale i misjonarze (missionaries.pl w Lab11a).

Lab 12a (11.05)

1. Technika "Generate and Test" (Lab12a) -- sortowanie liczb.
2. Do przemyślenia -- problem 8. hetmanów.

Lab 12b (15.05)

1. Technika "Generate and Test" (Lab12b) -- sudoku.
2. Do przemyślenia -- optymalizacje w sudoku, częściowo wypełniony problem N hetmanów.
3. Można np poprawić funkcję doomed_sudoku tak, żeby wykrywawła sytuacje w której są zmienne do których nic nie pasuje (wykrywanie tego jest całkiem kosztowne, więc nie jest pewne jak bardzo to przyspieszy działanie zwłaszcza w małych przypadkach).
4. Można też poczytać o CLP(FD): Constraint Logic Programming over Finite Domains w Prologu, zwłascza sekcję Example: Sudoku

Lab 13a (18.05)

1. Grafy (Lab13a) -- graphs.pl, fib.pl
2. Dzisiaj zajmujemy się grafami, i dodatkowo predykatami table i assert.
3. O table można przeczytać więcej w dokumentacji SWI-Prologu.
4. Dokumentacja ordset.
5. Do zrobienia są zadania z graphs.pl
   1. Szukanie ścieżki.
   2. Szukanie cyklu.
   3. Zadanie o NFA z egzaminu 2014 + wariant na assert.
   4. BFS

Lab 13b (22.05)

1. Technnika "Incomplete Data Structures" Lab13b
2. Na zajęciach przechodzimy razem przez plik incomplete_data_structures.pl
3. Do zrobienia problemy TODO z incomplete_data_structures.pl:
   1. Zadania: odwróć, flaga holenderska, quick sort, slowo (f) z Lab Prolog 2 z Moodla (przy użyciu list różnicowych)
   2. * Kolejka (FIFO, Queue) w Prologu.
   3. Niemodyfikująca wersja lookup.
   4. Otwarte drzewa BST.