Reader-Monade für Dependency Injection: mehrere Abhängigkeiten, geschachtelte Aufrufe

, Wie das Modell in diesem Beispiel

Wie konnte dies sein, modelliert mit der Reader-Monade?

Ich bin mir nicht sicher, ob dies sollte modelliert werden mit dem Reader, aber es kann sein durch:

1. Codierung der Klassen, die wie Funktionen, die die code-Spiel mit schöner Reader
2. Komposition der Funktionen mit dem Leser für das Verständnis und die Verwendung es

Gerade Recht-vor dem start muss ich Ihnen sagen, über kleine Probe code-Anpassungen, fühlte ich mich von Vorteil für diese Antwort.
Erste änderung ist über FindUsers.inactive Methode. Ich ließ es zurück List[String] also die Liste der Adressen, die verwendet werden können
in UserReminder.emailInactive Methode. Außerdem habe ich einfache Implementierungen der Methoden. Schließlich wird die Probe verwenden
folgende hand-gerollte version der Reader-Monade:

case class Reader[Conf, T](read: Conf => T) { self =>

  def map[U](convert: T => U): Reader[Conf, U] =
    Reader(self.read andThen convert)

  def flatMap[V](toReader: T => Reader[Conf, V]): Reader[Conf, V] =
    Reader[Conf, V](conf => toReader(self.read(conf)).read(conf))

  def local[BiggerConf](extractFrom: BiggerConf => Conf): Reader[BiggerConf, T] =
    Reader[BiggerConf, T](extractFrom andThen self.read)
}

object Reader {
  def pure[C, A](a: A): Reader[C, A] =
    Reader(_ => a)

  implicit def funToReader[Conf, A](read: Conf => A): Reader[Conf, A] =
    Reader(read)
}

Modellierung Schritt 1. Codierung Klassen als Funktionen

Vielleicht ist das optional, ich bin mir nicht sicher, aber später macht es die für das Verständnis besser Aussehen.
Beachten Sie, dass die resultierende Funktion ist Curry. Es dauert auch ehemalige Konstruktor-argument(s) als ersten parameter (parameter-Liste).
So

class Foo(dep: Dep) {
  def bar(arg: Arg): Res = ???
}
//usage: val result = new Foo(dependency).bar(arg)

wird

object Foo {
  def bar: Dep => Arg => Res = ???
}
//usage: val result = Foo.bar(dependency)(arg)

Bedenken Sie, dass jeder von Dep, Arg, Res Arten werden können, völlig willkürlich: ein Tupel, eine Funktion oder einen einfachen Typ.

Hier ist der Beispiel-code nach der ersten Anpassungen, verwandelt sich in Funktionen:

trait Datastore { def runQuery(query: String): List[String] }
trait EmailServer { def sendEmail(to: String, content: String): Unit }

object FindUsers {
  def inactive: Datastore => () => List[String] =
    dataStore => () => dataStore.runQuery("select inactive")
}

object UserReminder {
  def emailInactive(inactive: () => List[String]): EmailServer => () => Unit =
    emailServer => () => inactive().foreach(emailServer.sendEmail(_, "We miss you"))
}

object CustomerRelations {
  def retainUsers(emailInactive: () => Unit): () => Unit =
    () => {
      println("emailing inactive users")
      emailInactive()
    }
}

Eine Sache zu beachten ist hier, dass bestimmte Funktionen nicht hängt davon ab, die ganze Objekte, sondern nur auf die direkt verwendet Teile.
Wo in der OOP-version UserReminder.emailInactive() Instanz nennen würde userFinder.inactive() hier, man ruft einfach inactive()
- eine Funktion übergeben Sie im ersten parameter.

Bitte beachten Sie, dass der code weist die drei wünschenswerte Eigenschaften, die aus der Frage:

1. es ist klar, welche Art von Abhängigkeiten, jede Funktionalität muss
2. verbirgt Abhängigkeiten von Funktionalität von einem anderen
3. retainUsers Methode sollten Sie nicht wissen müssen über den Datastore-Abhängigkeit

Modellierung Schritt 2. Mit dem Reader zu Komponieren-Funktionen, und führen Sie

Reader-Monade können Sie nur verfassen, Funktionen, die hängen alle von dem gleichen Typ. Dies ist oft nicht der Fall. In unserem Beispiel
FindUsers.inactive hängt Datastore und UserReminder.emailInactive auf EmailServer. Um dieses problem zu lösen
man könnte sich vorstellen, eine neue Art (oft bezeichnet als Config), die enthält alle Abhängigkeiten, dann ändern
die Funktionen, so dass Sie alle hängen und nur daraus die relevanten Daten.
Das ist offensichtlich falsch aus der Abhängigkeit-management-Perspektive, da Sie so machen diese Funktionen auch abhängig
auf Typen, die Sie gar nicht kennen in den ersten Platz.

Glücklicherweise stellt sich heraus, dass es gibt einen Weg, um die Funktion der Arbeit mit Config auch wenn es akzeptiert nur ein Teil davon als parameter.
Es ist eine Methode namens local, definiert im Reader. Es muss mit einem Verfahren zum extrahieren der relevante Teil aus der Config.

Dieses wissen angewendet, um die Beispiel bei der hand würde das so Aussehen, dass:

object Main extends App {

  case class Config(dataStore: Datastore, emailServer: EmailServer)

