Function to Accept Any Type but `AnyVal`?

Question

Looking at the Akka docs for creating an Actor:

The recommended approach to create the actor Props is not supported for cases when the actor constructor takes value classes as arguments.

Is it possible to define a function:

def anyTypeButValueClass[A : ...](x: A) = ???

where A is any type except for a value class at compile-time?

My understanding is that value classes extend AnyVal,(per docs) but there's also:

The standard implementation includes nine AnyVal subtypes:

Double, Float, Long, Int, Char, Short, and Byte are the numeric value types.

Unit and Boolean are the non-numeric value types.

per AnyVal.

How can this function be written?

for the `AnyVal` specific case, Lee's answer is spot on. If you want to exclude a particular type, check http://stackoverflow.com/questions/7781782/type-parameter-does-not-extend-given-type — Gabriele Petronella, Jul 15 '16 at 16:44

score 6 · Accepted Answer · edited Jul 15 '16 at 17:17

6

The Scala type hierarchy shows that Any has two direct subtypes, AnyRef and AnyVal for reference and value types respectively.

This means you can just add an AnyRef constraint:

def anyTypeButValueClass[A <: AnyRef](x: A) = ???

edited Jul 15 '16 at 17:17

jub0bs

60,866
25
183
186

answered Jul 15 '16 at 16:00

Lee

142,018
20
234
287

Isn't this wrong per this, I believe, counter-example? `scala> anyTypeButValueClass(true) :13: error: inferred type arguments [Boolean] do not conform to method anyTypeButValueClass's type parameter bounds [A <: AnyRef]` – Kevin Meredith Jul 15 '16 at 16:05
3

@KevinMeredith - Isn't that the behaviour you want? `Boolean` extends `AnyVal`. – Lee Jul 15 '16 at 16:07
My mistake - I was thinking there's a way to distinguish a value class (`extends AnyVal`) from a primitive, e.g. `true, Int, etc.` – Kevin Meredith Jul 15 '16 at 16:44
1

I'm curious to know what the restriction is. Is it just a problem with boxing? Then maybe the API works with primitives but not other value types. – som-snytt Jul 15 '16 at 18:31
@som-snytt https://groups.google.com/forum/#!topic/akka-user/th_zKjeCVSg – Kevin Meredith Jul 20 '16 at 13:40

score 2 · Answer 2 · edited May 23 '17 at 11:58

2

"Accept any type but AnyVal" is answered at Enforce type difference, but it's very different from "Accept any type which doesn't extend AnyVal", which is again different from "Accept any type except for a value class". Value classes do extend AnyVal, but so do the primitive types.

You can do it in this way:

// just a marker trait
sealed trait NotAValueClass[A]

object NotAValueClass {
  implicit def AnyRefIsNotAValueClass[A <: AnyRef]: NotAValueClass[A] = new NotAValueClass[A] {}
  implicit val IntIsNotAValueClass: NotAValueClass[Int] = new NotAValueClass[Int] {}
  ... // same for other primitive types
}

def anyTypeButValueClass[A : NotAValueClass](x: A) = ...

edited May 23 '17 at 11:58

Community

1
1

answered Jul 15 '16 at 16:49

Alexey Romanov

167,066
35
309
487

Thanks, Alexey. Does any library (`shapeless`, etc.) already provide `NotAValueClass[A]` out of the box? – Kevin Meredith Jul 15 '16 at 16:51
I don't know, but I wouldn't expect it. – Alexey Romanov Jul 15 '16 at 16:54
@KevinMeredith, not specifically for `AnyVal`, but shapeless provides a "not subtype of" utility. See my answer for details. – Gabriele Petronella Jul 16 '16 at 09:18
@GabrielePetronella Right, but the point of my answer is that it's different from `NotAValueClass`. – Alexey Romanov Jul 16 '16 at 14:28

score 1 · Answer 3 · answered Jul 16 '16 at 09:14

If you're willing to use a library like shapeless, you could also encode it like

import shapeless._

def anyTypeButValueClass[A: |¬|[AnyVal]#λ](x: A) = x

ref: https://github.com/milessabin/shapeless/blob/master/core/src/main/scala/shapeless/package.scala#L54

example:

@ def anyTypeButValueClass[A: |¬|[AnyVal]#λ](x: A) = x
defined function anyTypeButValueClass

@ anyTypeButValueClass(42)
Compilation Failed
Main.scala:296: ambiguous implicit values:
 both method nsubAmbig1 in package shapeless of type [A, B >: A]=> shapeless.<:!<[A,B]
 and method nsubAmbig2 in package shapeless of type [A, B >: A]=> shapeless.<:!<[A,B]
 match expected type shapeless.<:!<[Int,AnyVal]
anyTypeButValueClass(42)
                ^
@ anyTypeButValueClass("foo")
res0: String = "foo"

Function to Accept Any Type but `AnyVal`?

3 Answers3