the documention seems a bit sparse. I tried creating a sample project.
~/learn/sbt on ☁️ saml took 5s
❯ sbt launchIDE
[info] welcome to sbt 1.3.12 (Private Build Java 14.0.1)
[info] loading project definition from /home/sjoshi/learn/sbt/project
[info] set current project to sbt (in build file:/home/sjoshi/learn/sbt/)
[error] Expected ';'
[error] Not a valid command: launchIDE
[error] Not a valid project ID: launchIDE
[error] Expected ':'
[error] Not a valid key: launchIDE
[error] launchIDE
[error] ^
I hope I am not annoying anyone with my fuzzing results
or at least not too much :)
they are sometimes so weird and require such a cascade of compiler errors to trigger that I am not sure I could come up with a real-life example
@Swoorup anyway, if you're completely new to Scala, I suggest looking for a resource that teaches you Scala from the ground up, there's no Scala 3 specific material for that yet, but a lot of things you'll find in existing Scala 2 tutorials is still valid, check out https://docs.scala-lang.org/overviews/scala-book/introduction.html for example
@alexknvl :heart:
that's like 5 compiler errors in a row :sweat_smile:
takes about a day or two for me to recompile all of them from scratch :sweat_smile:
this is all done using an RNN right?
instrumentation by a java agent
I have a "build server" that handles http requests, creates a new compiler context, collects branch coverage info and any error messages and sends it back to a python process
have you tried to use it to actually fuzz the compiler?
@smarter not yet, haha, even though I have known about it for years now :sweat_smile:
it's really impressive when it fuzzes jsoup
pretty quickly finds a ton edge cases
to do it more efficiently, I think there is a way to start from a small initial corpus of samples with maximized coverage
quick q, how do you pattern match on something like this:
var testVar: String | Integer = 1
Awesome, i realized union types were introduced in dotty, wouldn't union types be preferred over enums, and the inheritance way of doing sum types more now? Any cases why one would still use enums or code like this
sealed trait List[+A]
final case class Empty() extends List[Nothing]
final case class Cons[+A](h: A, t: List[A]) extends List[A]
1 reply
I am not sure how Dotty handles methods on
Empty | Cons[A]... I guess you could very carefully make them have the same methods.
I see, I wasn't aware of the things mentioned above. In that case it does make sense. I do see the value of them in message based systems though, particularly highlighted by this comment: https://github.com/fsharp/fslang-suggestions/issues/538#issuecomment-279976406
Hi, what's the best way to create a group (something with unit, combine and inverse) typeclass and instantiate it using integer modulo some number? For example I have something like:
trait SemiGroup[T] {
extension (x: T) def combine(y: T): T
}
trait Monoid[T] extends SemiGroup[T] {
def unit: T
}
trait Group[T] extends Monoid[T] {
extension (x: T) def inverse: T
}
given Group[Int]:
def unit = 0
extension (x: Int) def combine(y: Int) = x + y
extension (x: Int) def inverse = -xIf I want to implement integer modulo 7, a naive way is to do
case class ModInt7(x: Int, m: Int) {
def add(y: ModInt7) = ModInt7((x + y.x) % m, m)
def inv = ModInt7((-x) % m, m)
}
given Group[ModInt7]:
def unit = ModInt7(0, 7)
extension (x: ModInt7) def combine(y: ModInt7) = x.add(y)
extension (x: ModInt7) def inverse = x.invwhat's the way to generalise this to modulo any number?
@kc1212 here's one way to do it:
trait SemiGroup[T] {
extension (x: T) def combine(y: T): T
}
trait Monoid[T] extends SemiGroup[T] {
def unit: T
}
trait Group[T] extends Monoid[T] {
extension (x: T) def inverse: T
}
trait GroupMod[N <: Int] extends Group[Int] {
def unit: N
extension (x: Int) def combine(y: Int) = (x + y) % unit
extension (x: Int) def inverse = (-x) % unit
}
given [N <: Int : ValueOf] as GroupMod[N] {
val unit: N = valueOf[N]
}
def foo(x: Int, y: Int)(using GroupMod[7]): Int =
x.combine(y)
@main def Test =
println(foo(10, 3))
do you need to distinguish between a.x and b.x, if they both point to the same symbol for x?
do you care about local definitions? (e.g. in
val x = { val a = ...; a }, a is local)