Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision
Previous revision
sesiuni:scala:lab6 [2016/07/04 15:57]
dciocirlan
sesiuni:scala:lab6 [2016/07/04 20:07] (current)
dciocirlan
Line 26: Line 26:
  
   - Let's write a monad equivalent with ''​Option''​. Let's call this ''​Maybe'',​ as in Haskell.   - Let's write a monad equivalent with ''​Option''​. Let's call this ''​Maybe'',​ as in Haskell.
-    * create a trait ''​Maybe[T]''​ (remember the ''​[T]''​ is equivalent to Java's ''<​T>''​ syntax for generics)+    * create a trait ''​Maybe[+A]''​ (remember the ''​[A]''​ is equivalent to Java's ''<​A>''​ syntax for generics ​and ignore the + for now)
     * add some functional primitives as methods to ''​Maybe'':​     * add some functional primitives as methods to ''​Maybe'':​
       * the monad requirements:​ ''​map'',​ ''​flatMap'',​ ''​filter''​       * the monad requirements:​ ''​map'',​ ''​flatMap'',​ ''​filter''​
-      * ''​zipWith'',​ which receives a ''​Maybe[A]''​ and returns a ''​Maybe[(T,A)]''​\\ The signature is just a tiny bit more complex:\\ <code scala>​def zipWith[A](other: Maybe[A]): Maybe[T,​A]</​code>​ +      * ''​zipWith'',​ which receives a ''​Maybe[B]''​ and returns a ''​Maybe[(A,B)]''​\\ The signature is just a tiny bit more complex:\\ <code scala>​def zipWith[B](other: Maybe[B]): Maybe[(A,B)]</​code>​ If either ''​this''​ or ''​other''​ is empty, the result will be an empty ''​Maybe''​. 
-      * +      * ''​exists'',​ which receives a predicate (a function of A to Boolean) and returns true if this instance contains an element which satisfies the predicate 
 +      * ''​orElse'',​ a special method for ''​Maybe'',​ which returns this instance if it's not empty, or an alternative otherwise; the signature will be\\ <code scala>​def orElse[B >: A](alternative:​ Maybe[B]): Maybe[B]</​code> ​(ignore the ''>:''​ for now)\\ How can you //delay// the computation of the alternative until you actually need it? (hint: call by value/call by name) 
 +    * add some utility methods to the ''​Maybe''​ trait: 
 +      * ''​isEmpty''​ 
 +      * ''​toList''​ 
 +      * ''​size''​ 
 +    * create two case subclasses: ''​Just[A]''​ and ''​Empty''​ and implement the methods 
 +      * what is ''​Empty'',​ actually? a case class? a case object? 
 +      * methods should be quick to write and probably take two lines of code, at most 
 +  - An equivalent to Scala'​s ''​Try''​ monad, call this ''​Attempt[A]''​. 
 +    * as before, create a trait ''​Attempt[A]''​ and two case subclasses, ''​Success[A]''​ and ''​Fail''​ 
 +    * ''​Success''​ has a member of type ''​A'',​ Fail has a member of type ''​Throwable''​ 
 +    * add some functional primitives to your ''​Attempt''​ and implement them in the subclasses:​ 
 +      * ''​map'',​ ''​flatMap'',​ ''​filter''​ 
 +      * ''​zipWith''​ 
 +      * ''​exists''​ 
 +      * ''​isEmpty'',​ ''​toList'',​ ''​size''​ 
 +      * a special method - ''​recoverWith'';​ the method returns an alternative ''​Attempt''​ computation if this one fails 
 +  - Talk about the Future[T] (pun intended) if you finish early!
sesiuni/scala/lab6.1467637025.txt.gz · Last modified: 2016/07/04 15:57 by dciocirlan