Docs4dev
Docs
scala / 3.2 / scala / function1.html

Trait Function1.Function1

Companion object • Source code

trait Function1[-T1, +R] extends AnyRef

A function of 1 parameter.

In the following example, the definition of succ is a shorthand for the anonymous class definition anonfun1:

object Main extends App {
  val succ = (x: Int) => x + 1
  val anonfun1 = new Function1[Int, Int] {
    def apply(x: Int): Int = x + 1
  }
  assert(succ(0) == anonfun1(0))
}

Note that the difference between Function1 and scala.PartialFunction is that the latter can specify inputs which it will not handle.

Supertypes
class Object
trait Matchable
class Any
Known subtypes
219 types
class From <:< To
class From =:= To
class Conversion[T, U]
trait PartialFunction[A, B]
trait MapOps[K, V, CC, C]
trait Map[K, V]
class AbstractMap[K, V]
class AbstractMap[K, V]
class HashMap[K, V]
class IntMap[T]
class ListMap[K, V]
class LongMap[T]
class Map1[K, V]
class Map2[K, V]
class Map3[K, V]
class Map4[K, V]
class WithDefault[K, V]
class WithDefault[K, V]
class TreeMap[K, V]
class TreeSeqMap[K, V]
class VectorMap[K, V]
class AbstractMap[K, V]
class TrieMap[K, V]
class AnyRefMap[K, V]
class CollisionProofHashMap[K, V]
class HashMap[K, V]
class LinkedHashMap[K, V]
class ListMap[K, V]
class LongMap[V]
class WithDefault[K, V]
class WithDefault[K, V]
class OpenHashMap[Key, Value]
class TreeMap[K, V]
class SystemProperties
trait DefaultMap[K, V]
trait SeqMap[K, V]
trait SeqMap[K, V]
trait SeqMap[K, V]
trait SortedMap[K, V]
trait SortedMap[K, V]
trait SortedMap[K, V]
trait Map[K, V]
trait Map[K, V]
trait Map[K, V]
trait MultiMap[K, V]
trait MapFactoryDefaults[K, V, CC, WithFilterCC]
class WeakHashMap[K, V]
trait MapView[K, V]
class AbstractMapView[K, V]
class Filter[K, V]
class FilterKeys[K, V]
class Id[K, V]
class MapValues[K, V, W]
class TapEach[K, V, U]
trait SortedMapFactoryDefaults[K, V, CC, WithFilterCC, UnsortedCC]
trait SortedMapOps[K, V, CC, C]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait StrictOptimizedSortedMapOps[K, V, CC, C]
trait SortedMapOps[K, V, CC, C]
trait SortedMapOps[K, V, CC, C]
trait StrictOptimizedMapOps[K, V, CC, C]
trait StrictOptimizedMapOps[K, V, CC, C]
trait MapOps[K, V, CC, C]
trait MapOps[K, V, CC, C]
trait Seq[A]
class AbstractSeq[A]
class AbstractSeq[A]
class ArraySeq[A]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class LazyList[A]
class List[A]
class ::[A]
object Nil.type
class NumericRange[T]
class Exclusive[T]
class Inclusive[T]
class Queue[A]
class Range
class Exclusive
class Inclusive
class Stream[A]
class Cons[A]
object Empty.type
class Vector[A]
class WrappedString
class AbstractSeq[A]
class AbstractBuffer[A]
class ArrayBuffer[A]
class ArrayDeque[A]
class Queue[A]
class Stack[A]
class ListBuffer[A]
class UnrolledBuffer[T]
class ArraySeq[T]
class ofBoolean
class ofByte
class ofChar
class ofDouble
class ofFloat
class ofInt
class ofLong
class ofRef[T]
class ofShort
class ofUnit
class StringBuilder
trait IndexedSeq[A]
trait IndexedSeq[A]
trait IndexedSeq[T]
trait IndexedBuffer[A]
trait LinearSeq[A]
trait LinearSeq[A]
trait Seq[A]
trait Seq[A]
trait Buffer[A]
class Accumulator[A, CC, C]
class AnyAccumulator[A]
class DoubleAccumulator
class IntAccumulator
class LongAccumulator
class AbstractPartialFunction[T1, R]
trait SetOps[A, CC, C]
trait Set[A]
class AbstractSet[A]
class AbstractSet[A]
class ValueSet
class ImmutableKeySet
class BitSet
class BitSet1
class BitSet2
class BitSetN
class HashSet[A]
class ListSet[A]
class Set1[A]
class Set2[A]
class Set3[A]
class Set4[A]
class ImmutableKeySortedSet
class TreeSet[A]
class AbstractSet[A]
class BitSet
class HashSet[A]
class LinkedHashSet[A]
class TreeSet[A]
trait SortedSet[A]
trait BitSet
trait SortedSet[A]
trait SortedSet[A]
trait Set[A]
trait Set[A]
trait SortedSetOps[A, CC, C]
trait BitSetOps[C]
trait SortedSetFactoryDefaults[A, CC, WithFilterCC]
trait StrictOptimizedSortedSetOps[A, CC, C]
trait StrictOptimizedSortedSetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
trait SortedSetOps[A, CC, C]
trait StrictOptimizedSetOps[A, CC, C]
trait StrictOptimizedSetOps[A, CC, C]
trait SetOps[A, CC, C]
trait SetOps[A, CC, C]
class FromJavaConsumer[T]
class FromJavaDoubleConsumer
class FromJavaDoubleFunction[R]
class FromJavaDoublePredicate
class FromJavaDoubleToIntFunction
class FromJavaDoubleToLongFunction
class FromJavaDoubleUnaryOperator
class FromJavaFunction[T, R]
class FromJavaIntConsumer
class FromJavaIntFunction[R]
class FromJavaIntPredicate
class FromJavaIntToDoubleFunction
class FromJavaIntToLongFunction
class FromJavaIntUnaryOperator
class FromJavaLongConsumer
class FromJavaLongFunction[R]
class FromJavaLongPredicate
class FromJavaLongToDoubleFunction
class FromJavaLongToIntFunction
class FromJavaLongUnaryOperator
class FromJavaPredicate[T]
class FromJavaToDoubleFunction[T]
class FromJavaToIntFunction[T]
class FromJavaToLongFunction[T]
class FromJavaUnaryOperator[T]
class AbstractFunction1[T1, R]
trait JFunction1$mcDD$sp
trait JFunction1$mcDF$sp
trait JFunction1$mcDI$sp
trait JFunction1$mcDJ$sp
trait JFunction1$mcFD$sp
trait JFunction1$mcFF$sp
trait JFunction1$mcFI$sp
trait JFunction1$mcFJ$sp
trait JFunction1$mcID$sp
trait JFunction1$mcIF$sp
trait JFunction1$mcII$sp
trait JFunction1$mcIJ$sp
trait JFunction1$mcJD$sp
trait JFunction1$mcJF$sp
trait JFunction1$mcJI$sp
trait JFunction1$mcJJ$sp
trait JFunction1$mcVD$sp
trait JFunction1$mcVF$sp
trait JFunction1$mcVI$sp
trait JFunction1$mcVJ$sp
trait JFunction1$mcZD$sp
trait JFunction1$mcZF$sp
trait JFunction1$mcZI$sp
trait JFunction1$mcZJ$sp
Self type
T1 => R

Abstract methods

Source
def apply(v1: T1): R

Apply the body of this function to the argument.

Returns

the result of function application.

Concrete methods

Source
def andThen[A](g: R => A): T1 => A

Composes two instances of Function1 in a new Function1, with this function applied first.

Type parameters
A

the result type of function g
Value parameters
g

a function R => A
Returns

a new function f such that f(x) == g(apply(x))

Source
def compose[A](g: A => T1): A => R

Composes two instances of Function1 in a new Function1, with this function applied last.

Type parameters
A

the type to which function g can be applied
Value parameters
g

a function A => T1
Returns

a new function f such that f(x) == apply(g(x))

Source
override def toString(): String

Returns a string representation of the object.

The default representation is platform dependent.

Returns

a string representation of the object.
Definition Classes Any

Source
def unlift: PartialFunction[A, B]

Implicitly added by UnliftOps

Converts an optional function to a partial function.

Example

Unlike Function.unlift, this UnliftOps.unlift method can be used in extractors.

val of: Int => Option[String] = { i =>
  if (i == 2) {
    Some("matched by an optional function")
  } else {
    None
  }
}
util.Random.nextInt(4) match {
  case of.unlift(m) => // Convert an optional function to a pattern
    println(m)
  case _ =>
    println("Not matched")
}

© 2002-2022 EPFL, with contributions from Lightbend.
Licensed under the Apache License, Version 2.0.
https://scala-lang.org/api/3.2.0/scala/Function1.html