What is the equivalent of Product in other langugages?


#1

Topic says it all


#2

Do you mean as in tuples? (Int, String) for instance. Shapeless, Cats, and Scalaz are libraries that have some extensions to these, but that is typically for advanced use.


#3

I’m not sure I understand the question. Are you asking whether Scala has a concept of Product (which it does, and it’s called Product), or whether other languages have something equivalent to Scala’s Product?


#4

I am asking what is the equivalent of Scala’s Product in other languages?

Thanks


#5

Which languages?


#6

It obviously depends on the language, but honestly, not much is coming to mind, at least in terms of direct comparisons. It stands in an odd place, letting a strongly-typed language talk in terms of things positionally.

Obviously, it’s kind of trivial in untyped languages (where position is often much more important), and it’s sometimes accomplished via reflection in some languages. But this precise notion seems unusual, at least in my experience. Don’t know if the pure-functional languages usually have it or not…


#7

In Java the closest thing in vavr library is IMO io.vavr.Tuple . Kotlin has Pair and Triple which are equivalent’s of Scala’s Tuple2 and Tuple3.

Tuples in Scala are subtypes of Product. Tuples add unapply methods so you can pattern match on them. Pattern matching is not built in into Product type itself.


#8

There’s no direct equivalent that I’m aware of. Product is a base trait for all Scala tuple and case class types. It provides a few convenience methods, like getting the Nth element of the product. Other statically-typed languages that have tuple and record types usually don’t provide these kinds of conveniences. For example, in OCaml a 2-tuple type of an int and a string is written like this:

type intString = int * string

In Scala it looks like:

type IntString = (Int, String)

You can call certain convenience methods on Scala values of type IntString, but not on OCaml intString values. But on the other hand, OCaml tuples don’t have a size restriction like Scala does:

scala> (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
<console>:1: error: too many elements for tuple: 27, allowed: 22
       (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
       ^
utop # (1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);;
- : int * int * int * int * int * int * int * int * int * int * int * 
    int * int * int * int * int * int * int * int * int * int * int * 
    int * int * int * int * int
=
(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 1)

#9

Product is really not much used in Scala at all, since it doesn’t provide any type safety. So you might say it it’s hardly even a thing in Scala, let alone in other languages. If it were removed from Scala, few would notice.

It’s really hard to answer a question like this without any context all… without knowing with Product means to you. What are you using it for? Why are you asking about it? If we knew what your goal was in asking about it, we could say more useful things about how those goals are accomplished in other languages. (And about how those same goals are probably better accomplished in Scala with something else.)

“Topic says it all”, but it doesn’t, really.


#10

In other words, do any other languages have a type as annoying as Product with Serializable?

No, in terms of transfinite annoyances, Product with Serializable has been shown to be maximally annoying. There is a famous conjecture that this can be achieved with Product alone, but as far as I know, this has not yet been proved.