Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/augustjune/context-applied
Compiler plugin for intuitive tagless final
https://github.com/augustjune/context-applied
Last synced: 7 days ago
JSON representation
Compiler plugin for intuitive tagless final
- Host: GitHub
- URL: https://github.com/augustjune/context-applied
- Owner: augustjune
- License: mit
- Created: 2019-12-17T10:41:44.000Z (about 5 years ago)
- Default Branch: master
- Last Pushed: 2024-07-30T08:05:35.000Z (6 months ago)
- Last Synced: 2024-12-28T20:11:54.732Z (14 days ago)
- Language: Scala
- Homepage:
- Size: 45.9 KB
- Stars: 126
- Watchers: 4
- Forks: 8
- Open Issues: 9
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
context-applied
=============
[](https://travis-ci.com/augustjune/context-applied)
[](https://maven-badges.herokuapp.com/maven-central/org.augustjune/context-applied_2.13)
### Overview
**context-applied** is a Scala compiler plugin that gives you a handle to the value
that has the abilities specified by type parameter context bounds.
Example:
```scala
def fn[F[_]: Monad]: F[Int] = F.pure(12)
```
This scales across multiple contexts as well as multiple type parameters:
```scala
def fn[F[_]: Applicative: Traverse, G[_]: Applicative]: G[F[Int]] =
F.traverse(F.pure(""))(s => G.pure(s.size))
```
*This doesn't require any type class specific syntax nor "summoner" method*.
In fact it is achieved by introducing implicit conversions to the
appropriate value from the implicit scope.
Roughly speaking, you can pretend like you have a value named after the type parameter
of the type that combines specified contexts:
```scala
def fn[A: B: C: D] = {
val A: B[A] with C[A] with D[A] = ???
// In reality A can be either B[A] or C[A] or D[A] in a particular moment
}
```
### Usage
Plugin is available for Scala 2.11, 2.12 and 2.13.
```scala
addCompilerPlugin("org.augustjune" %% "context-applied" % "0.1.4")
```
### Use cases
1. **Custom algebras.**
```scala
trait Console[F[_]] {
def read: F[String]
def write(s: String): F[Unit]
}
def reply[F[_]: Console: FlatMap]: F[String] =
for {
s <- F.read
_ <- F.write(s)
} yield s
```
1. **Non-linear type class hierarchy.**
If you specify two algebras that derive from the same parent,
because of ambiguity you cannot use that parent's syntax.
Typical example of this problem is `Monad` and `Traverse` from *cats*
since they are both subtypes of `Functor`.
```scala
import cats.syntax.all._
def fn[F[_]: Monad: Traverse](fs: F[String]) =
fs.map(_.size) // Compiler error
```
With **context-applied** the first context that has *map* method
in function's context bounds is used.
```scala
def fn[F[_]: Monad: Traverse](fs: F[String]) =
F.map(fs)(_.size) // Monad's map is used
```
### Supported features
1. Kind-projector support.
```scala
def fn[F[_]: ApplicativeError[*[_], Throwable]]: F[Nothing] =
F.raiseError(new RuntimeException)
```
1. Type parameters of any kinds.
```scala
def fn[F[_]: Applicative, B[_, _]: Bifunctor, A: Monoid] = {
val fa: F[A] = F.pure(A.empty)
val rf: Functor[B[A, *]] = B.rightFunctor[A]
}
```
1. Nested scopes.
Syntax is available for any context bounds: in classes, methods and nested methods.
```scala
class Foo[F[_]: Applicative] {
def bar[A: Monoid] = {
def baz[G[_]: Functor](ga: G[A]) =
G.map(ga)(F.pure)
baz(List(A.empty))
}
}
```
### Special cases
Since **context-applied** introduces additional syntax to your program
it is important not to break any existing code or change its meaning.
For this reason there are cases when the plugin
just gracefully skips parts of the program.
It happens when:
1. Name of type parameter is already taken.
```scala
class Foo[F[_]: Functor] {
val F: Int = 12 // F: Functor[F] will not be introduced inside Foo
def f1[A: Monoid](A: Int) = () // A: Monoid[A] will not be introduced inside f1
def f2[F[_]: Monad] = ??? // F: Monad[F] will be available inside f2 as local value
}
```
1. Inside value classes.
```scala
class Foo(val dummy: Boolean) extends AnyVal {
def fn[F[_]: Monad] = ??? // F: Monad[F] will not be introduced inside fn
}
```