К основному содержанию
скилл CX Codex

python-scala-functional — скилл для Claude Code

Скилл python-scala-functional для Claude Code помогает переписывать Python-код в функциональном стиле Scala. Показывает приёмы работы с замыканиями, генераторами, обработкой ошибок и Optional.

Apache-2.0 1 установок ★ 1 933 обновлён 2026-10-24

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add benchflow-ai/skillsbench --skill python-scala-functional -a claude-code
Открыть на GitHub

Что делает python-scala-functional

Скилл показывает, как переносить в Scala функции высшего порядка, декораторы, сопоставление с образцом и композицию функций. На примерах разбираются Option, Try и Either, каррирование и частичное применение, а генераторы заменяются на LazyList или Iterator.

В руководстве есть фрагменты кода на Python и Scala с пояснениями к соответствующим приёмам. Для бесконечной последовательности Фибоначчи приведены варианты на LazyList и Iterator; в Scala 2.12 вместо LazyList использовался Stream.

Какие задачи решает

  • переписать функцию высшего порядка с Python на Scala
  • заменить декоратор композицией функций
  • перенести обработку Optional на Option и flatMap
  • представить генератор как LazyList или Iterator
  • обработать ошибки через Try или Either

Примеры запросов агенту

  • Перепиши эту Python-функцию с замыканием в функциональном стиле Scala.
  • Покажи, как заменить цепочку проверок None на Option и flatMap в Scala.
  • Перенеси Python-генератор в Scala через LazyList.

Как установить python-scala-functional

1Через Skills CLI (Vercel)

npx skills add benchflow-ai/skillsbench --skill python-scala-functional -a claude-code

2Вручную: положить файлы

~/.claude/skills/python-scala-functional/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/python-scala-functional/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о python-scala-functional

Как установить python-scala-functional в Claude Code?

Выполните npx skills add benchflow-ai/skillsbench --skill python-scala-functional -a claude-code. Файл скилла находится по пути ~/.claude/skills/python-scala-functional/SKILL.md.

Что делает python-scala-functional?

Подсказывает, как переносить конструкции Python в функциональный стиль Scala: от композиции функций до Option, Try и ленивых последовательностей.

Чем заменить Python-генератор в Scala?

В примерах скилла генератор представлен через LazyList или Iterator. Для бесконечного ряда Фибоначчи показаны оба варианта.

Исходный текст

SKILL.md · Apache-2.0
---
name: python-scala-functional
description: Guide for translating Python code to functional Scala style. Use when converting Python code involving higher-order functions, decorators, closures, generators, or when aiming for idiomatic functional Scala with pattern matching, Option handling, and monadic operations.
---

# Python to Scala Functional Programming Translation

## Higher-Order Functions

```python
# Python
def apply_twice(f, x):
    return f(f(x))

def make_multiplier(n):
    return lambda x: x * n

double = make_multiplier(2)
result = apply_twice(double, 5)  # 20
```

```scala
// Scala
def applyTwice[A](f: A => A, x: A): A = f(f(x))

def makeMultiplier(n: Int): Int => Int = x => x * n

val double = makeMultiplier(2)
val result = applyTwice(double, 5)  // 20
```

## Decorators → Function Composition

```python
# Python
def log_calls(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        result = func(*args, **kwargs)
        print(f"Finished {func.__name__}")
        return result
    return wrapper

@log_calls
def add(a, b):
    return a + b
```

```scala
// Scala - function composition
def logCalls[A, B](f: A => B, name: String): A => B = { a =>
  println(s"Calling $name")
  val result = f(a)
  println(s"Finished $name")
  result
}

val add = (a: Int, b: Int) => a + b
val loggedAdd = logCalls(add.tupled, "add")

// Alternative: using by-name parameters
def withLogging[A](name: String)(block: => A): A = {
  println(s"Calling $name")
  val result = block
  println(s"Finished $name")
  result
}
```

## Pattern Matching

```python
# Python (3.10+)
def describe(value):
    match value:
        case 0:
            return "zero"
        case int(x) if x > 0:
            return "positive int"
        case int(x):
            return "negative int"
        case [x, y]:
            return f"pair: {x}, {y}"
        case {"name": name, "age": age}:
            return f"{name} is {age}"
        case _:
            return "unknown"
```

```scala
// Scala - pattern matching is more powerful
def describe(value: Any): String = value match {
  case 0 => "zero"
  case x: Int if x > 0 => "positive int"
  case _: Int => "negative int"
  case (x, y) => s"pair: $x, $y"
  case List(x, y) => s"list of two: $x, $y"
  case m: Map[_, _] if m.contains("name") =>
    s"${m("name")} is ${m("age")}"
  case _ => "unknown"
}

// Case class pattern matching (preferred)
sealed trait Result
case class Success(value: Int) extends Result
case class Error(message: String) extends Result

def handle(result: Result): String = result match {
  case Success(v) if v > 100 => s"Big success: $v"
  case Success(v) => s"Success: $v"
  case Error(msg) => s"Failed: $msg"
}
```

