A tool to analyze Rust workspace dependency structures and identify opportunities for splitting crates into smaller, parallelizable units to improve build times.
Why "tarjanize"? The tool is named after Robert Tarjan, whose algorithms are central to both phases of our analysis:
| sealed trait Validation[+E, +A] { | |
| def map[B](f: A => B): Validation[E, B] | |
| def flatMap[EE >: E, B](f: A => Validation[EE, B]): Validation[EE, B] | |
| def <*>[EE >: E, AA, B](aa: Validation[EE, AA])(implicit valueToFunction: A <:< (AA => B)): Validation[EE, B] | |
| } | |
| object Validation { | |
| case class Success[+A](value: A) extends Validation[Nothing, A] { | |
| def map[B](f: A => B): Validation[Nothing, B] = |
| import language.{ higherKinds, implicitConversions } | |
| trait Unapply[TC[_[+_]], FA] { | |
| type F[+_] | |
| type A | |
| def TC: TC[F] | |
| def apply(fa: FA): F[A] | |
| } | |
| object Unapply { |
| // this is really "category" but omg math words | |
| trait Stackable[S[_, _]] { | |
| def compose[A, B, C](lhs: S[A, B], rhs: S[B, C]): S[A, C] | |
| def id[A]: S[A, A] | |
| } | |
| object Stackable { | |
| // for example ... | |
| implicit val function1stackable = new Stackable[Function1] { | |
| def compose[A, B, C](lhs: A => B, rhs: B => C): A => C = lhs andThen rhs |
| data Term = Var Int | |
| | Abs Term | |
| | App Term Term | |
| deriving Eq | |
| instance Show Term where | |
| show (Var index) = show index | |
| show (Abs body) = "λ." ++ show body | |
| show (App lhs rhs) = "(" ++ show lhs ++ " " ++ show rhs ++ ")" |
| package sandbox | |
| import akka.actor.{ Actor, ActorRef, ActorSystem, Props } | |
| class Println extends Actor { | |
| def receive = { | |
| case message => println(message) | |
| } | |
| } | |
| object Println { |
| package sandbox | |
| trait Monoid[A] { | |
| def empty: A | |
| def append(lhs: A, rhs: A): A | |
| } | |
| case class Writer[W, A](a: A, w: W) { | |
| def map[B](f: A => B): Writer[W, B] = Writer(f(a), w) | |
| def flatMap[B](f: A => Writer[W, B])(implicit W: Monoid[W]) = { |
| case class Inject[-E, +A](inject: E => A) { | |
| // covariant functor and monad | |
| def map[B](f: A => B): Inject[E, B] = | |
| Inject { e => f(inject(e)) } | |
| def flatMap[ε <: E, B](f: A => Inject[ε, B]): Inject[ε, B] = | |
| Inject { e => f(inject(e)).inject(e) } | |
| // to satisfy for-comprehension desugaring in scala < 2.10 | |
| def filter(f: A => Boolean): Inject[E, A] = |
| import java.util.function.BiFunction; | |
| import java.util.function.Function; | |
| import java.util.function.Supplier; | |
| /* | |
| * Java 8 fantasy land spec: | |
| * | |
| * A monad is a parameterized data type `M` with the following constraints | |
| * - An instance `M<A>` must have a method: `public <B> M<B> bind(Function<A, M<B>> f)` | |
| * - `M` must have a static method: `public static <A> M<A> point(A value)` |
| import java.util.function.Function; | |
| public interface Bug { | |
| static void bug() { | |
| bug(a -> a); | |
| } | |
| static void bug(Function<?, ?> f) {} | |
| } |