Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Activity
  • 10:39
    apointeau opened #2246
  • 10:39
    apointeau synchronize #2233
  • 10:37
    apointeau synchronize #2245
  • 09:41
    apointeau synchronize #2245
  • 09:40
    apointeau synchronize #2245
  • 07:34
    lrytz closed #12505
  • 07:34
    lrytz commented #12505
  • 06:48
    eed3si9n edited #2235
  • 03:44
    eed3si9n edited #2235
  • 03:44
    eed3si9n edited #2235
  • 03:44
    eed3si9n edited #2235
  • 03:44
    eed3si9n edited #2235
  • 03:44
    eed3si9n edited #2235
  • 03:39
    eed3si9n edited #2235
  • Dec 01 23:42
    tribbloid opened #12505
  • Dec 01 21:09

    SethTisue on 2.12.x

    2.12: new Scala SHA (#1511) (compare)

  • Dec 01 21:09
    SethTisue closed #1511
  • Dec 01 16:32
    apointeau opened #2245
  • Dec 01 16:04
    badrinathpatchikolla commented #10129
  • Dec 01 15:28
    arata-honda opened #2244
Rob Norris
@tpolecat
Same reasoning as class/interface in Java I imagine.
nafg
@nafg
@klassegeljakt if the reason is JVM startup time, you may want to look into scala-native or Graal VM
Klas Segeljakt
@segeljakt
Ok I'll take a look
If you know any more libs please let me know 🙏
Rob Norris
@tpolecat
I guess I should own up to writing a cursed DSL. Take it as a warning https://github.com/tpolecat/basic-dsl
Miguel Pérez Pasalodos
@mpasa
That is just great :smile:
Hanns Holger Rutz
@Sciss

Is there a way to constrain a Double to "just smaller than 1.0" such that (aDouble * aPositiveInt).toInt < aPositiveInt is guaranteed to hold? I.e. I don't want to perform that check after each multiplication. Like I can empircally get a very long literal:

assert (0.999999999999999944488848768742172978818416595 < 1)

assert ((0.999999999999999944488848768742172978818416595 * Int.MaxValue).toInt < Int.MaxValue)

But I wasn't patient enough to keep looking for the digits (seems there are more)

(Plus I'm afraid this might rely on the particular JVM, OS, or something)
Hanns Holger Rutz
@Sciss
This looks better: java.lang.Double.longBitsToDouble(0x3fefffffffffffffL) - comments?
Otto Chrons
@ochrons
yea, use longBitsToDouble, that's what I would use :)
Martijn Hoekstra
@martijnhoekstra
I think what you're asking is equivalent to the largest double smaller than 1.0. That's java.lang.Math.nextAfter(1.0, -1.0)
Otto Chrons
@ochrons
funny enough, I had exactly the same concern in my scheduling algorithm yesterday as it takes in 0.0 <= x < 1.0
and I needed to scale that to 0..N-1 where N is the number of input elements
Luciano
@lJoublanc

I'm writing a typeclass that should have an instance for a type refinement (using shapelss' Aux trick). However, I keep on getting this kind of compiler error when trying to instantiate the extension ops:

<console>:21: error: inferred kinds of the type arguments (Int,Int,res1.F[a],res1.O[k],res
1.U) do not conform to the expected kinds of the type parameters (type K,type V,type F,typ
e O,type U).
res1.F[a]'s type parameters do not match type F's expected parameters:
type F has one type parameter, but type F has one, res1.O[k]'s type parameters do not matc
h type O's expected parameters:
type O has one type parameter, but type O has one
       Series.Indexable.ops.toAllIndexableOps(res1)
                            ^

It seems nonsensical to me. Anybody got ideas how to fix this?

The above occurs when calling e.g. Series.Indexable.ops.toAllIndexableOps(res1)
Jan Bessai
@JanBessai
does it need to be called with rest1.F instead of res1.F[a] maybe?
can you try and make an example with minimal context?
abstract class A {
  protected def foo(): Unit
}

object X {
  def proxyA(x: A): A = new A { def foo() = x.foo() }
}
any idea why this yields
Test.scala:6: error: method foo in class A cannot be accessed in A
 Access to protected method foo not permitted because
 prefix type A does not conform to
 <$anon: A> where the access takes place
  def proxyA(x: A): A = new A { def foo() = x.foo() }
I feel this is confusing, since access happens within a subclass of A
Jan Bessai
@JanBessai
this is fixable with protected [somePackage], but I'm not sure I understand why it doesn't work without that
Martijn Hoekstra
@martijnhoekstra
I think (I'm not sure) that what you wrote is the moral equivalent to object X = { def foo() = x.foo }; new A with X
at least, that's the only way I can make sense of it, and it sounds sort of kind of consistent
no, that's nonsense
disregard that
Harrison Houghton
@hrhino
I think you can't access protected methods of a superclass if you can't prove that it's a subclass of your enclosing class.
hrhino @hrhino has spent way too much time pondering how exactly does a protected do.
Muhammad Asif Adnan
@MuhammadAsifAdnan
Any beginner friendly tutorial on how to build a web application with the play framework scala 2.6x ? Thanks
every tutorial i try to follow is outdated like it uses some library that is deprecated or its in java. im a beginner on web server technology so im thinking if i should change my track
Hanns Holger Rutz
@Sciss
@martijnhoekstra java.lang.Math.nextAfter looks good, thanks
Ichoran
@Ichoran
You can also use java.lang.Math.nextDown(1.0) to avoid the second sign argument (which can be confusing).
Martijn Hoekstra
@martijnhoekstra
+1
Ichoran
@Ichoran
Do be sure you use 1.0 and not 1! It's overloaded and will select the Float version if you use 1.
Hanns Holger Rutz
@Sciss
LOL, ok
Hanns Holger Rutz
@Sciss

Is there a way to make import aliasing work with setters. Like

class Foo { var bar = 0 }

def test1(f: Foo): Unit = {
  import f.{bar => baz}
  baz += 1  // no
}

def test2(f: Foo): Unit = {
  import f.{bar => baz, bar_= => baz_=}
  baz += 1  // no
}

?

Luciano
@lJoublanc
You can do something similar with Lenses/Optics (set/get)
Harrison Houghton
@hrhino
that's a bug
Luciano
@lJoublanc
But it doesn't use import, but rather a lens, declared as a val.
Harrison Houghton
@hrhino
the hint is telling:
<console>:15: error: value += is not a member of Int
  Expression does not convert to assignment because:
    value baz is not a member of Foo
    expansion: f.<baz: error> = f.baz.$plus(1)
         baz += 1  // no
             ^
please report it?
Martijn Hoekstra
@martijnhoekstra
def test1(f: Foo): Unit = {
  import f.{bar => baz}
  baz += 1  // no
}
sounds like it should work. I'd investigate if not working is not a bug.
Luciano
@lJoublanc
@JanBessai Thanks for your hint. I've managed to minimize the use case, as follows:
import simulacrum.typeclass

@typeclass trait MyTypeclass[F[_[a] <: Option[a]]] {
  def foo[A,G[a] <: Option[a],H[a] <: Option[a]](fa : F[G]) : F[H]
}

trait Test[A] {
  type F[a] <: Option[a]
  type B <: Int
}

object Test {

  type Aux[A,F0[a] <: Option[a], B0 <: Int] = Test[A] { type F[a] = F0[a] ; type B = B0 }

  def apply[A,F0[a] <: Option[a],B0 <: Int] : Aux[A,F0,B0] = new Test[A] { type F[a] = F0[a]  ; type B = B0 }

  implicit def instance[A,B] : MyTypeclass[Aux[A,?[_],B]] = ???
}
And I think I know what causes this ... I now recall asking this before. I think it's a problem with partial unification.
This doesn't raise errors when F0[a] is the last parameter.
Harrison Houghton
@hrhino
@martijnhoekstra it's a bug because when the rewrite happens, the setter is referenced by name, not by symbol
or at least, that's what I'd say
Martijn Hoekstra
@martijnhoekstra
I'd say the same, but the spec surprised me before. Then again, if this is as specced, I'd argue it's a bug in the spec and the implementation both
Harrison Houghton
@hrhino
If x is a parameterless method defined in some template, and the same template contains a setter method x_= as member, then the assignment x = e is interpreted as the invocation x_=(e) of that setter method. Analogously, an assignment f.x = e to a parameterless method x is interpreted as the invocation f.x_=(e).
hmm, so, that's vaguely ambiguous since x is a symbol, not a name, but it doesn't explain what a "setter method" is
other than that in this case x's setter method is x_=

when it comes to imports,

If x is bound by an import clause, then the simple name x is taken to be equivalent to the qualified name to which x is mapped by the import clause.

which is also kinda ambiguous

but I would argue that on the whole, if some expression works with a non-renaming import, it should work with the renaming import modulo α-conversion of the name within the scope of the import