Type class on a function type

Question
1

Hi!

I am looking to implement a custom functionality, similar to f1 andThen f2, in order to compose 2 specific function types. So, I attempted to do it via type classes and implement it for the type I want Map[String, Any] => Tag[Int] but apparently the compiler doesn’t like it. I will appreciate your help and do not hesitate to correct my errors.

Thanks!!! :slight_smile:

package com.tagging_core



trait AttemptComposer[A] {

  def orElse(t1: A, t2: A): A
}


case class Tag[A](
  result: Option[A],
  writer: Seq[Map[String, Any]]
)

object Attempt {

  type Something = Map[String, Any]

  type FunctionTag = Something => Tag[Int]

  implicit val attemptComposerFunctionTag: AttemptComposer[FunctionTag] = new AttemptComposer[FunctionTag] {

    def orElse(fT1: FunctionTag, fT2: FunctionTag): FunctionTag = fT1

  }

  def cTag1(s: Something): Tag[Int] = Tag(None, Seq(Map.empty))
  def cTag2(s: Something): Tag[Int] = Tag(Some(3), Seq(Map.empty))
               
  def cTag3(s: Something): Tag[Int] = cTag1 _ orElse cTag2 _
}


Attempt.scala:31: error: value orElse is not a member of com.tagging_core.Attempt.Something => com.tagging_core.Tag[Int]
[ERROR]   def cTag3(s: Something): Tag[Int] = cTag1 _ orElse cTag2 _
2

First thing: you do not automatically get infix syntax (x orElse y) from a typeclass, you have to introduce that. Your code looks as if you’re using Scala 2.x where this can be done as follows:

  implicit class AttemptComposerOps[A](a1: A) {
    def orElse(a2: A)(implicit ac: AttemptComposer[A]): A = ac.orElse(a1, a2)
  }

With that in scope, the compiler will still not be able to figure out what you want to achieve because the return value of cTag3 is not FunctionTag. One of the following two will help:

// change return type to FunctionTag
def cTag3: FunctionTag = cTag1 _ orElse cTag2 _

or

// pass s to the combined FunctionTag function
def cTag3(s: Something): Tag[Int] = (cTag1 _ orElse cTag2 _).apply(s)
2 Likes
3

Hi Martin,

Thanks, it fixed my issue!!

1 Like
4

For the record, in Scala 3 you can get closer to what you were trying to do without extra implicit classes:

trait AttemptComposer[A] {
  extension (t1: A) infix def orElse(t2: A): A
}

case class Tag[A](
  result: Option[A],
  writer: Seq[Map[String, Any]]
)

object Tag {
  type Something = Map[String, Any]
  type FunctionTag = Something => Tag[Int]

  implicit val attemptComposerFunctionTag: AttemptComposer[FunctionTag] = new AttemptComposer[FunctionTag] {
    extension (fT1: FunctionTag) def orElse(fT2: FunctionTag): FunctionTag = fT1
  }
}

import Tag.{Something, FunctionTag}

def cTag1(s: Something): Tag[Int] = Tag(None, Seq(Map.empty))
def cTag2(s: Something): Tag[Int] = Tag(Some(3), Seq(Map.empty))
               
val cTag3 = cTag1 orElse cTag2
2 Likes
5

Thanks for the replies!!

If you let me abuse this post a little bit more, how would you implement the same functionality for any type of Tag?

Something like this I mean

package com.tagging_core



trait AttemptComposer[A] {

  def orElse(t1: A, t2: A): A
}


case class Tag[A](
  result: Option[A],
  writer: Seq[Map[String, Any]]
)

object Attempt {

  type Something = Map[String, Any]

  type FunctionTag[A] = Something => Tag[A]

  implicit val attemptComposerFunctionTag: AttemptComposer[FunctionTag] = new AttemptComposer[FunctionTag] {

    def orElse(fT1: FunctionTag, fT2: FunctionTag): FunctionTag = fT1

  }

  def cTag1(s: Something): Tag[Int] = Tag(None, Seq(Map.empty))
  def cTag2(s: Something): Tag[Int] = Tag(Some(3), Seq(Map.empty))
               
  def cTag3(s: Something): Tag[Int] = cTag1 _ orElse cTag2 _
}

Thanks in advance, and if you can link me to somewhere in the docs that talks about this topic I will appreciate it a lot.

Jorge

6

You can make your typeclass “instance” parameterized as well:

implicit def attemptComposerFunctionTag[A]: AttemptComposer[FunctionTag[A]] = new AttemptComposer[FunctionTag[A]] {

  def orElse(fT1: FunctionTag[A], fT2: FunctionTag[A]): FunctionTag[A] = fT1

}

(or in the latest Scala 3 syntax)

given [A] => AttemptComposer[FunctionTag[A]]:
    def orElse(fT1: FunctionTag[A], fT2: FunctionTag[A]): FunctionTag[A] = fT1
1 Like
7

Great! that solves all my problems.

Thank you so much!