- codewars.com
- excercism.io
- Learn You a Haskell for Great Good!
- Przykładowe rozwiązania i testy do zadań z Moodla
- Zadania na foldy
- Zadania 5,6,8 z Moodla -- Lab1 (zadanie 9 zrobimy w piątek)
- Ćwiczymy Data.Set i Data.Map (SetsAndMaps.hs w Lab2a)
- Ćwiczymy funktory (Functors.hs w Lab2a)
- Na początku ćwiczymy razem leniwość
- W pliku Laziness.hs w Lab2b można znaleźć dwa przykłady nieskończonych list
- Do pomyślenia:
- Zrobić listę wszystkich liczb pierwszych
- Zrobić listę wszystkich liczb Fibbonacciego
- (rozwiązania w Lab2b/LazinessSolutions.hs )
- W ramach ćwiczenia leniwości można rozwiązać zadanie Functional streams z codewars.com
- Ćwiczymy funkcję interact :: (String -> String) -> IO ()
- Napisać program Hello World w Haskellu.
- Napisać program, który wypisuje długość wejścia
- Napisać program, który wypisuje swój input
- Napisać program który odwraca swój input (porównać "interaktywność" 3 i 4)
- Napisać program który odwraca każde słowo na wejściu (potem tak samo z każdą linią)
- * Tak samo jak 3, ale żeby wszystko wypisało się dopiero na koniec
- ** Tak samo jak 3, ale żeby wyjście wypisywało się co dwie linijki
- Zadanie 9 z moodla (ignorując newline'y na wejściu)
- Zadanie 9 z moodla respektująć newline'y na wejściu -- dzielimy tylko długie linijki
- (Rozwiązania w Lab2b/Interact.hs)
- Robimy zadanie z moodla o BST (Zadanie 3), ale jescze z funkcją remove :: (Ord a) => BST a -> BST a
- Implementujemy funckje:
- insert
- fromList
- toList (można zapoznać się z Data.DList)
- remove
- (testy można znaleźć w Lab3a/BSTTests.hs)
- Implementujemy instajce Show, Eq i Functor.
- Robimy zadanie z moodla o wyrażeniach (Zadanie 4), na razie bez ELet
- Dla chętnych zadanie o liczeniu pochodniej na codewars (raczej pracochłonne)
- 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.
- Zajęcia odbywają się zdalnie (wszystkie informacje będzie można znaleźć na Slacku).
- Czytamy rozdział Input and Output z "Learn You a Haskell for Great Good!"
- Można pominąć sekcje Bytestrings i randomness (nie dlatego, że są nieciekawe, tylko dlatego że są trochę mniej w temacie).
- Robimy zadania na IO:
- Napisać program, który odpyta użytkownika z tabliczki mnożenia.
- Podstawowa wersja powinna wyglądać jak tu: mnozenie.txt (tu może przydać się funkcja readMaybe z Text.Read)
- Można dodać wypisywanie na koniec liczby zdobytych punktów. (Podpowiedź: nie trzeba do tego używać IO zmiennych).
- 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)
- Dla chętnych: można urozmaicić program używając losowości.
- Rozwiązanie w wersji 2 można znaleźć w pliku Lab3b/mnożenie_rozwiązanie.hs
- 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).
- Zajęcia dalej odbywają się zdalnie. Dzisiaj ćwiczmy monady: głównie Maybe i Either.
- Na początku wspólnie przechodzimy przez Lab4a/MaybeEitherDemoEmpty.hs (rozwiązanie w Lab4a/MaybeEitherDemo.hs).
- Zadanie: Lab4a/ManyOperations.hs
- Zadanie: Lab4a/MonadicOperations.hs
- 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.
- Dzisiaj ćwiczymy monadę state (laby odbywają się poprzez slack i meets).
- Na początku wspólnie przechodzimy przez Lab4b/StateDemo.hs (rozwiązanie w StateDemoSolved.hs).
- Zadanie: napisać numerowanie wierzchołków drzewa in-order i pre-order (w stylu StateDemo.hs)
- Jeśli ktoś nie skończył zadań z zeszłego tygodnia, to teraz jest na to dobry czas.
- Trudniejsze: Zadanie The most imperative functional language? z Codewars.
- Można przeczytać fragment z Learn You a Haskell o monadzie State (rozdział For a few monads more).
- Dzisiaj ćwiczymy monadę reader (laby odbywają się poprzez slack i meets).
- Na początku wspólnie przechodziimy przez Lab5a/StateDemo.hs (rozwiązanie w Lab5a/StateDemoFilled.hs)
- Robimy zadanie 2b z Moodla (Lab Monady 2), o interpretowaniu wyrażeń.
- Robimy zadanie 3b z Moodla o interpretowaniu programu imperatywnego, ale jeszcze nie 3c.
- Można przeczytać fragment z Learn You a Haskell o monadzie Reader.
- Dzisiaj ćwiczymy transformatory monad.
- Na początku wspólnie przechodzimy przez Lab5b/TransformersDemo.hs (rozwiązanie w TransformersDemoFilled.hs).
- Potem do zrobienia jest zadanie (częściowo z Moodla) Lab5b/SmallInterpreter.hs
- Można przeczytać wpis o transformatorach monad (zwłaszcza warto zapoznać się z ExceptT -- eleganckiej wersji EitherT).
- Dzisiaj zaczynamy parsery.
- Zaczynamy od BNFC (w szczególności: krótszy i dłuższy tutorial)
- Tworzymy razem gramatykę do prostych wyrażeń, i programów.
- 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).
- Przy pracy z bnfc trzeba pamiętać o:
bnfc -m -haskell <nazwa_pliku>- Umieszczamy pliki wytworzone przez bnfc w podkatalogu (może być ten sam co gramatyka), inaczej zrobi się zamieszanie.
- 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)
- Kontynuujemy parsery.
- Dzisiaj zajmujemy się modułem Parsec (Text.Parsec, Text.ParsecChar, Text.ParsecToken)
- Najpierw przeglądamy razem pliki ParsecSimple.hs i ProgramParser.hs z Lab6b (rozwiązania odpowiednio w plikach *Done.hs).
- Piszemy parser dla języka z tygodnia 5.
- Dla chętnych: tutorial z parseca na Real World Haskell
- (trudniejsze) Dla chętnych: Zadanie z codewars: Writing applicative parsers from scratch
- Testowanie w Haskellu: Hspec + QuickCheck
- Piszemy testy do rozwiązań zadań z pierwszego labu:
- Przechodzimy razem przez Lab7a Solutions.hs is SolutionsSpec.hs
- Dopisujemy więcej testów w Lab7a SolutionsSpec.hs
- Pełną listę oczekiwań (jak
shouldBe albo shouldThrow) można znaleźć w Test.Hspec.Expectations - Hint: Monadę IO można testować używając
shouldReturn i capture
- Dzisiaj zajmiemy się typowaniem (zadanie z moodla), pliki można znaleźć w Lab8a
- Na początku przechodzimy razem przez TypeChecker.hs (rozwiązanie w TypeCheckerDone.hs)
- Muismy otypować rachunek lambda z anotacjami: (\x:int -> f:(int -> int) ->f x)
- Typy to funkcje i inty
- Do zrobienia samemu jest zadanie TypeCheckerString.hs
- mamy dwa typy Int i String i przeciążone operatory + i *
- 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).
- Dla chętnych: j. w tylko, że z polimorficznym let (szczegóły na Moodlu).
- Dzisiaj ostanie zajęcia z Haskella.
- Przeglądamy razem grę snake: https://github.com/ravst/HGE2D
- Do zrobienia samemu jest jakaś modyfikacja tej gry:
- Wyświetlanie wyniku
- Przechodzenie przez ściany (i wychodzenie z drugiej strony)
- Zwiększający się poziom trudności (wąż rusza się coraz szybciej)
- ...
- Można też napisać swoją grę