La invocación de una función en un "lado" de un bifuntor depende del valor de un booleano

Question

Si tengo una instancia de Bifunctor[A,A] bf, una función f : A => A y un valor Booleanp:

def calc[A, F[_,_]: Bifunctor](p: Boolean, bf: F[A, A], f: A => A): F[A, A] = { 
    val BF = implicitly[Bifunctor[F]] 
    BF.bimap(bf, (a : A) => if (p) f(a) else a, (a : A) => if (!p) f(a) else a) 
} 

¿Cómo puedo poner esto de manera más concisa (y expresiva)? Básicamente, estoy tratando de invocar una función en un lado de un bifunctor (por ejemplo, un Tuple2) dependiendo de algún predicado. Si el predicado es cierto, quiero asignar el LHS y el RHS si es falsa

val t2 = (1, 2) 
def add4 = (_ : Int) + 4 
calc(true, t2, add4) //should be (5,2) 
calc(false, t2, add4) //should be (1,6) 

---

Dado que yo quiero usar tuplas (a diferencia de la más general Bifunctor), que parecen ser capaces utilizar arrows de la siguiente manera:

def calc[A](p: Boolean, bf: (A, A), f: A => A): (A, A) 
    = (if (p) f.first[A] else f.second[A]) apply bf 

Answer 1

No todo lo que mucho más agradable:

def calc[A, F[_,_]:Bifunctor](p: Boolean, bf: F[A, A], f: A => A): F[A, A] = 
    (if (p) (bf :-> (_: A => A)) else ((_:A => A) <-: bf))(f) 

Un poco más agradable:

def cond[A:Zero](b: Boolean, a: A) = if (b) a else mzero 

def calc[A, F[_,_]:Bifunctor](p: Boolean, bf: F[A, A], f: Endo[A]): F[A, A] = 
    cond(p, f) <-: bf :-> cond(!p, f) 

Algunos Haskell, sólo por la envidia idioma:

calc p = if p then first else second 

Answer 2

Editar: fija para volver (A,A) en lugar de A

Tal vez me falta algo, pero ¿no es esto para lo que son las variables temporales? Con una tupla Scala normal:

Some(bf).map(x => if (p) x.copy(_1 = f(x._1)) else x.copy(_2 = f(x._2))).get 

o

{ val (l,r) = bf; if (p) (f(l),r) else (l,f(r)) } 

Answer 3

¿Esta variante de Apocalisp's solution trabajo?

def calc[A, F[_,_]:Bifunctor](p: Boolean, bf: F[A, A], f: A => A): F[A, A] = 
    (if (p) ((_: F[A,A]) :-> f) else (f <-: (_: F[A,A])))(bf) 

Nota: No he probado esto con scalaz.