## Option Handling (None/null Safety)

```python
# Python
def find_user(user_id: int) -> Optional[User]:
    user = db.get(user_id)
    return user if user else None

def get_user_email(user_id: int) -> Optional[str]:
    user = find_user(user_id)
    if user is None:
        return None
    return user.email

# Chained operations
def get_user_city(user_id: int) -> Optional[str]:
    user = find_user(user_id)
    if user is None:
        return None
    address = user.address
    if address is None:
        return None
    return address.city
```

```scala
// Scala - Option monad
def findUser(userId: Int): Option[User] = db.get(userId)

def getUserEmail(userId: Int): Option[String] =
  findUser(userId).map(_.email)

// Chained operations with flatMap
def getUserCity(userId: Int): Option[String] =
  findUser(userId)
    .flatMap(_.address)
    .map(_.city)

// For-comprehension (cleaner for multiple operations)
def getUserCity(userId: Int): Option[String] = for {
  user <- findUser(userId)
  address <- user.address
  city <- Option(address.city)
} yield city

// Getting values out
val email = getUserEmail(1).getOrElse("[email protected]")
val emailOrThrow = getUserEmail(1).get  // Throws if None
```

## Generators → Iterators/LazyList

```python
# Python
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# Take first 10
fibs = list(itertools.islice(fibonacci(), 10))
```

```scala
// Scala - LazyList (was Stream in Scala 2.12)
def fibonacci: LazyList[BigInt] = {
  def loop(a: BigInt, b: BigInt): LazyList[BigInt] =
    a #:: loop(b, a + b)
  loop(0, 1)
}

val fibs = fibonacci.take(10).toList

// Alternative: Iterator
def fibonacciIterator: Iterator[BigInt] = new Iterator[BigInt] {
  private var (a, b) = (BigInt(0), BigInt(1))
  def hasNext: Boolean = true
  def next(): BigInt = {
    val result = a
    val newB = a + b
    a = b
    b = newB
    result
  }
}
```

## Try/Either for Error Handling

```python
# Python - exceptions
def parse_int(s: str) -> int:
    try:
        return int(s)
    except ValueError:
        return 0

# Python - Optional for errors
def safe_parse_int(s: str) -> Optional[int]:
    try:
        return int(s)
    except ValueError:
        return None
```

```scala
// Scala - Try monad
import scala.util.{Try, Success, Failure}

def parseInt(s: String): Try[Int] = Try(s.toInt)

val result = parseInt("123") match {
  case Success(n) => s"Got: $n"
  case Failure(e) => s"Error: ${e.getMessage}"
}

// Chaining Try operations
val doubled = parseInt("123").map(_ * 2)

// Either for custom error types
def parsePositive(s: String): Either[String, Int] = {
  Try(s.toInt).toEither
    .left.map(_ => "Not a number")
    .flatMap { n =>
      if (n > 0) Right(n)
      else Left("Must be positive")
    }
}
```

## Function Composition

```python
# Python
def compose(f, g):
    return lambda x: f(g(x))

def pipe(*functions):
    def inner(x):
        result = x
        for f in functions:
            result = f(result)
        return result
    return inner

# Usage
add_one = lambda x: x + 1
double = lambda x: x * 2
pipeline = pipe(add_one, double, add_one)  # (x + 1) * 2 + 1
```

```scala
// Scala - built-in composition
val addOne: Int => Int = _ + 1
val double: Int => Int = _ * 2

// compose: f.compose(g) = f(g(x))
val composed = addOne.compose(double)  // addOne(double(x))

// andThen: f.andThen(g) = g(f(x))
val pipeline = addOne.andThen(double).andThen(addOne)  // (x + 1) * 2 + 1
```

## Currying and Partial Application

```python
# Python
from functools import partial

def add(a, b, c):
    return a + b + c

add_5 = partial(add, 5)
result = add_5(3, 2)  # 10
```

```scala
// Scala - curried functions
def add(a: Int)(b: Int)(c: Int): Int = a + b + c

val add5 = add(5) _  // Partially applied
val result = add5(3)(2)  // 10

// Converting between curried and uncurried
val uncurried = Function.uncurried(add _)
val curried = (uncurried _).curried

// Multiple parameter lists
def fold[A, B](init: B)(list: List[A])(f: (B, A) => B): B =
  list.foldLeft(init)(f)

val sum = fold(0)(List(1, 2, 3))(_ + _)
```

