Programovací jazyky F# a OCaml

Prezentace a další

  • Chapter 1: Expression as a basic building block (formát pptx, pdf)
  • Tutorial: Ukázkový projekt pro Visual Studio 2008, který by vám měl fungovat po nainstalování F# CTP (formát zip)
  • Chapter 2: Refactoring code using functions (formát pptx, pdf)
  • Series demo: Konzolová aplikace, která používá ReadLine a počítá sumu prvních X členů nějaké posloupnosti (formát zip)
  • Chapter 3: Composing primitive types into data (formát pptx, pdf)
  • Drawing: Příklad z přednášky, který ukazuje jak kreslit pomocí Windows Forms a zároveň kostra pro DÚ plot (formát zip)
  • Chapter 4: Generic and recursive types (formát pptx, pdf)
  • Recursion: Příklady rekurzivních funkcí procházející seznamy pomocí strukturální rekurze (formát zip)
  • Chapter 5: Hiding recursion using function-as-values (formát pptx, pdf)
  • Sequences: Pár poznámek k úkolu "folds" a ukázky sequnece expressions (formát zip)
  • Chapter 6: Sequence expressions, computation expressions & asynchronous workflows (updated!) (formát pptx, pdf)
  • Monads: Ukázky computation expressions (neboli monádů) a asynchronních výpočtů (formát zip)

Jednotlivé soubory neodpovídají přesně tomu, co jsme stihli projít na jednotlivých přednáškách. Pokud jsme prošli pouze část prezentace, tak jí nahraji na web celou, ale zbytek se pravděpodobně ještě změní. Na přednáškách jsme zatím stihli následující části:

  • 5. 10. - Skončili jsme na slidu 25 z "Chapter 1"
  • 12. 10. - Skončili jsme na slidu 7 z "Chapter 2"
  • 19. 10. - Skončili jsme na slidu 27 z "Chapter 2"
  • 26. 10. - Skončili jsme na slidu 15 z "Chapter 3"
  • 2. 11. - Skončili jsme na slidu 7 z "Chapter 4"
  • 9. 11. - Skončili jsme na slidu 13 z "Chapter 4"
  • 16. 11. - Přednáška se nekonala
  • 23. 11. - Skončili jsme na slidu 5 z "Chapter 5"
  • 30. 11. - Skončili jsme na slidu 13 z "Chapter 5"
  • 7. 12. - Přednáška se nekoná
  • 14. 12. - Přijde Honza Stoklasa: Stromové datové struktury (z důvodu chřipky zrušeno!)
  • 21. 12. - Vánoční prázdniny. Posunul jsem termíny na odevzdání některých nových úkolů, takže se jim můžete věnovat i během svátků :-).
  • 4. 1. - Skončili jsme na slidu 12 z "Chapter 6"
  • 11. 1. - Dokončili jsme vše z "Chapter 6"
  • 18. 1. Náhradní přednáška od 14:00 v SW1 - Práce s .NET knihovnami z F# (například 3D pomocí WPF a další)
  • Posunul jsem termín na odevzdání úkolů "folds", abyste měli během zkouškového více času na zkoušky :-).

Odkazy

Pokud hledáte dokumentaci k vlastnostem jazyka F#, nebo přehled funkcí ze standardních F# knihoven, mohou se vám hodit následující odkazy:

  • Lehký úvod do F# s přehledem většiny důležitých vlastností: Visual F# - MSDN
  • Přehled funkcí pro práci se seznamy (k ostatním se snadno doklikáte): Collections.List Module (F#) - MSDN

Za co bude zápočet?

Zápočet bude možné získat všemi možnými způsoby. Za všechny možné aktivity se dají získat nějaké body a kdo získá nějaký počet bodů ten má nárok na zápočet. Body se dají získávat za úkoly (viz níže), při přednáškách za "aktivitu" a nebo různými alternativními metodami.

Upřesnění: Potřebný počet bodů

Potřebný počet bodů bude 2/3 z celkového počtu. Ještě nějaké úkoly zadám na poslední a na náhradní přednášce, takže celkový počet bude 18 a pro zápočet bude tedy nutné získat 12 bodů. Pokud jste tedy úkoly průběžně posílali během roku, tak (soudě podle tabulky níže) nebudete mít problém zápočet za body z úkolů získat. Pokud chcete odevzdat nějaký úkol (rozumně) po termínu, tak můžete, ale musí být obzvláště hezky udělaný (tím 'rozumně' myslím lednové úkoly).

Alternativní metody

Alternativně můžete získat více bodů, takže pokud budete pracovat například na nějakém projektu, nebudete muset dělat nic jiného (pokud bude projekt rozumně složitý). Alternativní metody, které mě zatím napadly jsou následující:

  • Nějaká esej nebo článek - například porovnání různých funkcionálních jazyků, nějakých zajímavých vlastností F# a vašeho oblíbeného jazyka atd.
  • Referát nebo přednáška - například povídání o nějaké zajímavé knihovně, nebo F# projektu, povídání o nějaké pokročilejší vlastnosti F# na kterou by se jinak nedostalo...
  • Projekt - naprogramování nějakého zajímavého (netriviálního) programu v F#/OCaml. Ideální pokud se chystáte použít F# při tvorbě bakalářská práce..
  • ... a pokud máte nějaký vlastní nápad, neváhejte se ozvat!

Pokud máte libovolné dotazy ohledně F# nebo přednášek, nápady na zápočtový projekt, prezentaci, atd., tak se nebojte ozvat :-). Ideální je odchytit mě před přednáškou (nebo po přednášce) osobně, protože tak dostanete odpověď zaručeně a nejrychleji. Pokud chcete, můžete napsat i mail: tomas@tomasp.net.

Domácí úkoly

Úkoly (dotazy, atd...) posílejte mailem (tomas@tomasp.net). Do předmětu prosím uveďte "[mff]", ať do předu vím o co se jedná. S úkolem pošlete také jeho "ID" ať vím, co řešíte (ne, že bych to nepoznal, ale usnadní mi to opravování). Některé úkoly budou spíše hádanky nad kterými je potřeba se zamyslet a napadne vás řešení. Na ty bude méně času, abychom si mohli potom řešení prozradit :-). U složitějších úkolu, kde je potřeba něco opravdu udělat, bude času pochopitelně více...

