0

I've seen some APIs that have a def foo and then a slightly different def foo1, but I can't figure out what this means other than "foo1 is kind of like foo but slightly different." It reminds me of "Ex" ( What does "Ex" stand for in Windows API function names? )

I'm guessing this is a reference to a Haskell/FP or mathematical convention, is it just foo-prime?

Is there any meaning implied (does foo1 have to relate to foo in some specific way) or is it more "I needed two similar functions and overloading was ambiguous, screw it, let's put a 1 on the end"? Should I assume anything beyond "these two functions are somehow related"?

Community
  • 1
  • 1
Havoc P
  • 8,365
  • 1
  • 31
  • 46
  • 2
    +1 "some APIs" is not much to go on. Perhaps these are crap APIs, designed by morons? – oxbow_lakes Jun 25 '12 at 15:57
  • well I was thinking if it's an actual convention people would know it without knowing the specific API ;-) I'm looking at for example Play Promise has extend/extend1, Play Iteratee has fold/fold1, and I was just reading this morning about an example in scalaz that I'm not personally familiar with. – Havoc P Jun 25 '12 at 17:27
  • If nobody knows examples the answer could be "this is not a well-known convention" I think. – Havoc P Jun 25 '12 at 17:32

3 Answers3

2

The example I can think of is rep and rep1 in scala.util.parsing.combinator.Parsers, where rep is any number of repeats and rep1 is for 1 or more. There's also a repN method for N repeats, so here the meaning of the 1 suffix is pretty obvious.

Luigi Plinge
  • 50,650
  • 20
  • 113
  • 180
1

I think that context is probably everything here. The only example I can think of this is the foldl1 method in scalaz. As the library authors would no doubt point out, what the method actually does it completely transparent from looking at the types themselves:

trait MA[M[_], A] {
  def foobar(f: (A, A) => A)(implicit FoldableM: Foldable[M]): Option[A]
}

However, in this case, it's clearly a special form of foldl, that is, fold left but use the 1st element as a seed rather than an explicitly provided value. Hence foldl1 is sensible and intuitive in context.

You say you have seen this a few times: can you point out other occurrences?

oxbow_lakes
  • 133,303
  • 56
  • 317
  • 449
  • Here's a fold1: https://github.com/playframework/Play20/blob/master/framework/src/play/src/main/scala/play/api/libs/iteratee/Iteratee.scala#L51 and an extend1: https://github.com/playframework/Play20/blob/master/framework/src/play/src/main/scala/play/api/libs/concurrent/Promise.scala#L53 – Havoc P Jun 25 '12 at 17:30
0

Scala's contains types like Function and Tuple, which have a family of types, each member being named for the number of arguments it takes.

Function1[T1] => R
Function2[T1, T2] => R

Tuple1[T1]
Tuple2[T1, T2]

In both cases the name of the type must be distinct and using the number of arguments is a great way to describe the type (Function4 is the type of a function that takes 4 arguments, Tuple3 is the type of a Tuple containing 3 items).

As the other answers have said, it helps to have some context but it could be that your examples are inspired (rightly or wrongly) by these choices in the standard library.

adamnfish
  • 10,935
  • 4
  • 31
  • 40