Tell me more ×
Code Review Stack Exchange is a question and answer site for peer programmer code reviews. It's 100% free, no registration required.
up vote 0 down vote favorite

Please, review my implementation of the F# pipeline operator in Scala

class PipelineContainer[F](value: F) {
  def |>[G] (f: F => G) = f(value)
}

implicit def pipelineEnrichment[T](xs: T) = new PipelineContainer(xs)

  test("Find the last but one element in the list") {
    // example: penultimate(List(1,2,3,3,4,5))
    // result: 4

    def reverse[T](list: List[T]) = list.reverse

    def head[T](list: List[T]) = list.head

    def tail[T](list: List[T]) = list.tail

    def lastButOne[T](list: List[T]) = list |> reverse |> tail |> head
  }
share|improve this question

1 Answer

up vote 4 down vote accepted

There isn't much that can be reviewed. If you use Scala 2.10 then you should use an implicit class instead of an implicit conversion. Even better: use an implicit value class:

implicit class PipelineContainer[F](val value: F) extends AnyVal {
  def |>[G] (f: F => G) = f(value)
}

Furthermore, in Scala, type parameter are enumerated starting with an A, but this is more a style issue.

share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.