Add mr Hyde using thirdparty library

hyde/jvm/src/main/scala/pl/writeonly/scala/hyde/common/states/api/DisjunctionAPIState.scala

@@ -0,0 +1,30 @@
+package pl.writeonly.scala.hyde.common.states.api
+
+import pl.writeonly.scala.hyde.common.url._
+import pl.writeonly.scala.hyde.common.url.urls._
+import pl.writeonly.scala.hyde.sourcepage.thirdparty._
+
+abstract class DisjunctionAPIState(data: UrlsWithThrowableList)(implicit d: Domain) extends AbstractAPIState(data) {
+  override type HP = SourcePageDisjunction
+
+  def nextData(set: SourcePageDisjunctionSet): UrlsWithThrowableList = {
+
+    val partitioned = set.partition(_.isRight)
+
+    val newWrappedUrls: WrappedUrlSet = partitioned._1
+      .flatMap(DisjunctionAPIState.sourcePageDisjunctionToWrappedUrlSet)
+
+    val newThrowableList: ThrowableList = partitioned._2.toList
+      .flatMap(_.swap.toOption.toList)
+
+    val newUrls = NewUrls(newWrappedUrls)
+
+    data.next(newUrls, newThrowableList)
+  }
+
+}
+
+object DisjunctionAPIState {
+  val sourcePageDisjunctionToWrappedUrlSet: SourcePageDisjunction => WrappedUrlSet =
+    _.map(_.getWrappedUrlSet).toOption.toSet.flatten
+}

hyde/jvm/src/main/scala/pl/writeonly/scala/hyde/common/states/api/package.scala

@@ -2,6 +2,11 @@ package pl.writeonly.scala.hyde.common.states
 
 import scala.concurrent.Future
 
+import scalaz.concurrent.Task
+
 package object api {
   type ParallelStateFuture = Future[EitherAPIState]
+
+  type ParallelStateTask = Task[DisjunctionAPIState]
+
 }

hyde/jvm/src/main/scala/pl/writeonly/scala/hyde/impl/Hyde.scala

@@ -11,6 +11,10 @@ import pl.writeonly.scala.hyde.impl.std.std1.EitherHyde
 import pl.writeonly.scala.hyde.impl.std.std2.EitherBeginHyde
 import pl.writeonly.scala.hyde.impl.std.std3.EitherEndHyde
 import pl.writeonly.scala.hyde.impl.std.std4.FutureHyde
