[7.x] Bump coursier/cache-action from 8.0.0 to 8.0.1#1043
Merged
Conversation
dependabot
bot
added
dependencies
dependabot
bot
added
dependencies
diff --git a/index.html b/index.html
index 8e7071a..94e59f2 100644
--- a/index.html
+++ b/index.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
diff --git a/org.atnos.site.ApplicativeEvaluation.html b/org.atnos.site.ApplicativeEvaluation.html
index 2aa8697..deaeeef 100644
--- a/org.atnos.site.ApplicativeEvaluation.html
+++ b/org.atnos.site.ApplicativeEvaluation.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -316,13 +322,133 @@ typeclasses">Know your Membe...</a>
<p>The default interpretation of <code class="prettyprint">Eff</code> values is “monadic”
meaning that effectful values are being evaluated in order. This becomes
clear when traversing a list of values with the
-<code class="prettyprint">FutureEffect</code>:`<code class="prettyprint"></code>> List(1000, 500, 50)`</p>
+<code class="prettyprint">FutureEffect</code>:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, future._, syntax.all._
+ import cats.Eval
+ import cats.data.Writer
+ import cats.syntax.traverse._
+ import scala.concurrent._, duration._, ExecutionContext.Implicits.global
+ import org.atnos.eff.concurrent.Scheduler
+ import org.atnos.eff.syntax.future._
+
+ type WriterString[A] = Writer[String, A]
+ type _writerString[R] = WriterString |= R
+
+ type S = Fx.fx3[Eval, TimedFuture, WriterString]
+
+ implicit val scheduler: Scheduler = ExecutorServices.schedulerFromGlobalExecutionContext
+
+ def execute[E: _eval: _writerString: _future](i: Int): Eff[E, Int] =
+ for {
+ i1 <- delay(i)
+ i2 <- futureDelay(i1)
+ _ <- tell(i2.toString)
+ } yield i2
+
+ val action: Eff[S, List[Int]] =
+ List(1000, 500, 50).traverse(execute[S])
+
+ Await.result(action.runEval.runWriterLog.runSequential, 2.seconds)</code></pre>
+<p><code class="prettyprint">> List(1000, 500, 50)</code></p>
<p>We can however run all those computations concurrently using the
-applicative execution for <code class="prettyprint">Eff</code>:`<code class="prettyprint"></code>> List(1000,
-500, 50)`</p>
+applicative execution for <code class="prettyprint">Eff</code>:</p>
+<pre><code class="prettyprint"> val action: Eff[S, List[Int]] =
+ List(1000, 500, 50).traverseA(execute[S])
+
+ Await.result(
+ Eff
+ .detachA(action.runEval.runWriterLog[String])(using TimedFuture.MonadTimedFuture, TimedFuture.ApplicativeTimedFuture)
+ .runNow(scheduler, global),
+ 2.seconds
+ )</code></pre>
+<p><code class="prettyprint">> List(1000, 500, 50)</code></p>
<p>This uses now <code class="prettyprint">traverseA</code> (instead of
<code class="prettyprint">traverse</code>) to do an applicative traversal and execute
futures concurrently and the fastest actions finish first.</p>
+<h3 id="batching">Batching</h3>
+<p>Another advantage of applicative effects is that we can intercept
+them individual requests and “batch” them into one single request. For
+example:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+
+// An effect to get users from a database
+// calls can be individual or batched
+ case class User(i: Int)
+ sealed trait UserDsl[+A]
+
+ case class GetUser(i: Int) extends UserDsl[User]
+ case class GetUsers(is: List[Int]) extends UserDsl[List[User]]
+ type _userDsl[R] = UserDsl /= R
+
+ def getUser[R: _userDsl](i: Int): Eff[R, User] =
+ send[UserDsl, R, User](GetUser(i))
+
+</code></pre>
+<p>Let’s create an interpreter for this DSL:</p>
+<pre><code class="prettyprint">// the real method calls to a webservice
+ def getWebUser(i: Int): User = User(i)
+ def getWebUsers(is: List[Int]): List[User] = is.map(i => User(i))
+
+// the interpreter simply calls the webservice
+// and return a trace of the executed call
+ def runDsl[A](eff: Eff[Fx1[UserDsl], A]): (A, Vector[String]) = {
+ @tailrec
+ def go(e: Eff[Fx1[UserDsl], A], trace: Vector[String]): (A, Vector[String]) =
+ e match {
+ case Pure(a, _) =>
+ (a, trace)
+ case Impure(UnionTagged(GetUser(i), _), c, _) =>
+ go(c.asInstanceOf[User => Eff[Fx1[UserDsl], A]].apply(getWebUser(i)), trace :+ "getWebUser")
+ case Impure(UnionTagged(GetUsers(is), _), c, _) =>
+ go(c.asInstanceOf[List[User] => Eff[Fx1[UserDsl], A]].apply(getWebUsers(is)), trace :+ "getWebUsers")
+ case ap @ ImpureAp(_, _, _) =>
+ go(ap.toMonadic, trace)
+ case Impure(_, _, _) =>
+ sys.error("this should not happen with just one effect")
+ }
+ go(eff, Vector())
+ }
+
+</code></pre>
+<p>We can also optimise a <code class="prettyprint">UserDsl</code> program by providing a
+<code class="prettyprint">Batchable</code> instance describing how to “batch” 2 calls into
+1:</p>
+<pre><code class="prettyprint"> implicit def BatchableUserDsl: Batchable[UserDsl] = new Batchable[UserDsl] {
+ type Z = List[User]
+ type E = User
+
+ def distribute(z: List[User]) = z
+
+ def batch[X, Y](tx: UserDsl[X], ty: UserDsl[Y]): Option[UserDsl[Z]] = Option {
+ (tx, ty) match {
+ case (GetUser(i), GetUser(j)) => GetUsers(List(i, j))
+ case (GetUser(i), GetUsers(is)) => GetUsers(i :: is)
+ case (GetUsers(is), GetUser(i)) => GetUsers(is :+ i)
+ case (GetUsers(is), GetUsers(js)) => GetUsers(is ++ js)
+ }
+ }
+ }
+
+</code></pre>
+<p>Now let’s create a program using the <code class="prettyprint">User</code> DSL with
+applicative calls which can be optimised:</p>
+<pre><code class="prettyprint"> def program[R: _userDsl]: Eff[R, List[User]] =
+ Eff.traverseA(List(1, 2, 3))(i => getUser(i))
+
+</code></pre>
+<p>And its optimised version:</p>
+<pre><code class="prettyprint"> def optimised[R: _userDsl]: Eff[R, List[User]] =
+ program.batch
+
+</code></pre>
+<p>Running the optimised and non-optimised version of the program must
+yield the same results:</p>
+<pre><code class="prettyprint"> show(runDsl(program[Fx1[UserDsl]]), runDsl(optimised[Fx1[UserDsl]]))</code></pre>
+<pre><code class="prettyprint">original: User(1), User(2), User(3)
+ trace: getWebUser, getWebUser, getWebUser
+
+optimised: User(1), User(2), User(3)
+ trace: getWebUsers</code></pre>
</div>
<script>
diff --git a/org.atnos.site.CommunityResources.html b/org.atnos.site.CommunityResources.html
index 9de96c9..cc134af 100644
--- a/org.atnos.site.CommunityResources.html
+++ b/org.atnos.site.CommunityResources.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
diff --git a/org.atnos.site.Cookbook.html b/org.atnos.site.Cookbook.html
index 651c8a8..389bed1 100644
--- a/org.atnos.site.Cookbook.html
+++ b/org.atnos.site.Cookbook.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -330,8 +336,64 @@ additional effects, like state, within one part.</p>
<li><p><code class="prettyprint">runState</code> is called within
<code class="prettyprint">incrementNTimes</code> to finally interpret that effect</p></li>
</ul>
-<p>`<code class="prettyprint"></code>> Right((6,List(counter == 4, counter == 5, counter
-== 6)))`</p>
+<pre><code class="prettyprint">import cats._, data._
+ import cats.syntax.all._
+ import org.atnos.eff._
+ import org.atnos.eff.all._
+ import org.atnos.eff.syntax.all._
+
+// Some type definitions for the effects we will use
+ type EitherString[A] = Either[String, A]
+ type WriterString[A] = Writer[String, A]
+ type StateInt[A] = State[Int, A]
+
+ type _err[R] = EitherString |= R
+ type _log[R] = WriterString |= R
+ type _count[R] = StateInt |= R
+
+ /**
+ * In module 1, some utility methods
+ */
+
+// repeat a side-effect n times
+ def repeatM[M[_]: Monad](n: Int, computation: M[Unit]): M[Unit] =
+ if (n <= 0) computation
+ else computation >> repeatM(n - 1, computation)
+
+// check a condition and abort computations with a message if the condition is false
+ def assert[R: _err](condition: Boolean, msg: String): Eff[R, Unit] =
+ if (!condition) left(msg) else right(())
+
+// increment a counter and log the new value
+ def incrementCounter[R: _log: _count]: Eff[R, Unit] = for {
+ c <- get
+ c2 = c + 1
+ _ <- tell(s"counter == $c2")
+ _ <- put(c2)
+ } yield ()
+
+ /**
+ * In module 2 your "business" logic
+ */
+
+// increment a value n times (n need to be positive)
+ def incrementNTimes[R: _err: _log](start: Int, times: Int): Eff[R, Int] = for {
+ // this call uses the stack R
+ _ <- assert(times >= 0, s"$times is negative")
+
+ // the call uses the stack R plus an additional StateInt effect which is interpreted right away.
+ // The other effects remain
+ result <- repeatM(times, incrementCounter[Fx.prepend[StateInt, R]]).execState(start)
+ } yield result
+
+ /**
+ * A top-level call
+ */
+
+ type Stack = Fx.fx2[EitherString, WriterString]
+
+ incrementNTimes[Stack](3, 2).runWriter.runEither.run</code></pre>
+<p><code class="prettyprint">> Right((6,List(counter == 4, counter == 5, counter == 6)))</code></p>
</div>
<script>
diff --git a/org.atnos.site.CreateEffects.html b/org.atnos.site.CreateEffects.html
index 8f4f075..fc020d3 100644
--- a/org.atnos.site.CreateEffects.html
+++ b/org.atnos.site.CreateEffects.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -342,7 +348,7 @@ an Effect for a new “optional” type.</p>
def nothing[R: _maybe, A]: Eff[R, A] =
send[Maybe, R, A](Nothing())
- def runMaybe[R, U, A](effect: Eff[R, A])(using m: Member.Aux[Maybe, R, U]): Eff[U, Option[A]] =
+ def runMaybe[R, U, A](effect: Eff[R, A])(implicit m: Member.Aux[Maybe, R, U]): Eff[U, Option[A]] =
recurse(effect)(new Recurser[Maybe, U, A, Option[A]] {
def onPure(a: A): Option[A] = Some(a)
@@ -356,7 +362,7 @@ an Effect for a new “optional” type.</p>
Right(ms.sequence)
})
- given Applicative[Maybe] = new Applicative[Maybe] {
+ implicit val applicativeMaybe: Applicative[Maybe] = new Applicative[Maybe] {
def pure[A](a: A): Maybe[A] = Just(a)
def ap[A, B](ff: Maybe[A => B])(fa: Maybe[A]): Maybe[B] =
@@ -380,7 +386,15 @@ values</p></li>
<h3 id="compiler-limitation">Compiler limitation</h3>
<p>When you create an effect you can define a sealed trait and case
classes to represent different possibilities for that effect. For
-example for interacting with a database you might create: ``</p>
+example for interacting with a database you might create:</p>
+<pre><code class="prettyprint">trait DatabaseEffect {
+
+ case class Record(fields: List[String])
+
+ sealed trait Db[A]
+ case class Get[A](id: Int) extends Db[Record]
+ case class Update[A](id: Int, record: Record) extends Db[Record]
+ }</code></pre>
<p>It is recommended to create the <code class="prettyprint">Db</code> types
<strong>outside</strong> of the <code class="prettyprint">DatabaseEffect</code> trait.
Indeed, during <code class="prettyprint">Member</code> implicit resolution, depending on how
@@ -408,8 +422,19 @@ and its removal from <code class="prettyprint">R</code> should be the effect sta
<code class="prettyprint">U</code></li>
</ul>
<p><br/></p>
-<p>Then we can use this effect in a computation:`<code class="prettyprint"></code>>
-Some(5)`</p>
+<p>Then we can use this effect in a computation:</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+ import org.atnos.eff.eff._
+ import MaybeEffect._
+
+ val action: Eff[Fx.fx1[Maybe], Int] =
+ for {
+ a <- just(2)
+ b <- just(3)
+ } yield a + b
+
+ run(runMaybe(action))</code></pre>
+<p><code class="prettyprint">> Some(5)</code></p>
<hr />
</div>
diff --git a/org.atnos.site.Installation.html b/org.atnos.site.Installation.html
index 3658127..39aab6a 100644
--- a/org.atnos.site.Installation.html
+++ b/org.atnos.site.Installation.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -314,14 +320,35 @@ typeclasses">Know your Membe...</a>
<p>You add <code class="prettyprint">eff</code> as an sbt dependency:</p>
<div class="sourceCode" id="cb1"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a>libraryDependencies <span class="op">+=</span> <span class="st">"org.atnos"</span> <span class="op">%%</span> <span class="st">"eff"</span> <span class="op">%</span> <span class="st">"8.0.0"</span></span>
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a>libraryDependencies <span class="op">+=</span> <span class="st">"org.atnos"</span> <span class="op">%%</span> <span class="st">"eff"</span> <span class="op">%</span> <span class="st">"7.0.6"</span></span>
<span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a><span class="co">// to write types like Reader[String, *]</span></span>
-<span id="cb1-4"><a href="#cb1-4" aria-hidden="true" tabindex="-1"></a><span class="co">// for Scala 3.3.x</span></span>
-<span id="cb1-5"><a href="#cb1-5" aria-hidden="true" tabindex="-1"></a>scalacOptions <span class="op">+=</span> <span class="st">"-Ykind-projector"</span></span>
-<span id="cb1-6"><a href="#cb1-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb1-7"><a href="#cb1-7" aria-hidden="true" tabindex="-1"></a><span class="co">// for latest Scala 3</span></span>
-<span id="cb1-8"><a href="#cb1-8" aria-hidden="true" tabindex="-1"></a>scalacOptions <span class="op">+=</span> <span class="st">"-Xkind-projector"</span></span></code></pre></div>
+<span id="cb1-4"><a href="#cb1-4" aria-hidden="true" tabindex="-1"></a>libraryDependencies <span class="op">++=</span> <span class="op">{</span></span>
+<span id="cb1-5"><a href="#cb1-5" aria-hidden="true" tabindex="-1"></a> <span class="cf">if</span> <span class="op">(</span>scalaBinaryVersion<span class="op">.</span>value <span class="op">==</span> <span class="st">"3"</span><span class="op">)</span> <span class="op">{</span></span>
+<span id="cb1-6"><a href="#cb1-6" aria-hidden="true" tabindex="-1"></a> Nil</span>
+<span id="cb1-7"><a href="#cb1-7" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span> <span class="cf">else</span> <span class="op">{</span></span>
+<span id="cb1-8"><a href="#cb1-8" aria-hidden="true" tabindex="-1"></a> <span class="bu">Seq</span><span class="op">(</span><span class="fu">compilerPlugin</span><span class="op">(</span><span class="st">"org.typelevel"</span> <span class="op">%%</span> <span class="st">"kind-projector"</span> <span class="op">%</span> <span class="st">"0.13.3"</span> cross CrossVersion<span class="op">.</span>full<span class="op">))</span></span>
+<span id="cb1-9"><a href="#cb1-9" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span></span>
+<span id="cb1-10"><a href="#cb1-10" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb1-11"><a href="#cb1-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb1-12"><a href="#cb1-12" aria-hidden="true" tabindex="-1"></a>scalacOptions <span class="op">++=</span> <span class="op">{</span></span>
+<span id="cb1-13"><a href="#cb1-13" aria-hidden="true" tabindex="-1"></a> <span class="cf">if</span> <span class="op">(</span>scalaBinaryVersion<span class="op">.</span>value <span class="op">==</span> <span class="st">"3"</span><span class="op">)</span> <span class="op">{</span></span>
+<span id="cb1-14"><a href="#cb1-14" aria-hidden="true" tabindex="-1"></a> <span class="bu">Seq</span><span class="op">(</span><span class="st">"-Ykind-projector"</span><span class="op">)</span></span>
+<span id="cb1-15"><a href="#cb1-15" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span> <span class="cf">else</span> <span class="op">{</span></span>
+<span id="cb1-16"><a href="#cb1-16" aria-hidden="true" tabindex="-1"></a> Nil</span>
+<span id="cb1-17"><a href="#cb1-17" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span></span>
+<span id="cb1-18"><a href="#cb1-18" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
+<p>To get types like <code class="prettyprint">Reader[String, *]</code> (with more than one
+type parameter) correctly inferred, you’ll have to use the following
+compiler option</p>
+<div class="sourceCode" id="cb2"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a>scalacOptions <span class="op">++=</span> <span class="op">{</span></span>
+<span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a> <span class="cf">if</span> <span class="op">(</span>scalaBinaryVersion<span class="op">.</span>value <span class="op">==</span> <span class="st">"2.12"</span><span class="op">)</span> <span class="op">{</span></span>
+<span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a> <span class="bu">Seq</span><span class="op">(</span><span class="st">"-Ypartial-unification"</span><span class="op">)</span></span>
+<span id="cb2-4"><a href="#cb2-4" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span> <span class="cf">else</span> <span class="op">{</span></span>
+<span id="cb2-5"><a href="#cb2-5" aria-hidden="true" tabindex="-1"></a> Nil</span>
+<span id="cb2-6"><a href="#cb2-6" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span></span>
+<span id="cb2-7"><a href="#cb2-7" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
<h5 id="additional-dependencies">Additional dependencies</h5>
<p>This table lists the other available eff modules:</p>
<table>
@@ -353,6 +380,10 @@ functional programming. This gives you a <code class="prettyprint">Scalaz</code>
<td>to use cats’s <code class="prettyprint">IO</code> effect</td>
</tr>
<tr>
+<td><code class="prettyprint">eff-twitter</code></td>
+<td>to use Twitter’s <code class="prettyprint">Future</code> effect</td>
+</tr>
+<tr>
<td><code class="prettyprint">eff-doobie</code></td>
<td>to use Doobie’s <code class="prettyprint">ConnectionIO</code> effect</td>
</tr>
@@ -364,8 +395,8 @@ functional programming. This gives you a <code class="prettyprint">Scalaz</code>
<p>The main <code class="prettyprint">eff</code> types: <code class="prettyprint">Eff</code>,
<code class="prettyprint">Member</code>, <code class="prettyprint">Fx</code> are accessible in the
<code class="prettyprint">org.atnos.eff</code> package:</p>
-<div class="sourceCode" id="cb2"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>_</span></code></pre></div>
+<div class="sourceCode" id="cb3"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>_</span></code></pre></div>
<p>Many other effects are also available
<link class="ok"><a href="org.atnos.site.OutOfTheBox.html" tooltip="" class="ok">Out
of the box</a></link>.</p>
@@ -373,11 +404,11 @@ of the box</a></link>.</p>
<p>The functions used to create effects are grouped under different
objects named after the effect type. For example if you want to create
the <code class="prettyprint">Eval</code> effect you need to import:</p>
-<div class="sourceCode" id="cb3"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>eval<span class="op">.</span>_</span></code></pre></div>
-<p>You can also import most of the effects at once with:</p>
<div class="sourceCode" id="cb4"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>all<span class="op">.</span>_</span></code></pre></div>
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>eval<span class="op">.</span>_</span></code></pre></div>
+<p>You can also import most of the effects at once with:</p>
+<div class="sourceCode" id="cb5"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>all<span class="op">.</span>_</span></code></pre></div>
<p>The only effects not included in the previous import are:</p>
<ul>
<li><p>the <code class="prettyprint">Error</code> effect. This effect requires a type
@@ -392,17 +423,17 @@ monix’s <code class="prettyprint">TaskEffect</code> and the import could clash
<p>Interpreting effects usually requires some syntax to “run” a given
effect. For example to “run” the <code class="prettyprint">Option</code> effect you will
import:</p>
-<div class="sourceCode" id="cb5"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="co">// to create the effect</span></span>
-<span id="cb5-2"><a href="#cb5-2" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>option<span class="op">.</span>_</span>
-<span id="cb5-3"><a href="#cb5-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-4"><a href="#cb5-4" aria-hidden="true" tabindex="-1"></a><span class="co">// to access the runOption method</span></span>
-<span id="cb5-5"><a href="#cb5-5" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>syntax<span class="op">.</span>option<span class="op">.</span>_</span>
-<span id="cb5-6"><a href="#cb5-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-7"><a href="#cb5-7" aria-hidden="true" tabindex="-1"></a><span class="fu">fromOption</span><span class="op">(</span><span class="ex">Option</span><span class="op">(</span><span class="dv">1</span><span class="op">)).</span>runOption</span></code></pre></div>
-<p>You can also access all the syntax imports at once with:</p>
<div class="sourceCode" id="cb6"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>syntax<span class="op">.</span>all<span class="op">.</span>given</span></code></pre></div>
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a><span class="co">// to create the effect</span></span>
+<span id="cb6-2"><a href="#cb6-2" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>option<span class="op">.</span>_</span>
+<span id="cb6-3"><a href="#cb6-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-4"><a href="#cb6-4" aria-hidden="true" tabindex="-1"></a><span class="co">// to access the runOption method</span></span>
+<span id="cb6-5"><a href="#cb6-5" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>syntax<span class="op">.</span>option<span class="op">.</span>_</span>
+<span id="cb6-6"><a href="#cb6-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-7"><a href="#cb6-7" aria-hidden="true" tabindex="-1"></a><span class="fu">fromOption</span><span class="op">(</span><span class="ex">Option</span><span class="op">(</span><span class="dv">1</span><span class="op">)).</span>runOption</span></code></pre></div>
+<p>You can also access all the syntax imports at once with:</p>
+<div class="sourceCode" id="cb7"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>syntax<span class="op">.</span>all<span class="op">.</span>_</span></code></pre></div>
<h4 id="intellij-support">Intellij support</h4>
<p>Intellij error highlighting doesn’t support implicit-directed type
inference yet, check https://youtrack.jetbrains.com/issue/SCL-11140 or
@@ -411,23 +442,23 @@ https://youtrack.jetbrains.com/issue/SCL-10753 for progress.</p>
<p>If you use Scalaz as your functional programming library you might
need additional imports in order to use some creation methods specific
to Scalaz. For example:</p>
-<div class="sourceCode" id="cb7"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>either<span class="op">.</span>_</span>
-<span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb7-3"><a href="#cb7-3" aria-hidden="true" tabindex="-1"></a><span class="fu">fromDisjunction</span><span class="op">(</span>\<span class="op">/-(</span><span class="dv">1</span><span class="op">))</span></span></code></pre></div>
-<p>There is also an <code class="prettyprint">all</code> object importing all those methods
-at once:</p>
<div class="sourceCode" id="cb8"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>all<span class="op">.</span>_</span>
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>either<span class="op">.</span>_</span>
<span id="cb8-2"><a href="#cb8-2" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb8-3"><a href="#cb8-3" aria-hidden="true" tabindex="-1"></a><span class="fu">fromDisjunction</span><span class="op">(</span>\<span class="op">/-(</span><span class="dv">1</span><span class="op">))</span></span></code></pre></div>
+<p>There is also an <code class="prettyprint">all</code> object importing all those methods
+at once:</p>
+<div class="sourceCode" id="cb9"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>all<span class="op">.</span>_</span>
+<span id="cb9-2"><a href="#cb9-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-3"><a href="#cb9-3" aria-hidden="true" tabindex="-1"></a><span class="fu">fromDisjunction</span><span class="op">(</span>\<span class="op">/-(</span><span class="dv">1</span><span class="op">))</span></span></code></pre></div>
<p>And you can already guess, there are some syntax imports following
the same pattern:</p>
-<div class="sourceCode" id="cb9"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>either<span class="op">.</span>_</span>
-<span id="cb9-2"><a href="#cb9-2" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>syntax<span class="op">.</span>either<span class="op">.</span>_</span>
-<span id="cb9-3"><a href="#cb9-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-4"><a href="#cb9-4" aria-hidden="true" tabindex="-1"></a><span class="fu">fromDisjunction</span><span class="op">(</span>\<span class="op">/-(</span><span class="dv">1</span><span class="op">)).</span>runDisjunction</span></code></pre></div>
+<div class="sourceCode" id="cb10"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>either<span class="op">.</span>_</span>
+<span id="cb10-2"><a href="#cb10-2" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>syntax<span class="op">.</span>either<span class="op">.</span>_</span>
+<span id="cb10-3"><a href="#cb10-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-4"><a href="#cb10-4" aria-hidden="true" tabindex="-1"></a><span class="fu">fromDisjunction</span><span class="op">(</span>\<span class="op">/-(</span><span class="dv">1</span><span class="op">)).</span>runDisjunction</span></code></pre></div>
</div>
<script>
diff --git a/org.atnos.site.Introduction.html b/org.atnos.site.Introduction.html
index 2c8ddd1..e84a1e0 100644
--- a/org.atnos.site.Introduction.html
+++ b/org.atnos.site.Introduction.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -341,8 +347,15 @@ page first</em></p>
<code class="prettyprint">A</code> is the value returned by the computation, possibly
triggering some effects when evaluated.</p>
<p>The effects <code class="prettyprint">R</code> are modelled by a type-level list of
-“effect constructors”, for example:`<code class="prettyprint">The stack</code>Stack` above
-declares 3 effects:</p>
+“effect constructors”, for example:</p>
+<pre><code class="prettyprint">import cats._, data._
+ import org.atnos.eff._
+
+ type ReaderInt[A] = Reader[Int, A]
+ type WriterString[A] = Writer[String, A]
+
+ type Stack = Fx.fx3[WriterString, ReaderInt, Eval]</code></pre>
+<p>The stack <code class="prettyprint">Stack</code> above declares 3 effects:</p>
<ul>
<li><p>a <code class="prettyprint">ReaderInt</code> effect to access some configuration
number of type <code class="prettyprint">Int</code></p></li>
@@ -353,8 +366,33 @@ bit like lazy values)</p></li>
</ul>
<p>Now we can write a program with those 3 effects, using the primitive
operations provided by <code class="prettyprint">ReaderEffect</code>,
-<code class="prettyprint">WriterEffect</code> and <code class="prettyprint">EvalEffect</code>:`<code class="prettyprint"></code>>
-(64,List(the required power is 6, the result is 64))`</p>
+<code class="prettyprint">WriterEffect</code> and <code class="prettyprint">EvalEffect</code>:</p>
+<pre><code class="prettyprint">import org.atnos.eff.all._
+ import org.atnos.eff.syntax.all._
+
+// useful type aliases showing that the ReaderInt and the WriterString effects are "members" of R
+// note that R could have more effects
+ type _readerInt[R] = ReaderInt |= R
+ type _writerString[R] = WriterString |= R
+
+ def program[R: _readerInt: _writerString: _eval]: Eff[R, Int] = for {
+ // get the configuration
+ n <- ask[R, Int]
+
+ // log the current configuration value
+ _ <- tell("the required power is " + n)
+
+ // compute the nth power of 2
+ a <- delay(math.pow(2, n.toDouble).toInt)
+
+ // log the result
+ _ <- tell("the result is " + a)
+ } yield a
+
+// run the action with all the interpreters
+// each interpreter running one effect
+ program[Stack].runReader(6).runWriter.runEval.run</code></pre>
+<p><code class="prettyprint">> (64,List(the required power is 6, the result is 64))</code></p>
<p>As you can see, all the effects of the <code class="prettyprint">Stack</code> type are
being executed one by one:</p>
<ol type="1">
diff --git a/org.atnos.site.MemberImplicits.html b/org.atnos.site.MemberImplicits.html
index 7340326..12c7121 100644
--- a/org.atnos.site.MemberImplicits.html
+++ b/org.atnos.site.MemberImplicits.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -314,12 +320,43 @@ typeclasses">Know your Membe...</a>
<p>Type inference with the Eff monad can be a bit tricky to get right if
we want to avoid type annotations. Here are some tips to help you.</p>
+<h3 id="running-effects-with-several-type-parameters">Running effects
+with several type parameters</h3>
+<p>Some effects use 2 type variables, like <code class="prettyprint">Reader</code> or
+<code class="prettyprint">Writer</code>. If you want to use those effects in an effect stack
+you need to make sure you have the following <code class="prettyprint">scalac</code>
+option:</p>
+<div class="sourceCode" id="cb1"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a>scalacOptions <span class="op">+=</span> <span class="st">"-Ypartial-unification"</span></span></code></pre></div>
<h3 id="use-context-bounds-and-type-aliases">Use context bounds and type
aliases</h3>
<p>When creating effects you can always “require” a stack containing the
-right effects with the <code class="prettyprint">MemberIn</code> typeclass:``</p>
+right effects with the <code class="prettyprint">MemberIn</code> typeclass:</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+ import org.atnos.eff.all._
+
+ type StateInt[A] = State[Int, A]
+ type WriterString[A] = Writer[String, A]
+
+// for creating state effects
+ def putAndTell[R](i: Int)(implicit s: StateInt |= R, w: WriterString |= R): Eff[R, Int] =
+ for {
+ // no type annotations needed!
+ _ <- put(i)
+ _ <- tell("stored " + i)
+ } yield i</code></pre>
<p>You can even use context bounds to make the declaration of
-<code class="prettyprint">putAndTell</code> more concise:``</p>
+<code class="prettyprint">putAndTell</code> more concise:</p>
+<pre><code class="prettyprint">import org.atnos.eff.all._
+
+ type _stateInt[R] = State[Int, *] |= R
+ type _writerString[R] = Writer[String, *] |= R
+
+ def putAndTell[R: _stateInt: _writerString](i: Int): Eff[R, Int] =
+ for {
+ _ <- put(i)
+ _ <- tell("stored " + i)
+ } yield i</code></pre>
<h3 id="know-your-member-typeclasses">Know your <code class="prettyprint">Member</code>
typeclasses</h3>
<p>There are 3 different ways to declare that an effect is part of an
@@ -369,12 +406,47 @@ and remove the effect from the stack</td>
<h3 id="packing-member-instances">“Packing” member instances</h3>
<p>Some function signatures can be repetitive when they always require
the same list of effects:</p>
-<div class="sourceCode" id="cb1"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> foo1<span class="op">[</span>R <span class="op">:</span>_foo <span class="op">:</span>_bar <span class="op">:</span>_baz<span class="op">](</span>i<span class="op">:</span> <span class="bu">Int</span><span class="op">):</span> Eff<span class="op">[</span>R<span class="op">,</span> <span class="bu">Int</span><span class="op">]</span></span>
-<span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> foo2<span class="op">[</span>R <span class="op">:</span>_foo <span class="op">:</span>_bar <span class="op">:</span>_baz<span class="op">](</span>i<span class="op">:</span> <span class="bu">Int</span><span class="op">):</span> Eff<span class="op">[</span>R<span class="op">,</span> <span class="bu">Int</span><span class="op">]</span></span>
-<span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> foo3<span class="op">[</span>R <span class="op">:</span>_foo <span class="op">:</span>_bar <span class="op">:</span>_baz<span class="op">](</span>i<span class="op">:</span> <span class="bu">Int</span><span class="op">):</span> Eff<span class="op">[</span>R<span class="op">,</span> <span class="bu">Int</span><span class="op">]</span></span></code></pre></div>
+<div class="sourceCode" id="cb4"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> foo1<span class="op">[</span>R <span class="op">:</span>_foo <span class="op">:</span>_bar <span class="op">:</span>_baz<span class="op">](</span>i<span class="op">:</span> <span class="bu">Int</span><span class="op">):</span> Eff<span class="op">[</span>R<span class="op">,</span> <span class="bu">Int</span><span class="op">]</span></span>
+<span id="cb4-2"><a href="#cb4-2" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> foo2<span class="op">[</span>R <span class="op">:</span>_foo <span class="op">:</span>_bar <span class="op">:</span>_baz<span class="op">](</span>i<span class="op">:</span> <span class="bu">Int</span><span class="op">):</span> Eff<span class="op">[</span>R<span class="op">,</span> <span class="bu">Int</span><span class="op">]</span></span>
+<span id="cb4-3"><a href="#cb4-3" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> foo3<span class="op">[</span>R <span class="op">:</span>_foo <span class="op">:</span>_bar <span class="op">:</span>_baz<span class="op">](</span>i<span class="op">:</span> <span class="bu">Int</span><span class="op">):</span> Eff<span class="op">[</span>R<span class="op">,</span> <span class="bu">Int</span><span class="op">]</span></span></code></pre></div>
<p>It is possible to “pack” them with the following
-<code class="prettyprint">_effects</code> type definition:``</p>
+<code class="prettyprint">_effects</code> type definition:</p>
+<pre><code class="prettyprint">import org.atnos.eff.Members.{&:, &&:}
+
+ trait Foo[A]
+ trait Bar[A]
+ trait Baz[A]
+ trait Boo[A]
+
+ type _foo[R] = Foo |= R
+ type _bar[R] = Bar |= R
+ type _baz[R] = Baz |= R
+
+// Note the last &&:, you can write instead: _foo[R] &: _bar[R] &: _baz[R] &: NoMember
+ type _effects[R] = _foo[R] &: _bar[R] &&: _baz[R]
+
+ def getFoo[R: _foo: _bar]: Eff[R, Int] = Eff.pure(1)
+ def getBar[R: _bar]: Eff[R, Int] = Eff.pure(1)
+ def getBaz[R: _baz]: Eff[R, Int] = Eff.pure(1)
+
+ object t {
+
+ import org.atnos.eff.Members.extractMember
+
+ def foo[R: _effects](i: Int): Eff[R, Int] =
+ getFoo[R] >>
+ getBar[R] >>
+ getBaz[R]
+
+ }
+
+// Then call foo with a concrete stack
+ type S = Fx.fx3[Foo, Bar, Baz]
+ type U = Fx.fx4[Foo, Bar, Baz, Boo]
+
+ t.foo[S](1)
+ t.foo[U](1)</code></pre>
<p>The implicit definition <code class="prettyprint">extractMember</code> in the
<code class="prettyprint">Members</code> object will take care of “unpacking” the member
instances where required. Note that this implicit must <em>not</em> be
diff --git a/org.atnos.site.OutOfTheBox.html b/org.atnos.site.OutOfTheBox.html
index de5ad49..ef873df 100644
--- a/org.atnos.site.OutOfTheBox.html
+++ b/org.atnos.site.OutOfTheBox.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -406,7 +412,8 @@ failures</td>
<p><small>(from <code class="prettyprint">org.atnos.eff._</code>)</small></p>
<p>Other modules listed in
<link class="ok"><a href="org.atnos.site.Installation.html" tooltip="" class="ok">Installation</a></link>
-provide additional effects (Scalaz Task, Doobie ConnectionIO,…).</p>
+provide additional effects (Twitter Future, Scalaz Task, Doobie
+ConnectionIO,…).</p>
<p><br/></p>
<h2 id="whats-next">What’s next?</h2>
<p>Now you can learn how to
diff --git a/org.atnos.site.TransformStack.html b/org.atnos.site.TransformStack.html
index 72f70dc..e0e3e03 100644
--- a/org.atnos.site.TransformStack.html
+++ b/org.atnos.site.TransformStack.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -334,15 +340,36 @@ would leave us with the tree:</p>
Fx1[T1],
Fx2[T2, T4]
]</code></pre>
-<p>This code should prove it: ``</p>
+<p>This code should prove it:</p>
+<pre><code class="prettyprint">// for now the following implicit summoning crashes the compiler
+ // val member_ : Member.Aux[T3, FxAppend[Fx1[T1], Fx3[T2, T3, T4]], FxAppend[Fx1[T1], Fx2[T2, T4]]] =
+ // implicitly[Member.Aux[T3, FxAppend[Fx1[T1], Fx3[T2, T3, T4]], FxAppend[Fx1[T1], Fx2[T2, T4]]]]</code></pre>
<p>Unfortunately the compiler has some difficulties with it, so you can
either get the member value by using the implicit definitions “manually”
or you can just summon the member instance without the <code class="prettyprint">Aux</code>
-part: ``</p>
+part:</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+
+// so you need to explicitly define the implicit
+ val member_ : Member.Aux[T3, FxAppend[Fx1[T1], Fx3[T2, T3, T4]], FxAppend[Fx1[T1], Fx2[T2, T4]]] =
+ Member.MemberAppendR(using Member.Member3M)
+
+// but this works
+ val member: Member[T3, FxAppend[Fx1[T1], Fx3[T2, T3, T4]]] =
+ implicitly[Member[T3, FxAppend[Fx1[T1], Fx3[T2, T3, T4]]]]</code></pre>
<p>More importantly the compiler is still able to track the right types
resulting of the interpretation of a given effect so the following
compiles ok:</p>
-<p>``</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+
+ def runT3[R, U, A](e: Eff[R, A])(implicit m: Member.Aux[T3, R, U]): Eff[U, A] = ???
+ def runT2[R, U, A](e: Eff[R, A])(implicit m: Member.Aux[T2, R, U]): Eff[U, A] = ???
+ def runT1[R, U, A](e: Eff[R, A])(implicit m: Member.Aux[T1, R, U]): Eff[U, A] = ???
+ def runT4[R, U, A](e: Eff[R, A])(implicit m: Member.Aux[T4, R, U]): Eff[U, A] = ???
+
+ type S = FxAppend[Fx1[T1], Fx3[T2, T3, T4]]
+
+ runT1(runT4(runT2(runT3(Eff.send[T3, S, Int](???)))))</code></pre>
<h3 id="transform-an-effect-to-another">Transform an effect to
another</h3>
<h4 id="change-the-effect">Change the effect</h4>
@@ -350,8 +377,47 @@ another</h3>
<code class="prettyprint">Reader[S, *]</code> effect to a stack having a
<code class="prettyprint">Reader[B, *]</code> effect where <code class="prettyprint">S</code> is “contained” in
<code class="prettyprint">B</code> (meaning that there is a mapping from <code class="prettyprint">B</code>,
-“big”, to <code class="prettyprint">S</code>, “small”). Here is an
-example:`<code class="prettyprint"></code>> Some(hello world)`</p>
+“big”, to <code class="prettyprint">S</code>, “small”). Here is an example:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._
+ import org.atnos.eff.syntax.all._
+ import cats._
+ import cats.data._
+
+ case class Conf(host: String, port: Int)
+
+ type ReaderPort[A] = Reader[Int, A]
+ type ReaderHost[A] = Reader[String, A]
+ type ReaderConf[A] = Reader[Conf, A]
+
+ type S1 = Fx.fx2[ReaderHost, Option]
+ type S2 = Fx.fx2[ReaderPort, Option]
+ type SS = Fx.fx2[ReaderConf, Option]
+
+ val readHost: Eff[S1, String] = for {
+ c <- ask[S1, String]
+ h <- OptionEffect.some[S1, String]("hello")
+ } yield h
+
+ val readPort: Eff[S2, String] = for {
+ c <- ask[S2, Int]
+ h <- OptionEffect.some[S2, String]("world")
+ } yield h
+
+ val fromHost = new (ReaderHost ~> ReaderConf) {
+ def apply[X](r: ReaderHost[X]) = Reader((c: Conf) => r.run(c.host))
+ }
+
+ val fromPort = new (ReaderPort ~> ReaderConf) {
+ def apply[X](r: ReaderPort[X]) = Reader((c: Conf) => r.run(c.port))
+ }
+
+ val action: Eff[SS, String] = for {
+ s1 <- readHost.transform(fromHost)
+ s2 <- readPort.transform(fromPort)
+ } yield s1 + " " + s2
+
+ action.runReader(Conf("www.me.com", 8080)).runOption.run</code></pre>
+<p><code class="prettyprint">> Some(hello world)</code></p>
<p>There are also specialized versions of <code class="prettyprint">transform</code> for
<code class="prettyprint">Reader</code> and <code class="prettyprint">State</code>:</p>
<ul>
@@ -373,7 +439,53 @@ example) into multiple others (<code class="prettyprint">TimedFuture</code>,
<pre><code class="prettyprint">type S = Fx.fx3[Authenticated, TimedFuture, Either[AuthError, *]]</code></pre>
<p>And you want to write an interpreter which will translate
authentication actions into <code class="prettyprint">TimedFuture</code> and
-<code class="prettyprint">Either</code>:``</p>
+<code class="prettyprint">Either</code>:</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+ import org.atnos.eff.syntax.eff._
+ import org.atnos.eff.future._
+ import org.atnos.eff.interpret._
+ import scala.concurrent.Future
+
+// list of access rights for a valid token
+ case class AccessRights(rights: List[String])
+
+// authentication error
+ case class AuthError(message: String)
+
+// DSL for authenticating users
+ sealed trait Authenticated[A]
+ case class Authenticate(token: String) extends Authenticated[AccessRights]
+ type _authenticate[U] = Authenticated |= U
+
+ type AuthErroEither[A] = Either[AuthError, A]
+ type _error[U] = AuthErroEither |= U
+
+ /**
+ * The order of implicit parameters is really important for type inference!
+ * see below
+ */
+ def runAuth[R, U, A](e: Eff[R, A])(implicit authenticated: Member.Aux[Authenticated, R, U], future: _future[U], either: _error[U]): Eff[U, A] =
+ translate(e)(new Translate[Authenticated, U] {
+ def apply[X](ax: Authenticated[X]): Eff[U, X] =
+ ax match {
+ case Authenticate(token) =>
+ // send the TimedFuture effect in the stack U
+ fromFuture(authenticateImpl(token)).
+ // send the Either value in the stack U
+ collapse
+ }
+ })
+
+// call to a service to authenticate tokens
+ def authenticateImpl(token: String): Future[Either[AuthError, AccessRights]] =
+ Future.successful[Either[AuthError, AccessRights]] { Left(AuthError("token invalid!")) }
+
+ def authenticate[S: _authenticate](token: String) = Authenticate(token).send
+
+ type S1 = Fx.fx3[Authenticated, Either[AuthError, *], TimedFuture]
+ type R1 = Fx.fx2[Either[AuthError, *], TimedFuture]
+
+ val result: Eff[R1, AccessRights] = runAuth(authenticate[S1]("faketoken"))</code></pre>
<p>The call to <code class="prettyprint">send</code> above needs to send an
<code class="prettyprint">TimedFuture</code> value in the stack <code class="prettyprint">U</code>. This is
possible because <code class="prettyprint">TimedFuture</code> is an effect in <code class="prettyprint">U</code>
@@ -394,7 +506,15 @@ like:</p>
<p>And then <code class="prettyprint">authenticated</code> is last in the list of implicits
parameters and can not be used to guide type inference.</p>
<h3 id="interpret-an-effect-locally">Interpret an effect “locally”</h3>
-<p>Let’s say you have a method to run database queries ``</p>
+<p>Let’s say you have a method to run database queries</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+ import org.atnos.eff.all._
+ import cats.data._
+
+ trait Db[A]
+ type _writerString[R] = Writer[String, *] |= R
+
+ def runDb[R, U, A](queries: Eff[R, A])(implicit db: Member.Aux[Db, R, U], eval: _eval[U], writer: _writerString[U]): Eff[U, A] = ???</code></pre>
<p>The database queries (the <code class="prettyprint">Db</code> effect) are being executed
by the <code class="prettyprint">runDb</code> method inside the <code class="prettyprint">Eval</code> effect,
and they use a <code class="prettyprint">WriterString</code> effect to log what is being
@@ -402,9 +522,18 @@ executed.</p>
<p>However you know that some clients of your component don’t care about
the logs and they don’t want to have the <code class="prettyprint">WriterString</code>
effect. that they consider an implementation detail.</p>
-<p>So you’d like to provide this additional method: ``</p>
+<p>So you’d like to provide this additional method:</p>
+<pre><code class="prettyprint"> def executeOnDb[R, U, A](queries: Eff[R, A])(implicit db: Member.Aux[Db, R, U], eval: _eval[U]): Eff[U, A] = ???</code></pre>
<p>How can you implement <code class="prettyprint">executeOnDb</code> with
-<code class="prettyprint">runDb</code>? ``</p>
+<code class="prettyprint">runDb</code>?</p>
+<pre><code class="prettyprint"> import org.atnos.eff.syntax.all._
+
+ def executeOnDb[R, U, A](queries: Eff[R, A])(implicit db: Member.Aux[Db, R, U], eval: _eval[U]): Eff[U, A] = {
+
+ type S = Fx.prepend[WriterString, R]
+ runDb(queries.into[S]).runWriterNoLog[String]
+
+ }</code></pre>
<p>You create a “local” stack containing the <code class="prettyprint">WriterString</code>
effect using the <code class="prettyprint">prepend</code> method. You now run the
<code class="prettyprint">Db</code> effect and discard the logs to finally return only
@@ -433,7 +562,7 @@ href="https://aws.amazon.com/s3">S3</a>.</p>
_ <- tell[Hadoop, String]("Reading from " + path)
} yield c.mappers.toString
- def runHadoopReader[R, U, A](conf: HadoopConf)(e: Eff[R, A])(using Member.Aux[HadoopReader, R, U]): Eff[U, A] =
+ def runHadoopReader[R, U, A](conf: HadoopConf)(e: Eff[R, A])(implicit r: Member.Aux[HadoopReader, R, U]): Eff[U, A] =
ReaderEffect.runReader(conf)(e)
}
@@ -453,16 +582,37 @@ href="https://aws.amazon.com/s3">S3</a>.</p>
_ <- tell[S3, String]("Writing to bucket " + c.bucket + ": " + content)
} yield ()
- def runS3Reader[R, U, A](conf: S3Conf)(e: Eff[R, A])(using Member.Aux[S3Reader, R, U]): Eff[U, A] =
+ def runS3Reader[R, U, A](conf: S3Conf)(e: Eff[R, A])(implicit r: Member.Aux[S3Reader, R, U]): Eff[U, A] =
ReaderEffect.runReader(conf)(e)
}
</code></pre>
<p>So what happens when you want to both use S3 and Hadoop? As you can
see from the definition above those 2 stacks share some common effects,
-so the resulting stack we want to work with is:``</p>
+so the resulting stack we want to work with is:</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+ import cats.Eval
+ import HadoopStack._
+ import S3Stack.{WriterString as _, _}
+
+ type HadoopS3 = Fx.fx4[S3Reader, HadoopReader, WriterString, Eval]</code></pre>
<p>Then we can use the <code class="prettyprint">into</code> method to inject effects from
-each stack into this common stack:`<code class="prettyprint"></code>> ((),List(Reading
-from /tmp/data, Writing to bucket bucket: 10))`</p>
+each stack into this common stack:</p>
+<pre><code class="prettyprint"> import S3Stack._
+ import HadoopStack._
+// this imports the `into` and runXXX syntax
+ import org.atnos.eff.syntax.all._
+
+ val action = for {
+ // read a file from hadoop
+ s <- readFile("/tmp/data").into[HadoopS3]
+
+ // write a file on S3
+ _ <- writeFile("key", s).into[HadoopS3]
+ } yield ()
+
+ // and we can run the composite action
+ action.runReader(S3Conf("bucket")).runReader(HadoopConf(10)).runWriter.runEval.run</code></pre>
+<p><code class="prettyprint">> ((),List(Reading from /tmp/data, Writing to bucket bucket: 10))</code></p>
<p>You can find a fully working example of this approach in
<code class="prettyprint">src/test/org/atnos/example/StacksSpec</code>.</p>
</div>
diff --git a/org.atnos.site.Tutorial.html b/org.atnos.site.Tutorial.html
index f614f1a..db95fec 100644
--- a/org.atnos.site.Tutorial.html
+++ b/org.atnos.site.Tutorial.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -448,7 +454,7 @@ abstract language into concrete values.</p>
* The resulting effect stack is m.Out which is R without the KVStore effects
*
*/
- def runKVStoreUnsafe[R, A](effects: Eff[R, A])(using m: KVStore <= R): Eff[m.Out, A] = {
+ def runKVStoreUnsafe[R, A](effects: Eff[R, A])(implicit m: KVStore <= R): Eff[m.Out, A] = {
// a very simple (and imprecise) key-value store
val kvs = Map.empty[String, Any]
@@ -530,7 +536,7 @@ delegate the results to other effects in the same stack:</p>
*/
def runKVStore[R, U, A](
effects: Eff[R, A]
- )(using m: Member.Aux[KVStore, R, U], throwable: _throwableEither[U], writer: _writerString[U], state: _stateMap[U]): Eff[U, A] = {
+ )(implicit m: Member.Aux[KVStore, R, U], throwable: _throwableEither[U], writer: _writerString[U], state: _stateMap[U]): Eff[U, A] = {
translate(effects)(new Translate[KVStore, U] {
def apply[X](kv: KVStore[X]): Eff[U, X] =
@@ -601,7 +607,12 @@ stack)</li>
<li>call a final <code class="prettyprint">run</code> to get an <code class="prettyprint">A</code> value
<p/></li>
</ul>
-<p>Like this: `<code class="prettyprint"></code>> Some(14)`</p>
+<p>Like this:</p>
+<pre><code class="prettyprint"> import org.atnos.eff._, syntax.all._
+
+// run the program with the unsafe interpreter
+ runKVStoreUnsafe(program[Fx.fx1[KVStore]]).run</code></pre>
+<p><code class="prettyprint">> Some(14)</code></p>
<p>With the safe interpreter, the process is the same and we need to</p>
<ul>
<li>specify an effect stack definition with all the effects</li>
@@ -610,7 +621,17 @@ stack)</li>
<code class="prettyprint">NoFx</code> effect with <code class="prettyprint">run</code>
<p/></li>
</ul>
-<p>Like that: ``</p>
+<p>Like that:</p>
+<pre><code class="prettyprint"> import org.atnos.eff._, syntax.all._
+ import cats._, data._
+
+// run the program with the safe interpreter
+ type Stack = Fx.fx4[KVStore, Either[Throwable, *], State[Map[String, Any], *], Writer[String, *]]
+
+ val (result, logs) =
+ runKVStore(program[Stack]).runEither.evalState(Map.empty[String, Any]).runWriter.run
+
+ (result.toString +: logs).mkString("\n")</code></pre>
<pre><code class="prettyprint">> Right(Some(14))
put(wild-cats, 2)
get(wild-cats)
@@ -620,7 +641,21 @@ get(wild-cats)
delete(tame-cats)</code></pre>
<h3 id="add-some-syntax">Add some syntax</h3>
<p>It is nice to be able to “chain” <code class="prettyprint">run</code> methods with this
-additional piece of syntax: ``</p>
+additional piece of syntax:</p>
+<pre><code class="prettyprint"> implicit class KVStoreOps[R, A](effects: Eff[R, A]) {
+ def runStore[U](implicit
+ m: Member.Aux[KVStore, R, U],
+ throwable: _throwableEither[U],
+ writer: _writerString[U],
+ state: _stateMap[U]
+ ): Eff[U, A] =
+ runKVStore(effects)
+ }
+
+ val (result, logs) =
+ program[Stack].runStore.runEither.evalState(Map.empty[String, Any]).runWriter.run
+
+ (result.toString +: logs).mkString("\n")</code></pre>
<pre><code class="prettyprint">> Right(Some(14))
put(wild-cats, 2)
get(wild-cats)
@@ -685,7 +720,7 @@ instances for those effects:</p>
def readLine(): String =
"snuggles"
- def runInteract[R, A](effect: Eff[R, A])(using m: Interact <= R): Eff[m.Out, A] =
+ def runInteract[R, A](effect: Eff[R, A])(implicit m: Interact <= R): Eff[m.Out, A] =
recurse(effect)(new Recurser[Interact, m.Out, A, A] {
def onPure(a: A): A = a
@@ -708,7 +743,7 @@ instances for those effects:</p>
})(using m)
- def runDataOp[R, A](effect: Eff[R, A])(using m: DataOp <= R): Eff[m.Out, A] = {
+ def runDataOp[R, A](effect: Eff[R, A])(implicit m: DataOp <= R): Eff[m.Out, A] = {
val memDataSet = new scala.collection.mutable.ListBuffer[String]
recurse(effect)(new Recurser[DataOp, m.Out, A, A] {
@@ -731,7 +766,10 @@ instances for those effects:</p>
}
</code></pre>
<p>Now if we run our program for a Stack combining both effects and type
-in “snuggles” when prompted, we see something like this:``</p>
+in “snuggles” when prompted, we see something like this:</p>
+<pre><code class="prettyprint"> type Stack = Fx.fx2[Interact, DataOp]
+
+ runInteract(runDataOp(program[Stack])).run</code></pre>
<pre><code class="prettyprint">What's the kitty's name?
Current cats: snuggles</code></pre>
</div>
diff --git a/org.atnos.site.lib.ChooseEffectPage.html b/org.atnos.site.lib.ChooseEffectPage.html
index 8dcc092..9572848 100644
--- a/org.atnos.site.lib.ChooseEffectPage.html
+++ b/org.atnos.site.lib.ChooseEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -324,8 +330,23 @@ where instead of “exploring” all the branches we might “cut” some of
them. That behaviour is controlled by the <code class="prettyprint">Alternative[F]</code>
instance you use when running <code class="prettyprint">Choose</code>.</p>
<p>For example if we take <code class="prettyprint">List</code> to run a similar example as
-before, we get the list of all the accepted pairs: `<code class="prettyprint"></code>>
-List((2,4), (3,3), (3,4), (4,2), (4,3), (4,4))`</p>
+before, we get the list of all the accepted pairs:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+
+ type S = Fx.fx1[Choose]
+
+// create all the possible pairs for a given list
+// where the sum is greater than a value
+ def pairsBiggerThan[R: _choose](list: List[Int], n: Int): Eff[R, (Int, Int)] = for {
+ a <- chooseFrom(list)
+ b <- chooseFrom(list)
+ found <-
+ if (a + b > n) Monad[Eff[R, *]].pure((a, b))
+ else zero
+ } yield found
+
+ pairsBiggerThan[S](List(1, 2, 3, 4), 5).runChoose[List].run</code></pre>
+<p><code class="prettyprint">> List((2,4), (3,3), (3,4), (4,2), (4,3), (4,4))</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.EitherEffectPage.html b/org.atnos.site.lib.EitherEffectPage.html
index 729fea3..ab55ab8 100644
--- a/org.atnos.site.lib.EitherEffectPage.html
+++ b/org.atnos.site.lib.EitherEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -313,13 +319,47 @@ typeclasses">Know your Membe...</a>
<div id="tipue_search_content"></div>
<p>The <code class="prettyprint">Either</code> effect is similar to the <code class="prettyprint">Option</code>
-effect but adds the possibility to specify why a computation stopped:
-`<code class="prettyprint"></code>> (Right(30),Left(‘missing’ not found))`</p>
+effect but adds the possibility to specify why a computation
+stopped:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+
+ /**
+ * Stack declaration
+ */
+ type S = Fx.fx1[Either[String, *]]
+
+ // compute with this stack
+ val map: Map[String, Int] =
+ Map("key1" -> 10, "key2" -> 20)
+
+ // get 2 keys from the map and add the corresponding values
+ def addKeys(key1: String, key2: String): Eff[S, Int] = for {
+ a <- optionEither(map.get(key1), s"'$key1' not found")
+ b <- optionEither(map.get(key2), s"'$key2' not found")
+ } yield a + b
+
+ (addKeys("key1", "key2").runEither.run, addKeys("key1", "missing").runEither.run)</code></pre>
+<p><code class="prettyprint">> (Right(30),Left('missing' not found))</code></p>
<p><em>Note</em>: the <code class="prettyprint">*</code> syntax comes from the <a
href="https://github.com/typelevel/kind-projector">kind-projector</a>
project and allows us to avoid type lambdas.</p>
<p>A <code class="prettyprint">catchLeft</code> method can also be used to intercept an
-error and possibly recover from it:``</p>
+error and possibly recover from it:</p>
+<pre><code class="prettyprint"> case class TooBig(value: Int)
+ type E = Fx.fx1[Either[TooBig, *]]
+
+ val i = 7
+
+ val value: Eff[E, Int] =
+ if (i > 5) left[E, TooBig, Int](TooBig(i))
+ else right[E, TooBig, Int](i)
+
+ val action: Eff[E, Int] = catchLeft[E, TooBig, Int](value) { case TooBig(k) =>
+ if (k < 10) right[E, TooBig, Int](k)
+ else left[E, TooBig, Int](TooBig(k))
+ }
+
+ action.runEither.run ==== Right(7)</code></pre>
<p><em>Note</em>: the type annotations on <code class="prettyprint">left</code> and
<code class="prettyprint">right</code> can be avoided by adding an implicit declaration in
scope. You can learn more about this in the
diff --git a/org.atnos.site.lib.ErrorEffectPage.html b/org.atnos.site.lib.ErrorEffectPage.html
index d9ad110..b592845 100644
--- a/org.atnos.site.lib.ErrorEffectPage.html
+++ b/org.atnos.site.lib.ErrorEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
diff --git a/org.atnos.site.lib.EvalEffectPage.html b/org.atnos.site.lib.EvalEffectPage.html
index 24fb1f5..1dcad99 100644
--- a/org.atnos.site.lib.EvalEffectPage.html
+++ b/org.atnos.site.lib.EvalEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -323,7 +329,10 @@ computations</p></li>
the computations but also catch any <code class="prettyprint">Throwable</code> that would be
thrown</p></li>
</ul>
-<p>`<code class="prettyprint"></code>> 2`</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+
+ delay(1 + 1).runEval.run</code></pre>
+<p><code class="prettyprint">> 2</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.ListEffectPage.html b/org.atnos.site.lib.ListEffectPage.html
index f634419..33e8f9e 100644
--- a/org.atnos.site.lib.ListEffectPage.html
+++ b/org.atnos.site.lib.ListEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -313,8 +319,23 @@ typeclasses">Know your Membe...</a>
<div id="tipue_search_content"></div>
<p>The <code class="prettyprint">List</code> effect is used for computations which may
-return several values. A simple example using this effect would be
-`<code class="prettyprint"></code>> List((2,4), (3,3), (3,4), (4,2), (4,3), (4,4))`</p>
+return several values. A simple example using this effect would be</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+
+ type S = Fx.fx1[List]
+
+// create all the possible pairs for a given list
+// where the sum is greater than a value
+ def pairsBiggerThan[R: _list](list: List[Int], n: Int): Eff[R, (Int, Int)] = for {
+ a <- values(list*)
+ b <- values(list*)
+ found <-
+ if (a + b > n) singleton((a, b))
+ else empty
+ } yield found
+
+ pairsBiggerThan[S](List(1, 2, 3, 4), 5).runList.run</code></pre>
+<p><code class="prettyprint">> List((2,4), (3,3), (3,4), (4,2), (4,3), (4,4))</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.MemoEffectPage.html b/org.atnos.site.lib.MemoEffectPage.html
index dfb4981..c02eb4f 100644
--- a/org.atnos.site.lib.MemoEffectPage.html
+++ b/org.atnos.site.lib.MemoEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -315,8 +321,26 @@ typeclasses">Know your Membe...</a>
<p>The Memo effect allows the caching of expensive computations.
Computations are “stored” with a given key, so that the next computation
with the same key will return the previously computed value. When
-interpreting those computations a <code class="prettyprint">Cache</code> must be provided:
-`<code class="prettyprint"></code>> there is only one invocation <=> true`</p>
+interpreting those computations a <code class="prettyprint">Cache</code> must be
+provided:</p>
+<pre><code class="prettyprint">import cats.Eval
+ import cats.syntax.all._
+ import org.atnos.eff._, memo._
+ import org.atnos.eff.syntax.memo._
+ import org.atnos.eff.syntax.eval._
+ import org.atnos.eff.syntax.eff._
+
+ type S = Fx.fx2[Memoized, Eval]
+
+ var i = 0
+
+ def expensive[R: _memo]: Eff[R, Int] =
+ memoize("key", { i += 1; 10 * 10 })
+
+ (expensive[S] >> expensive[S]).runMemo(ConcurrentHashMapCache()).runEval.run === 100
+
+ "there is only one invocation" <==> (i === 1)</code></pre>
+<p><code class="prettyprint">> there is only one invocation <=> true</code></p>
<p>There are 2 cache implementations provided in this library to support
the Memo effect:</p>
<ul>
@@ -334,10 +358,10 @@ be garbage collected when necessary.</p></li>
href="https://github.com/ben-manes/caffeine">Caffeine</a> to get more
functionalities like eviction policies, maximum size and so on. You will
need to implement the <code class="prettyprint">Cache</code> interface for this</p>
-<div class="sourceCode" id="cb1"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="kw">trait</span> Cache <span class="op">{</span></span>
-<span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a> <span class="kw">def</span> memo<span class="op">[</span>V<span class="op">](</span>key<span class="op">:</span> <span class="bu">AnyRef</span><span class="op">,</span> value<span class="op">:</span> <span class="op">=></span>V<span class="op">):</span> V</span>
-<span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb2"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a><span class="kw">trait</span> Cache <span class="op">{</span></span>
+<span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a> <span class="kw">def</span> memo<span class="op">[</span>V<span class="op">](</span>key<span class="op">:</span> <span class="bu">AnyRef</span><span class="op">,</span> value<span class="op">:</span> <span class="op">=></span>V<span class="op">):</span> V</span>
+<span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
</div>
<script>
diff --git a/org.atnos.site.lib.OptionEffectPage.html b/org.atnos.site.lib.OptionEffectPage.html
index 989afdc..661c9c8 100644
--- a/org.atnos.site.lib.OptionEffectPage.html
+++ b/org.atnos.site.lib.OptionEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -315,8 +321,26 @@ typeclasses">Know your Membe...</a>
<p>Adding an <code class="prettyprint">Option</code> effect in your stack allows to stop
computations when necessary. If you create a value with
<code class="prettyprint">some(a)</code> this value will be used downstream but if you use
-<code class="prettyprint">none</code> all computations will stop:`<code class="prettyprint"></code>>
-(Some(30),None)`</p>
+<code class="prettyprint">none</code> all computations will stop:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+
+ /**
+ * Stack declaration
+ */
+ type S = Fx.fx1[Option]
+
+// compute with this stack
+ val map: Map[String, Int] =
+ Map("key1" -> 10, "key2" -> 20)
+
+// get 2 keys from the map and add the corresponding values
+ def addKeys(key1: String, key2: String): Eff[S, Int] = for {
+ a <- fromOption(map.get(key1))
+ b <- fromOption(map.get(key2))
+ } yield a + b
+
+ (addKeys("key1", "key2").runOption.run, addKeys("key1", "missing").runOption.run)</code></pre>
+<p><code class="prettyprint">> (Some(30),None)</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.ReaderEffectPage.html b/org.atnos.site.lib.ReaderEffectPage.html
index 7932829..775dcfc 100644
--- a/org.atnos.site.lib.ReaderEffectPage.html
+++ b/org.atnos.site.lib.ReaderEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -318,8 +324,23 @@ environment (or “configuration” if you prefer to see it that way) and
you can run an effect stack containing a <code class="prettyprint">Reader</code> effect by
providing a value for the environment with the <code class="prettyprint">runReader</code>
method.</p>
-<p>You can also inject a “local” reader into a “bigger”
-one:`<code class="prettyprint"></code>> the port is 80`</p>
+<p>You can also inject a “local” reader into a “bigger” one:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+ import cats.data._
+
+ case class Conf(host: String, port: Int)
+
+ type R1[A] = Reader[Int, A]
+ type R2[A] = Reader[Conf, A]
+
+ type S = Fx.fx2[R1, R2]
+
+ def getPort[R](implicit r: Reader[Int, *] |= R): Eff[R, String] = for {
+ p1 <- ask[R, Int]
+ } yield "the port is " + p1
+
+ getPort[S].translateReader((_: Conf).port).runReader(Conf("prod", 80)).run</code></pre>
+<p><code class="prettyprint">> the port is 80</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.SafeEffectPage.html b/org.atnos.site.lib.SafeEffectPage.html
index e7844ae..d4a9017 100644
--- a/org.atnos.site.lib.SafeEffectPage.html
+++ b/org.atnos.site.lib.SafeEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -322,7 +328,31 @@ executed after another one, even if the first one fails</li>
and then close it safely. The <code class="prettyprint">close</code> part is a “finalizer”
<p/></li>
</ul>
-<p>Let’s see an example for the protection of a resource: ``</p>
+<p>Let’s see an example for the protection of a resource:</p>
+<pre><code class="prettyprint">import org.atnos.eff.syntax.all._
+ import org.atnos.eff._, all._
+
+// let's represent a resource which can be in use
+ case class Resource(values: List[Int] = (1 to 10).toList, inUse: Boolean = false) {
+ def isClosed = !inUse
+ }
+
+ var resource = Resource()
+
+// our stack of effects, with safe evaluation
+ type S = Fx.fx1[Safe]
+
+ def openResource: Eff[S, Resource] =
+ protect { resource = resource.copy(inUse = true); resource }
+
+ def closeResource(r: Resource): Eff[S, Unit] =
+ protect { resource = r.copy(inUse = false) }
+
+ def useResource(ok: Boolean) = (r: Resource) => protect[S, Int](if (ok) r.values.sum else throw new Exception("boo"))
+
+// this program uses the resource safely even if there is an exception
+ def program(ok: Boolean): (Either[Throwable, Int], List[Throwable]) =
+ bracket(openResource)(useResource(ok))(closeResource).runSafe.run</code></pre>
<pre><code class="prettyprint">> Results
Without exception: Right(55), finalizers exceptions: no exceptions, resource is closed: true
With exception : Left(boo), finalizers exceptions: no exceptions, resource is closed: true</code></pre>
@@ -335,7 +365,22 @@ which can themselves fail.</p>
<p>A simpler version of <code class="prettyprint">bracket</code> is
<code class="prettyprint">finally</code>.</p>
<p>This example show how to use <code class="prettyprint">finally</code> but also what
-happens if a finalizer fails:``</p>
+happens if a finalizer fails:</p>
+<pre><code class="prettyprint">import org.atnos.eff.syntax.all._
+ import org.atnos.eff._, all._
+
+// our stack of effects, with safe evaluation
+ type S = Fx.fx1[Safe]
+
+ var sumDone: Boolean = false
+
+ def setDone(ok: Boolean): Eff[S, Unit] =
+ protect[S, Unit](if (ok) sumDone = true else throw new Exception("failed!!"))
+
+// this program tries to set sumDone to true when the computation is done
+ def program(ok: Boolean, finalizeOk: Boolean): (Either[Throwable, Int], List[Throwable]) =
+ (protect[S, Int](if (ok) (1 to 10).sum else throw new Exception("boo")) `finally` setDone(finalizeOk)).runSafe.run
+</code></pre>
<pre><code class="prettyprint">> Results
Computation ok, finalizer ok: Right(55), finalizers exceptions: no exceptions
Computation ok, finalizer ko: Right(55), finalizers exceptions: List(failed!!)
diff --git a/org.atnos.site.lib.StateEffectPage.html b/org.atnos.site.lib.StateEffectPage.html
index b735467..174d028 100644
--- a/org.atnos.site.lib.StateEffectPage.html
+++ b/org.atnos.site.lib.StateEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -319,15 +325,61 @@ typeclasses">Know your Membe...</a>
<li><p><code class="prettyprint">put</code> set a new state</p></li>
</ul>
<p>Let’s see an example showing that we can also use tags to track
-different states at the same time:`<code class="prettyprint"></code>> initial:
-(10,hello), final: (5,10)`</p>
+different states at the same time:</p>
+<pre><code class="prettyprint">import cats.data._
+ import org.atnos.eff._, all._, syntax.all._
+
+ type S1[A] = State[Int, A]
+ type S2[A] = State[String, A]
+
+ type S = Fx.fx2[S1, S2]
+
+ val swapVariables: Eff[S, String] = for {
+ v1 <- get[S, Int]
+ v2 <- get[S, String]
+ _ <- put[S, Int](v2.size)
+ _ <- put[S, String](v1.toString)
+ w1 <- get[S, Int]
+ w2 <- get[S, String]
+ } yield "initial: " + (v1, v2).toString + ", final: " + (w1, w2).toString
+
+ swapVariables.evalState(10).evalState("hello").run</code></pre>
+<p><code class="prettyprint">> initial: (10,hello), final: (5,10)</code></p>
<p>In the example above we have used an <code class="prettyprint">eval</code> method to get
the <code class="prettyprint">A</code> in <code class="prettyprint">Eff[R, A]</code> but it is also possible to
get both the value and the state with <code class="prettyprint">run</code> or only the state
with <code class="prettyprint">exec</code>.</p>
<p>Instead of tagging state effects it is also possible to transform a
State effect acting on a “small” state into a State effect acting on a
-“bigger” state:``</p>
+“bigger” state:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+ import cats.data.State
+
+ type Count[A] = State[Int, A]
+ type Sum[A] = State[Int, A]
+ type Mean[A] = State[(Int, Int), A]
+
+ type S1 = Fx.fx1[Count]
+ type S2 = Fx.fx1[Sum]
+ type S = Fx.fx1[Mean]
+
+ def count(list: List[Int]): Eff[S1, String] = for {
+ _ <- put(list.size)
+ } yield s"there are ${list.size} values"
+
+ def sum(list: List[Int]): Eff[S2, String] = {
+ val s = if (list.isEmpty) 0 else list.sum
+ for {
+ _ <- put(s)
+ } yield s"the sum is $s"
+ }
+
+ def mean(list: List[Int]): Eff[S, String] = for {
+ m1 <- count(list).lensState((_: (Int, Int))._1, (s: (Int, Int), i: Int) => (i, s._2))
+ m2 <- sum(list).lensState((_: (Int, Int))._2, (s: (Int, Int), i: Int) => (s._1, i))
+ } yield m1 + "\n" + m2
+
+ mean(List(1, 2, 3)).runState((0, 0)).run</code></pre>
<pre><code class="prettyprint">> (there are 3 values
the sum is 6,(3,6))</code></pre>
</div>
diff --git a/org.atnos.site.lib.TaskEffectPage.html b/org.atnos.site.lib.TaskEffectPage.html
index 0b3ef20..2efc5ec 100644
--- a/org.atnos.site.lib.TaskEffectPage.html
+++ b/org.atnos.site.lib.TaskEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -315,8 +321,40 @@ typeclasses">Know your Membe...</a>
<p>The <code class="prettyprint">Task</code> effect is a thin shim on top of Monix’s
<code class="prettyprint">Task</code>. This effect is not bundled in core Eff and requires
the <code class="prettyprint">eff-monix</code> extension to use.</p>
-<p>Now, let’s create some <code class="prettyprint">Task</code> effects:`<code class="prettyprint"></code>>
-Some(1)`</p>
+<p>Now, let’s create some <code class="prettyprint">Task</code> effects:</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+ import org.atnos.eff.addon.monix.task._
+ import org.atnos.eff.syntax.addon.monix.task._
+
+ import monix.eval.Task
+
+ type R = Fx.fx2[Task, Option]
+
+ val action: Eff[R, Int] =
+ for {
+ // create a value now
+ a <- Eff.pure[R, Int](1)
+
+ // evaluate a value later, on the thread pool specified by a Monix `Scheduler`, and continue when it's finished
+ b <- taskDelay[R, Int](1)
+ } yield b
+
+</code></pre>
+<p>Then we need to pass a Monix <code class="prettyprint">Scheduler</code> in to begin the
+computation.</p>
+<pre><code class="prettyprint">
+ implicit val scheduler: monix.execution.Scheduler =
+ monix.execution.Scheduler(ExecutionContext.fromExecutorService(Executors.newScheduledThreadPool(10)): ExecutionContext)
+
+</code></pre>
+<p>Monix doesn’t natively offer an Await API to block on a Task result.
+Instead it advises converting to a Scala <code class="prettyprint">Future</code> and using
+<code class="prettyprint">Await.result</code>. See
+https://monix.io/docs/3x/eval/task.html#blocking-for-a-result</p>
+<pre><code class="prettyprint"> import scala.concurrent.Await
+
+ Await.result(action.runOption.runAsync.runToFuture, 1.second)</code></pre>
+<p><code class="prettyprint">> Some(1)</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.TimedFutureEffectPage.html b/org.atnos.site.lib.TimedFutureEffectPage.html
index 51ec883..846c2a9 100644
--- a/org.atnos.site.lib.TimedFutureEffectPage.html
+++ b/org.atnos.site.lib.TimedFutureEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -321,17 +327,48 @@ timeouts, which are supported by passing in a
<code class="prettyprint">Future</code>. This means if you start a computation before
passing the <code class="prettyprint">Future</code> into Eff, the <code class="prettyprint">Future</code> will
begin less predictably.</p>
-<p>Now, let’s create some <code class="prettyprint">TimedFuture</code>
-effects:`<code class="prettyprint"></code>> Some(1)`</p>
+<p>Now, let’s create some <code class="prettyprint">TimedFuture</code> effects:</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+ import org.atnos.eff.future._
+ import org.atnos.eff.syntax.all._
+ import org.atnos.eff.concurrent.Scheduler
+
+ import scala.concurrent._, duration._
+ import scala.concurrent.ExecutionContext.Implicits.global
+
+ type R = Fx.fx2[TimedFuture, Option]
+
+ val action: Eff[R, Int] =
+ for {
+ // create a value now
+ a <- Eff.pure[R, Int](1)
+
+ // evaluate a value later, on some other thread pool, and continue when it's finished
+ b <- futureDelay[R, Int](1)
+ } yield b
+
+</code></pre>
+<p>Then we need to pass a <code class="prettyprint">Scheduler</code> and an
+<code class="prettyprint">ExecutionContext</code> in to begin the computation.</p>
+<pre><code class="prettyprint">
+ implicit val scheduler: Scheduler = ExecutorServices.schedulerFromGlobalExecutionContext
+ import org.atnos.eff.syntax.future._
+
+ Await.result(action.runOption.runSequential, 1.second)</code></pre>
+<p><code class="prettyprint">> Some(1)</code></p>
<p>You can also use other <code class="prettyprint">Future</code> or <code class="prettyprint">Task</code>
effects:</p>
<ul>
+<li><code class="prettyprint">twitter</code>: depend on <code class="prettyprint">eff-twitter</code> and import
+<code class="prettyprint">org.atnos.eff.addon.twitter.future._</code></li>
<li><code class="prettyprint">monix</code>: depend on <code class="prettyprint">eff-monix</code> and import
<code class="prettyprint">org.atnos.eff.addon.monix.task._</code></li>
</ul>
<p>There are corresponding syntax imports to be able to call
<code class="prettyprint">runAsync</code> methods in:</p>
<ul>
+<li><code class="prettyprint">twitter</code>:
+<code class="prettyprint">org.atnos.eff.syntax.addon.twitter.future._</code></li>
<li><code class="prettyprint">monix</code>:
<code class="prettyprint">org.atnos.eff.syntax.addon.monix.task._</code></li>
</ul>
@@ -345,7 +382,30 @@ cache</li>
<code class="prettyprint">Memoized</code> effect (you will need to provide the cache later)
<p/></li>
</ul>
-<p>`<code class="prettyprint"></code>> there is only one invocation <=> true`</p>
+<pre><code class="prettyprint">import cats.syntax.all._
+ import org.atnos.eff._, future._, all._
+ import org.atnos.eff.concurrent.Scheduler
+ import org.atnos.eff.syntax.all._
+ import org.atnos.eff.syntax.future._
+ import scala.concurrent._, duration._
+ import scala.concurrent.ExecutionContext.Implicits.global
+
+ var i = 0
+
+ def expensive[R: _Future: _memo]: Eff[R, Int] =
+ futureMemoized[R, Int]("key", futureDelay[R, Int] { i += 1; 10 * 10 })
+
+ type S = Fx.fx2[Memoized, TimedFuture]
+
+ implicit val scheduler: Scheduler = ExecutorServices.schedulerFromGlobalExecutionContext
+
+ val futureMemo: Future[Int] =
+ (expensive[S] >> expensive[S]).runFutureMemo(ConcurrentHashMapCache()).runSequential
+
+ Await.result(futureMemo, 1.second)
+
+ "there is only one invocation" <==> (i === 1)</code></pre>
+<p><code class="prettyprint">> there is only one invocation <=> true</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.ValidateEffectPage.html b/org.atnos.site.lib.ValidateEffectPage.html
index 3f2b46b..12487da 100644
--- a/org.atnos.site.lib.ValidateEffectPage.html
+++ b/org.atnos.site.lib.ValidateEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -313,9 +319,25 @@ typeclasses">Know your Membe...</a>
<div id="tipue_search_content"></div>
<p>The <code class="prettyprint">Validate</code> effect is similar to the
-<code class="prettyprint">Either</code> effect but let you accumulate failures:
-`<code class="prettyprint"></code>> Left(NonEmptyList(-3 is not positive, -2 is not
-positive))`</p>
+<code class="prettyprint">Either</code> effect but let you accumulate failures:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+
+ /**
+ * Stack declaration
+ */
+ type S = Fx.fx1[Validate[String, *]]
+
+ def checkPositiveInt(i: Int): Eff[S, Unit] =
+ validateCheck(i >= 0, s"$i is not positive")
+
+ def checkPositiveInts(a: Int, b: Int, c: Int): Eff[S, (Int, Int, Int)] = for {
+ _ <- checkPositiveInt(a)
+ _ <- checkPositiveInt(b)
+ _ <- checkPositiveInt(c)
+ } yield (a, b, c)
+
+ checkPositiveInts(1, -3, -2).runNel.run</code></pre>
+<p><code class="prettyprint">> Left(NonEmptyList(-3 is not positive, -2 is not positive))</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.WriterEffectPage.html b/org.atnos.site.lib.WriterEffectPage.html
index 4f89ef7..60c2d64 100644
--- a/org.atnos.site.lib.WriterEffectPage.html
+++ b/org.atnos.site.lib.WriterEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -313,8 +319,36 @@ typeclasses">Know your Membe...</a>
<div id="tipue_search_content"></div>
<p>You can then define your own custom <code class="prettyprint">Fold</code> to log the
-values to a file:`<code class="prettyprint"></code>> List(second value 2, first value
-1)`</p>
+values to a file:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+ import cats.data.Writer
+ import java.io.PrintWriter
+ import scala.io
+
+ type S = Fx.fx1[Writer[String, *]]
+
+ val action: Eff[S, Int] = for {
+ a <- pure[S, Int](1)
+ _ <- tell("first value " + a)
+ b <- pure[S, Int](2)
+ _ <- tell("second value " + b)
+
+ } yield a + b
+
+// define a fold to output values
+ def fileFold(path: String) = new RightFold[String, Unit] {
+ type S = PrintWriter
+ val init: S = new PrintWriter(path)
+
+ def fold(a: String, s: S): S = { s.println(a); s }
+
+ def finalize(s: S): Unit =
+ s.close
+ }
+
+ action.runWriterFold(fileFold("target/log")).run
+ io.Source.fromFile("target/log").getLines().toList</code></pre>
+<p><code class="prettyprint">> List(second value 2, first value 1)</code></p>
</div>
<script>
|
Bumps [coursier/cache-action](https://github.com/coursier/cache-action) from 8.0.0 to 8.0.1. - [Release notes](https://github.com/coursier/cache-action/releases) - [Commits](coursier/cache-action@c5ca793...e47d7d3) --- updated-dependencies: - dependency-name: coursier/cache-action dependency-version: 8.0.1 dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com>
dependabot
bot
force-pushed
the
dependabot/github_actions/7.x/coursier/cache-action-8.0.1
branch
from
cba45a1 to
02cf8a8
Compare
diff --git a/index.html b/index.html
index 8e7071a..94e59f2 100644
--- a/index.html
+++ b/index.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
diff --git a/org.atnos.site.ApplicativeEvaluation.html b/org.atnos.site.ApplicativeEvaluation.html
index 2aa8697..deaeeef 100644
--- a/org.atnos.site.ApplicativeEvaluation.html
+++ b/org.atnos.site.ApplicativeEvaluation.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -316,13 +322,133 @@ typeclasses">Know your Membe...</a>
<p>The default interpretation of <code class="prettyprint">Eff</code> values is “monadic”
meaning that effectful values are being evaluated in order. This becomes
clear when traversing a list of values with the
-<code class="prettyprint">FutureEffect</code>:`<code class="prettyprint"></code>> List(1000, 500, 50)`</p>
+<code class="prettyprint">FutureEffect</code>:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, future._, syntax.all._
+ import cats.Eval
+ import cats.data.Writer
+ import cats.syntax.traverse._
+ import scala.concurrent._, duration._, ExecutionContext.Implicits.global
+ import org.atnos.eff.concurrent.Scheduler
+ import org.atnos.eff.syntax.future._
+
+ type WriterString[A] = Writer[String, A]
+ type _writerString[R] = WriterString |= R
+
+ type S = Fx.fx3[Eval, TimedFuture, WriterString]
+
+ implicit val scheduler: Scheduler = ExecutorServices.schedulerFromGlobalExecutionContext
+
+ def execute[E: _eval: _writerString: _future](i: Int): Eff[E, Int] =
+ for {
+ i1 <- delay(i)
+ i2 <- futureDelay(i1)
+ _ <- tell(i2.toString)
+ } yield i2
+
+ val action: Eff[S, List[Int]] =
+ List(1000, 500, 50).traverse(execute[S])
+
+ Await.result(action.runEval.runWriterLog.runSequential, 2.seconds)</code></pre>
+<p><code class="prettyprint">> List(1000, 500, 50)</code></p>
<p>We can however run all those computations concurrently using the
-applicative execution for <code class="prettyprint">Eff</code>:`<code class="prettyprint"></code>> List(1000,
-500, 50)`</p>
+applicative execution for <code class="prettyprint">Eff</code>:</p>
+<pre><code class="prettyprint"> val action: Eff[S, List[Int]] =
+ List(1000, 500, 50).traverseA(execute[S])
+
+ Await.result(
+ Eff
+ .detachA(action.runEval.runWriterLog[String])(using TimedFuture.MonadTimedFuture, TimedFuture.ApplicativeTimedFuture)
+ .runNow(scheduler, global),
+ 2.seconds
+ )</code></pre>
+<p><code class="prettyprint">> List(1000, 500, 50)</code></p>
<p>This uses now <code class="prettyprint">traverseA</code> (instead of
<code class="prettyprint">traverse</code>) to do an applicative traversal and execute
futures concurrently and the fastest actions finish first.</p>
+<h3 id="batching">Batching</h3>
+<p>Another advantage of applicative effects is that we can intercept
+them individual requests and “batch” them into one single request. For
+example:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+
+// An effect to get users from a database
+// calls can be individual or batched
+ case class User(i: Int)
+ sealed trait UserDsl[+A]
+
+ case class GetUser(i: Int) extends UserDsl[User]
+ case class GetUsers(is: List[Int]) extends UserDsl[List[User]]
+ type _userDsl[R] = UserDsl /= R
+
+ def getUser[R: _userDsl](i: Int): Eff[R, User] =
+ send[UserDsl, R, User](GetUser(i))
+
+</code></pre>
+<p>Let’s create an interpreter for this DSL:</p>
+<pre><code class="prettyprint">// the real method calls to a webservice
+ def getWebUser(i: Int): User = User(i)
+ def getWebUsers(is: List[Int]): List[User] = is.map(i => User(i))
+
+// the interpreter simply calls the webservice
+// and return a trace of the executed call
+ def runDsl[A](eff: Eff[Fx1[UserDsl], A]): (A, Vector[String]) = {
+ @tailrec
+ def go(e: Eff[Fx1[UserDsl], A], trace: Vector[String]): (A, Vector[String]) =
+ e match {
+ case Pure(a, _) =>
+ (a, trace)
+ case Impure(UnionTagged(GetUser(i), _), c, _) =>
+ go(c.asInstanceOf[User => Eff[Fx1[UserDsl], A]].apply(getWebUser(i)), trace :+ "getWebUser")
+ case Impure(UnionTagged(GetUsers(is), _), c, _) =>
+ go(c.asInstanceOf[List[User] => Eff[Fx1[UserDsl], A]].apply(getWebUsers(is)), trace :+ "getWebUsers")
+ case ap @ ImpureAp(_, _, _) =>
+ go(ap.toMonadic, trace)
+ case Impure(_, _, _) =>
+ sys.error("this should not happen with just one effect")
+ }
+ go(eff, Vector())
+ }
+
+</code></pre>
+<p>We can also optimise a <code class="prettyprint">UserDsl</code> program by providing a
+<code class="prettyprint">Batchable</code> instance describing how to “batch” 2 calls into
+1:</p>
+<pre><code class="prettyprint"> implicit def BatchableUserDsl: Batchable[UserDsl] = new Batchable[UserDsl] {
+ type Z = List[User]
+ type E = User
+
+ def distribute(z: List[User]) = z
+
+ def batch[X, Y](tx: UserDsl[X], ty: UserDsl[Y]): Option[UserDsl[Z]] = Option {
+ (tx, ty) match {
+ case (GetUser(i), GetUser(j)) => GetUsers(List(i, j))
+ case (GetUser(i), GetUsers(is)) => GetUsers(i :: is)
+ case (GetUsers(is), GetUser(i)) => GetUsers(is :+ i)
+ case (GetUsers(is), GetUsers(js)) => GetUsers(is ++ js)
+ }
+ }
+ }
+
+</code></pre>
+<p>Now let’s create a program using the <code class="prettyprint">User</code> DSL with
+applicative calls which can be optimised:</p>
+<pre><code class="prettyprint"> def program[R: _userDsl]: Eff[R, List[User]] =
+ Eff.traverseA(List(1, 2, 3))(i => getUser(i))
+
+</code></pre>
+<p>And its optimised version:</p>
+<pre><code class="prettyprint"> def optimised[R: _userDsl]: Eff[R, List[User]] =
+ program.batch
+
+</code></pre>
+<p>Running the optimised and non-optimised version of the program must
+yield the same results:</p>
+<pre><code class="prettyprint"> show(runDsl(program[Fx1[UserDsl]]), runDsl(optimised[Fx1[UserDsl]]))</code></pre>
+<pre><code class="prettyprint">original: User(1), User(2), User(3)
+ trace: getWebUser, getWebUser, getWebUser
+
+optimised: User(1), User(2), User(3)
+ trace: getWebUsers</code></pre>
</div>
<script>
diff --git a/org.atnos.site.CommunityResources.html b/org.atnos.site.CommunityResources.html
index 9de96c9..cc134af 100644
--- a/org.atnos.site.CommunityResources.html
+++ b/org.atnos.site.CommunityResources.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
diff --git a/org.atnos.site.Cookbook.html b/org.atnos.site.Cookbook.html
index 651c8a8..389bed1 100644
--- a/org.atnos.site.Cookbook.html
+++ b/org.atnos.site.Cookbook.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -330,8 +336,64 @@ additional effects, like state, within one part.</p>
<li><p><code class="prettyprint">runState</code> is called within
<code class="prettyprint">incrementNTimes</code> to finally interpret that effect</p></li>
</ul>
-<p>`<code class="prettyprint"></code>> Right((6,List(counter == 4, counter == 5, counter
-== 6)))`</p>
+<pre><code class="prettyprint">import cats._, data._
+ import cats.syntax.all._
+ import org.atnos.eff._
+ import org.atnos.eff.all._
+ import org.atnos.eff.syntax.all._
+
+// Some type definitions for the effects we will use
+ type EitherString[A] = Either[String, A]
+ type WriterString[A] = Writer[String, A]
+ type StateInt[A] = State[Int, A]
+
+ type _err[R] = EitherString |= R
+ type _log[R] = WriterString |= R
+ type _count[R] = StateInt |= R
+
+ /**
+ * In module 1, some utility methods
+ */
+
+// repeat a side-effect n times
+ def repeatM[M[_]: Monad](n: Int, computation: M[Unit]): M[Unit] =
+ if (n <= 0) computation
+ else computation >> repeatM(n - 1, computation)
+
+// check a condition and abort computations with a message if the condition is false
+ def assert[R: _err](condition: Boolean, msg: String): Eff[R, Unit] =
+ if (!condition) left(msg) else right(())
+
+// increment a counter and log the new value
+ def incrementCounter[R: _log: _count]: Eff[R, Unit] = for {
+ c <- get
+ c2 = c + 1
+ _ <- tell(s"counter == $c2")
+ _ <- put(c2)
+ } yield ()
+
+ /**
+ * In module 2 your "business" logic
+ */
+
+// increment a value n times (n need to be positive)
+ def incrementNTimes[R: _err: _log](start: Int, times: Int): Eff[R, Int] = for {
+ // this call uses the stack R
+ _ <- assert(times >= 0, s"$times is negative")
+
+ // the call uses the stack R plus an additional StateInt effect which is interpreted right away.
+ // The other effects remain
+ result <- repeatM(times, incrementCounter[Fx.prepend[StateInt, R]]).execState(start)
+ } yield result
+
+ /**
+ * A top-level call
+ */
+
+ type Stack = Fx.fx2[EitherString, WriterString]
+
+ incrementNTimes[Stack](3, 2).runWriter.runEither.run</code></pre>
+<p><code class="prettyprint">> Right((6,List(counter == 4, counter == 5, counter == 6)))</code></p>
</div>
<script>
diff --git a/org.atnos.site.CreateEffects.html b/org.atnos.site.CreateEffects.html
index 8f4f075..fc020d3 100644
--- a/org.atnos.site.CreateEffects.html
+++ b/org.atnos.site.CreateEffects.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -342,7 +348,7 @@ an Effect for a new “optional” type.</p>
def nothing[R: _maybe, A]: Eff[R, A] =
send[Maybe, R, A](Nothing())
- def runMaybe[R, U, A](effect: Eff[R, A])(using m: Member.Aux[Maybe, R, U]): Eff[U, Option[A]] =
+ def runMaybe[R, U, A](effect: Eff[R, A])(implicit m: Member.Aux[Maybe, R, U]): Eff[U, Option[A]] =
recurse(effect)(new Recurser[Maybe, U, A, Option[A]] {
def onPure(a: A): Option[A] = Some(a)
@@ -356,7 +362,7 @@ an Effect for a new “optional” type.</p>
Right(ms.sequence)
})
- given Applicative[Maybe] = new Applicative[Maybe] {
+ implicit val applicativeMaybe: Applicative[Maybe] = new Applicative[Maybe] {
def pure[A](a: A): Maybe[A] = Just(a)
def ap[A, B](ff: Maybe[A => B])(fa: Maybe[A]): Maybe[B] =
@@ -380,7 +386,15 @@ values</p></li>
<h3 id="compiler-limitation">Compiler limitation</h3>
<p>When you create an effect you can define a sealed trait and case
classes to represent different possibilities for that effect. For
-example for interacting with a database you might create: ``</p>
+example for interacting with a database you might create:</p>
+<pre><code class="prettyprint">trait DatabaseEffect {
+
+ case class Record(fields: List[String])
+
+ sealed trait Db[A]
+ case class Get[A](id: Int) extends Db[Record]
+ case class Update[A](id: Int, record: Record) extends Db[Record]
+ }</code></pre>
<p>It is recommended to create the <code class="prettyprint">Db</code> types
<strong>outside</strong> of the <code class="prettyprint">DatabaseEffect</code> trait.
Indeed, during <code class="prettyprint">Member</code> implicit resolution, depending on how
@@ -408,8 +422,19 @@ and its removal from <code class="prettyprint">R</code> should be the effect sta
<code class="prettyprint">U</code></li>
</ul>
<p><br/></p>
-<p>Then we can use this effect in a computation:`<code class="prettyprint"></code>>
-Some(5)`</p>
+<p>Then we can use this effect in a computation:</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+ import org.atnos.eff.eff._
+ import MaybeEffect._
+
+ val action: Eff[Fx.fx1[Maybe], Int] =
+ for {
+ a <- just(2)
+ b <- just(3)
+ } yield a + b
+
+ run(runMaybe(action))</code></pre>
+<p><code class="prettyprint">> Some(5)</code></p>
<hr />
</div>
diff --git a/org.atnos.site.Installation.html b/org.atnos.site.Installation.html
index 3658127..39aab6a 100644
--- a/org.atnos.site.Installation.html
+++ b/org.atnos.site.Installation.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -314,14 +320,35 @@ typeclasses">Know your Membe...</a>
<p>You add <code class="prettyprint">eff</code> as an sbt dependency:</p>
<div class="sourceCode" id="cb1"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a>libraryDependencies <span class="op">+=</span> <span class="st">"org.atnos"</span> <span class="op">%%</span> <span class="st">"eff"</span> <span class="op">%</span> <span class="st">"8.0.0"</span></span>
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a>libraryDependencies <span class="op">+=</span> <span class="st">"org.atnos"</span> <span class="op">%%</span> <span class="st">"eff"</span> <span class="op">%</span> <span class="st">"7.0.6"</span></span>
<span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a><span class="co">// to write types like Reader[String, *]</span></span>
-<span id="cb1-4"><a href="#cb1-4" aria-hidden="true" tabindex="-1"></a><span class="co">// for Scala 3.3.x</span></span>
-<span id="cb1-5"><a href="#cb1-5" aria-hidden="true" tabindex="-1"></a>scalacOptions <span class="op">+=</span> <span class="st">"-Ykind-projector"</span></span>
-<span id="cb1-6"><a href="#cb1-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb1-7"><a href="#cb1-7" aria-hidden="true" tabindex="-1"></a><span class="co">// for latest Scala 3</span></span>
-<span id="cb1-8"><a href="#cb1-8" aria-hidden="true" tabindex="-1"></a>scalacOptions <span class="op">+=</span> <span class="st">"-Xkind-projector"</span></span></code></pre></div>
+<span id="cb1-4"><a href="#cb1-4" aria-hidden="true" tabindex="-1"></a>libraryDependencies <span class="op">++=</span> <span class="op">{</span></span>
+<span id="cb1-5"><a href="#cb1-5" aria-hidden="true" tabindex="-1"></a> <span class="cf">if</span> <span class="op">(</span>scalaBinaryVersion<span class="op">.</span>value <span class="op">==</span> <span class="st">"3"</span><span class="op">)</span> <span class="op">{</span></span>
+<span id="cb1-6"><a href="#cb1-6" aria-hidden="true" tabindex="-1"></a> Nil</span>
+<span id="cb1-7"><a href="#cb1-7" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span> <span class="cf">else</span> <span class="op">{</span></span>
+<span id="cb1-8"><a href="#cb1-8" aria-hidden="true" tabindex="-1"></a> <span class="bu">Seq</span><span class="op">(</span><span class="fu">compilerPlugin</span><span class="op">(</span><span class="st">"org.typelevel"</span> <span class="op">%%</span> <span class="st">"kind-projector"</span> <span class="op">%</span> <span class="st">"0.13.3"</span> cross CrossVersion<span class="op">.</span>full<span class="op">))</span></span>
+<span id="cb1-9"><a href="#cb1-9" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span></span>
+<span id="cb1-10"><a href="#cb1-10" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span>
+<span id="cb1-11"><a href="#cb1-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb1-12"><a href="#cb1-12" aria-hidden="true" tabindex="-1"></a>scalacOptions <span class="op">++=</span> <span class="op">{</span></span>
+<span id="cb1-13"><a href="#cb1-13" aria-hidden="true" tabindex="-1"></a> <span class="cf">if</span> <span class="op">(</span>scalaBinaryVersion<span class="op">.</span>value <span class="op">==</span> <span class="st">"3"</span><span class="op">)</span> <span class="op">{</span></span>
+<span id="cb1-14"><a href="#cb1-14" aria-hidden="true" tabindex="-1"></a> <span class="bu">Seq</span><span class="op">(</span><span class="st">"-Ykind-projector"</span><span class="op">)</span></span>
+<span id="cb1-15"><a href="#cb1-15" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span> <span class="cf">else</span> <span class="op">{</span></span>
+<span id="cb1-16"><a href="#cb1-16" aria-hidden="true" tabindex="-1"></a> Nil</span>
+<span id="cb1-17"><a href="#cb1-17" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span></span>
+<span id="cb1-18"><a href="#cb1-18" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
+<p>To get types like <code class="prettyprint">Reader[String, *]</code> (with more than one
+type parameter) correctly inferred, you’ll have to use the following
+compiler option</p>
+<div class="sourceCode" id="cb2"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a>scalacOptions <span class="op">++=</span> <span class="op">{</span></span>
+<span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a> <span class="cf">if</span> <span class="op">(</span>scalaBinaryVersion<span class="op">.</span>value <span class="op">==</span> <span class="st">"2.12"</span><span class="op">)</span> <span class="op">{</span></span>
+<span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a> <span class="bu">Seq</span><span class="op">(</span><span class="st">"-Ypartial-unification"</span><span class="op">)</span></span>
+<span id="cb2-4"><a href="#cb2-4" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span> <span class="cf">else</span> <span class="op">{</span></span>
+<span id="cb2-5"><a href="#cb2-5" aria-hidden="true" tabindex="-1"></a> Nil</span>
+<span id="cb2-6"><a href="#cb2-6" aria-hidden="true" tabindex="-1"></a> <span class="op">}</span></span>
+<span id="cb2-7"><a href="#cb2-7" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
<h5 id="additional-dependencies">Additional dependencies</h5>
<p>This table lists the other available eff modules:</p>
<table>
@@ -353,6 +380,10 @@ functional programming. This gives you a <code class="prettyprint">Scalaz</code>
<td>to use cats’s <code class="prettyprint">IO</code> effect</td>
</tr>
<tr>
+<td><code class="prettyprint">eff-twitter</code></td>
+<td>to use Twitter’s <code class="prettyprint">Future</code> effect</td>
+</tr>
+<tr>
<td><code class="prettyprint">eff-doobie</code></td>
<td>to use Doobie’s <code class="prettyprint">ConnectionIO</code> effect</td>
</tr>
@@ -364,8 +395,8 @@ functional programming. This gives you a <code class="prettyprint">Scalaz</code>
<p>The main <code class="prettyprint">eff</code> types: <code class="prettyprint">Eff</code>,
<code class="prettyprint">Member</code>, <code class="prettyprint">Fx</code> are accessible in the
<code class="prettyprint">org.atnos.eff</code> package:</p>
-<div class="sourceCode" id="cb2"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>_</span></code></pre></div>
+<div class="sourceCode" id="cb3"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>_</span></code></pre></div>
<p>Many other effects are also available
<link class="ok"><a href="org.atnos.site.OutOfTheBox.html" tooltip="" class="ok">Out
of the box</a></link>.</p>
@@ -373,11 +404,11 @@ of the box</a></link>.</p>
<p>The functions used to create effects are grouped under different
objects named after the effect type. For example if you want to create
the <code class="prettyprint">Eval</code> effect you need to import:</p>
-<div class="sourceCode" id="cb3"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>eval<span class="op">.</span>_</span></code></pre></div>
-<p>You can also import most of the effects at once with:</p>
<div class="sourceCode" id="cb4"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>all<span class="op">.</span>_</span></code></pre></div>
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>eval<span class="op">.</span>_</span></code></pre></div>
+<p>You can also import most of the effects at once with:</p>
+<div class="sourceCode" id="cb5"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>all<span class="op">.</span>_</span></code></pre></div>
<p>The only effects not included in the previous import are:</p>
<ul>
<li><p>the <code class="prettyprint">Error</code> effect. This effect requires a type
@@ -392,17 +423,17 @@ monix’s <code class="prettyprint">TaskEffect</code> and the import could clash
<p>Interpreting effects usually requires some syntax to “run” a given
effect. For example to “run” the <code class="prettyprint">Option</code> effect you will
import:</p>
-<div class="sourceCode" id="cb5"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="co">// to create the effect</span></span>
-<span id="cb5-2"><a href="#cb5-2" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>option<span class="op">.</span>_</span>
-<span id="cb5-3"><a href="#cb5-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-4"><a href="#cb5-4" aria-hidden="true" tabindex="-1"></a><span class="co">// to access the runOption method</span></span>
-<span id="cb5-5"><a href="#cb5-5" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>syntax<span class="op">.</span>option<span class="op">.</span>_</span>
-<span id="cb5-6"><a href="#cb5-6" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb5-7"><a href="#cb5-7" aria-hidden="true" tabindex="-1"></a><span class="fu">fromOption</span><span class="op">(</span><span class="ex">Option</span><span class="op">(</span><span class="dv">1</span><span class="op">)).</span>runOption</span></code></pre></div>
-<p>You can also access all the syntax imports at once with:</p>
<div class="sourceCode" id="cb6"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>syntax<span class="op">.</span>all<span class="op">.</span>given</span></code></pre></div>
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a><span class="co">// to create the effect</span></span>
+<span id="cb6-2"><a href="#cb6-2" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>option<span class="op">.</span>_</span>
+<span id="cb6-3"><a href="#cb6-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-4"><a href="#cb6-4" aria-hidden="true" tabindex="-1"></a><span class="co">// to access the runOption method</span></span>
+<span id="cb6-5"><a href="#cb6-5" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>syntax<span class="op">.</span>option<span class="op">.</span>_</span>
+<span id="cb6-6"><a href="#cb6-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb6-7"><a href="#cb6-7" aria-hidden="true" tabindex="-1"></a><span class="fu">fromOption</span><span class="op">(</span><span class="ex">Option</span><span class="op">(</span><span class="dv">1</span><span class="op">)).</span>runOption</span></code></pre></div>
+<p>You can also access all the syntax imports at once with:</p>
+<div class="sourceCode" id="cb7"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>syntax<span class="op">.</span>all<span class="op">.</span>_</span></code></pre></div>
<h4 id="intellij-support">Intellij support</h4>
<p>Intellij error highlighting doesn’t support implicit-directed type
inference yet, check https://youtrack.jetbrains.com/issue/SCL-11140 or
@@ -411,23 +442,23 @@ https://youtrack.jetbrains.com/issue/SCL-10753 for progress.</p>
<p>If you use Scalaz as your functional programming library you might
need additional imports in order to use some creation methods specific
to Scalaz. For example:</p>
-<div class="sourceCode" id="cb7"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>either<span class="op">.</span>_</span>
-<span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb7-3"><a href="#cb7-3" aria-hidden="true" tabindex="-1"></a><span class="fu">fromDisjunction</span><span class="op">(</span>\<span class="op">/-(</span><span class="dv">1</span><span class="op">))</span></span></code></pre></div>
-<p>There is also an <code class="prettyprint">all</code> object importing all those methods
-at once:</p>
<div class="sourceCode" id="cb8"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>all<span class="op">.</span>_</span>
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>either<span class="op">.</span>_</span>
<span id="cb8-2"><a href="#cb8-2" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb8-3"><a href="#cb8-3" aria-hidden="true" tabindex="-1"></a><span class="fu">fromDisjunction</span><span class="op">(</span>\<span class="op">/-(</span><span class="dv">1</span><span class="op">))</span></span></code></pre></div>
+<p>There is also an <code class="prettyprint">all</code> object importing all those methods
+at once:</p>
+<div class="sourceCode" id="cb9"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>all<span class="op">.</span>_</span>
+<span id="cb9-2"><a href="#cb9-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb9-3"><a href="#cb9-3" aria-hidden="true" tabindex="-1"></a><span class="fu">fromDisjunction</span><span class="op">(</span>\<span class="op">/-(</span><span class="dv">1</span><span class="op">))</span></span></code></pre></div>
<p>And you can already guess, there are some syntax imports following
the same pattern:</p>
-<div class="sourceCode" id="cb9"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>either<span class="op">.</span>_</span>
-<span id="cb9-2"><a href="#cb9-2" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>syntax<span class="op">.</span>either<span class="op">.</span>_</span>
-<span id="cb9-3"><a href="#cb9-3" aria-hidden="true" tabindex="-1"></a></span>
-<span id="cb9-4"><a href="#cb9-4" aria-hidden="true" tabindex="-1"></a><span class="fu">fromDisjunction</span><span class="op">(</span>\<span class="op">/-(</span><span class="dv">1</span><span class="op">)).</span>runDisjunction</span></code></pre></div>
+<div class="sourceCode" id="cb10"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>either<span class="op">.</span>_</span>
+<span id="cb10-2"><a href="#cb10-2" aria-hidden="true" tabindex="-1"></a><span class="kw">import</span> org<span class="op">.</span>atnos<span class="op">.</span>eff<span class="op">.</span>addon<span class="op">.</span>scalaz<span class="op">.</span>syntax<span class="op">.</span>either<span class="op">.</span>_</span>
+<span id="cb10-3"><a href="#cb10-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-4"><a href="#cb10-4" aria-hidden="true" tabindex="-1"></a><span class="fu">fromDisjunction</span><span class="op">(</span>\<span class="op">/-(</span><span class="dv">1</span><span class="op">)).</span>runDisjunction</span></code></pre></div>
</div>
<script>
diff --git a/org.atnos.site.Introduction.html b/org.atnos.site.Introduction.html
index 2c8ddd1..e84a1e0 100644
--- a/org.atnos.site.Introduction.html
+++ b/org.atnos.site.Introduction.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -341,8 +347,15 @@ page first</em></p>
<code class="prettyprint">A</code> is the value returned by the computation, possibly
triggering some effects when evaluated.</p>
<p>The effects <code class="prettyprint">R</code> are modelled by a type-level list of
-“effect constructors”, for example:`<code class="prettyprint">The stack</code>Stack` above
-declares 3 effects:</p>
+“effect constructors”, for example:</p>
+<pre><code class="prettyprint">import cats._, data._
+ import org.atnos.eff._
+
+ type ReaderInt[A] = Reader[Int, A]
+ type WriterString[A] = Writer[String, A]
+
+ type Stack = Fx.fx3[WriterString, ReaderInt, Eval]</code></pre>
+<p>The stack <code class="prettyprint">Stack</code> above declares 3 effects:</p>
<ul>
<li><p>a <code class="prettyprint">ReaderInt</code> effect to access some configuration
number of type <code class="prettyprint">Int</code></p></li>
@@ -353,8 +366,33 @@ bit like lazy values)</p></li>
</ul>
<p>Now we can write a program with those 3 effects, using the primitive
operations provided by <code class="prettyprint">ReaderEffect</code>,
-<code class="prettyprint">WriterEffect</code> and <code class="prettyprint">EvalEffect</code>:`<code class="prettyprint"></code>>
-(64,List(the required power is 6, the result is 64))`</p>
+<code class="prettyprint">WriterEffect</code> and <code class="prettyprint">EvalEffect</code>:</p>
+<pre><code class="prettyprint">import org.atnos.eff.all._
+ import org.atnos.eff.syntax.all._
+
+// useful type aliases showing that the ReaderInt and the WriterString effects are "members" of R
+// note that R could have more effects
+ type _readerInt[R] = ReaderInt |= R
+ type _writerString[R] = WriterString |= R
+
+ def program[R: _readerInt: _writerString: _eval]: Eff[R, Int] = for {
+ // get the configuration
+ n <- ask[R, Int]
+
+ // log the current configuration value
+ _ <- tell("the required power is " + n)
+
+ // compute the nth power of 2
+ a <- delay(math.pow(2, n.toDouble).toInt)
+
+ // log the result
+ _ <- tell("the result is " + a)
+ } yield a
+
+// run the action with all the interpreters
+// each interpreter running one effect
+ program[Stack].runReader(6).runWriter.runEval.run</code></pre>
+<p><code class="prettyprint">> (64,List(the required power is 6, the result is 64))</code></p>
<p>As you can see, all the effects of the <code class="prettyprint">Stack</code> type are
being executed one by one:</p>
<ol type="1">
diff --git a/org.atnos.site.MemberImplicits.html b/org.atnos.site.MemberImplicits.html
index 7340326..12c7121 100644
--- a/org.atnos.site.MemberImplicits.html
+++ b/org.atnos.site.MemberImplicits.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -314,12 +320,43 @@ typeclasses">Know your Membe...</a>
<p>Type inference with the Eff monad can be a bit tricky to get right if
we want to avoid type annotations. Here are some tips to help you.</p>
+<h3 id="running-effects-with-several-type-parameters">Running effects
+with several type parameters</h3>
+<p>Some effects use 2 type variables, like <code class="prettyprint">Reader</code> or
+<code class="prettyprint">Writer</code>. If you want to use those effects in an effect stack
+you need to make sure you have the following <code class="prettyprint">scalac</code>
+option:</p>
+<div class="sourceCode" id="cb1"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a>scalacOptions <span class="op">+=</span> <span class="st">"-Ypartial-unification"</span></span></code></pre></div>
<h3 id="use-context-bounds-and-type-aliases">Use context bounds and type
aliases</h3>
<p>When creating effects you can always “require” a stack containing the
-right effects with the <code class="prettyprint">MemberIn</code> typeclass:``</p>
+right effects with the <code class="prettyprint">MemberIn</code> typeclass:</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+ import org.atnos.eff.all._
+
+ type StateInt[A] = State[Int, A]
+ type WriterString[A] = Writer[String, A]
+
+// for creating state effects
+ def putAndTell[R](i: Int)(implicit s: StateInt |= R, w: WriterString |= R): Eff[R, Int] =
+ for {
+ // no type annotations needed!
+ _ <- put(i)
+ _ <- tell("stored " + i)
+ } yield i</code></pre>
<p>You can even use context bounds to make the declaration of
-<code class="prettyprint">putAndTell</code> more concise:``</p>
+<code class="prettyprint">putAndTell</code> more concise:</p>
+<pre><code class="prettyprint">import org.atnos.eff.all._
+
+ type _stateInt[R] = State[Int, *] |= R
+ type _writerString[R] = Writer[String, *] |= R
+
+ def putAndTell[R: _stateInt: _writerString](i: Int): Eff[R, Int] =
+ for {
+ _ <- put(i)
+ _ <- tell("stored " + i)
+ } yield i</code></pre>
<h3 id="know-your-member-typeclasses">Know your <code class="prettyprint">Member</code>
typeclasses</h3>
<p>There are 3 different ways to declare that an effect is part of an
@@ -369,12 +406,47 @@ and remove the effect from the stack</td>
<h3 id="packing-member-instances">“Packing” member instances</h3>
<p>Some function signatures can be repetitive when they always require
the same list of effects:</p>
-<div class="sourceCode" id="cb1"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> foo1<span class="op">[</span>R <span class="op">:</span>_foo <span class="op">:</span>_bar <span class="op">:</span>_baz<span class="op">](</span>i<span class="op">:</span> <span class="bu">Int</span><span class="op">):</span> Eff<span class="op">[</span>R<span class="op">,</span> <span class="bu">Int</span><span class="op">]</span></span>
-<span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> foo2<span class="op">[</span>R <span class="op">:</span>_foo <span class="op">:</span>_bar <span class="op">:</span>_baz<span class="op">](</span>i<span class="op">:</span> <span class="bu">Int</span><span class="op">):</span> Eff<span class="op">[</span>R<span class="op">,</span> <span class="bu">Int</span><span class="op">]</span></span>
-<span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> foo3<span class="op">[</span>R <span class="op">:</span>_foo <span class="op">:</span>_bar <span class="op">:</span>_baz<span class="op">](</span>i<span class="op">:</span> <span class="bu">Int</span><span class="op">):</span> Eff<span class="op">[</span>R<span class="op">,</span> <span class="bu">Int</span><span class="op">]</span></span></code></pre></div>
+<div class="sourceCode" id="cb4"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> foo1<span class="op">[</span>R <span class="op">:</span>_foo <span class="op">:</span>_bar <span class="op">:</span>_baz<span class="op">](</span>i<span class="op">:</span> <span class="bu">Int</span><span class="op">):</span> Eff<span class="op">[</span>R<span class="op">,</span> <span class="bu">Int</span><span class="op">]</span></span>
+<span id="cb4-2"><a href="#cb4-2" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> foo2<span class="op">[</span>R <span class="op">:</span>_foo <span class="op">:</span>_bar <span class="op">:</span>_baz<span class="op">](</span>i<span class="op">:</span> <span class="bu">Int</span><span class="op">):</span> Eff<span class="op">[</span>R<span class="op">,</span> <span class="bu">Int</span><span class="op">]</span></span>
+<span id="cb4-3"><a href="#cb4-3" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> foo3<span class="op">[</span>R <span class="op">:</span>_foo <span class="op">:</span>_bar <span class="op">:</span>_baz<span class="op">](</span>i<span class="op">:</span> <span class="bu">Int</span><span class="op">):</span> Eff<span class="op">[</span>R<span class="op">,</span> <span class="bu">Int</span><span class="op">]</span></span></code></pre></div>
<p>It is possible to “pack” them with the following
-<code class="prettyprint">_effects</code> type definition:``</p>
+<code class="prettyprint">_effects</code> type definition:</p>
+<pre><code class="prettyprint">import org.atnos.eff.Members.{&:, &&:}
+
+ trait Foo[A]
+ trait Bar[A]
+ trait Baz[A]
+ trait Boo[A]
+
+ type _foo[R] = Foo |= R
+ type _bar[R] = Bar |= R
+ type _baz[R] = Baz |= R
+
+// Note the last &&:, you can write instead: _foo[R] &: _bar[R] &: _baz[R] &: NoMember
+ type _effects[R] = _foo[R] &: _bar[R] &&: _baz[R]
+
+ def getFoo[R: _foo: _bar]: Eff[R, Int] = Eff.pure(1)
+ def getBar[R: _bar]: Eff[R, Int] = Eff.pure(1)
+ def getBaz[R: _baz]: Eff[R, Int] = Eff.pure(1)
+
+ object t {
+
+ import org.atnos.eff.Members.extractMember
+
+ def foo[R: _effects](i: Int): Eff[R, Int] =
+ getFoo[R] >>
+ getBar[R] >>
+ getBaz[R]
+
+ }
+
+// Then call foo with a concrete stack
+ type S = Fx.fx3[Foo, Bar, Baz]
+ type U = Fx.fx4[Foo, Bar, Baz, Boo]
+
+ t.foo[S](1)
+ t.foo[U](1)</code></pre>
<p>The implicit definition <code class="prettyprint">extractMember</code> in the
<code class="prettyprint">Members</code> object will take care of “unpacking” the member
instances where required. Note that this implicit must <em>not</em> be
diff --git a/org.atnos.site.OutOfTheBox.html b/org.atnos.site.OutOfTheBox.html
index de5ad49..ef873df 100644
--- a/org.atnos.site.OutOfTheBox.html
+++ b/org.atnos.site.OutOfTheBox.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -406,7 +412,8 @@ failures</td>
<p><small>(from <code class="prettyprint">org.atnos.eff._</code>)</small></p>
<p>Other modules listed in
<link class="ok"><a href="org.atnos.site.Installation.html" tooltip="" class="ok">Installation</a></link>
-provide additional effects (Scalaz Task, Doobie ConnectionIO,…).</p>
+provide additional effects (Twitter Future, Scalaz Task, Doobie
+ConnectionIO,…).</p>
<p><br/></p>
<h2 id="whats-next">What’s next?</h2>
<p>Now you can learn how to
diff --git a/org.atnos.site.TransformStack.html b/org.atnos.site.TransformStack.html
index 72f70dc..e0e3e03 100644
--- a/org.atnos.site.TransformStack.html
+++ b/org.atnos.site.TransformStack.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -334,15 +340,36 @@ would leave us with the tree:</p>
Fx1[T1],
Fx2[T2, T4]
]</code></pre>
-<p>This code should prove it: ``</p>
+<p>This code should prove it:</p>
+<pre><code class="prettyprint">// for now the following implicit summoning crashes the compiler
+ // val member_ : Member.Aux[T3, FxAppend[Fx1[T1], Fx3[T2, T3, T4]], FxAppend[Fx1[T1], Fx2[T2, T4]]] =
+ // implicitly[Member.Aux[T3, FxAppend[Fx1[T1], Fx3[T2, T3, T4]], FxAppend[Fx1[T1], Fx2[T2, T4]]]]</code></pre>
<p>Unfortunately the compiler has some difficulties with it, so you can
either get the member value by using the implicit definitions “manually”
or you can just summon the member instance without the <code class="prettyprint">Aux</code>
-part: ``</p>
+part:</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+
+// so you need to explicitly define the implicit
+ val member_ : Member.Aux[T3, FxAppend[Fx1[T1], Fx3[T2, T3, T4]], FxAppend[Fx1[T1], Fx2[T2, T4]]] =
+ Member.MemberAppendR(using Member.Member3M)
+
+// but this works
+ val member: Member[T3, FxAppend[Fx1[T1], Fx3[T2, T3, T4]]] =
+ implicitly[Member[T3, FxAppend[Fx1[T1], Fx3[T2, T3, T4]]]]</code></pre>
<p>More importantly the compiler is still able to track the right types
resulting of the interpretation of a given effect so the following
compiles ok:</p>
-<p>``</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+
+ def runT3[R, U, A](e: Eff[R, A])(implicit m: Member.Aux[T3, R, U]): Eff[U, A] = ???
+ def runT2[R, U, A](e: Eff[R, A])(implicit m: Member.Aux[T2, R, U]): Eff[U, A] = ???
+ def runT1[R, U, A](e: Eff[R, A])(implicit m: Member.Aux[T1, R, U]): Eff[U, A] = ???
+ def runT4[R, U, A](e: Eff[R, A])(implicit m: Member.Aux[T4, R, U]): Eff[U, A] = ???
+
+ type S = FxAppend[Fx1[T1], Fx3[T2, T3, T4]]
+
+ runT1(runT4(runT2(runT3(Eff.send[T3, S, Int](???)))))</code></pre>
<h3 id="transform-an-effect-to-another">Transform an effect to
another</h3>
<h4 id="change-the-effect">Change the effect</h4>
@@ -350,8 +377,47 @@ another</h3>
<code class="prettyprint">Reader[S, *]</code> effect to a stack having a
<code class="prettyprint">Reader[B, *]</code> effect where <code class="prettyprint">S</code> is “contained” in
<code class="prettyprint">B</code> (meaning that there is a mapping from <code class="prettyprint">B</code>,
-“big”, to <code class="prettyprint">S</code>, “small”). Here is an
-example:`<code class="prettyprint"></code>> Some(hello world)`</p>
+“big”, to <code class="prettyprint">S</code>, “small”). Here is an example:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._
+ import org.atnos.eff.syntax.all._
+ import cats._
+ import cats.data._
+
+ case class Conf(host: String, port: Int)
+
+ type ReaderPort[A] = Reader[Int, A]
+ type ReaderHost[A] = Reader[String, A]
+ type ReaderConf[A] = Reader[Conf, A]
+
+ type S1 = Fx.fx2[ReaderHost, Option]
+ type S2 = Fx.fx2[ReaderPort, Option]
+ type SS = Fx.fx2[ReaderConf, Option]
+
+ val readHost: Eff[S1, String] = for {
+ c <- ask[S1, String]
+ h <- OptionEffect.some[S1, String]("hello")
+ } yield h
+
+ val readPort: Eff[S2, String] = for {
+ c <- ask[S2, Int]
+ h <- OptionEffect.some[S2, String]("world")
+ } yield h
+
+ val fromHost = new (ReaderHost ~> ReaderConf) {
+ def apply[X](r: ReaderHost[X]) = Reader((c: Conf) => r.run(c.host))
+ }
+
+ val fromPort = new (ReaderPort ~> ReaderConf) {
+ def apply[X](r: ReaderPort[X]) = Reader((c: Conf) => r.run(c.port))
+ }
+
+ val action: Eff[SS, String] = for {
+ s1 <- readHost.transform(fromHost)
+ s2 <- readPort.transform(fromPort)
+ } yield s1 + " " + s2
+
+ action.runReader(Conf("www.me.com", 8080)).runOption.run</code></pre>
+<p><code class="prettyprint">> Some(hello world)</code></p>
<p>There are also specialized versions of <code class="prettyprint">transform</code> for
<code class="prettyprint">Reader</code> and <code class="prettyprint">State</code>:</p>
<ul>
@@ -373,7 +439,53 @@ example) into multiple others (<code class="prettyprint">TimedFuture</code>,
<pre><code class="prettyprint">type S = Fx.fx3[Authenticated, TimedFuture, Either[AuthError, *]]</code></pre>
<p>And you want to write an interpreter which will translate
authentication actions into <code class="prettyprint">TimedFuture</code> and
-<code class="prettyprint">Either</code>:``</p>
+<code class="prettyprint">Either</code>:</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+ import org.atnos.eff.syntax.eff._
+ import org.atnos.eff.future._
+ import org.atnos.eff.interpret._
+ import scala.concurrent.Future
+
+// list of access rights for a valid token
+ case class AccessRights(rights: List[String])
+
+// authentication error
+ case class AuthError(message: String)
+
+// DSL for authenticating users
+ sealed trait Authenticated[A]
+ case class Authenticate(token: String) extends Authenticated[AccessRights]
+ type _authenticate[U] = Authenticated |= U
+
+ type AuthErroEither[A] = Either[AuthError, A]
+ type _error[U] = AuthErroEither |= U
+
+ /**
+ * The order of implicit parameters is really important for type inference!
+ * see below
+ */
+ def runAuth[R, U, A](e: Eff[R, A])(implicit authenticated: Member.Aux[Authenticated, R, U], future: _future[U], either: _error[U]): Eff[U, A] =
+ translate(e)(new Translate[Authenticated, U] {
+ def apply[X](ax: Authenticated[X]): Eff[U, X] =
+ ax match {
+ case Authenticate(token) =>
+ // send the TimedFuture effect in the stack U
+ fromFuture(authenticateImpl(token)).
+ // send the Either value in the stack U
+ collapse
+ }
+ })
+
+// call to a service to authenticate tokens
+ def authenticateImpl(token: String): Future[Either[AuthError, AccessRights]] =
+ Future.successful[Either[AuthError, AccessRights]] { Left(AuthError("token invalid!")) }
+
+ def authenticate[S: _authenticate](token: String) = Authenticate(token).send
+
+ type S1 = Fx.fx3[Authenticated, Either[AuthError, *], TimedFuture]
+ type R1 = Fx.fx2[Either[AuthError, *], TimedFuture]
+
+ val result: Eff[R1, AccessRights] = runAuth(authenticate[S1]("faketoken"))</code></pre>
<p>The call to <code class="prettyprint">send</code> above needs to send an
<code class="prettyprint">TimedFuture</code> value in the stack <code class="prettyprint">U</code>. This is
possible because <code class="prettyprint">TimedFuture</code> is an effect in <code class="prettyprint">U</code>
@@ -394,7 +506,15 @@ like:</p>
<p>And then <code class="prettyprint">authenticated</code> is last in the list of implicits
parameters and can not be used to guide type inference.</p>
<h3 id="interpret-an-effect-locally">Interpret an effect “locally”</h3>
-<p>Let’s say you have a method to run database queries ``</p>
+<p>Let’s say you have a method to run database queries</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+ import org.atnos.eff.all._
+ import cats.data._
+
+ trait Db[A]
+ type _writerString[R] = Writer[String, *] |= R
+
+ def runDb[R, U, A](queries: Eff[R, A])(implicit db: Member.Aux[Db, R, U], eval: _eval[U], writer: _writerString[U]): Eff[U, A] = ???</code></pre>
<p>The database queries (the <code class="prettyprint">Db</code> effect) are being executed
by the <code class="prettyprint">runDb</code> method inside the <code class="prettyprint">Eval</code> effect,
and they use a <code class="prettyprint">WriterString</code> effect to log what is being
@@ -402,9 +522,18 @@ executed.</p>
<p>However you know that some clients of your component don’t care about
the logs and they don’t want to have the <code class="prettyprint">WriterString</code>
effect. that they consider an implementation detail.</p>
-<p>So you’d like to provide this additional method: ``</p>
+<p>So you’d like to provide this additional method:</p>
+<pre><code class="prettyprint"> def executeOnDb[R, U, A](queries: Eff[R, A])(implicit db: Member.Aux[Db, R, U], eval: _eval[U]): Eff[U, A] = ???</code></pre>
<p>How can you implement <code class="prettyprint">executeOnDb</code> with
-<code class="prettyprint">runDb</code>? ``</p>
+<code class="prettyprint">runDb</code>?</p>
+<pre><code class="prettyprint"> import org.atnos.eff.syntax.all._
+
+ def executeOnDb[R, U, A](queries: Eff[R, A])(implicit db: Member.Aux[Db, R, U], eval: _eval[U]): Eff[U, A] = {
+
+ type S = Fx.prepend[WriterString, R]
+ runDb(queries.into[S]).runWriterNoLog[String]
+
+ }</code></pre>
<p>You create a “local” stack containing the <code class="prettyprint">WriterString</code>
effect using the <code class="prettyprint">prepend</code> method. You now run the
<code class="prettyprint">Db</code> effect and discard the logs to finally return only
@@ -433,7 +562,7 @@ href="https://aws.amazon.com/s3">S3</a>.</p>
_ <- tell[Hadoop, String]("Reading from " + path)
} yield c.mappers.toString
- def runHadoopReader[R, U, A](conf: HadoopConf)(e: Eff[R, A])(using Member.Aux[HadoopReader, R, U]): Eff[U, A] =
+ def runHadoopReader[R, U, A](conf: HadoopConf)(e: Eff[R, A])(implicit r: Member.Aux[HadoopReader, R, U]): Eff[U, A] =
ReaderEffect.runReader(conf)(e)
}
@@ -453,16 +582,37 @@ href="https://aws.amazon.com/s3">S3</a>.</p>
_ <- tell[S3, String]("Writing to bucket " + c.bucket + ": " + content)
} yield ()
- def runS3Reader[R, U, A](conf: S3Conf)(e: Eff[R, A])(using Member.Aux[S3Reader, R, U]): Eff[U, A] =
+ def runS3Reader[R, U, A](conf: S3Conf)(e: Eff[R, A])(implicit r: Member.Aux[S3Reader, R, U]): Eff[U, A] =
ReaderEffect.runReader(conf)(e)
}
</code></pre>
<p>So what happens when you want to both use S3 and Hadoop? As you can
see from the definition above those 2 stacks share some common effects,
-so the resulting stack we want to work with is:``</p>
+so the resulting stack we want to work with is:</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+ import cats.Eval
+ import HadoopStack._
+ import S3Stack.{WriterString as _, _}
+
+ type HadoopS3 = Fx.fx4[S3Reader, HadoopReader, WriterString, Eval]</code></pre>
<p>Then we can use the <code class="prettyprint">into</code> method to inject effects from
-each stack into this common stack:`<code class="prettyprint"></code>> ((),List(Reading
-from /tmp/data, Writing to bucket bucket: 10))`</p>
+each stack into this common stack:</p>
+<pre><code class="prettyprint"> import S3Stack._
+ import HadoopStack._
+// this imports the `into` and runXXX syntax
+ import org.atnos.eff.syntax.all._
+
+ val action = for {
+ // read a file from hadoop
+ s <- readFile("/tmp/data").into[HadoopS3]
+
+ // write a file on S3
+ _ <- writeFile("key", s).into[HadoopS3]
+ } yield ()
+
+ // and we can run the composite action
+ action.runReader(S3Conf("bucket")).runReader(HadoopConf(10)).runWriter.runEval.run</code></pre>
+<p><code class="prettyprint">> ((),List(Reading from /tmp/data, Writing to bucket bucket: 10))</code></p>
<p>You can find a fully working example of this approach in
<code class="prettyprint">src/test/org/atnos/example/StacksSpec</code>.</p>
</div>
diff --git a/org.atnos.site.Tutorial.html b/org.atnos.site.Tutorial.html
index f614f1a..db95fec 100644
--- a/org.atnos.site.Tutorial.html
+++ b/org.atnos.site.Tutorial.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -448,7 +454,7 @@ abstract language into concrete values.</p>
* The resulting effect stack is m.Out which is R without the KVStore effects
*
*/
- def runKVStoreUnsafe[R, A](effects: Eff[R, A])(using m: KVStore <= R): Eff[m.Out, A] = {
+ def runKVStoreUnsafe[R, A](effects: Eff[R, A])(implicit m: KVStore <= R): Eff[m.Out, A] = {
// a very simple (and imprecise) key-value store
val kvs = Map.empty[String, Any]
@@ -530,7 +536,7 @@ delegate the results to other effects in the same stack:</p>
*/
def runKVStore[R, U, A](
effects: Eff[R, A]
- )(using m: Member.Aux[KVStore, R, U], throwable: _throwableEither[U], writer: _writerString[U], state: _stateMap[U]): Eff[U, A] = {
+ )(implicit m: Member.Aux[KVStore, R, U], throwable: _throwableEither[U], writer: _writerString[U], state: _stateMap[U]): Eff[U, A] = {
translate(effects)(new Translate[KVStore, U] {
def apply[X](kv: KVStore[X]): Eff[U, X] =
@@ -601,7 +607,12 @@ stack)</li>
<li>call a final <code class="prettyprint">run</code> to get an <code class="prettyprint">A</code> value
<p/></li>
</ul>
-<p>Like this: `<code class="prettyprint"></code>> Some(14)`</p>
+<p>Like this:</p>
+<pre><code class="prettyprint"> import org.atnos.eff._, syntax.all._
+
+// run the program with the unsafe interpreter
+ runKVStoreUnsafe(program[Fx.fx1[KVStore]]).run</code></pre>
+<p><code class="prettyprint">> Some(14)</code></p>
<p>With the safe interpreter, the process is the same and we need to</p>
<ul>
<li>specify an effect stack definition with all the effects</li>
@@ -610,7 +621,17 @@ stack)</li>
<code class="prettyprint">NoFx</code> effect with <code class="prettyprint">run</code>
<p/></li>
</ul>
-<p>Like that: ``</p>
+<p>Like that:</p>
+<pre><code class="prettyprint"> import org.atnos.eff._, syntax.all._
+ import cats._, data._
+
+// run the program with the safe interpreter
+ type Stack = Fx.fx4[KVStore, Either[Throwable, *], State[Map[String, Any], *], Writer[String, *]]
+
+ val (result, logs) =
+ runKVStore(program[Stack]).runEither.evalState(Map.empty[String, Any]).runWriter.run
+
+ (result.toString +: logs).mkString("\n")</code></pre>
<pre><code class="prettyprint">> Right(Some(14))
put(wild-cats, 2)
get(wild-cats)
@@ -620,7 +641,21 @@ get(wild-cats)
delete(tame-cats)</code></pre>
<h3 id="add-some-syntax">Add some syntax</h3>
<p>It is nice to be able to “chain” <code class="prettyprint">run</code> methods with this
-additional piece of syntax: ``</p>
+additional piece of syntax:</p>
+<pre><code class="prettyprint"> implicit class KVStoreOps[R, A](effects: Eff[R, A]) {
+ def runStore[U](implicit
+ m: Member.Aux[KVStore, R, U],
+ throwable: _throwableEither[U],
+ writer: _writerString[U],
+ state: _stateMap[U]
+ ): Eff[U, A] =
+ runKVStore(effects)
+ }
+
+ val (result, logs) =
+ program[Stack].runStore.runEither.evalState(Map.empty[String, Any]).runWriter.run
+
+ (result.toString +: logs).mkString("\n")</code></pre>
<pre><code class="prettyprint">> Right(Some(14))
put(wild-cats, 2)
get(wild-cats)
@@ -685,7 +720,7 @@ instances for those effects:</p>
def readLine(): String =
"snuggles"
- def runInteract[R, A](effect: Eff[R, A])(using m: Interact <= R): Eff[m.Out, A] =
+ def runInteract[R, A](effect: Eff[R, A])(implicit m: Interact <= R): Eff[m.Out, A] =
recurse(effect)(new Recurser[Interact, m.Out, A, A] {
def onPure(a: A): A = a
@@ -708,7 +743,7 @@ instances for those effects:</p>
})(using m)
- def runDataOp[R, A](effect: Eff[R, A])(using m: DataOp <= R): Eff[m.Out, A] = {
+ def runDataOp[R, A](effect: Eff[R, A])(implicit m: DataOp <= R): Eff[m.Out, A] = {
val memDataSet = new scala.collection.mutable.ListBuffer[String]
recurse(effect)(new Recurser[DataOp, m.Out, A, A] {
@@ -731,7 +766,10 @@ instances for those effects:</p>
}
</code></pre>
<p>Now if we run our program for a Stack combining both effects and type
-in “snuggles” when prompted, we see something like this:``</p>
+in “snuggles” when prompted, we see something like this:</p>
+<pre><code class="prettyprint"> type Stack = Fx.fx2[Interact, DataOp]
+
+ runInteract(runDataOp(program[Stack])).run</code></pre>
<pre><code class="prettyprint">What's the kitty's name?
Current cats: snuggles</code></pre>
</div>
diff --git a/org.atnos.site.lib.ChooseEffectPage.html b/org.atnos.site.lib.ChooseEffectPage.html
index 8dcc092..9572848 100644
--- a/org.atnos.site.lib.ChooseEffectPage.html
+++ b/org.atnos.site.lib.ChooseEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -324,8 +330,23 @@ where instead of “exploring” all the branches we might “cut” some of
them. That behaviour is controlled by the <code class="prettyprint">Alternative[F]</code>
instance you use when running <code class="prettyprint">Choose</code>.</p>
<p>For example if we take <code class="prettyprint">List</code> to run a similar example as
-before, we get the list of all the accepted pairs: `<code class="prettyprint"></code>>
-List((2,4), (3,3), (3,4), (4,2), (4,3), (4,4))`</p>
+before, we get the list of all the accepted pairs:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+
+ type S = Fx.fx1[Choose]
+
+// create all the possible pairs for a given list
+// where the sum is greater than a value
+ def pairsBiggerThan[R: _choose](list: List[Int], n: Int): Eff[R, (Int, Int)] = for {
+ a <- chooseFrom(list)
+ b <- chooseFrom(list)
+ found <-
+ if (a + b > n) Monad[Eff[R, *]].pure((a, b))
+ else zero
+ } yield found
+
+ pairsBiggerThan[S](List(1, 2, 3, 4), 5).runChoose[List].run</code></pre>
+<p><code class="prettyprint">> List((2,4), (3,3), (3,4), (4,2), (4,3), (4,4))</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.EitherEffectPage.html b/org.atnos.site.lib.EitherEffectPage.html
index 729fea3..ab55ab8 100644
--- a/org.atnos.site.lib.EitherEffectPage.html
+++ b/org.atnos.site.lib.EitherEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -313,13 +319,47 @@ typeclasses">Know your Membe...</a>
<div id="tipue_search_content"></div>
<p>The <code class="prettyprint">Either</code> effect is similar to the <code class="prettyprint">Option</code>
-effect but adds the possibility to specify why a computation stopped:
-`<code class="prettyprint"></code>> (Right(30),Left(‘missing’ not found))`</p>
+effect but adds the possibility to specify why a computation
+stopped:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+
+ /**
+ * Stack declaration
+ */
+ type S = Fx.fx1[Either[String, *]]
+
+ // compute with this stack
+ val map: Map[String, Int] =
+ Map("key1" -> 10, "key2" -> 20)
+
+ // get 2 keys from the map and add the corresponding values
+ def addKeys(key1: String, key2: String): Eff[S, Int] = for {
+ a <- optionEither(map.get(key1), s"'$key1' not found")
+ b <- optionEither(map.get(key2), s"'$key2' not found")
+ } yield a + b
+
+ (addKeys("key1", "key2").runEither.run, addKeys("key1", "missing").runEither.run)</code></pre>
+<p><code class="prettyprint">> (Right(30),Left('missing' not found))</code></p>
<p><em>Note</em>: the <code class="prettyprint">*</code> syntax comes from the <a
href="https://github.com/typelevel/kind-projector">kind-projector</a>
project and allows us to avoid type lambdas.</p>
<p>A <code class="prettyprint">catchLeft</code> method can also be used to intercept an
-error and possibly recover from it:``</p>
+error and possibly recover from it:</p>
+<pre><code class="prettyprint"> case class TooBig(value: Int)
+ type E = Fx.fx1[Either[TooBig, *]]
+
+ val i = 7
+
+ val value: Eff[E, Int] =
+ if (i > 5) left[E, TooBig, Int](TooBig(i))
+ else right[E, TooBig, Int](i)
+
+ val action: Eff[E, Int] = catchLeft[E, TooBig, Int](value) { case TooBig(k) =>
+ if (k < 10) right[E, TooBig, Int](k)
+ else left[E, TooBig, Int](TooBig(k))
+ }
+
+ action.runEither.run ==== Right(7)</code></pre>
<p><em>Note</em>: the type annotations on <code class="prettyprint">left</code> and
<code class="prettyprint">right</code> can be avoided by adding an implicit declaration in
scope. You can learn more about this in the
diff --git a/org.atnos.site.lib.ErrorEffectPage.html b/org.atnos.site.lib.ErrorEffectPage.html
index d9ad110..b592845 100644
--- a/org.atnos.site.lib.ErrorEffectPage.html
+++ b/org.atnos.site.lib.ErrorEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
diff --git a/org.atnos.site.lib.EvalEffectPage.html b/org.atnos.site.lib.EvalEffectPage.html
index 24fb1f5..1dcad99 100644
--- a/org.atnos.site.lib.EvalEffectPage.html
+++ b/org.atnos.site.lib.EvalEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -323,7 +329,10 @@ computations</p></li>
the computations but also catch any <code class="prettyprint">Throwable</code> that would be
thrown</p></li>
</ul>
-<p>`<code class="prettyprint"></code>> 2`</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+
+ delay(1 + 1).runEval.run</code></pre>
+<p><code class="prettyprint">> 2</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.ListEffectPage.html b/org.atnos.site.lib.ListEffectPage.html
index f634419..33e8f9e 100644
--- a/org.atnos.site.lib.ListEffectPage.html
+++ b/org.atnos.site.lib.ListEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -313,8 +319,23 @@ typeclasses">Know your Membe...</a>
<div id="tipue_search_content"></div>
<p>The <code class="prettyprint">List</code> effect is used for computations which may
-return several values. A simple example using this effect would be
-`<code class="prettyprint"></code>> List((2,4), (3,3), (3,4), (4,2), (4,3), (4,4))`</p>
+return several values. A simple example using this effect would be</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+
+ type S = Fx.fx1[List]
+
+// create all the possible pairs for a given list
+// where the sum is greater than a value
+ def pairsBiggerThan[R: _list](list: List[Int], n: Int): Eff[R, (Int, Int)] = for {
+ a <- values(list*)
+ b <- values(list*)
+ found <-
+ if (a + b > n) singleton((a, b))
+ else empty
+ } yield found
+
+ pairsBiggerThan[S](List(1, 2, 3, 4), 5).runList.run</code></pre>
+<p><code class="prettyprint">> List((2,4), (3,3), (3,4), (4,2), (4,3), (4,4))</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.MemoEffectPage.html b/org.atnos.site.lib.MemoEffectPage.html
index dfb4981..c02eb4f 100644
--- a/org.atnos.site.lib.MemoEffectPage.html
+++ b/org.atnos.site.lib.MemoEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -315,8 +321,26 @@ typeclasses">Know your Membe...</a>
<p>The Memo effect allows the caching of expensive computations.
Computations are “stored” with a given key, so that the next computation
with the same key will return the previously computed value. When
-interpreting those computations a <code class="prettyprint">Cache</code> must be provided:
-`<code class="prettyprint"></code>> there is only one invocation <=> true`</p>
+interpreting those computations a <code class="prettyprint">Cache</code> must be
+provided:</p>
+<pre><code class="prettyprint">import cats.Eval
+ import cats.syntax.all._
+ import org.atnos.eff._, memo._
+ import org.atnos.eff.syntax.memo._
+ import org.atnos.eff.syntax.eval._
+ import org.atnos.eff.syntax.eff._
+
+ type S = Fx.fx2[Memoized, Eval]
+
+ var i = 0
+
+ def expensive[R: _memo]: Eff[R, Int] =
+ memoize("key", { i += 1; 10 * 10 })
+
+ (expensive[S] >> expensive[S]).runMemo(ConcurrentHashMapCache()).runEval.run === 100
+
+ "there is only one invocation" <==> (i === 1)</code></pre>
+<p><code class="prettyprint">> there is only one invocation <=> true</code></p>
<p>There are 2 cache implementations provided in this library to support
the Memo effect:</p>
<ul>
@@ -334,10 +358,10 @@ be garbage collected when necessary.</p></li>
href="https://github.com/ben-manes/caffeine">Caffeine</a> to get more
functionalities like eviction policies, maximum size and so on. You will
need to implement the <code class="prettyprint">Cache</code> interface for this</p>
-<div class="sourceCode" id="cb1"><pre
-class="sourceCode scala"><code class="sourceCode scala"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="kw">trait</span> Cache <span class="op">{</span></span>
-<span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a> <span class="kw">def</span> memo<span class="op">[</span>V<span class="op">](</span>key<span class="op">:</span> <span class="bu">AnyRef</span><span class="op">,</span> value<span class="op">:</span> <span class="op">=></span>V<span class="op">):</span> V</span>
-<span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb2"><pre
+class="sourceCode scala"><code class="sourceCode scala"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a><span class="kw">trait</span> Cache <span class="op">{</span></span>
+<span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a> <span class="kw">def</span> memo<span class="op">[</span>V<span class="op">](</span>key<span class="op">:</span> <span class="bu">AnyRef</span><span class="op">,</span> value<span class="op">:</span> <span class="op">=></span>V<span class="op">):</span> V</span>
+<span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
</div>
<script>
diff --git a/org.atnos.site.lib.OptionEffectPage.html b/org.atnos.site.lib.OptionEffectPage.html
index 989afdc..661c9c8 100644
--- a/org.atnos.site.lib.OptionEffectPage.html
+++ b/org.atnos.site.lib.OptionEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -315,8 +321,26 @@ typeclasses">Know your Membe...</a>
<p>Adding an <code class="prettyprint">Option</code> effect in your stack allows to stop
computations when necessary. If you create a value with
<code class="prettyprint">some(a)</code> this value will be used downstream but if you use
-<code class="prettyprint">none</code> all computations will stop:`<code class="prettyprint"></code>>
-(Some(30),None)`</p>
+<code class="prettyprint">none</code> all computations will stop:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+
+ /**
+ * Stack declaration
+ */
+ type S = Fx.fx1[Option]
+
+// compute with this stack
+ val map: Map[String, Int] =
+ Map("key1" -> 10, "key2" -> 20)
+
+// get 2 keys from the map and add the corresponding values
+ def addKeys(key1: String, key2: String): Eff[S, Int] = for {
+ a <- fromOption(map.get(key1))
+ b <- fromOption(map.get(key2))
+ } yield a + b
+
+ (addKeys("key1", "key2").runOption.run, addKeys("key1", "missing").runOption.run)</code></pre>
+<p><code class="prettyprint">> (Some(30),None)</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.ReaderEffectPage.html b/org.atnos.site.lib.ReaderEffectPage.html
index 7932829..775dcfc 100644
--- a/org.atnos.site.lib.ReaderEffectPage.html
+++ b/org.atnos.site.lib.ReaderEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -318,8 +324,23 @@ environment (or “configuration” if you prefer to see it that way) and
you can run an effect stack containing a <code class="prettyprint">Reader</code> effect by
providing a value for the environment with the <code class="prettyprint">runReader</code>
method.</p>
-<p>You can also inject a “local” reader into a “bigger”
-one:`<code class="prettyprint"></code>> the port is 80`</p>
+<p>You can also inject a “local” reader into a “bigger” one:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+ import cats.data._
+
+ case class Conf(host: String, port: Int)
+
+ type R1[A] = Reader[Int, A]
+ type R2[A] = Reader[Conf, A]
+
+ type S = Fx.fx2[R1, R2]
+
+ def getPort[R](implicit r: Reader[Int, *] |= R): Eff[R, String] = for {
+ p1 <- ask[R, Int]
+ } yield "the port is " + p1
+
+ getPort[S].translateReader((_: Conf).port).runReader(Conf("prod", 80)).run</code></pre>
+<p><code class="prettyprint">> the port is 80</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.SafeEffectPage.html b/org.atnos.site.lib.SafeEffectPage.html
index e7844ae..d4a9017 100644
--- a/org.atnos.site.lib.SafeEffectPage.html
+++ b/org.atnos.site.lib.SafeEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -322,7 +328,31 @@ executed after another one, even if the first one fails</li>
and then close it safely. The <code class="prettyprint">close</code> part is a “finalizer”
<p/></li>
</ul>
-<p>Let’s see an example for the protection of a resource: ``</p>
+<p>Let’s see an example for the protection of a resource:</p>
+<pre><code class="prettyprint">import org.atnos.eff.syntax.all._
+ import org.atnos.eff._, all._
+
+// let's represent a resource which can be in use
+ case class Resource(values: List[Int] = (1 to 10).toList, inUse: Boolean = false) {
+ def isClosed = !inUse
+ }
+
+ var resource = Resource()
+
+// our stack of effects, with safe evaluation
+ type S = Fx.fx1[Safe]
+
+ def openResource: Eff[S, Resource] =
+ protect { resource = resource.copy(inUse = true); resource }
+
+ def closeResource(r: Resource): Eff[S, Unit] =
+ protect { resource = r.copy(inUse = false) }
+
+ def useResource(ok: Boolean) = (r: Resource) => protect[S, Int](if (ok) r.values.sum else throw new Exception("boo"))
+
+// this program uses the resource safely even if there is an exception
+ def program(ok: Boolean): (Either[Throwable, Int], List[Throwable]) =
+ bracket(openResource)(useResource(ok))(closeResource).runSafe.run</code></pre>
<pre><code class="prettyprint">> Results
Without exception: Right(55), finalizers exceptions: no exceptions, resource is closed: true
With exception : Left(boo), finalizers exceptions: no exceptions, resource is closed: true</code></pre>
@@ -335,7 +365,22 @@ which can themselves fail.</p>
<p>A simpler version of <code class="prettyprint">bracket</code> is
<code class="prettyprint">finally</code>.</p>
<p>This example show how to use <code class="prettyprint">finally</code> but also what
-happens if a finalizer fails:``</p>
+happens if a finalizer fails:</p>
+<pre><code class="prettyprint">import org.atnos.eff.syntax.all._
+ import org.atnos.eff._, all._
+
+// our stack of effects, with safe evaluation
+ type S = Fx.fx1[Safe]
+
+ var sumDone: Boolean = false
+
+ def setDone(ok: Boolean): Eff[S, Unit] =
+ protect[S, Unit](if (ok) sumDone = true else throw new Exception("failed!!"))
+
+// this program tries to set sumDone to true when the computation is done
+ def program(ok: Boolean, finalizeOk: Boolean): (Either[Throwable, Int], List[Throwable]) =
+ (protect[S, Int](if (ok) (1 to 10).sum else throw new Exception("boo")) `finally` setDone(finalizeOk)).runSafe.run
+</code></pre>
<pre><code class="prettyprint">> Results
Computation ok, finalizer ok: Right(55), finalizers exceptions: no exceptions
Computation ok, finalizer ko: Right(55), finalizers exceptions: List(failed!!)
diff --git a/org.atnos.site.lib.StateEffectPage.html b/org.atnos.site.lib.StateEffectPage.html
index b735467..174d028 100644
--- a/org.atnos.site.lib.StateEffectPage.html
+++ b/org.atnos.site.lib.StateEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -319,15 +325,61 @@ typeclasses">Know your Membe...</a>
<li><p><code class="prettyprint">put</code> set a new state</p></li>
</ul>
<p>Let’s see an example showing that we can also use tags to track
-different states at the same time:`<code class="prettyprint"></code>> initial:
-(10,hello), final: (5,10)`</p>
+different states at the same time:</p>
+<pre><code class="prettyprint">import cats.data._
+ import org.atnos.eff._, all._, syntax.all._
+
+ type S1[A] = State[Int, A]
+ type S2[A] = State[String, A]
+
+ type S = Fx.fx2[S1, S2]
+
+ val swapVariables: Eff[S, String] = for {
+ v1 <- get[S, Int]
+ v2 <- get[S, String]
+ _ <- put[S, Int](v2.size)
+ _ <- put[S, String](v1.toString)
+ w1 <- get[S, Int]
+ w2 <- get[S, String]
+ } yield "initial: " + (v1, v2).toString + ", final: " + (w1, w2).toString
+
+ swapVariables.evalState(10).evalState("hello").run</code></pre>
+<p><code class="prettyprint">> initial: (10,hello), final: (5,10)</code></p>
<p>In the example above we have used an <code class="prettyprint">eval</code> method to get
the <code class="prettyprint">A</code> in <code class="prettyprint">Eff[R, A]</code> but it is also possible to
get both the value and the state with <code class="prettyprint">run</code> or only the state
with <code class="prettyprint">exec</code>.</p>
<p>Instead of tagging state effects it is also possible to transform a
State effect acting on a “small” state into a State effect acting on a
-“bigger” state:``</p>
+“bigger” state:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+ import cats.data.State
+
+ type Count[A] = State[Int, A]
+ type Sum[A] = State[Int, A]
+ type Mean[A] = State[(Int, Int), A]
+
+ type S1 = Fx.fx1[Count]
+ type S2 = Fx.fx1[Sum]
+ type S = Fx.fx1[Mean]
+
+ def count(list: List[Int]): Eff[S1, String] = for {
+ _ <- put(list.size)
+ } yield s"there are ${list.size} values"
+
+ def sum(list: List[Int]): Eff[S2, String] = {
+ val s = if (list.isEmpty) 0 else list.sum
+ for {
+ _ <- put(s)
+ } yield s"the sum is $s"
+ }
+
+ def mean(list: List[Int]): Eff[S, String] = for {
+ m1 <- count(list).lensState((_: (Int, Int))._1, (s: (Int, Int), i: Int) => (i, s._2))
+ m2 <- sum(list).lensState((_: (Int, Int))._2, (s: (Int, Int), i: Int) => (s._1, i))
+ } yield m1 + "\n" + m2
+
+ mean(List(1, 2, 3)).runState((0, 0)).run</code></pre>
<pre><code class="prettyprint">> (there are 3 values
the sum is 6,(3,6))</code></pre>
</div>
diff --git a/org.atnos.site.lib.TaskEffectPage.html b/org.atnos.site.lib.TaskEffectPage.html
index 0b3ef20..2efc5ec 100644
--- a/org.atnos.site.lib.TaskEffectPage.html
+++ b/org.atnos.site.lib.TaskEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -315,8 +321,40 @@ typeclasses">Know your Membe...</a>
<p>The <code class="prettyprint">Task</code> effect is a thin shim on top of Monix’s
<code class="prettyprint">Task</code>. This effect is not bundled in core Eff and requires
the <code class="prettyprint">eff-monix</code> extension to use.</p>
-<p>Now, let’s create some <code class="prettyprint">Task</code> effects:`<code class="prettyprint"></code>>
-Some(1)`</p>
+<p>Now, let’s create some <code class="prettyprint">Task</code> effects:</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+ import org.atnos.eff.addon.monix.task._
+ import org.atnos.eff.syntax.addon.monix.task._
+
+ import monix.eval.Task
+
+ type R = Fx.fx2[Task, Option]
+
+ val action: Eff[R, Int] =
+ for {
+ // create a value now
+ a <- Eff.pure[R, Int](1)
+
+ // evaluate a value later, on the thread pool specified by a Monix `Scheduler`, and continue when it's finished
+ b <- taskDelay[R, Int](1)
+ } yield b
+
+</code></pre>
+<p>Then we need to pass a Monix <code class="prettyprint">Scheduler</code> in to begin the
+computation.</p>
+<pre><code class="prettyprint">
+ implicit val scheduler: monix.execution.Scheduler =
+ monix.execution.Scheduler(ExecutionContext.fromExecutorService(Executors.newScheduledThreadPool(10)): ExecutionContext)
+
+</code></pre>
+<p>Monix doesn’t natively offer an Await API to block on a Task result.
+Instead it advises converting to a Scala <code class="prettyprint">Future</code> and using
+<code class="prettyprint">Await.result</code>. See
+https://monix.io/docs/3x/eval/task.html#blocking-for-a-result</p>
+<pre><code class="prettyprint"> import scala.concurrent.Await
+
+ Await.result(action.runOption.runAsync.runToFuture, 1.second)</code></pre>
+<p><code class="prettyprint">> Some(1)</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.TimedFutureEffectPage.html b/org.atnos.site.lib.TimedFutureEffectPage.html
index 51ec883..846c2a9 100644
--- a/org.atnos.site.lib.TimedFutureEffectPage.html
+++ b/org.atnos.site.lib.TimedFutureEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -321,17 +327,48 @@ timeouts, which are supported by passing in a
<code class="prettyprint">Future</code>. This means if you start a computation before
passing the <code class="prettyprint">Future</code> into Eff, the <code class="prettyprint">Future</code> will
begin less predictably.</p>
-<p>Now, let’s create some <code class="prettyprint">TimedFuture</code>
-effects:`<code class="prettyprint"></code>> Some(1)`</p>
+<p>Now, let’s create some <code class="prettyprint">TimedFuture</code> effects:</p>
+<pre><code class="prettyprint">import org.atnos.eff._
+ import org.atnos.eff.future._
+ import org.atnos.eff.syntax.all._
+ import org.atnos.eff.concurrent.Scheduler
+
+ import scala.concurrent._, duration._
+ import scala.concurrent.ExecutionContext.Implicits.global
+
+ type R = Fx.fx2[TimedFuture, Option]
+
+ val action: Eff[R, Int] =
+ for {
+ // create a value now
+ a <- Eff.pure[R, Int](1)
+
+ // evaluate a value later, on some other thread pool, and continue when it's finished
+ b <- futureDelay[R, Int](1)
+ } yield b
+
+</code></pre>
+<p>Then we need to pass a <code class="prettyprint">Scheduler</code> and an
+<code class="prettyprint">ExecutionContext</code> in to begin the computation.</p>
+<pre><code class="prettyprint">
+ implicit val scheduler: Scheduler = ExecutorServices.schedulerFromGlobalExecutionContext
+ import org.atnos.eff.syntax.future._
+
+ Await.result(action.runOption.runSequential, 1.second)</code></pre>
+<p><code class="prettyprint">> Some(1)</code></p>
<p>You can also use other <code class="prettyprint">Future</code> or <code class="prettyprint">Task</code>
effects:</p>
<ul>
+<li><code class="prettyprint">twitter</code>: depend on <code class="prettyprint">eff-twitter</code> and import
+<code class="prettyprint">org.atnos.eff.addon.twitter.future._</code></li>
<li><code class="prettyprint">monix</code>: depend on <code class="prettyprint">eff-monix</code> and import
<code class="prettyprint">org.atnos.eff.addon.monix.task._</code></li>
</ul>
<p>There are corresponding syntax imports to be able to call
<code class="prettyprint">runAsync</code> methods in:</p>
<ul>
+<li><code class="prettyprint">twitter</code>:
+<code class="prettyprint">org.atnos.eff.syntax.addon.twitter.future._</code></li>
<li><code class="prettyprint">monix</code>:
<code class="prettyprint">org.atnos.eff.syntax.addon.monix.task._</code></li>
</ul>
@@ -345,7 +382,30 @@ cache</li>
<code class="prettyprint">Memoized</code> effect (you will need to provide the cache later)
<p/></li>
</ul>
-<p>`<code class="prettyprint"></code>> there is only one invocation <=> true`</p>
+<pre><code class="prettyprint">import cats.syntax.all._
+ import org.atnos.eff._, future._, all._
+ import org.atnos.eff.concurrent.Scheduler
+ import org.atnos.eff.syntax.all._
+ import org.atnos.eff.syntax.future._
+ import scala.concurrent._, duration._
+ import scala.concurrent.ExecutionContext.Implicits.global
+
+ var i = 0
+
+ def expensive[R: _Future: _memo]: Eff[R, Int] =
+ futureMemoized[R, Int]("key", futureDelay[R, Int] { i += 1; 10 * 10 })
+
+ type S = Fx.fx2[Memoized, TimedFuture]
+
+ implicit val scheduler: Scheduler = ExecutorServices.schedulerFromGlobalExecutionContext
+
+ val futureMemo: Future[Int] =
+ (expensive[S] >> expensive[S]).runFutureMemo(ConcurrentHashMapCache()).runSequential
+
+ Await.result(futureMemo, 1.second)
+
+ "there is only one invocation" <==> (i === 1)</code></pre>
+<p><code class="prettyprint">> there is only one invocation <=> true</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.ValidateEffectPage.html b/org.atnos.site.lib.ValidateEffectPage.html
index 3f2b46b..12487da 100644
--- a/org.atnos.site.lib.ValidateEffectPage.html
+++ b/org.atnos.site.lib.ValidateEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -313,9 +319,25 @@ typeclasses">Know your Membe...</a>
<div id="tipue_search_content"></div>
<p>The <code class="prettyprint">Validate</code> effect is similar to the
-<code class="prettyprint">Either</code> effect but let you accumulate failures:
-`<code class="prettyprint"></code>> Left(NonEmptyList(-3 is not positive, -2 is not
-positive))`</p>
+<code class="prettyprint">Either</code> effect but let you accumulate failures:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+
+ /**
+ * Stack declaration
+ */
+ type S = Fx.fx1[Validate[String, *]]
+
+ def checkPositiveInt(i: Int): Eff[S, Unit] =
+ validateCheck(i >= 0, s"$i is not positive")
+
+ def checkPositiveInts(a: Int, b: Int, c: Int): Eff[S, (Int, Int, Int)] = for {
+ _ <- checkPositiveInt(a)
+ _ <- checkPositiveInt(b)
+ _ <- checkPositiveInt(c)
+ } yield (a, b, c)
+
+ checkPositiveInts(1, -3, -2).runNel.run</code></pre>
+<p><code class="prettyprint">> Left(NonEmptyList(-3 is not positive, -2 is not positive))</code></p>
</div>
<script>
diff --git a/org.atnos.site.lib.WriterEffectPage.html b/org.atnos.site.lib.WriterEffectPage.html
index 4f89ef7..60c2d64 100644
--- a/org.atnos.site.lib.WriterEffectPage.html
+++ b/org.atnos.site.lib.WriterEffectPage.html
@@ -255,7 +255,11 @@ into multiple others">Translate an ef...</a>
</li>
</ul><ul>
<li id="org-atnos-site-memberimplicits"><a href="org.atnos.site.MemberImplicits.html" title="Member implicits">Member implicits</a>
- <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
+ <ul><ul><li><a href="org.atnos.site.MemberImplicits.html#running-effects
+with-several-type-parameters" title="Running effects
+with several type parameters">Running effects...</a>
+
+ </li><li><a href="org.atnos.site.MemberImplicits.html#use-context-bounds-and-type
aliases" title="Use context bounds and type
aliases">Use context bou...</a>
@@ -274,6 +278,8 @@ typeclasses">Know your Membe...</a>
<li id="org-atnos-site-applicativeevaluation"><a href="org.atnos.site.ApplicativeEvaluation.html" title="Applicative">Applicative</a>
<ul><ul><li><a href="org.atnos.site.ApplicativeEvaluation.html#concurrent-evaluation" title="Concurrent evaluation">Concurrent eval...</a>
+ </li><li><a href="org.atnos.site.ApplicativeEvaluation.html#batching" title="Batching">Batching</a>
+
</li></ul></ul>
<ul>
@@ -313,8 +319,36 @@ typeclasses">Know your Membe...</a>
<div id="tipue_search_content"></div>
<p>You can then define your own custom <code class="prettyprint">Fold</code> to log the
-values to a file:`<code class="prettyprint"></code>> List(second value 2, first value
-1)`</p>
+values to a file:</p>
+<pre><code class="prettyprint">import org.atnos.eff._, all._, syntax.all._
+ import cats.data.Writer
+ import java.io.PrintWriter
+ import scala.io
+
+ type S = Fx.fx1[Writer[String, *]]
+
+ val action: Eff[S, Int] = for {
+ a <- pure[S, Int](1)
+ _ <- tell("first value " + a)
+ b <- pure[S, Int](2)
+ _ <- tell("second value " + b)
+
+ } yield a + b
+
+// define a fold to output values
+ def fileFold(path: String) = new RightFold[String, Unit] {
+ type S = PrintWriter
+ val init: S = new PrintWriter(path)
+
+ def fold(a: String, s: S): S = { s.println(a); s }
+
+ def finalize(s: S): Unit =
+ s.close
+ }
+
+ action.runWriterFold(fileFold("target/log")).run
+ io.Source.fromFile("target/log").getLines().toList</code></pre>
+<p><code class="prettyprint">> List(second value 2, first value 1)</code></p>
</div>
<script>
|
dependabot
bot
deleted the
dependabot/github_actions/7.x/coursier/cache-action-8.0.1
branch
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Bumps coursier/cache-action from 8.0.0 to 8.0.1.
Commits
e47d7d3Update dist (#788)274e756Bump@actions/cachefrom 4.1.0 to 6.0.0 (#771)c89b422Bump@actions/corefrom 2.0.2 to 3.0.0 (#770)e119d89Update dist (#786)edd5d55Bump eslint-plugin-github from 4.10.2 to 6.0.0 (#652)13142dcBump@typescript-eslint/parserfrom 6.20.0 to 8.54.0 (#769)b0d5c28Update dist (#776)f49daa4Add a flag enabling to ignore saving/restoring Ammonite cache (#774)b1d85baImprove and update Mill support (#773)2306146Add AGENTS.mdDependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting
@dependabot rebase.Dependabot commands and options
You can trigger Dependabot actions by commenting on this PR:
@dependabot rebasewill rebase this PR@dependabot recreatewill recreate this PR, overwriting any edits that have been made to it@dependabot show <dependency name> ignore conditionswill show all of the ignore conditions of the specified dependency@dependabot ignore this major versionwill close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)@dependabot ignore this minor versionwill close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)@dependabot ignore this dependencywill close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)