{"id":14982412,"url":"https://github.com/kotlin/kotlin-spark-api","last_synced_at":"2025-04-12T19:43:36.804Z","repository":{"id":37091241,"uuid":"268498799","full_name":"Kotlin/kotlin-spark-api","owner":"Kotlin","description":"This projects gives Kotlin bindings and several extensions for Apache Spark. We are looking to have this as a part of Apache Spark 3.x","archived":false,"fork":false,"pushed_at":"2024-06-20T12:39:02.000Z","size":4636,"stargazers_count":463,"open_issues_count":20,"forks_count":35,"subscribers_count":20,"default_branch":"release","last_synced_at":"2024-12-16T09:29:02.473Z","etag":null,"topics":["bigdata","kotlin","nullability","scala","spark"],"latest_commit_sha":null,"homepage":"","language":"Kotlin","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Kotlin.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":"CODE_OF_CONDUCT.md","threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2020-06-01T11:07:43.000Z","updated_at":"2024-12-10T03:41:38.000Z","dependencies_parsed_at":"2024-01-02T13:53:48.791Z","dependency_job_id":"a2920a0d-e274-4493-bd2d-c006cd2ab320","html_url":"https://github.com/Kotlin/kotlin-spark-api","commit_stats":{"total_commits":550,"total_committers":22,"mean_commits":25.0,"dds":0.510909090909091,"last_synced_commit":"470bcf4dd6a0318a1cd0e947670f921f8f62969e"},"previous_names":["jetbrains/kotlin-spark-api"],"tags_count":25,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Kotlin%2Fkotlin-spark-api","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Kotlin%2Fkotlin-spark-api/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Kotlin%2Fkotlin-spark-api/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Kotlin%2Fkotlin-spark-api/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Kotlin","download_url":"https://codeload.github.com/Kotlin/kotlin-spark-api/tar.gz/refs/heads/release","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":248625479,"owners_count":21135512,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["bigdata","kotlin","nullability","scala","spark"],"created_at":"2024-09-24T14:05:22.319Z","updated_at":"2025-04-12T19:43:36.781Z","avatar_url":"https://github.com/Kotlin.png","language":"Kotlin","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Kotlin for Apache® Spark™\n\n[![Kotlin Stable](https://kotl.in/badges/stable.svg)](https://kotlinlang.org/docs/components-stability.html)\n[![JetBrains official project](http://jb.gg/badges/official.svg)](https://confluence.jetbrains.com/display/ALL/JetBrains+on+GitHub)\n[![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlinx.spark/kotlin-spark-api_3.3.2_2.13.svg?label=Maven%20Central)](https://search.maven.org/search?q=g:\"org.jetbrains.kotlinx.spark\"%20AND%20a:\"kotlin-spark-api_3.3.2_2.13\")\n[![Join the chat at https://gitter.im/JetBrains/kotlin-spark-api](https://badges.gitter.im/JetBrains/kotlin-spark-api.svg)](https://gitter.im/JetBrains/kotlin-spark-api?utm_source=badge\u0026utm_medium=badge\u0026utm_campaign=pr-badge\u0026utm_content=badge)\n\nYour next API to work with  [Apache Spark](https://spark.apache.org/). \n\nThis project adds a missing layer of compatibility between [Kotlin](https://kotlinlang.org/) and [Apache Spark](https://spark.apache.org/).\nIt allows Kotlin developers to use familiar language features such as data classes, and lambda expressions as simple expressions in curly braces or method references. \n\nWe have opened a Spark Project Improvement Proposal: [Kotlin support for Apache Spark](http://issues.apache.org/jira/browse/SPARK-32530) to work with the community towards getting Kotlin support as a first-class citizen in Apache Spark. We encourage you to voice your opinions and participate in the discussion.\n\n## Table of Contents\n\n- [Supported versions of Apache Spark](#supported-versions-of-apache-spark)\n- [Releases](#releases)\n- [How to configure Kotlin for Apache Spark in your project](#how-to-configure-kotlin-for-apache-spark-in-your-project)\n- [Kotlin for Apache Spark features](#kotlin-for-apache-spark-features)\n    - [Creating a SparkSession in Kotlin](#creating-a-sparksession-in-kotlin)\n    - [Creating a Dataset in Kotlin](#creating-a-dataset-in-kotlin)\n    - [Null safety](#null-safety)\n    - [withSpark function](#withspark-function)\n    - [withCached function](#withcached-function)\n    - [toList and toArray](#tolist-and-toarray-methods)\n    - [Column infix/operator functions](#column-infixoperator-functions)\n    - [Overload Resolution Ambiguity](#overload-resolution-ambiguity)\n    - [Tuples](#tuples)\n    - [Streaming](#streaming)\n    - [User Defined Functions](#user-defined-functions)\n- [Examples](#examples)\n- [Reporting issues/Support](#reporting-issues--support)\n- [Code of Conduct](#code-of-conduct)\n- [License](#license)\n\n## Supported versions of Apache Spark\n\n| Apache Spark | Scala |       Kotlin for Apache Spark       |\n|:------------:|:-----:|:-----------------------------------:|\n|    3.3.2     | 2.13  | kotlin-spark-api_3.3.2_2.13:VERSION |\n|              | 2.12  | kotlin-spark-api_3.3.2_2.12:VERSION |\n|    3.3.1     | 2.13  | kotlin-spark-api_3.3.1_2.13:VERSION |\n|              | 2.12  | kotlin-spark-api_3.3.1_2.12:VERSION |\n|    3.3.0     | 2.13  | kotlin-spark-api_3.3.0_2.13:VERSION |\n|              | 2.12  | kotlin-spark-api_3.3.0_2.12:VERSION |\n|    3.2.3     | 2.13  | kotlin-spark-api_3.2.3_2.13:VERSION |\n|              | 2.12  | kotlin-spark-api_3.2.3_2.12:VERSION |\n|    3.2.2     | 2.13  | kotlin-spark-api_3.2.2_2.13:VERSION |\n|              | 2.12  | kotlin-spark-api_3.2.2_2.12:VERSION |\n|    3.2.1     | 2.13  | kotlin-spark-api_3.2.1_2.13:VERSION |\n|              | 2.12  | kotlin-spark-api_3.2.1_2.12:VERSION |\n|    3.2.0     | 2.13  | kotlin-spark-api_3.2.0_2.13:VERSION |\n|              | 2.12  | kotlin-spark-api_3.2.0_2.12:VERSION |\n|    3.1.3     | 2.12  | kotlin-spark-api_3.1.3_2.12:VERSION |\n|    3.1.2     | 2.12  | kotlin-spark-api_3.1.2_2.12:VERSION |\n|    3.1.1     | 2.12  | kotlin-spark-api_3.1.1_2.12:VERSION |\n|    3.1.0     | 2.12  | kotlin-spark-api_3.1.0_2.12:VERSION |\n|    3.0.3     | 2.12  | kotlin-spark-api_3.0.3_2.12:VERSION |\n|    3.0.2     | 2.12  | kotlin-spark-api_3.0.2_2.12:VERSION |\n|    3.0.1     | 2.12  | kotlin-spark-api_3.0.1_2.12:VERSION |\n|    3.0.0     | 2.12  | kotlin-spark-api_3.0.0_2.12:VERSION |\n\n## Deprecated versions\n| Apache Spark | Scala |     Kotlin for Apache Spark     |\n|:------------:|:-----:|:-------------------------------:|\n|    2.4.1+    | 2.12  | kotlin-spark-api-2.4_2.12:1.0.2 |\n|    2.4.1+    | 2.11  | kotlin-spark-api-2.4_2.11:1.0.2 |\n## Releases\n\nThe list of Kotlin for Apache Spark releases is available [here](https://github.com/JetBrains/kotlin-spark-api/releases/).\nThe Kotlin for Spark artifacts adhere to the following convention:\n`[name]_[Apache Spark version]_[Scala core version]:[Kotlin for Apache Spark API version]` \n\nThe only exception to this is `scala-tuples-in-kotlin_[Scala core version]:[Kotlin for Apache Spark API version]`, which is \nindependent of Spark.\n\n[![Maven Central](https://img.shields.io/maven-central/v/org.jetbrains.kotlinx.spark/kotlin-spark-api_3.3.2_2.13.svg?label=Maven%20Central)](https://search.maven.org/search?q=g:\"org.jetbrains.kotlinx.spark\"%20AND%20a:\"kotlin-spark-api_3.3.2_2.13\")\n\n## How to configure Kotlin for Apache Spark in your project\n\nYou can add Kotlin for Apache Spark as a dependency to your project: `Maven`, `Gradle`, `SBT`, and `leinengen` are supported.\n \nHere's an example `pom.xml`:\n\n```xml\n\u003cdependency\u003e\n  \u003cgroupId\u003eorg.jetbrains.kotlinx.spark\u003c/groupId\u003e\n  \u003cartifactId\u003ekotlin-spark-api_3.3.2_2.13\u003c/artifactId\u003e\n  \u003cversion\u003e${kotlin-spark-api.version}\u003c/version\u003e\n\u003c/dependency\u003e\n\u003cdependency\u003e\n    \u003cgroupId\u003eorg.apache.spark\u003c/groupId\u003e\n    \u003cartifactId\u003espark-sql_2.13\u003c/artifactId\u003e\n    \u003cversion\u003e${spark.version}\u003c/version\u003e\n\u003c/dependency\u003e\n```\n\nNote that you must match the version of the Kotlin for Apache Spark API to the Spark- and Scala version of your project.\nYou can find a complete example with `pom.xml` and `build.gradle` in the [Quick Start Guide](https://github.com/JetBrains/kotlin-spark-api/wiki/Quick-Start-Guide).\n\nIf you want to try a development version. You can use the versions published to [GH Packages](https://github.com/orgs/Kotlin/packages?tab=packages\u0026q=kotlin-spark-api_3.3.0_2.13).\nThey typically have the same version as the release version, but with a `-SNAPSHOT` suffix. See the [GitHub Docs](https://docs.github.com/en/packages/learn-github-packages/installing-a-package)\nfor more information.\n\nOnce you have configured the dependency, you only need to add the following import to your Kotlin file: \n```kotlin\nimport org.jetbrains.kotlinx.spark.api.*\n```   \n\n### Jupyter\n\nThe Kotlin Spark API also supports Kotlin Jupyter notebooks.\nTo it, simply add\n\n```jupyterpython\n%use spark\n```\nto the top of your notebook. This will get the latest version of the API, together with the latest version of Spark.\nTo define a certain version of Spark or the API itself, simply add it like this:\n```jupyterpython\n%use spark(spark=3.3.2, scala=2.13, v=1.2.4)\n```\n\nInside the notebook a Spark session will be initiated automatically. This can be accessed via the `spark` value.\n`sc: JavaSparkContext` can also be accessed directly. The API operates pretty similarly.\n\nThere is also support for HTML rendering of Datasets and simple (Java)RDDs.\nCheck out the [example](examples/src/main/kotlin/org/jetbrains/kotlinx/spark/examples/JupyterExample.ipynb) as well.\n\n\nTo use Spark Streaming abilities, instead use\n```jupyterpython\n%use spark-streaming\n```\nThis does not start a Spark session right away, meaning you can call `withSparkStreaming(batchDuration) {}` \nin whichever cell you want.\nCheck out the [example](examples/src/main/kotlin/org/jetbrains/kotlinx/spark/examples/streaming/JupyterStreamingExample.ipynb).\n\nNOTE: You need `kotlin-jupyter-kernel` to be at least version 0.11.0.83 for the Kotlin Spark API to work. Also, if the \n`%use spark` magic does not output \"Spark session has been started...\", and `%use spark-streaming` doesn't work at all, \nadd `%useLatestDescriptors` above it.\n\nFor more information, check the [wiki](https://github.com/JetBrains/kotlin-spark-api/wiki/Jupyter).\n\n## Kotlin for Apache Spark features\n\n### Creating a SparkSession in Kotlin\n```kotlin\nval spark = SparkSession\n        .builder()\n        .master(\"local[2]\")\n        .appName(\"Simple Application\").orCreate\n```\n\nThis is not needed when running the Kotlin Spark API from a Jupyter notebook.\n\n### Creating a Dataset in Kotlin\n```kotlin\nspark.dsOf(\"a\" to 1, \"b\" to 2)\n```\nThe example above produces `Dataset\u003cPair\u003cString, Int\u003e\u003e`. While Kotlin Pairs and Triples are supported, Scala Tuples are \nrecommended for better support.\n \n### Null safety\nThere are several aliases in API, like `leftJoin`, `rightJoin` etc. These are null-safe by design. \nFor example, `leftJoin` is aware of nullability and returns `Dataset\u003cPair\u003cLEFT, RIGHT?\u003e\u003e`.\nNote that we are forcing `RIGHT` to be nullable for you as a developer to be able to handle this situation. \n`NullPointerException`s are hard to debug in Spark, and we're doing our best to make them as rare as possible.\n\nIn Spark, you might also come across Scala-native `Option\u003c*\u003e` or Java-compatible `Optional\u003c*\u003e` classes.\nWe provide `getOrNull()` and `getOrElse()` functions for these to use Kotlin's null safety for good.\n\nSimilarly, you can also create `Option\u003c*\u003e`s and `Optional\u003c*\u003e`s like `T?.toOptional()` if a Spark function requires it.\n### withSpark function\n\nWe provide you with useful function `withSpark`, which accepts everything that may be needed to run Spark — properties, name, master location and so on. It also accepts a block of code to execute inside Spark context.\n\nAfter work block ends, `spark.stop()` is called automatically.\n\nDo not use this when running the Kotlin Spark API from a Jupyter notebook.\n\n```kotlin\nwithSpark {\n    dsOf(1, 2)\n        .map { it X it } // creates Tuple2\u003cInt, Int\u003e\n        .show()\n}\n```\n\n`dsOf` is just one more way to create `Dataset` (`Dataset\u003cInt\u003e`) from varargs.\n\n### withCached function\nIt can easily happen that we need to fork our computation to several paths. To compute things only once we should call `cache`\nmethod. However, it becomes difficult to control when we're using cached `Dataset` and when not.\nIt is also easy to forget to unpersist cached data, which can break things unexpectedly or take up more memory\nthan intended.\n\nTo solve these problems we've added `withCached` function\n\n```kotlin\nwithSpark {\n    dsOf(1, 2, 3, 4, 5)\n        .map { tupleOf(it, it + 2) }\n        .withCached {\n            showDS()\n  \n            filter { it._1 % 2 == 0 }.showDS()\n        }\n        .map { tupleOf(it._1, it._2, (it._1 + it._2) * 2) }\n        .show()\n}\n```\n\nHere we're showing cached `Dataset` for debugging purposes then filtering it. \nThe `filter` method returns filtered `Dataset` and then the cached `Dataset` is being unpersisted, so we have more memory t\no call the `map` method and collect the resulting `Dataset`.\n\n### toList and toArray methods\n\nFor more idiomatic Kotlin code we've added `toList` and `toArray` methods in this API. You can still use the `collect` method as in Scala API, however the result should be casted to `Array`.\n  This is because `collect` returns a Scala array, which is not the same as Java/Kotlin one.\n\n### Column infix/operator functions\n\nSimilar to the Scala API for `Columns`, many of the operator functions could be ported over.\nFor example:\n```kotlin\ndataset.select( col(\"colA\") + 5 )\ndataset.select( col(\"colA\") / col(\"colB\") )\n\ndataset.where( col(\"colA\") `===` 6 )\n// or alternatively\ndataset.where( col(\"colA\") eq 6)\n```\n\nTo read more, check the [wiki](https://github.com/JetBrains/kotlin-spark-api/wiki/Column-functions).\n\n### Overload resolution ambiguity\n\nWe had to implement the functions `reduceGroups` and `reduce` for Kotlin separately as `reduceGroupsK` and `reduceK` respectively, because otherwise it caused resolution ambiguity between Kotlin, Scala and Java APIs, which was quite hard to solve.\n\nWe have a special example of work with this function in the [Groups example](https://github.com/JetBrains/kotlin-spark-api/blob/main/examples/src/main/kotlin/org/jetbrains/kotlinx/spark/examples/Group.kt).\n\n### Tuples\n\nInspired by [ScalaTuplesInKotlin](https://github.com/Jolanrensen/ScalaTuplesInKotlin), the API introduces a lot of helper- extension functions\nto make working with Scala Tuples a breeze in your Kotlin Spark projects. While working with data classes is encouraged,\nfor pair-like Datasets / RDDs / DStreams Scala Tuples are recommended, both for the useful helper functions, as well as Spark performance.\nTo enable these features\nsimply add\n```kotlin\nimport org.jetbrains.kotlinx.spark.api.tuples.*\n```\nto the start of your file.\n\nTuple creation can be done in the following manners:\n```kotlin\nval a: Tuple2\u003cInt, Long\u003e = tupleOf(1, 2L)\nval b: Tuple3\u003cString, Double, Int\u003e = t(\"test\", 1.0, 2)\nval c: Tuple3\u003cFloat, String, Int\u003e = 5f X \"aaa\" X 1\n```\nTo read more about tuples and all the added functions, refer to the [wiki](https://github.com/JetBrains/kotlin-spark-api/wiki/Tuples).\n\n### Streaming\n\nA popular Spark extension is [Spark Streaming](https://spark.apache.org/docs/latest/streaming-programming-guide.html). \nOf course the Kotlin Spark API also introduces a more Kotlin-esque approach to write your streaming programs.\nThere are examples for use with a checkpoint, Kafka and SQL in the [examples module](examples/src/main/kotlin/org/jetbrains/kotlinx/spark/examples/streaming).\n\nWe shall also provide a quick example below:\n```kotlin\n// Automatically provides ssc: JavaStreamingContext which starts and awaits termination or timeout\nwithSparkStreaming(batchDuration = Durations.seconds(1), timeout = 10_000) { // this: KSparkStreamingSession\n\n    // create input stream for, for instance, Netcat: `$ nc -lk 9999`\n    val lines: JavaReceiverInputDStream\u003cString\u003e = ssc.socketTextStream(\"localhost\", 9999)\n  \n    // split input stream on space\n    val words: JavaDStream\u003cString\u003e = lines.flatMap { it.split(\" \").iterator() }\n\n    // perform action on each formed RDD in the stream\n    words.foreachRDD { rdd: JavaRDD\u003cString\u003e, _: Time -\u003e\n      \n          // to convert the JavaRDD to a Dataset, we need a spark session using the RDD context\n          withSpark(rdd) { // this: KSparkSession\n            val dataframe: Dataset\u003cTestRow\u003e = rdd.map { TestRow(word = it) }.toDS()\n            dataframe\n                .groupByKey { it.word }\n                .count()\n                .show()\n            // +-----+--------+\n            // |  key|count(1)|\n            // +-----+--------+\n            // |hello|       1|\n            // |   is|       1|\n            // |    a|       1|\n            // | this|       1|\n            // | test|       3|\n            // +-----+--------+\n        }\n    }\n}\n```\n\nFor more information, check the [wiki](https://github.com/JetBrains/kotlin-spark-api/wiki/Streaming).\n\n### User Defined Functions\n\nSpark has a way to call functions from SQL using so-called [UDFs](https://spark.apache.org/docs/latest/sql-ref-functions-udf-scalar.html).\nUsing the Scala/Java API from Kotlin is not that obvious, so we decided to add special UDF support for Kotlin.\nThis support grew into a typesafe, name-safe, and feature-rich solution for which we will give an example:\n```kotlin\n// example of creation/naming, and registering of a simple UDF\nval plusOne by udf { x: Int -\u003e x + 1 }\nplusOne.register()\nspark.sql(\"SELECT plusOne(5)\").show()\n// +----------+\n// |plusOne(5)|\n// +----------+\n// |         6|\n// +----------+\n\n// directly registering\nudf.register(\"plusTwo\") { x: Double -\u003e x + 2.0 }\nspark.sql(\"SELECT plusTwo(2.0d)\").show()\n// +------------+\n// |plusTwo(2.0)|\n// +------------+\n// |         4.0|\n// +------------+\n\n// dataset select\nval result: Dataset\u003cInt\u003e = myDs.select(\n  plusOne(col(MyType::age))\n)\n```\n\nWe support:\n  - a notation close to Spark's\n  - smart naming (with reflection)\n  - creation from function references\n  - typed column operations\n  - UDAF support and functional creation\n  - (Unique!) simple vararg UDF support\n\nFor more, check the [extensive examples](examples/src/main/kotlin/org/jetbrains/kotlinx/spark/examples/UDFs.kt).\nAlso, check out the [wiki](https://github.com/Kotlin/kotlin-spark-api/wiki/UDF).\n\n## Examples\n\nFor more, check out [examples](examples/src/main/kotlin/org/jetbrains/kotlinx/spark/examples) module.\nTo get up and running quickly, check out this [tutorial](https://github.com/JetBrains/kotlin-spark-api/wiki/Quick-Start-Guide). \n\n## Reporting issues / support\nPlease use [GitHub issues](https://github.com/JetBrains/kotlin-spark-api/issues) for filing feature requests and bug reports.\nYou are also welcome to join [kotlin-spark channel](https://kotlinlang.slack.com/archives/C015B9ZRGJF) in the Kotlin Slack.\n\n## Contribution guide\nContributions are more than welcome! Pull requests can be created for the [main](https://github.com/Kotlin/kotlin-spark-api/tree/main) branch\nand will be considered as soon as possible. Be sure to add the necessary tests for any new feature you add. The [main](https://github.com/Kotlin/kotlin-spark-api/tree/main)\nbranch always aims to target the latest available [Apache Spark version](https://spark.apache.org/downloads.html).\nNote that we use [Java Comment Preprocessor](https://github.com/raydac/java-comment-preprocessor) to build the library\nfor all different supported versions of Apache Spark and Scala. \nThe current values of these versions can be edited in `gradle.properties` and should always be the latest versions for commits.\nFor testing, all versions need a pass for the request to be accepted.\nWe use GitHub Actions to test and deploy the library for all versions, but locally you can also use the `gradlew_all_versions` file.\n\n\nOf the [main](https://github.com/Kotlin/kotlin-spark-api/tree/main) branch, development versions of the library are published to \n[GitHub Packages](https://github.com/orgs/Kotlin/packages?tab=packages\u0026q=kotlin-spark-api). This way, new features can be\ntested quickly without having to wait for a full release. \n\nFor full releases, the [release](https://github.com/Kotlin/kotlin-spark-api/tree/release) branch is updated.\n\n## Code of Conduct\nThis project and the corresponding community is governed by the [JetBrains Open Source and Community Code of Conduct](https://confluence.jetbrains.com/display/ALL/JetBrains+Open+Source+and+Community+Code+of+Conduct). Please make sure you read it. \n\n## License\n\nKotlin for Apache Spark is licensed under the [Apache 2.0 License](LICENSE).\n\n\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fkotlin%2Fkotlin-spark-api","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fkotlin%2Fkotlin-spark-api","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fkotlin%2Fkotlin-spark-api/lists"}