class Ref[T](var x: T)
val f: [T] Ref[List[T]] = new Ref(Nil) //This line does not compile
val r1: Ref[List[Int]] = f[Int]
val r2: Ref[List[String]] = f[String]
r1.x = List(1)'=>>' expected, but identifier found@smarter was this example meant to be compiled?
syntax errors for extension method returning implicit function: I get syntax errors with combining both of these together.
type Processor[T] = given Context => T
def (root: xml.Elem) process: Processor[Result] = ...
val root = XML.loadString(...)
given ctx as Context = ...
val result = root.processgives an error value process is not a member of xml.Elem. However, def (root: xml.Elem) blah: Result typechecks fine. I'm using extension methods, implicits functions and typeclasses fine on their own. Thoughts?
type Result = ParseResult[T1] | ParseResult[T1]. The problem is that when I use match statements to operate on the results, type erasure means that I cannot distinguish between the two. Is there a better dotty way? ParseResult is a GADT with three possible subtypes.
I was reading a paper that made an interesting claim about equalisers and coequalisers
Products and co-products are common, but equalizers and co-equalizers are not, perhaps because they correspond to dependent types (since they are objects depending on morphisms).
I had actually never thought of (co)equalisers as something that could appear in types, so I asked the authors if they might have an example in DOT as it is a Dependent Object Types. They showed me the following code in Coq, but thought did not know if this could be expressed in Scala.
Record Quotient {T} (R: T->T->Prop) (pf : equivalence T R) := mkQuo {
Quo : Type;
eqc : T -> Quo;
repr: Quo -> T;
pfResp1 : forall {a b}, R a b -> eqc a = eqc b;
pfResp2 : forall {q}, R q (repr (eqc q));
pfSurj : forall q, eqc (repr q) = q;
}.
Axiom axiomQ : forall {T} (R:T->T->Prop) pf, Quotient R pf. //quotients must be postulated in vanilla CoqIn the above, you can see very clearly that the type Quo is a function of the term R. But I do not know enough Dotty/Scala to be able to rule out such a type altogether.
scala> def bar(xs: Seq[given Int => String]) = classOf[ImplicitFunction1[Int, String]].isAssignableFrom(xs.asInstanceOf[Seq[Any]].head.getClass)
def bar(xs: Seq[given Int => String]): Boolean
scala> bar(Seq(""))
val res2: Boolean = true
scala> class A extends ImplicitFunction1[Int, String] { override def apply given Int: String = the[Int].toString }
// defined class A
scala> bar(Seq(new A))
1 |bar(Seq(new A))
| ^^^^^
| Found: A
| Required: Stringclass A extends ImplicitFunction1[Int, String]is not accepted where ImplicitFunction1[Int, String] is expected
ImplicitFunction1 is actually not a class, just some magic
I'm trying to use AnyKind but I'm not sure its working in this case (this involves connecting to AWS, sttp, Zio):
type RequestType = [T]=>> RequestT[Id, T, Nothing]
trait RequestSigner[R <: AnyKind] extends (R => R) { ... }
class AWSSigner() extends RequestSigner[RequestType] {
def apply[T](r: RequestType[T]): RequestType[T] = { ... }
}
trait Client[R <: AnyKind] extends (R => R) { def host: String }
class ESClient(signer: RequestSigner[RequestType]) extends Client[RequestType] {
def apply[T](r: RequestType[T]) = signer[T](r)
def host = "blah"
}The error I get is
method apply in trait Function1 does not take type parameters
[error] def apply[T](r: RequestType[T]) = signer[T](r)I've tried signer[T] and signer(r) and other things. It seems that the (R => R) in Client causes a problem and I wonder if the (R => R) is handling AnyKind correctly as I would expect it to adapt to the right kind of function argument.
Thoughts?