scala-expert — скилл для Claude Code: Scala, Akka, Cats, ZIO
Скилл scala-expert для Claude Code даёт агенту справочник по Scala перед написанием кода: от неизменяемых структур и pattern matching до монад, Akka и стримов с backpressure.
Apache-2.0 226 установок ★ 45 обновлён 2026-10-12
npx skills add personamanagmentlayer/pcl --skill scala-expert -a claude-codeЧто делает scala-expert
Скилл даёт агенту справочник по Scala: неизменяемость, case-классы, трейты, pattern matching, for-выражения. Дальше функциональная часть — функторы, аппликативы, монады Option, Either и Try, тайп-классы с примером на Cats.
В SKILL.md лежат рабочие фрагменты кода. Типизированный актор Akka с иерархией команд и ответов и запрос через AskPattern. Стрим с throttle, recover и параллельной обработкой в mapAsync. Маршруты Akka HTTP с JSON-форматами spray-json. Агент берёт структуру из примеров и переносит её в ваш проект.
Bash разрешён только для scala и sbt, плюс Read, Write и Edit. Сборку агент запустит, но без установленного sbt команда просто упадёт.
Какие задачи решает
- Объяснить, что возвращает for-выражение над
OptionиFuture - Перевести обработку ошибок с исключений на
Either - Собрать типизированного актора Akka с парой запрос-ответ
- Добавить в стрим
throttleи восстановление после исключения - Связать маршруты Akka HTTP с JSON-форматами spray-json
Примеры запросов агенту
- Перепиши
findUserтак, чтобы вместо null возвращалсяOption, и покажи вариант сgetOrElse - Сделай актора Akka Typed для заказов: команды, ответы и запрос через
AskPattern - Настрой в этом стриме обработку ошибки на пятом элементе через
recover
Как установить scala-expert
1Через Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill scala-expert -a claude-code2Вручную: положить файлы
~/.claude/skills/scala-expert/SKILL.mdПапка скилла целиком; для одного проекта — .claude/skills/scala-expert/
1Через Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill scala-expert -a codex2Вручную: положить файлы
.agents/skills/scala-expert/SKILL.mdДля всех проектов — ~/.agents/skills/
1Через Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill scala-expert -a cursor2Вручную: положить файлы
.cursor/skills/scala-expert/SKILL.mdCursor читает и .agents/skills/, и .claude/skills/
1GitHub CLI
gh skill install personamanagmentlayer/pcl stdlib/languages/scala-expert2Вручную: положить файлы
.github/skills/scala-expert/SKILL.md1Через Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill scala-expert -a gemini-cli2Командой платформы
gemini skills install https://github.com/personamanagmentlayer/pcl --path stdlib/languages/scala-expertВручную: положить файлы
.devin/skills/scala-expert/SKILL.mdСтарый путь .windsurf/skills/ тоже читается
Через Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill scala-expert -a opencodeClaude.ai
Упакуйте папку в zip и загрузите в Settings → Capabilities → Skills
По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов
Вопросы о scala-expert
Как установить scala-expert в Claude Code?
Выполните npx skills add personamanagmentlayer/pcl --skill scala-expert -a claude-code. Файл скилла появится по пути ~/.claude/skills/scala-expert/SKILL.md.
Что делает scala-expert?
Подсказывает агенту, как писать на Scala: case-классы, pattern matching, монады, тайп-классы Cats, акторы и стримы Akka, маршруты Akka HTTP.
Какие инструменты разрешены скиллу?
Read, Write, Edit и Bash только для команд scala и sbt. Сборку он запустит, а без установленного sbt команда не выполнится.
Исходный текст
SKILL.md · Apache-2.0
---
name: scala-expert
version: 1.1.0
description: >-
Expert-level Scala, functional programming, Akka, and reactive systems. Use when the user
mentions functional programming, Akka, Cats, or ZIO, or when the task involves Scala
Fundamentals, Reactive Systems, or Scala Style.
category: languages
tags: [scala, functional-programming, akka, cats, zio]
allowed-tools:
- Read
- Write
- Edit
- Bash(scala:*, sbt:*)
---
# Scala Expert
Expert guidance for Scala development, functional programming, Akka actors, and reactive systems.
## Core Concepts
### Scala Fundamentals
- Immutability
- Pattern matching
- Case classes
- Traits and mixins
- Implicit conversions
- For comprehensions
### Functional Programming
- Higher-order functions
- Monads (Option, Either, Try)
- Functors and Applicatives
- Type classes
- Pure functions
- Referential transparency
### Reactive Systems
- Akka actors
- Akka Streams
- Akka HTTP
- Play Framework
- Cats Effect
- ZIO
## Scala Basics
```scala
// Case classes
case class User(id: String, name: String, email: String, age: Int)
// Pattern matching
def processUser(user: User): String = user match {
case User(_, name, _, age) if age < 18 => s"$name is a minor"
case User(_, name, _, age) if age >= 65 => s"$name is a senior"
case User(_, name, _, _) => s"$name is an adult"
}
// Options instead of null
def findUser(id: String): Option[User] = {
database.get(id)
}
val userName = findUser("123") match {
case Some(user) => user.name
case None => "Unknown"
}
// Or using map
val name = findUser("123").map(_.name).getOrElse("Unknown")
// For comprehensions
def getUserWithPosts(userId: String): Option[(User, List[Post])] = {
for {
user <- findUser(userId)
posts <- findPosts(userId)
} yield (user, posts)
}
// Traits and mixins
trait Serializable {
def toJson: String
}
trait Loggable {
def log(message: String): Unit = println(s"[LOG] $message")
}
case class Person(name: String, age: Int) extends Serializable with Loggable {
def toJson: String = s"""{"name":"$name","age":$age}"""
}
// Implicit classes (extension methods)
implicit class StringOps(s: String) {
def isValidEmail: Boolean = s.contains("@") && s.contains(".")
}
"[email protected]".isValidEmail // true
```
## Functional Programming
```scala
import cats._
import cats.implicits._
// Functor
val numbers = List(1, 2, 3, 4, 5)
val doubled = numbers.map(_ * 2)
// Applicative
val result = (Option(1), Option(2), Option(3)).mapN { (a, b, c) =>
a + b + c
}
// Monad (flatMap)
def fetchUser(id: String): Future[Option[User]] = ???
def fetchPosts(userId: String): Future[List[Post]] = ???
val userWithPosts: Future[Option[(User, List[Post])]] = {
fetchUser("123").flatMap {
case Some(user) =>
fetchPosts(user.id).map(posts => Some((user, posts)))
case None =>
Future.successful(None)
}
}
// Or with for-comprehension
val result: Future[Option[(User, List[Post])]] = for {
userOpt <- fetchUser("123")
posts <- fetchPosts(userOpt.map(_.id).getOrElse(""))
} yield userOpt.map(user => (user, posts))
// Either for error handling
sealed trait Error
case class NotFound(id: String) extends Error
case class ValidationError(message: String) extends Error
def validateUser(user: User): Either[Error, User] = {
if (user.email.isValidEmail) Right(user)
else Left(ValidationError("Invalid email"))
}
def saveUser(user: User): Either[Error, User] = {
for {
validated <- validateUser(user)
saved <- database.save(validated)
} yield saved
}
// Type classes
trait Show[A] {
def show(a: A): String
}
object Show {
def apply[A](implicit sh: Show[A]): Show[A] = sh
implicit val stringShow: Show[String] = new Show[String] {
def show(s: String): String = s
}
implicit val intShow: Show[Int] = new Show[Int] {
def show(i: Int): String = i.toString
}
implicit def listShow[A: Show]: Show[List[A]] = new Show[List[A]] {
def show(list: List[A]): String = {
list.map(Show[A].show).mkString("[", ", ", "]")
}
}
}
def print[A: Show](a: A): Unit = {
println(Show[A].show(a))
}
```
## Akka Actors
```scala
import akka.actor.typed._
import akka.actor.typed.scaladsl._
// Actor definition
object UserActor {
sealed trait Command
final case class GetUser(id: String, replyTo: ActorRef[Response]) extends Command
final case class CreateUser(user: User, replyTo: ActorRef[Response]) extends Command
sealed trait Response
final case class UserFound(user: User) extends Response
final case class UserNotFound(id: String) extends Response
final case class UserCreated(user: User) extends Response
def apply(): Behavior[Command] = {
Behaviors.setup { context =>
var users = Map.empty[String, User]
Behaviors.receiveMessage {
case GetUser(id, replyTo) =>
users.get(id) match {
case Some(user) =>
replyTo ! UserFound(user)
case None =>
replyTo ! UserNotFound(id)
}
Behaviors.same
case CreateUser(user, replyTo) =>
users = users + (user.id -> user)
replyTo ! UserCreated(user)
Behaviors.same
}
}
}
}
// Using the actor
val system: ActorSystem[UserActor.Command] =
ActorSystem(UserActor(), "user-system")
import akka.actor.typed.scaladsl.AskPattern._
import akka.util.Timeout
import scala.concurrent.duration._
implicit val timeout: Timeout = 3.seconds
val response: Future[UserActor.Response] =
system.ask(ref => UserActor.GetUser("123", ref))
```
## Akka Streams
```scala
import akka.stream._
import akka.stream.scaladsl._
import akka.actor.ActorSystem
implicit val system = ActorSystem("streams")
implicit val materializer = ActorMaterializer()
// Simple stream
val source = Source(1 to 10)
val flow = Flow[Int].map(_ * 2)
val sink = Sink.foreach[Int](println)
source.via(flow).runWith(sink)
// Backpressure handling
val throttled = Source(1 to 100)
.throttle(10, 1.second)
.map { n =>
println(s"Processing $n")
n * 2
}
.runWith(Sink.ignore)
// Error handling
val resilient = Source(1 to 10)
.map { n =>
if (n == 5) throw new Exception("Error at 5")
n * 2
}
.recover {
case e: Exception => -1
}
.runWith(Sink.seq)
// Parallelism
val parallel = Source(1 to 100)
.mapAsync(parallelism = 4) { n =>
Future {
// Async operation
Thread.sleep(100)
n * 2
}
}
.runWith(Sink.seq)
```
## Akka HTTP
```scala
import akka.http.scaladsl.Http
import akka.http.scaladsl.server.Directives._
import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
import spray.json.DefaultJsonProtocol._
// JSON protocol
case class User(id: String, name: String, email: String)
object JsonProtocol {
implicit val userFormat = jsonFormat3(User)
}
import JsonProtocol._
// Routes
val routes =
pathPrefix("api") {
pathPrefix("users") {
get {
path(Segment) { userId =>
// GET /api/users/:userId
complete(findUser(userId))
} ~
pathEnd {
// GET /api/users
complete(getAllUsers())
}
} ~
post {
pathEnd {
// POST /api/users
entity(as[User]) { user =>
complete(createUser(user))
}
}
}
}
}
// Start server
val bindingFuture = Http().newServerAt("localhost", 8080).bind(routes)
```
## Cats Effect / ZIO
```scala
import cats.effect._
import cats.effect.implicits._
// Pure functional effects with Cats Effect
def fetchUser(id: String): IO[User] = IO {
// Effectful computation
database.get(id)
}
def saveUser(user: User): IO[Unit] = IO {
database.save(user)
}
val program: IO[Unit] = for {
user <- fetchUser("123")
updated = user.copy(name = "Updated")
_ <- saveUser(updated)
} yield ()
// Error handling
val safeProgram: IO[Either[Throwable, Unit]] = program.attempt
// Parallel execution
val parallel: IO[List[User]] = {
List("1", "2", "3")
.parTraverse(id => fetchUser(id))
}
// ZIO
import zio._
def fetchUserZIO(id: String): Task[User] = ZIO.attempt {
database.get(id)
}
val zioProgram: Task[Unit] = for {
user <- fetchUserZIO("123")
_ <- Console.printLine(s"Found user: ${user.name}")
} yield ()
```
## Best Practices
### Functional Programming
- Prefer immutability
- Use pure functions
- Avoid side effects
- Use Option/Either over null/exceptions
- Leverage type classes
- Use for-comprehensions
- Apply functional composition
### Scala Style
- Follow naming conventions
- Use case classes for data
- Prefer vals over vars
- Use pattern matching
- Avoid null
- Use implicits carefully
- Write idiomatic code
### Performance
- Use lazy evaluation
- Stream large datasets
- Avoid unnecessary allocations
- Use tail recursion
- Profile before optimizing
- Consider parallelism
## Anti-Patterns
❌ Using null
❌ Mutable state everywhere
❌ God objects
❌ Excessive implicits
❌ Not handling errors
❌ Blocking operations
❌ Not using type safety
## Resources
- Scala Documentation: https://docs.scala-lang.org/
- Akka Documentation: https://doc.akka.io/
- Cats: https://typelevel.org/cats/
- ZIO: https://zio.dev/
- Functional Programming in Scala (Red Book)
© personamanagmentlayer · Apache-2.0 · personamanagmentlayer/pcl