Monads

Question 1

Was ist ein Monad?

Answer 1

• Ein funktionales Design Pattern
• Ein Container für eine algebraische Datenstruktur z.b. Monoid

Question 2

Was ist ein Monoid?

Answer 2

Algebraische Struktur mit einer assoziativen binären Operation und einem identifizierenden Element

Question 3

Welche Regeln gelten für Monoids?

Answer 3

• Assoziativität: (a*b)*c=a*(b*c)
• Identifizierendes Element: Es gibt ein Element e in S für das jedes Element a in S gilt: e * a = a * e = a

Question 4

Beispiele für Monoiden

Answer 4

• String mit concat und leerem String
• Integer mit add und 0

Question 5

Funktionsweise Monad und Monoid?

Answer 5

1. Wir nehmen ein Monoid aus dem Container (Monad)
2. Führen eine Operation auf dem Monoid aus
3. Fügen das Monoid in einen neuen Container ein

Question 6

Sind Option und Try Monaden oder Monoiden?

Answer 6

Monaden

Question 7

Warum ist Option ein Monad?

Answer 7

Option kann Some() oder None enthalten (Container leer oder befüllt)

Question 8

Warum ist Try ein Monad?

Answer 8

Try kann Success oder Failure enthalten (Flasche ganz, Flasche kaputt)

Question 9

Welchem Pattern ähnelt ein Monad?

Answer 9

Dem State Pattern

Question 10

Unterschied Monad zu Monoid?

Answer 10

Monad: Unterscheidet guten und schlechten Fall

Monoid: Konvertiert von einem Set in das gleiche Set

Question 11

Beispiel für One Track Code

Answer 11

object BottleState extends Enumeration {
	type BottleState = Value
	val Empty, Labeled, Filled, Capsuled, Consumed = Value
}
import BottleState._

case class Bottle(state: BottleState = Empty) {
def label: Bottle = copy(state= Labeled)
def fill:Bottle = copy(state= Filled)
def capsule:Bottle = copy(state= Capsuled)
def consume:Bottle = {
println(“ consuming… “)
copy(Consumed)
}
}
~~~

new Bottle().label.fill.capsule

~~~

Question 12

Beispiel für Two Track Code

Answer 12

case class MaybeBottle(bottle: Option[Bottle]) {
	def label : MaybeBottle = bottle match {
		case Some(bottle:Bottle) => copy( Some(bottle.label))
		case None => copy(None)
	}
	def fill: MaybeBottle = bottle match {
		case Some(bottle:Bottle) => copy( Some(bottle.fill))
		case None => copy(None)
	}
	def capsule: MaybeBottle = bottle match {
		case Some(bottle:Bottle) => copy( Some(bottle.capsule))
	case None => copy(None)
	}
}

MaybeBottle(Some(new Bottle)).label.fill.capsule
MaybeBottle(None).label.fill.capsule

Question 13

Wie entpackt man Monads?

Answer 13

Durch for-comprehensions: for (x <- e1) yield toValue(x)

Monad:

for (bottle <- pack.bottles) yield bottle match {
	case Some(b) => b.consume
	case None => println("Found None")
}