opencode-skills-collection 3.0.49 → 3.0.51

package/bundled-skills/super-code/scala/SKILL.md

@@ -0,0 +1,302 @@
+---
+name: scala
+description: "Language-specific super-code guidelines for scala."
+risk: safe
+source: community
+date_added: "2026-06-16"
+---
+# Scala: Idiomatic Efficiency Reference
+
+## Table of Contents
+1. [Collections & Functional Transforms](#collections)
+2. [Pattern Matching](#patterns)
+3. [Case Classes & ADTs](#case-classes)
+4. [Option & Error Handling](#option)
+5. [Implicits & Given/Using](#implicits)
+6. [Concurrency](#concurrency)
+7. [Anti-patterns specific to Scala](#antipatterns)
+
+---
+
+## 1. Collections & Functional Transforms {#collections}
+
+```scala
+// ❌ Imperative accumulation
+val result = new ArrayBuffer[String]()
+for (item <- items) {
+  if (item.isActive) result += item.name.toUpperCase
+}
+
+// ✅
+val result = items.filter(_.isActive).map(_.name.toUpperCase)
+```
+
+```scala
+// ❌ Manual grouping
+val grouped = mutable.Map[String, List[Item]]()
+for (item <- items) {
+  grouped(item.category) = grouped.getOrElse(item.category, Nil) :+ item
+}
+
+// ✅
+val grouped = items.groupBy(_.category)
+```
+
+```scala
+// ❌ Manual fold when sum/product works
+var total = 0
+for (o <- orders) total += o.amount
+
+// ✅
+val total = orders.map(_.amount).sum
+```
+
+```scala
+// ❌ Using head on potentially empty collection
+val first = items.head // throws on empty
+
+// ✅
+val first = items.headOption // returns Option[T]
+```
+
+```scala
+// ❌ Chaining filter + head for find
+val found = items.filter(_.id == targetId).head
+
+// ✅
+val found = items.find(_.id == targetId) // returns Option[T]
+```
+
+**Use `view` for lazy evaluation on large collections to avoid intermediate allocations.**
+
+---
+
+## 2. Pattern Matching {#patterns}
+
+```scala
+// ❌ if-else chain for type dispatch
+if (shape.isInstanceOf[Circle]) {
+  val c = shape.asInstanceOf[Circle]
+  c.radius * c.radius * Math.PI
+} else if (shape.isInstanceOf[Rect]) { ... }
+
+// ✅
+shape match {
+  case Circle(r) => r * r * Math.PI
+  case Rect(w, h) => w * h
+}
+```
+
+```scala
+// ❌ Nested match with identical fallthrough
+x match {
+  case 1 => "low"
+  case 2 => "low"
+  case 3 => "mid"
+  case _ => "high"
+}
+
+// ✅
+x match {
+  case 1 | 2 => "low"
+  case 3     => "mid"
+  case _     => "high"
+}
+```
+
+```scala
+// ❌ Match to extract then use
+val result = opt match {
+  case Some(x) => x.toString
+  case None    => "N/A"
+}
+
+// ✅
+val result = opt.map(_.toString).getOrElse("N/A")
+// or:
+val result = opt.fold("N/A")(_.toString)
+```
+
+---
+
+## 3. Case Classes & ADTs {#case-classes}
+
+```scala
+// ❌ Regular class for data
+class User(val name: String, val age: Int) {
+  override def equals(obj: Any): Boolean = ...
+  override def hashCode(): Int = ...
+  override def toString: String = ...
+}
+
+// ✅
+case class User(name: String, age: Int)
+```
+
+```scala
+// ❌ Sealed trait with unrelated case objects
+sealed trait Result
+case class Success(value: Int) extends Result
+case class Failure(error: String) extends Result
+case object Unknown extends Result // what does "Unknown" mean?
+
+// ✅ — each variant should carry the data it represents
+sealed trait Result[+A]
+case class Success[A] (value: A) extends Result[A]
+case class Failure(error: Throwable) extends Result[Nothing]
+```
+
+```scala
+// ❌ (Scala 3) Verbose enum
+sealed trait Color
+object Color {
+  case object Red extends Color
+  case object Green extends Color
+  case object Blue extends Color
+}
+
+// ✅ (Scala 3)
+enum Color { case Red, Green, Blue }
+```
+
+---
+
+## 4. Option & Error Handling {#option}
+
+```scala
+// ❌ Null checks
+val name: String = if (user != null) user.name else "Unknown"
+
+// ✅
+val name = Option(user).map(_.name).getOrElse("Unknown")
+```
+
+```scala
+// ❌ .get on Option (defeats the purpose)
+val name = userOpt.get // throws if None
+
+// ✅
+val name = userOpt.getOrElse("default")
+// or: userOpt.map(process).getOrElse(fallback)
+// or: userOpt match { case Some(u) => ... case None => ... }
+```
+
+```scala
+// ❌ Try with .get
+val result = Try(parse(input)).get // throws on failure
+
+// ✅
+val result = Try(parse(input)) match {
+  case Success(v) => v
+  case Failure(e) => handleError(e)
+}
+// or: Try(parse(input)).getOrElse(default)
+// or: Try(parse(input)).toEither
+```
+
+```scala
+// ❌ Using exceptions for expected failures
+def findUser(id: String): User = {
+  val user = db.query(id)
+  if (user == null) throw new NotFoundException(id)
+  user
+}
+
+// ✅ — Option for absence, Either for expected errors
+def findUser(id: String): Option[User] = db.query(id)
+// or:
+def findUser(id: String): Either[AppError, User]
+```
+
+---
+
+## 5. Implicits & Given/Using {#implicits}
+
+```scala
+// ❌ (Scala 2) Implicit conversion that hides bugs
+implicit def stringToInt(s: String): Int = s.toInt
+
+// ✅ — extension methods instead of implicit conversions
+extension (s: String)
+  def toIntSafe: Option[Int] = s.toIntOption
+```
+
+```scala
+// ❌ (Scala 2) Implicit parameter with broad type
+def query(sql: String)(implicit conn: Connection): ResultSet
+
+// ✅ (Scala 3)
+def query(sql: String)(using conn: Connection): ResultSet
+```
+
+```scala
+// ❌ Importing implicits from everywhere
+import com.lib.implicits._
+
+// ✅ — import only what you need
+import com.lib.given
+// or specific: import com.lib.{given ExecutionContext}
+```
+
+---
+
+## 6. Concurrency {#concurrency}
+
+```scala
+// ❌ Thread.sleep in production code
+Thread.sleep(5000)
+
+// ✅ — use scheduler / timer abstraction
+import scala.concurrent.duration._
+system.scheduler.scheduleOnce(5.seconds)(doWork())
+```
+
+```scala
+// ❌ Blocking inside Future
+Future {
+  val result = blockingHttpCall() // starves thread pool
+  process(result)
+}
+
+// ✅
+Future {
+  blocking { val result = blockingHttpCall() }
+  // or use a dedicated blocking ExecutionContext
+}
+```
+
+```scala
+// ❌ Awaiting futures in a loop
+for (f <- futures) Await.result(f, Duration.Inf)
+
+// ✅
+val all = Future.sequence(futures)
+all.map(results => process(results))
+```
+
+**Prefer `Future.sequence`/`Future.traverse` over manual await loops.**
+
+---
+
+## 7. Anti-patterns specific to Scala {#antipatterns}
+
+| Anti-pattern | Preferred |
+|---|---|
+| `.get` on Option/Try | `.getOrElse` / pattern match |
+| `null` | `Option` |
+| `isInstanceOf` + `asInstanceOf` | pattern matching |
+| Implicit conversions (Scala 2) | extension methods (Scala 3) |
+| `var` for accumulation | `val` + functional transforms |
+| `return` keyword | last expression is the return value |
+| Mutable collections by default | immutable collections |
+| `Any` / `AnyRef` parameters | generics with type bounds |
+| Deeply nested `for` comprehensions | break into named values |
+| Tuple instead of case class | case class for anything with semantic meaning |
+| `Await.result` in production | compose with `map`/`flatMap` |
+
+
+
+
+## Limitations
+- These are language-specific guidelines and do not cover overall architectural decisions.
+- Over-compression might reduce readability; apply judgement.

package/bundled-skills/super-code/swift/SKILL.md

@@ -0,0 +1,299 @@
+---
+name: swift
+description: "Language-specific super-code guidelines for swift."
+risk: safe
+source: community
+date_added: "2026-06-16"
+---
+# Swift: Idiomatic Efficiency Reference
+
+## Table of Contents
+1. [Optionals](#optionals)
+2. [Collections & Functional Transforms](#collections)
+3. [Value vs Reference Types](#value-types)
+4. [Error Handling](#errors)
+5. [Concurrency](#concurrency)
+6. [Protocol-Oriented Design](#protocols)
+7. [Anti-patterns specific to Swift](#antipatterns)
+
+---
+
+## 1. Optionals {#optionals}
+
+```swift
+// ❌ Force unwrap
+let name = user.name!
+
+// ✅ — guard or if-let
+guard let name = user.name else { return }
+```
+
+```swift
+// ❌ Nested if-let pyramid
+if let user = fetchUser() {
+    if let address = user.address {
+        if let city = address.city {
+            display(city)
+        }
+    }
+}
+
+// ✅ — chained optional binding
+if let city = fetchUser()?.address?.city {
+    display(city)
+}
+// or guard-let for early exit
+guard let city = fetchUser()?.address?.city else { return }
+display(city)
+```
+
+```swift
+// ❌ Ternary for default
+let name = user.name != nil ? user.name! : "Unknown"
+
+// ✅
+let name = user.name ?? "Unknown"
+```
+
+```swift
+// ❌ Optional map when if-let is clearer for side effects
+user.name.map { display($0) }
+
+// ✅ — map for transforms, if-let for side effects
+let upper = user.name.map { $0.uppercased() }
+if let name = user.name { display(name) }
+```
+
+---
+
+## 2. Collections & Functional Transforms {#collections}
+
+```swift
+// ❌ Imperative filter + map
+var result: [String] = []
+for item in items {
+    if item.isActive { result.append(item.name.uppercased()) }
+}
+
+// ✅
+let result = items
+    .filter(\.isActive)
+    .map { $0.name.uppercased() }
+```
+
+```swift
+// ❌ Manual dictionary construction
+var dict: [String: User] = [:]
+for user in users { dict[user.id] = user }
+
+// ✅
+let dict = Dictionary(uniqueKeysWithValues: users.map { ($0.id, $0) })
+// or with possible duplicates:
+let dict = Dictionary(grouping: users, by: \.department)
+```
+
+```swift
+// ❌ Checking isEmpty then accessing first
+if !items.isEmpty { process(items[0]) }
+
+// ✅
+if let first = items.first { process(first) }
+```
+
+```swift
+// ❌ Index-based loop
+for i in 0..<items.count { process(items[i]) }
+
+// ✅
+for item in items { process(item) }
+// with index:
+for (i, item) in items.enumerated() { process(i, item) }
+```
+
+**Use key paths (`\.isActive`) as closure shorthand where supported.**
+
+---
+
+## 3. Value vs Reference Types {#value-types}
+
+```swift
+// ❌ Class for plain data (reference semantics where value semantics suffice)
+class Point {
+    var x: Double
+    var y: Double
+    init(x: Double, y: Double) { self.x = x; self.y = y }
+}
+
+// ✅
+struct Point { var x, y: Double }
+```
+
+```swift
+// ❌ Large struct copied repeatedly (performance hit)
+struct HugeData { var buffer: [UInt8] /* thousands of elements */ }
+func process(_ data: HugeData) { ... } // copies entire buffer
+
+// ✅ — use class or pass inout for mutation
+func process(_ data: inout HugeData) { ... }
+// or use copy-on-write wrapper for large value types
+```
+
+**Default to `struct`. Use `class` when you need identity, inheritance, or reference semantics.**
+
+---
+
+## 4. Error Handling {#errors}
+
+```swift
+// ❌ Using optionals to mask errors
+func parse(_ input: String) -> Data? { ... } // caller doesn't know why it failed
+
+// ✅
+func parse(_ input: String) throws -> Data { ... }
+```
+
+```swift
+// ❌ try! in production code
+let data = try! JSONDecoder().decode(User.self, from: jsonData)
+
+// ✅
+do {
+    let data = try JSONDecoder().decode(User.self, from: jsonData)
+} catch {
+    logger.error("decode failed: \(error)")
+    throw AppError.decodingFailed(underlying: error)
+}
+```
+
+```swift
+// ❌ Generic Error type
+enum AppError: Error { case generic(String) }
+
+// ✅ — specific, actionable error cases
+enum AppError: Error {
+    case networkUnreachable
+    case invalidInput(field: String, reason: String)
+    case unauthorized
+}
+```
+
+```swift
+// ❌ Catching all errors and ignoring
+do { try riskyOperation() } catch { }
+
+// ✅
+do {
+    try riskyOperation()
+} catch let error as NetworkError {
+    handleNetworkError(error)
+} catch {
+    throw error // rethrow unknown
+}
+```
+
+---
+
+## 5. Concurrency {#concurrency}
+
+```swift
+// ❌ Callback-based async (pyramid of doom)
+fetchUser { user in
+    fetchPosts(for: user) { posts in
+        fetchComments(for: posts.first!) { comments in
+            display(comments)
+        }
+    }
+}
+
+// ✅ (Swift 5.5+)
+let user = try await fetchUser()
+let posts = try await fetchPosts(for: user)
+let comments = try await fetchComments(for: posts[0])
+display(comments)
+```
+
+```swift
+// ❌ Sequential awaits for independent work
+let a = try await fetchA()
+let b = try await fetchB()
+
+// ✅
+async let a = fetchA()
+async let b = fetchB()
+let (resultA, resultB) = try await (a, b)
+```
+
+```swift
+// ❌ DispatchQueue.main.async for UI updates in async context
+DispatchQueue.main.async { label.text = result }
+
+// ✅
+await MainActor.run { label.text = result }
+// or mark the function/class @MainActor
+```
+
+**Use `actor` for mutable shared state instead of manual locks/queues.**
+
+---
+
+## 6. Protocol-Oriented Design {#protocols}
+
+```swift
+// ❌ Deep class inheritance hierarchy
+class Animal { ... }
+class Dog: Animal { ... }
+class GuideDog: Dog { ... }
+
+// ✅ — protocols + composition
+protocol Animal { var name: String { get } }
+protocol Trainable { func train() }
+struct Dog: Animal, Trainable { ... }
+```
+
+```swift
+// ❌ Protocol with default implementations for everything
+protocol Renderable {
+    func render()
+}
+extension Renderable {
+    func render() { /* default */ }
+}
+// Every conformer uses default — protocol serves no purpose
+
+// ✅ — only default implementations that provide genuine shared logic
+```
+
+```swift
+// ❌ Associated type when generic parameter suffices
+protocol Container {
+    associatedtype Element
+    func get() -> Element
+}
+
+// ✅ — use `some` or generic parameter for simple cases
+func process(_ item: some Equatable) { ... }
+```
+
+---
+
+## 7. Anti-patterns specific to Swift {#antipatterns}
+
+| Anti-pattern | Preferred |
+|---|---|
+| Force unwrap `!` in production code | `guard let` / `if let` / `??` |
+| `try!` outside tests | `do/catch` |
+| `class` for plain data | `struct` |
+| Deep inheritance hierarchies | protocol composition |
+| `@objc` when pure Swift works | native Swift types |
+| `NSArray` / `NSDictionary` | `Array` / `Dictionary` |
+| `DispatchQueue` in async/await code | `actor` / `MainActor` |
+| Implicitly unwrapped optionals as fields | regular optionals or non-optional with init |
+| `Any` / `AnyObject` everywhere | generics with protocol constraints |
+| Massive `switch` over string values | enum with raw values |
+| Singleton pattern (global mutable state) | dependency injection |
+
+
+
+## Limitations
+- These are language-specific guidelines and do not cover overall architectural decisions.
+- Over-compression might reduce readability; apply judgement.