  val config = Config(
    new Datastore { def runQuery(query: String) = List("[email protected]") },
    new EmailServer { def sendEmail(to: String, content: String) = println(s"sending [$content] to $to") }
  )

  import Reader._

  val reader = for {
    getAddresses <- FindUsers.inactive.local[Config](_.dataStore)
    emailInactive <- UserReminder.emailInactive(getAddresses).local[Config](_.emailServer)
    retainUsers <- pure(CustomerRelations.retainUsers(emailInactive))
  } yield retainUsers

  reader.read(config)()

}

Vorteile gegenüber der Verwendung von Konstruktor-Parameter

In welche Aspekte würden mit der Reader-Monade für so ein "business-Anwendung" besser sein als nur mit Konstruktor-Parameter?

Ich hoffe, dass durch die Vorbereitung dieser Antwort habe ich es leichter gemacht, für sich selbst beurteilen in welche Aspekte würde es schlagen plain-Konstruktoren.
Aber wenn ich aufzählen, diese hier ist meine Liste. Disclaimer: ich habe OOP-hintergrund, und ich kann nicht schätzen, Leser und Kleisli
voll, wie ich Sie nicht verwenden.

1. Homogenität - egal wie kurz/lang die für das Verständnis wichtig ist, es ist nur ein Leser und man kann leicht zu verfassen, es mit einem anderen
   Beispiel, vielleicht nur die Einführung eine weitere Config-Typ und bedüsung einige local fordert es. Dieser Punkt ist IMO
   eher eine Frage des Geschmacks, da bei Verwendung von Konstruktoren niemand verhindert, dass Sie zu Komponieren, was auch immer Dinge, die Sie mögen,
   es sei denn, jemand tut etwas dummes, wie die Arbeit im Konstruktor die sich als eine schlechte Praxis in der OOP.
2. Reader ist eine Monade, so wird es alle die Vorteile damit zu tun - sequence, traverse Methoden implementiert für Sie kostenlos.
3. In einigen Fällen Sie finden es möglicherweise vorzuziehen zu bauen, die der Leser nur einmal und verwenden Sie es für eine Vielzahl von Konfigurationen.
   Mit Konstruktoren niemand hindert Sie, das zu tun, müssen Sie nur bauen die ganze objektgraphen neu für jede Config
   eingehende. Ich habe zwar kein problem damit (ich selbst bevorzuge dabei, dass bei jeder Anforderung an die Anwendung), ist es nicht
   eine naheliegende Idee, um viele Menschen für Gründe kann ich nur spekulieren.
4. Reader schiebt Sie in Richtung der Verwendung von Funktionen mehr, die besser spielen mit Anwendung geschrieben, in der überwiegend FP-Stil.
5. Leser trennt Bedenken; können Sie erstellen, zu interagieren, mit allem, was ist, definieren Sie die Logik, ohne Abhängigkeiten. Tatsächlich liefern später separat. (Danke Ken Scrambler für diesen Punkt). Dies ist oft zu hören Vorteil der Leser, doch das ist auch möglich, mit einfachen Konstruktoren.

Ich würde auch gerne sagen, was ich nicht mag, im Leser.

1. Marketing. Manchmal bekomme ich Eindruck, dass der Reader vermarktet wird, für alle Arten von Abhängigkeiten, ohne Unterschied, ob das
   ein session-cookie oder in eine Datenbank. Für mich gibt es wenig Sinn, mit Reader für nahezu konstanter Objekte, wie E-Mail
   server oder repository aus diesem Beispiel. Für solche Abhängigkeiten finde ich schlicht Konstruktoren und/oder teilweise angewandte Funktionen
   die Art und Weise besser. Im wesentlichen Reader gibt Ihnen die Flexibilität, so können Sie die Abhängigkeiten bei jedem Anruf, aber wenn Sie
   nicht wirklich brauchen, zahlen Sie nur die Steuer.
2. Implizite schwere - mit Leser ohne implicits machen würde, die beispielsweise schwer zu Lesen. Auf der anderen Seite, wenn Sie sich zu verstecken
   die lauten Teile, die mit implicits und machen einige Fehler, compiler geben Ihnen manchmal schwer zu entziffern, Nachrichten.
3. Zeremonie mit pure, local und das erstellen von eigenen Config-Klassen /mit Tupeln für, die. Leser zwingt Sie, fügen Sie einige code
   das ist nicht über die problem domain, also die Einführung von etwas Rauschen in den code. Auf der anderen Seite, eine Anwendung
   verwendet Konstruktoren oft verwendet, factory pattern, welches auch von außerhalb der problem-Domäne, so dass diese Schwäche ist das nicht, dass
   ernst.

Was, wenn ich nicht konvertieren möchte meine Klassen von Objekten mit Funktionen?

Du willst. Sie technisch kann vermeiden, aber schau, was passieren würde, wenn ich nicht konvertieren FindUsers - Klasse-Objekt. Die entsprechende Zeile ist für das Verständnis Aussehen würde:

getAddresses <- ((ds: Datastore) => new FindUsers(ds).inactive _).local[Config](_.dataStore)

was nicht lesbar ist, ist, dass? Der Punkt ist, dass Leser arbeitet auf Funktionen, so dass, wenn Sie diese nicht haben bereits, müssen Sie Sie halt inline, das ist oft nicht schön.