+import pl.writeonly.scala.hyde.impl.thirdparty.thirdparty1.DisjunctionHyde
+import pl.writeonly.scala.hyde.impl.thirdparty.thirdparty2.DisjunctionBeginHyde
+import pl.writeonly.scala.hyde.impl.thirdparty.thirdparty3.DisjunctionEndHyde
+import pl.writeonly.scala.hyde.impl.thirdparty.thirdparty4.TaskHyde
 import slogging._
 
 object Hyde {
@@ -24,6 +28,9 @@ object Hyde {
 
     std()
 
+    thirdParty()
+
+
     println("end of program")
   }
 
@@ -65,6 +72,28 @@ object Hyde {
     println(futureState.throwableList.size.toString)
   }
 
+  def thirdParty(): Unit = {
+    val disjunctionState = time("DisjunctionHyde") {
+      DisjunctionHyde.apply()
+    }
+    println(disjunctionState.throwableList.size.toString)
+
+    val disjunctionBeginState = time("DisjunctionBeginHyde") {
+      DisjunctionBeginHyde.apply()
+    }
+    println(disjunctionBeginState.throwableList.size.toString)
+
+    val disjunctionEndState = time("DisjunctionEndHyde") {
+      DisjunctionEndHyde.apply()
+    }
+    println(disjunctionEndState.throwableList.size.toString)
+
+    val taskState = time("TaskHyde") {
+      TaskHyde.apply()
+    }
+    println(taskState.throwableList.size.toString)
+  }
+
   def time[R](name: String)(block: => R): R = {
     println(name)
 

hyde/jvm/src/main/scala/pl/writeonly/scala/hyde/impl/thirdparty/thirdparty1/DisjunctionHyde.scala

@@ -0,0 +1,13 @@
+package pl.writeonly.scala.hyde.impl.thirdparty.thirdparty1
+
+import pl.writeonly.scala.hyde.common.states.notexception.AbstractNextState
+
+object DisjunctionHyde {
+
+  private val domain = "https://www.writeonly.pl"
+
+  def main(args: Array[String]): Unit =
+    apply().showResult()
+
+  def apply(): AbstractNextState = DisjunctionState(domain)
+}

hyde/jvm/src/main/scala/pl/writeonly/scala/hyde/impl/thirdparty/thirdparty1/DisjunctionState.scala

@@ -0,0 +1,19 @@
+package pl.writeonly.scala.hyde.impl.thirdparty.thirdparty1
+
+import pl.writeonly.scala.hyde.common.states.api.DisjunctionAPIState
+import pl.writeonly.scala.hyde.common.states.notexception._
+import pl.writeonly.scala.hyde.common.url.Domain
+import pl.writeonly.scala.hyde.common.url.urls.UrlsWithThrowableList
+import pl.writeonly.scala.hyde.sourcepage.thirdparty.SourcePageDisjunctionFromInternalUrl
+
+class DisjunctionState(data: UrlsWithThrowableList)(implicit d: Domain) extends DisjunctionAPIState(data) with AbstractFunctionState {
+
+  override def impureFunction: HPFromInternalUrl = SourcePageDisjunctionFromInternalUrl
+
+  override def nextState(data: UrlsWithThrowableList): AbstractNextState = new DisjunctionState(data)
+}
+
+object DisjunctionState extends AbstractNextStateObject {
+
+  override def fromDomain(implicit d: Domain): AbstractNextState = new DisjunctionState(UrlsWithThrowableList.fromDomain)
+}

hyde/jvm/src/main/scala/pl/writeonly/scala/hyde/impl/thirdparty/thirdparty2/DisjunctionBeginHyde.scala

@@ -0,0 +1,13 @@
+package pl.writeonly.scala.hyde.impl.thirdparty.thirdparty2
+
+import pl.writeonly.scala.hyde.common.states.notexception.AbstractNextState
+
+object DisjunctionBeginHyde {
+
+  private val domain = "https://www.writeonly.pl"
+
+  def main(args: Array[String]): Unit = apply().showResult()
+
+  def apply(): AbstractNextState = DisjunctionBeginState(domain)
+
+}

hyde/jvm/src/main/scala/pl/writeonly/scala/hyde/impl/thirdparty/thirdparty2/DisjunctionBeginState.scala

@@ -0,0 +1,33 @@
+package pl.writeonly.scala.hyde.impl.thirdparty.thirdparty2
+
+import pl.writeonly.scala.hyde.common.states.api.DisjunctionAPIState
+import pl.writeonly.scala.hyde.common.states.notexception._
+import pl.writeonly.scala.hyde.common.url.Domain
+import pl.writeonly.scala.hyde.common.url.urls.UrlsWithThrowableList
+import pl.writeonly.scala.hyde.sourcepage.thirdparty._
+import scalaz.Scalaz._
+import scalaz.concurrent.Task
+
+class DisjunctionBeginState(data: UrlsWithThrowableList)(implicit d: Domain) extends DisjunctionAPIState(data) with AbstractNewSetState {
+
+  override def newSet: SourcePageDisjunctionSet = {
+
+    val set: Set[Task[SourcePageDisjunction]] = nextUrls
+      .map(SourcePageTaskFromInternalUrl.apply)
+
+    val monad: Task[SourcePageDisjunctionSet] = Task.gatherUnordered(set.toSeq).map(_.toSet)
+
+    monad.unsafePerformSync
+  }
+
+  override def nextState(data: UrlsWithThrowableList): AbstractNextState = new DisjunctionBeginState(data)
+}
+
+object DisjunctionBeginState {
+
+  def apply(domain: String): AbstractNextState = fromDomain(new Domain(domain)) |> AbstractNextState.run
+
+  def fromDomain(implicit d: Domain): AbstractNextState =
+    new DisjunctionBeginState(UrlsWithThrowableList.fromDomain)
+
+}

hyde/jvm/src/main/scala/pl/writeonly/scala/hyde/impl/thirdparty/thirdparty3/DisjunctionEndHyde.scala

@@ -0,0 +1,13 @@
+package pl.writeonly.scala.hyde.impl.thirdparty.thirdparty3
+
+import pl.writeonly.scala.hyde.common.states.notexception.AbstractNextState
+
+object DisjunctionEndHyde {
+
+  private val domain = "https://www.writeonly.pl"
+
+  def main(args: Array[String]): Unit = apply().showResult()
+
+  def apply(): AbstractNextState = DisjunctionEndState(domain)
+
+}

hyde/jvm/src/main/scala/pl/writeonly/scala/hyde/impl/thirdparty/thirdparty3/DisjunctionEndState.scala

@@ -0,0 +1,32 @@
+package pl.writeonly.scala.hyde.impl.thirdparty.thirdparty3
+
+import pl.writeonly.scala.hyde.common.states.api.DisjunctionAPIState
+import pl.writeonly.scala.hyde.common.states.notexception.AbstractNextState
+import pl.writeonly.scala.hyde.common.url.Domain
+import pl.writeonly.scala.hyde.common.url.urls.UrlsWithThrowableList
+import pl.writeonly.scala.hyde.sourcepage.thirdparty._
+import scalaz.Scalaz._
+import scalaz.concurrent.Task
+
+class DisjunctionEndState(data: UrlsWithThrowableList)(implicit d: Domain) extends DisjunctionAPIState(data) with AbstractNextState {
+
+  override def next: AbstractNextState = {
+
+    val set: Set[Task[SourcePageDisjunction]] = nextUrls
+      .map(SourcePageTaskFromInternalUrl.apply)
+
+    val monad: Task[SourcePageDisjunctionSet] = Task.gatherUnordered(set.toSeq).map(_.toSet)
+
+    monad.map(newState).unsafePerformSync
+  }
+
+  override def nextState(data: UrlsWithThrowableList): AbstractNextState = new DisjunctionEndState(data)
+}
+
+object DisjunctionEndState {
+
+  def apply(domain: String): AbstractNextState = fromDomain(new Domain(domain)) |> AbstractNextState.run
+
+  def fromDomain(implicit d: Domain): AbstractNextState =
+    new DisjunctionEndState(UrlsWithThrowableList.fromDomain)
+}

hyde/jvm/src/main/scala/pl/writeonly/scala/hyde/impl/thirdparty/thirdparty4/TaskHyde.scala

@@ -0,0 +1,15 @@
+package pl.writeonly.scala.hyde.impl.thirdparty.thirdparty4
+
+import pl.writeonly.scala.hyde.common.states.api._
+
+object TaskHyde {
+
+  private val domain = "https://www.writeonly.pl"
+
+  def main(args: Array[String]): Unit = apply().showResult()
+
+  def apply(): DisjunctionAPIState = applyTask().unsafePerformSync
+
+  def applyTask(): ParallelStateTask = TaskState(domain)
+
+}

hyde/jvm/src/main/scala/pl/writeonly/scala/hyde/impl/thirdparty/thirdparty4/TaskState.scala

@@ -0,0 +1,38 @@
+package pl.writeonly.scala.hyde.impl.thirdparty.thirdparty4
+
+import pl.writeonly.scala.hyde.common.states.api._
+import pl.writeonly.scala.hyde.common.url.Domain
+import pl.writeonly.scala.hyde.common.url.urls.UrlsWithThrowableList
+import pl.writeonly.scala.hyde.sourcepage.thirdparty._
+import scalaz.Scalaz._
+import scalaz.concurrent.Task
+
+class TaskState(refsWithThrowable: UrlsWithThrowableList)(implicit d: Domain) extends DisjunctionAPIState(refsWithThrowable) {
+
+  override type NextState = TaskState
+
+  override def nextState(data: UrlsWithThrowableList): TaskState = new TaskState(data)
+
+  def nextMonad: Task[TaskState] = {
+
+    val set: Set[Task[SourcePageDisjunction]] = refsWithThrowable.nextUrls
+      .map(SourcePageTaskFromInternalUrl.apply)
+
+    val monad: Task[SourcePageDisjunctionSet] = Task
+      .gatherUnordered(set.toSeq)
+      .map(_.toSet)
+
+    monad.map(newState)
+  }
+
+}
+
+object TaskState {
+
+  def apply(domain: String): ParallelStateTask = fromDomain(new Domain(domain)) |> TaskState.run
+
+  def fromDomain(implicit d: Domain): TaskState = new TaskState(UrlsWithThrowableList.fromDomain)
+
+  def run(state: TaskState): Task[DisjunctionAPIState] =
+    if (state.isEmptyNextInternalUrls) Task.now(state) else state.nextMonad.flatMap(run)
+}

hyde/jvm/src/main/scala/pl/writeonly/scala/hyde/sourcepage/thirdparty/SourcePageDisjunctionFromInternalUrl.scala

@@ -0,0 +1,13 @@
+package pl.writeonly.scala.hyde.sourcepage.thirdparty
+
+import pl.writeonly.scala.hyde.common.url.typed.InternalUrl
+import pl.writeonly.scala.hyde.sourcepage.oo.SourcePageFromInternalUrl
+import scalaz.Disjunction
+import scalaz.Scalaz._
+
+object SourcePageDisjunctionFromInternalUrl extends (InternalUrl => SourcePageDisjunction) {
+
+  override def apply(internalUrl: InternalUrl): SourcePageDisjunction =
+    Disjunction.attempt(internalUrl |> SourcePageFromInternalUrl.apply)(internalUrl.toException)
+
+}

hyde/jvm/src/main/scala/pl/writeonly/scala/hyde/sourcepage/thirdparty/SourcePageTaskFromInternalUrl.scala

@@ -0,0 +1,11 @@
+package pl.writeonly.scala.hyde.sourcepage.thirdparty
+
+import pl.writeonly.scala.hyde.common.url.typed.InternalUrl
+import scalaz.Scalaz._
+import scalaz.concurrent.Task
+
+object SourcePageTaskFromInternalUrl {
+
+  def apply(internalUrl: InternalUrl): SourcePageTask =
+    Task(internalUrl |> SourcePageDisjunctionFromInternalUrl.apply)
+}

hyde/jvm/src/main/scala/pl/writeonly/scala/hyde/sourcepage/thirdparty/package.scala

@@ -0,0 +1,14 @@
+package pl.writeonly.scala.hyde.sourcepage
+
+import pl.writeonly.scala.hyde.common.url.exception.UrlException
+import scalaz.Disjunction
+import scalaz.concurrent.Task
+
+package object thirdparty {
+  type SourcePageDisjunction = Disjunction[UrlException, SourcePage]
+
+  type SourcePageDisjunctionSet = Set[SourcePageDisjunction]
+
+  type SourcePageTask = Task[SourcePageDisjunction]
+
+}