HttpOps

Type Members

type D[E, A] = EitherT[W, E, A]

Definition Classes
HttpInstances
type H[E, A] = Http[E, A]

Definition Classes
HttpInstances
trait MonadErrorInstance[E] extends MonadError[H, E] with MonadInstance[E]

Definition Classes
HttpInstances
trait MonadInstance[E] extends Monad[[X]Http[E, X]]

Definition Classes
HttpInstances
type RequestLog = Vector[LogEntry]

Definition Classes
HttpInstances
type W[A] = WriterT[Future, RequestLog, A]

Definition Classes
HttpInstances

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def async[A](a: ⇒ A): Http[E, A]

Lift a value asynchronously into a HTTP computation.
Lift a value asynchronously into a HTTP computation.
The result will be computed concurrently according to ExecutionContext.global.
```
lazy val bigExpensiveComputation: Int = ???

val x: Http[String, Int] = HttpOps[String].async(bigExpensiveComputation)
```
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def liftFuture[A](fut: Future[A]): Http[E, A]

Wrap an asynchronous computation without handling exceptions.
Wrap an asynchronous computation without handling exceptions.
Any exception thrown by the original future will propagate up via Future.failed.

See also
HttpOps.liftFutureHandle
def liftFutureHandle[A](fut: Future[A])(f: PartialFunction[Throwable, Http[E, A]]): Http[E, A]

Wrap an arbitrary asynchronous computation, and selectively recover from them.
Wrap an arbitrary asynchronous computation, and selectively recover from them.
If a particular exception isn't handled, then it is propagated up via Future.failed.
Example
```
import scala.concurrent.ExecutionContext.Implicits.global

val x: Http[String, Int] = HttpOps[String].liftFutureHandle(Future("abc".toInt)) {
  case _: NumberFormatException => HttpOps[String].raiseError("Bad number")
}

scala> x
res0: com.pagerduty.sprayfunclient.Http[String, Int] = // ...
```
See also
HttpOps.liftFuture

def map2[A, B, C](ha: Http[E, A], hb: Http[E, B])(f: (A, B) ⇒ C): Http[E, C]

Map over the result of two independent HTTP computations.

Example

val x: Http[String, Int] = HttpOps[String].unit(3)
val y: Http[String, Double] = HttpOps[String].unit(4.2)

scala> HttpOps[String].map2(x, y) { _.toInt + _ }
res0: com.pagerduty.sprayfunclient.Http[String, Double] = // ...

implicit def monad[E]: MonadInstance[E]

Definition Classes
HttpInstances
implicit def monadError[E]: MonadErrorInstance[E]

Definition Classes
HttpInstances
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef

def raiseError[A](e: E): Http[E, A]

Fail the computation with a specific error.

The error will short-circuit any future computations.

Errors can be manipulated via Http.mapError or recovered from via Http.handleError.

Example

def sqrt(x: Double): Http[String, Double] = {
  if (x < 0)
    HttpOps[String].raiseError("negative number")
  else
    HttpOps[String].unit(math.sqrt(x))
}

scala> sqrt(4.0)
res0: com.pagerduty.sprayfunclient.Http[String, Double] = // ...

scala> sqrt(-4)
res1: com.pagerduty.sprayfunclient.Http[String, Double] = // ...

def sequence[A](hs: Seq[Http[E, A]]): Http[E, Seq[A]]

Execute multiple HTTP computations.
Execute multiple HTTP computations.
Asynchronous computations started via async will execute concurrently.
The computation fails if any one of the computations fail.
Example
```
val x = HttpOps[String].async("First big computation")
val y = HttpOps[String].async("Second big computation")

scala> HttpOps[String].sequence(Seq(x, y))
res0: com.pagerduty.sprayfunclient.Http[String, Seq[String]] = // ...
```
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def trace(entry: LogEntry): Http[E, Unit]

Add a HTTP request and it's execution time to the request log.
Add a HTTP request and it's execution time to the request log.
This log is accessible when the computation is "run" via Http.asFutureWithLog.

Note
request automatically invokes trace, so it is not necessary to invoke it manually when making HTTP requests.
def unit[A](a: A): Http[E, A]

Lift a value into an HTTP computation.
Lift a value into an HTTP computation.
The value is strict (computed immediately).
Example
```
val x = HttpOps[String].unit(3.2)
```
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

trait HttpOps[E] extends HttpInstances

Type Members

type D[E, A] = EitherT[W, E, A]

type H[E, A] = Http[E, A]

trait MonadErrorInstance[E] extends MonadError[H, E] with MonadInstance[E]

trait MonadInstance[E] extends Monad[[X]Http[E, X]]

type RequestLog = Vector[LogEntry]

type W[A] = WriterT[Future, RequestLog, A]

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def async[A](a: ⇒ A): Http[E, A]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def liftFuture[A](fut: Future[A]): Http[E, A]

def liftFutureHandle[A](fut: Future[A])(f: PartialFunction[Throwable, Http[E, A]]): Http[E, A]

Example

def map2[A, B, C](ha: Http[E, A], hb: Http[E, B])(f: (A, B) ⇒ C): Http[E, C]

Example

implicit def monad[E]: MonadInstance[E]

implicit def monadError[E]: MonadErrorInstance[E]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def raiseError[A](e: E): Http[E, A]

Example

def sequence[A](hs: Seq[Http[E, A]]): Http[E, Seq[A]]

Example

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def trace(entry: LogEntry): Http[E, Unit]

def unit[A](a: A): Http[E, A]

Example

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from HttpInstances

Inherited from AnyRef

Inherited from Any

Ungrouped