case class PinDefinition(
dataType: PinType,
direction: PinDirection,
voxel: Position
)
sealed trait PinType
object PinType {
case object Number extends PinType
case object Object extends PinType
case object Vector extends PinType
case object Rotation extends PinType
case object Truth extends PinType
case object Constraint extends PinType
case object Pull extends PinType
case class Pointer(of: PinType) extends PinType
}
sealed trait PinDirection
object PinDirection {
case object Input extends PinDirection
case object Output extends PinDirection
}PinType I guess. That's why it's Pull and not Execution because one Before can connect to many Afters
case class Level(
blocks: Set[Block],
wires: Graph[Pin, DiHyperEdge]
)Vector[PinDefinition]
Hmm. I'm close when I do something like this:
case class FancadeF[A](
exports: Vector[Export],
imports: Vector[Import[A]],
)
case class Export(
template: Exists[Template],
pin: PinDefinition
)
case class Import[A](
child: A,
theirExport: PinDefinition,
ourPin: PinDefinition
)It doesn't address:
- Distinguishing between multiple templates, i.e. if I need two different
Get Positionblocks that reference different objects. However realistically that should be handled in a single FancadeF, and I shouldn't have multiple exported templates - Selecting pins, i.e. when I only need to take the width from "screen size" or etc
So we have now the instrumentation stuff in tagless, would make sense for tracing to annotate generic data containers such a lists or options with how big they are or extract identifiers from the received type. How could we write middleware which annotates on such types? Like all transformations are now F ~> G but would it be possible to summon a type class which annotates that data ? Just sketching out loud:
trait ConstrainedFunctionK[F[_], G[_], T[_]] {
def apply[A](fa: F[A])(implicit T: T[A]): G[A]
}
trait TraceData[A] {
def trace(value: A): RIO[OpenTracing, Unit]
}
object TraceData {
implicit def option[A]: TraceData[Option[A]] = new TraceData[Option[A]] {
def trace(value: Option[A]): RIO[OpenTracing, Unit] = OpenTracing.tag("hasValue", value.isDefined)
}
implicit def list[A]: TraceData[List[A]] = new TraceData[List[A]] {
def trace(value: List[A]): RIO[OpenTracing, Unit] = OpenTracing.tag("size", value.size)
}
implicit val any: TraceData[Any] = new TraceData[Any] {
def trace(value: Any): RIO[OpenTracing, Unit] = ZIO.unit
}
}Where T[_] would be TraceData
However the ConstrainedFunctionK is not a valid natural transformation anymore.. :/
I have an abstract class that defines an abstract type, for which I want to require an instance of InvariantK, e.g.:
abstract class Foo {
type Bar[F[_]]
implicit val barInvariantK: InvariantK[Bar]
def bar[F[_]]: Bar[F]
def helloWorld[F[_], G[_]](fk: F ~> G, gk: G ~> F): Bar[G] =
bar[F].imapK(fk)(gk)
}This seems to work, but the implementation is kind of… boilerplatey? (AFAICT the implementing class has to explicitly specify the instance of InvariantK, instead of letting the compiler resolve it.)
Anyone know of a better way to restrict the Bar type alias to types for which an InvariantK[Bar] exists?
Bar really? it's existential to the user of Foo, so it's a bit weird to imapK over it
helloWorld to be passed the InvariantK, since that is the only place it's used.abstract class Foo {
type Bar[F[_]]
def bar[F[_]]: Bar[F]
def helloWorld[F[_], G[_]](fk: F ~> G, gk: G ~> F)(implicit barInvariantK: InvariantK[Bar]): Bar[G] =
bar[F].imapK(fk)(gk)
}helloWorld identical to imapK)
IOLambda class, similar to IOApp but for AWS Lambdas
imapK to try to find a way to support algebras that require ConcurrentEffect in their construction, while still supporting tracing using Natchez (which, since it uses Kleisli, can't go above Concurrent)
abstract class ResourceIOLambda[Resources[_[_]] : InvariantK, A, B] {
def resources[F[_] : ConcurrentEffect : ContextShift : Logger : Timer](blocker: Blocker)
(req: A, context: Context): Resource[F, Resources[F]]
def handleRequestF[F[_] : Concurrent : ContextShift : Logger : Timer : Trace](resources: Resources[F])
(req: A, context: Context): F[B]
private def handleRequest(input: IO[InputStream],
output: IO[OutputStream],
context: Context): IO[Unit] = {
// … calls resources (without tracing) and then handleRequestF (with tracing)
}
final override def handleRequest(input: InputStream, output: OutputStream, context: Context): Unit =
handleRequest(Sync[IO].delay(input), Sync[IO].delay(output), context)
.unsafeRunSync()
}handleRequestF is parameterized with F[_] instead of a concrete IO so tracing can be injected via Kleisli[IO, Span[IO], *]
Meaning the Resources[F] from resources needs to be converted to Resources[Kleisli[F, Span[F], *]] to be passed into handleRequestF
Bar it was failing to derive and I just realised the error is about Foo...
F ~> G and knowing nothing more about F or G we can only convert F[Foo[F]] to G[Foo[F]] but we can't peek inside F to convert the Foo. The type in the error message is how the compiler prints a type lambda F[_] => F[Foo[F]]. I guess it's always educational to try and write an instance FunctorK[Bar] by hand. If you can't (trivially) do it then it can't be derived automatically either. But it's a good way to convince yourself.