A relaxed chat room about all things Scala (2 & 3 both). Beginner questions welcome. https://scala-lang.org/conduct/ applies
I wasted a day struggling with this:
trait Model {
type State
}
trait Algorithm {
val model: Model
type State = model.State
def infer: State
}
val m: Model = new Model {
type State = Int
}
val a = new Algorithm {
val model = m
def infer = 1
}This throws an error:
ScalaFiddle.scala:21: error: type mismatch;
found : scala.this.Int(1)
required: $anon.this.State
(which expands to) $anon.this.model.State
def infer = 1
^I stared at the longest time on the definition of val a because that's where the error was coming from, but eventually realized the cause was my definition of val m. If I remove the : Model and make it val m = new Model {...} it works.
@_jedw_twitter here you could find more about matchers http://www.scalatest.org/user_guide/using_matchers
when you do
: Model you remove the refinement
which is inferred otherwise
it should be
m: Model {type State = Int }
which is very commonly used in the shapeless world
I'd recommend using existentials only when you need them though
the error is when you try to unify it with
Int later
well, replace that word with "abstract"
scala allows you to have abstract types
ok then i'm not sure when one would need a type to be existential as opposed to just a type parameter
for example, imagine
List[Algorithm]
and the in-out is the only thing that matters from the outside
if you had
Algorithm[State] you woudn't be able to put them in a List with a proper type
in this case through an abstract type
does that make any sense?
yeah
the answer is not that simple unfortunately
you need to distinguish between existential and universal types as a general concept (e.g. in type theory), and the programming language features that encode them
but in short, no, it's not an aesthetic thing
it sort of makes sense... coz when you define
trait MyTrait[T] you're saying MyTrait[T] exists for every T but if you say trait MyTrait {type T} you're making no such guarantees
it sort of makes sense... coz when you define
trait MyTrait[T]you're sayingMyTrait[T]exists for everyTbut if you saytrait MyTrait {type T}you're making no such guarantees
yes, you are making a different guarantee, that it exists a T for which MyTrait exist
those correspond to universal and existential quantification in logic
because at the heart of all this there's a very deep theoretical result which links type theory and logic