## Tail Recursion

```python
# Python - no tail call optimization
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)

# Workaround: iterative
def factorial_iter(n):
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result
```

```scala
// Scala - tail recursion with annotation
import scala.annotation.tailrec

def factorial(n: Int): BigInt = {
  @tailrec
  def loop(n: Int, acc: BigInt): BigInt = {
    if (n <= 1) acc
    else loop(n - 1, n * acc)
  }
  loop(n, 1)
}
```

## Implicit Conversions and Type Classes

```python
# Python - no direct equivalent
# Duck typing provides flexibility
```

```scala
// Scala - type classes via implicits (Scala 2) or given/using (Scala 3)

// Scala 3
trait Show[A]:
  def show(a: A): String

given Show[Int] with
  def show(a: Int): String = s"Int: $a"

def display[A](a: A)(using s: Show[A]): String = s.show(a)

// Scala 2
trait Show[A] {
  def show(a: A): String
}

implicit val intShow: Show[Int] = new Show[Int] {
  def show(a: Int): String = s"Int: $a"
}

def display[A](a: A)(implicit s: Show[A]): String = s.show(a)
```

© benchflow-ai · Apache-2.0 · benchflow-ai/skillsbench

Похожие скиллы

Все скиллы по теме «Языки программирования» →
scala-expert personamanagmentlayer Скилл scala-expert для Claude Code даёт агенту справочник по Scala перед написанием кода: от неизменяемых структур и pattern matching до монад, Akka и стримов с backpressure. CX Codex +1 226установок go-functional-options cxuu Скилл go-functional-options для Claude Code описывает сборку конструктора Go с необязательными настройками через функциональные опции. Схема применима при трёх и более необязательных параметрах New*. CX Codex +1 1 300установок 142-java-functional-programming Juan Antonio Breña Moral Скилл 142-java-functional-programming для ИИ-агента, который переписывает Java-код в функциональном стиле: Records, чистые функции, Stream API и Optional. CX Codex +1 399установок 143-java-functional-exception-handling Juan Antonio Breña Moral Скилл 143-java-functional-exception-handling переводит обработку ошибок в Java на монадические типы: Optional, VAVR Either, sealed-классы вместо исключений на каждый чих. CX Codex +1 386установок scala-spark официальный github Правило scala-spark для GitHub Copilot задаёт инструкции по разработке на Apache Spark в Scala. Оно помогает писать быстрые трансформации, настраивать партиционирование и избегать падений памяти. CX Codex +1 ★ 41 430звёзд репо scala-pro Seth Hobson Субагент scala-pro помогает проектировать распределённые системы на Scala 3, Pekko, Spark и настраивать функциональный код на Cats Effect или ZIO. CX Codex ★ 42 780звёзд репо

Из того же набора22

Весь набор →
hex-grid-spatial Скилл hex-grid-spatial для Claude Code считает соседей, расстояние и клетки в радиусе на гексагональной карте с odd-r offset координатами. Используется в логике ходов и зон вокруг юнита. CX Codex +1 1установок python-scala-syntax-mapping Скилл python-scala-syntax-mapping для Claude Code сопоставляет синтаксис Python и Scala, помогая ИИ-агенту переносить функции, циклы и типы данных. CX Codex +1 1установок image-ocr Скилл image-ocr извлекает текст из изображений через Tesseract OCR и Python. Попросите агента обработать скан, скриншот или папку с картинками. CX Codex +1 1установок audiobook Скилл audiobook собирает аудиокнигу из статьи по ссылке или текстового файла: вытягивает контент, чистит его и озвучивает через ElevenLabs, OpenAI TTS или gTTS. CX Codex +1 1установок nanogpt-training Скилл nanogpt-training для Claude Code содержит инструкции для обучения моделей масштаба GPT-2 на 124M параметров на одной GPU с оптимизатором Muon и данными из Hugging Face. CX Codex +1 1установок hierarchical-taxonomy-clustering Скилл hierarchical-taxonomy-clustering для Claude Code объединяет похожие категории из разных источников в многоуровневую таксономию. Анализирует товары по общей структуре категорий. CX Codex +1 1установок senior-data-engineer Скилл senior-data-engineer для Claude и других агентов: помогает проектировать ETL/ELT и стриминговые пайплайны, генерирует Airflow DAG, конфиги Kafka и проверки качества данных. CX Codex +1 1установок vulnerability-csv-reporting Скилл vulnerability-csv-reporting преобразует JSON-отчёты сканеров уязвимостей в плоские CSV-таблицы для аудитов и тикетов. CX Codex +1 1установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой