Понимание синтаксиса scala о функции высокого порядка

Question

Я новичок в scala, мне нужно понять, что происходит с фрагментом кода ниже, а именно sampleFun c val:

val sampleFunc: Seq[Row] => (Int, Long, Boolean, Row, String) = (mem: Seq[Row]) => {
                                //some code
                      (a1,b1,c1,d1,e1) // returning the value
                  }

spark.udf.register("sampleUDF", udf(sampleFunc,
  StructType(
    Seq(
      StructField(a, IntegerType),
      StructField(b, LongType),
      StructField(c, BooleanType),
      StructField(d, StructType(schema.fields)),
      StructField(e, StringType)
    )
  )))

Спасибо.

Answer 1

//<-value name-> <-------------- value type-------------------->   <--------------implementation ----------------------->
//              <-arg type-> <-----result type --------------->   <-function argument->   <----func implementation ---->
val  sampleFunc:  Seq[Row]  => (Int, Long, Boolean, Row, String) = (mem: Seq[Row])      => { /*...*/; (a1,b1,c1,d1,e1) }


//same written differently:
//<-value name-> <-------------- value type------------------------------>   <-------implementation ----------->
val sampleFunc: Funtion1[Seq[Row], Tuple5[Int,Long, Boolean, Row, String]] = {mem => /*...*/; (a1,b1,c1,d1,e1)}

• имя значения: здесь ничего особенного. Просто еще один val в вашем коде.
• тип значения: это долго, но довольно просто. Это тип Function1, который принимает Seq[Row] и возвращает Tuple5[Int, Long, Boolean, Row, String]. Это просто лучший синтаксис scala.
• реализация: Мы создаем функцию, которая принимает Seq[Row] с использованием синтаксиса =>. Здесь тоже ничего особенного.

Answer 2

Хорошо, я вижу, что в фрагменте кода используется Spark, но давайте опустим это и просто посмотрим на sampleFunc. Так что все довольно просто: в следующих конституциях объявляется сама функция:

val sampleFunc: Seq[Row] => (Int, Long, Boolean, Row, String) = ...

, где Seq[Row] тип аргумента функции и (Int, Long, Boolean, Row, String) результат функции. Другими словами, вы создаете переменную типа Function1[Seq[Row], (Int, Long, Boolean, Row, String)]

Затем идет тело функции или реализация, если вы будете

... = (mem: Seq[Row]) => {
                                //some code
                      (a1,b1,c1,d1,e1) // returning the value
                  }

, где mem - это переменная объявленного типа аргумента функции, которая должна быть того же типа или расширить тип, используемый в типе объявления функции. (Аргументы функции являются ко-вариантами. Пожалуйста, посмотрите для другого примера еще один хороший пост SO: Почему функция [-A1, ..., + B] не разрешает использование каких-либо супертипов в качестве параметров? )

=> оператор говорит, что после него идет само тело функции.

Если у вас есть больше Java фона или любого другого императивного языкового фона, это также может быть реализовано способом:

def sampleFunc(mem: Seq[Row]): (Int, Long, Boolean, Row, String) =  {
  //some code
  (a1,b1,c1,d1,e1) // returning the value
}

Надеюсь, это поможет!

Answer 3

Возможно, вам будет легче понять, если вы удалите вызовы фабричных методов Tuple5:

val sampleFunc: Seq[Row] => Tuple5[Int, Long, Boolean, Row, String] = 
    (mem: Seq[Row]) => Tuple5(a1,b1,c1,d1,e1)

и если вы go продолжите и замените => в типе на Function1, вы получите :

Function1[Seq[Row], Tuple5[Int, Long, Boolean, Row, String]]

, что означает, что sampleFunc - это функция, которая принимает аргумент типа Seq[Row] и возвращает Tuple5[Int, Long, Boolean, Row, String]