How to ensure Scala generic function outputs a primitive array instead of an object array?

The problem lies in your toArray in call:

val notFirstDecoded = decoded
      .zipWithIndex
      .filter({case (_, i) => i != 0})
      .map(_._1)
      .toArray

toArray takes implicit ClassTag argument - it needs to know the runtime type of array elements to create the Array.

As you provide implicit ClassTag argument to decodeAgg, toArray happily takes what you deliver.

def decodeAgg[A, B](bytes: Array[Byte], helper: Helper[A, B])(implicit ev: ClassTag[A]): B

You can see that ClassTag corresponds to first generic argument of Helper.

You pass following helper:

val helper: Helper[_, _] = args(1) match {
      case "int" => IntHelper
      case "string" => StringHelper
      case _ => throw new Exception("unknown data type")
    }

The ClassTag is thus inferred to Object, which is why you get an Array of objects.

Note that if you use an IntHelper directly, the ClassTag is constrained to the correct type, and the function works as expected.

val aggregated = decodeAgg(bytes, IntHelper)

Solution ideas

There might be multiple ways to resolve it. One idea might be to provide the classTag explicitly via Helper

import scala.reflect.ClassTag
import java.nio.charset.StandardCharsets

object Main {
  trait Helper[A, B] {
    def decode(bytes: Array[Byte]): Array[A]
    def aggregate(values: Array[A]): B
    def classTag: ClassTag[A]
  }

  object StringHelper extends Helper[Byte, String] {
    def decode(bytes: Array[Byte]): Array[Byte] = bytes.filter(_ != 0)
    def aggregate(values: Array[Byte]): String = new String(values, StandardCharsets.UTF_8)
    def classTag: ClassTag[Byte] = ClassTag(classOf[Byte])
  }

  object IntHelper extends Helper[Int, Int] {
    def decode(bytes: Array[Byte]): Array[Int] = bytes.map(_.toInt)
    def aggregate(values: Array[Int]): Int = values.sum
    def classTag: ClassTag[Int] = ClassTag(classOf[Int])
  }

  def decodeAgg[A, B](bytes: Array[Byte], helper: Helper[A, B]): B = {
    val decoded = helper.decode(bytes)
    val notFirstDecoded = decoded
      .zipWithIndex
      .filter({case (_, i) => i != 0})
      .map(_._1)
      .toArray(helper.classTag)
    helper.aggregate(notFirstDecoded)
  }

  def main(args: Array[String]) {
    val helper = args(1) match {
      case "int" => IntHelper
      case "string" => StringHelper
      case _ => throw new Exception("unknown data type")
    }
    val bytes = Array(97, 98, 99).map(_.toByte)
    val aggregated = decodeAgg(bytes, helper)
    println(s"aggregated to $aggregated")
  }
}