Kolik bodů je potřeba na udělení zápočtu? To ještě musím upřesnit, na základě toho kolik bude možné získat bodů celkem (tj. nebude to minimum ani maximum z toho co získáte :-)). Obecně to může být něco jako 50%, ale včas to upřesním.

Popis úkoluIDIntervalBody
1. Find an expression where evaluating the value of symbols first is better and another expression where replacing symbols with expressions is better (Note: better means smaller number of reduction steps (no unnecessary calculations). For more information, see Chapter 1, slide 33. reduction12. 10. - 2. 11.1
2. Write expression that prints “yes” if the value of n is less than 10 and “no” otherwise. The trick is, that you should do this without using if and match construct. This can be solved using other language features that are discussed in Chapter 1.ifthen12. 10. - 2. 11.2
3. Rewrite the following declaration to use only function declarations taking a single parameter. You can use currying as explained in Chapter 2 (you may need to download the latest version of slides!): 
let foo x y = 
  let add a b c = 
     (100 * a) + (10 * b) + c
  add y x
curry19. 10. - 2. 11.1
4. Write a function drawFunc that takes a function as an argument and draws the graph of the given function using WinForms (You can download template that demonstrates how to draw something above!) The simplest possible type signature of the function is: 
val drawFunc : (float32 -> float32) -> unit
Optionally, it can take two additional parameters to specify the X scale and Y scale (+1 point). 		plot26. 10. - 23. 11.1+1
5. Write a function diff that performs numerical differentiation of a function (This follows similar pattern as other operations for working with functions such as translate from slide 29, chapter 2). The signature of the function should be: 
val diff : (float32 -> float32) 
        -> (float32 -> float32)
You can use the standard definition of differentiation and use some small value of d (for example 0.01). 		diff26. 10. - 23. 11.2
6. We used “sum” of sets to model discriminated unions and “product” to model tuples (See chapter 3, slides 6 and 19). How can we use this operations to construct mathematical model of the following types: 
type Season = 
  | Spring | Summer | Autumn | Winter

type Shape = 
  | Circle of int
  | Rectangle of int * int
sets2. 11. - 30. 11.1
7. Write a function that compares two vehicles (Data type in chapter 3, slide 22) and prints detailed information about the more expensive one (You can find the rules for comparison in chapter 3, slide 24). patterns2. 11. - 30. 11.1
8. Write a function that counts the number of elements in the list that are larger than or equal to the average (using integer division for simplicity). The function should use just a single traversal of the list structure! It should give these results: 
foo [1; 2; 3; 4] = 3 // average 2
foo [1; 2; 3; 6] = 2 // average 3
foo [4; 4; 4; 4] = 4 // average 4
(Hint: You can perform some operation on the way "forward" and another operation on the way "backward", see also chapter 5, slide 14) 		traversal23. 11. - 4. 1.1
9. Write a tail-recursive function that takes a list and “removes” all odd numbers from the list (that is, returns a copy of the list that doesn't contain odd numbers): 
removeOdds [1; 2; 3; 5; 4] = [2; 4] // example
(Hints: 1. Tail-recursive functions do all processing when traversing the list forward. 2. You’ll need to do this during two traversals of some list) 		tail23. 11. - 4. 1.1
10. 
collect : ('a -> 'b list) -> 'a list -> 'b list
This function applies the given function to all elements of input list and concatenates all returned lists. It can be used for a wide range of different list processing operations.

Use this function to implement projection and filtering for lists (List.map and List.filter) with the usual type signatures (See Chapter 5 for more information.) 		collect30. 11. - 4. 1.1
11.
  • fold processes list elements on the way to the front
  • foldBack on the way back (from the end to the beginning
Write a more general function (e.g. twoWayFold) that allows us to do both things at once - perform one operation on the way to the front and an operation on the way back. Use this function to implement fold and foldBack (1 point) and also the 8. traversal homework (+1 point). (For more information see Chapter 5, slide 14). 		folds4. 12. - 15. 2.1+1
12. We've seen how to define a computation expression builder for creating computations that can be executed step-by-step using the Resumption type. The sample code also contains a function evaluate which evaluates a single computation and prints a number of each step before running it. Your task is to write a function parallel, which executes two step-by-step computations in parallel. When given computations first and second, it will execute one step of first, one step of second, one step of first etc. To show that your function works, write two computations (e.g. one that prints first ten factorials and other, which prints first ten fibonacci numbers). (See chapter 16 and download Monads demos above). resumptions13. 1. - 15. 2.2
13. Write a bind function for a simple Async type. This type represents an asynchronous computation: 
 type Async<'a> = 
  | Async of (('a -> unit) -> unit)
The type is represented as a function that takes a function as an argument. When the (outer) function is executed, it starts some operation. Once the operation completes (which could be immediately, or at some later time), it reports the result by calling the (inner) function, which it got as an argument. The bind function should have the following type (which pretty much tells you what it has to do): 
val bind : Async<'a> -> ('a -> Async<'b>) -> Async<'b>
bind13. 1. - 15. 2.3

Body

A konečně, dosud udělené body za úkoly, aktivitu a všechno možné. Pokud si nepřejete aby bylo vaše jméno veřejně na webu, tak mi napište mail a já ho odstraním.

JménoÚkoly atd..Součet
Bohumír Zámečníkifthen 2, curry 1, plot 1+1, diff 2, sets 1, aktivita 2, patterns 1, traversal 1, tail 1, collect 1, folds 1+116
Dan Kobrreduction 1, ifthen 2, plot 1, diff 2, sets 1, curry 1, patterns 1, tail 1, collect 1, folds 112
Jakub Čermákreduction 1, ifthen 2, curry 1, plot 1+1, diff 2, sets 1, patterns 1, folds 1+112
Jakub Šmídaktivita 1, reduction 1, ifthen 2, curry 1, plot 1, diff 2, sets 1, patterns 1, tail 1, collect 112
Jaromír Nechanickýreduction 1, ifthen 2, curry 1, diff 2, plot 1+1, sets 1, patterns 1, traversal 1, tail 1, collect 1, folds 1+115
Jindřich Helclaktivita 2, aktivita 1, reduction 1, ifthen 2, sets 1, patterns 1, traversal 1, tail 1, collect 1, folds 1+113
Marek Lereduction 1, ifthen 2, curry 1, sets 1, aktivita 3, traversal 1, tail 1, collect 1, folds 1+113
Miloš Chaloupkareduction 1, ifthen 2, curry 1, plot 1+1, diff 2, sets 1, patterns 1, traversal 1, tail 1, collect 1, folds 1+115
Miroslav Hédlaktivita 1, ifthen 2, curry 1, plot 1+1, diff 2, sets 1, patterns 1, traversal 1, tail 112
Ondřej Plátekreduction 1, ifthen 2, diff 2, aktivita 2, plot 1, sets 1, traversal 1, tail 1, collect 1, folds 1+114
Petr Vávroreduction 1, ifthen 2, curry 1, plot 1+1, diff 2, traversal 1, tail 110
Pavel Tupecreduction 1, ifthen 2, curry 1, plot 1+1, diff 2, traversal 1, tail 1, collect 1, folds 112
Tomáš Hercegreduction 1, ifthen 2, curry 1, plot 1+1, diff 2, sets 1, patterns 1, folds 1+112
Tomáš Humlifthen 2, curry 1, plot 1+1, diff 2, patterns 1, traversal 1, tail 1, collect 1, folds 1 12
Tomáš Křenaktivita 1, reduction 1, ifthen 2, curry 1, sets 1, plot 1+1, diff 2, folds 1+112
Vojtech Bardiovskýreduction 1, ifthen 2, curry 1, plot 1+1, diff 2, sets 1, patterns 1, traversal 1, tail 1, collect 1, folds 1+1 15
Maximumreduction 1, ifthen 2, curry 1, plot 1+1, diff 2, sets 1, patterns 1, traversal 1, tail 1, collect 1, folds 1+1, resumptions 1+1, bind 320

Ostatní informace

Odkazy na další přednášky na kterých se nějak podílím (programátorské večery) a původní verzi tohoto webu, která obsahuje například informace ohledně MSDN AA (tedy legálního způsobu jak získat Visual Studio a další MS produkty).

Published: October 3, 2009 23:31