mergeconflict

scala> implicitly[Bijection[String, Int]]
bijection.this.Bijection.identity is not a valid implicit value for com.twitter.bijection.Bijection[String,Int] because:
type mismatch;
 found   : com.twitter.bijection.Bijection[Any,Any]
 required: com.twitter.bijection.Bijection[String,Int]
Note: Any >: String, but trait Bijection is invariant in type A.
You may wish to define A as -A instead. (SLS 4.5)
Note: Any >: Int, but trait Bijection is invariant in type B.
You may wish to define B as -B instead. (SLS 4.5)
bijection.this.Bijection.identity is not a valid implicit value for com.twitter.bijection.Bijection[Int,String] because:

mergeconflict

package com.mergeconflict.outclass;

import static org.objectweb.asm.Opcodes.ACC_PUBLIC;
import static org.objectweb.asm.Opcodes.ACC_STATIC;
import static org.objectweb.asm.Opcodes.GETSTATIC;
import static org.objectweb.asm.Opcodes.RETURN;
import static org.objectweb.asm.Opcodes.*;

import java.io.FileOutputStream;
import java.io.IOException;

mergeconflict

module Main (main) where

import           Control.Monad.RWS
import           Control.Monad.Writer
import           Data.Binary.Builder
import qualified Data.ByteString.Lazy as Lazy
import           Data.Hashable
import           Data.HashMap.Lazy (HashMap)
import qualified Data.HashMap.Lazy as Map
-- import           Data.Map (Map)

mergeconflict

object AllExamples extends App {
  import shapeless._

  final class All[L <: HList](val values: L) {
    def apply[A](implicit selector: Selector[L, A]): A = values.select[A]
  }

  object All {

    // package a value of type A, convertible to type B, into an HList containing just B

mergeconflict

object Hoho {

  trait Foo[A] {
    def phooey(): Unit
  }

  implicit def intFoo(i: Int): Foo[Int] = new Foo[Int] {
    def phooey(): Unit = println("int " + i.toString)
  }

mergeconflict

trait CategoryFoldableV[F[_], C[_, _], A] extends FoldableV[F, C[A, A]] {
  implicit def C: Category[C]
  ////
  final def composeRight = sumr(Monoid.liftCategory)
}

trait ToFoldableV0 {
  implicit def ToFoldableVUnapply[FA](v: FA)(implicit F0: Unapply[Foldable, FA]) =
    new FoldableV[F0.M,F0.A] { def self = F0(v); implicit def F: Foldable[F0.M] = F0.TC }
}