shapeless

I have this code that I would like to improve on: sealed abstract class A case class B() extends A case class C() extends A case class D() extends A case class Foo[+T <: A](a: T) /** Puts instances that match Foo(B()) in the first list and everything else, * i.e. Foo(C()) and Foo(D()), in the second list. */ def partition(foos: List[Foo[_ <: A]]): (List[Foo[B]], List[Foo[_ <: A]]) = { // ... } I would like to improve on this in the following respects: Can I change partition 's return type so that it states that there is no Foo[B] in the second list? Can I get rid of Foo 's type parameter T (i

This question already has an answer here: Enforce type difference 7 answers Is there any way to constraint a method so that it only makes sense if two types are proved not to be equal? trait Something[A, B] { // I can only be called if type A is the same as type B def ifEqual(implicit ev: A =:= B) // Now I cannot be called if type A is proven to be the same as type B def ifNotEqual(implicit ev: A ??? B) } Yes. From shapeless , // Type inequalities trait =:!=[A, B] implicit def neq[A, B] : A =:!= B = new =:!=[A, B] {} implicit def neqAmbig1[A] : A =:!= A = ??? implicit def neqAmbig2[A] : A =:!=

This is essentially what I want: case class Foo[T](x: T) object combine extends Poly { implicit def caseFoo[A, B] = use((f1: Foo[A], f2: Foo[B]) => Foo((f1.x, f2.x))) } def combineHLatest[L <: HList](l: L) = l.reduceLeft(combine) So combineHLatest(Foo(1) :: Foo("hello") :: HNil) should yield Foo( (1, "hello") ) The above doesn't compile as it cannot find an implicit LeftReducer but I'm at a loss as to how to implement one. It was pretty late last night when I answered this, and while the information in the original answer below is correct, it's not necessarily the most helpful presentation.

How can I pass some HList as an argument? So I can make in a such way: def HFunc[F, S, T](hlist: F :: S :: T :: HNil) { // here is some code } HFunc(HList(1, true, "String")) // it works perfect But if I have a long list, and I dunno nothing about it, how can I make some operations on it? How can I pass argument and not to loose its type? It depends on your use-case. HList is useful for type-level code, so you should pass to your method not only HList , but also all necessary information like this: def hFunc[L <: HList](hlist: L)(implicit h1: Helper1[L], h2: Helper2[L]) { // here is some code

I've seen an object (probably a function) called "at" sprinkled throughout the shapeless source and in code that uses shapeless. In particular, it is used in the answer to this other question . Here is the code snippet: object iterateOverHList extends Poly1 { implicit def iterable[T, L[T] <: Iterable[T]] = at[L[T]](_.iterator) } I've had some clue that it is related to the apply method of the ~> type. What specifically does "at" do, and where is it defined? Definition of PolyN#at at is a general way to work with Poly . ~> with apply is a special case of Poly1 . apply here is used to define

I'm trying to use pureConfig and configFactory for my spark application configuration. here is my code: import pureconfig.{loadConfigOrThrow} object Source{ def apply(keyName: String, configArguments: Config): Source = { keyName.toLowerCase match { case "mysql" => val properties = loadConfigOrThrow[DBConnectionProperties](configArguments) new MysqlSource(None, properties) case "files" => val properties = loadConfigOrThrow[FilesSourceProperties](configArguments) new Files(properties) case _ => throw new NoSuchElementException(s"Unknown Source ${keyName.toLowerCase}") } } } import Source val