[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6KM37ZZGEEXKAAYP5A9X31F":3,"skill-same:01M6KM37ZZGEEXKAAYP5A9X31F":65},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":38,"linkOnly":39,"markdownContent":40,"markdownBody":41,"frontMatter":42,"refName":43,"commitSha":44,"skillDirectory":45,"forksCount":46,"repositoryHtmlUrl":47,"repositoryHomepageUrl":48,"ownerHtmlUrl":49,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":50,"install":51,"resources":64},"01M6KM37ZZGEEXKAAYP5A9X31F","python-scala-functional",null,"Guide for translating Python code to functional Scala style. Use when converting Python code involving numeric formatting, higher-order functions, decorators, closures, generators, or when aiming for idiomatic functional Scala with pattern matching, Option handling, and monadic operations.","cxcscmu\u002FSkillLearnBench","cxcscmu","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F142838272?v=4","01M6KCQDFQWPDSN0MKZY96MSQP","01M6KCQDM7G70TKJ28NTSQC0RZ",93,"MIT","https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fhuman_authored\u002Fpython-scala-translation\u002Fpython-scala-functional\u002FSKILL.md",[],[18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37],"scala","python scala functional","functional","python","style","idiomatic","for","python code","with","code","decorators","pattern matching","option","formatting","matching","pattern","functions","use","guide","operations","2026-11-10 10:12:30",false,"---\nname: python-scala-functional\ndescription: Guide for translating Python code to functional Scala style. Use when converting Python code involving numeric formatting, higher-order functions, decorators, closures, generators, or when aiming for idiomatic functional Scala with pattern matching, Option handling, and monadic operations.\n---\n\n# Python to Scala Functional Programming Translation\n\n\n## Numeric Formatting\n\nUse this translation when Python code formats floating-point or decimal values with fixed precision.\nThis Scala version preserves the same intent: rounding to the specified number of decimal places and returning a plain decimal string without scientific notation.\n\nPython:\n\n```python\nf\"{value:.{precision}f}\"\n```\n\nScala:\n```scala\nval strValue =\n  BigDecimal.decimal(value)\n    .setScale(precision, BigDecimal.RoundingMode.HALF_UP)\n    .bigDecimal\n    .toPlainString\n```\n\n\n## Higher-Order Functions\n\n```python\n# Python\ndef apply_twice(f, x):\n    return f(f(x))\n\ndef make_multiplier(n):\n    return lambda x: x * n\n\ndouble = make_multiplier(2)\nresult = apply_twice(double, 5)  # 20\n```\n\n```scala\n\u002F\u002F Scala\ndef applyTwice[A](f: A => A, x: A): A = f(f(x))\n\ndef makeMultiplier(n: Int): Int => Int = x => x * n\n\nval double = makeMultiplier(2)\nval result = applyTwice(double, 5)  \u002F\u002F 20\n```\n\n## Decorators → Function Composition\n\n```python\n# Python\ndef log_calls(func):\n    def wrapper(*args, **kwargs):\n        print(f\"Calling {func.__name__}\")\n        result = func(*args, **kwargs)\n        print(f\"Finished {func.__name__}\")\n        return result\n    return wrapper\n\n@log_calls\ndef add(a, b):\n    return a + b\n```\n\n```scala\n\u002F\u002F Scala - function composition\ndef logCalls[A, B](f: A => B, name: String): A => B = { a =>\n  println(s\"Calling $name\")\n  val result = f(a)\n  println(s\"Finished $name\")\n  result\n}\n\nval add = (a: Int, b: Int) => a + b\nval loggedAdd = logCalls(add.tupled, \"add\")\n\n\u002F\u002F Alternative: using by-name parameters\ndef withLogging[A](name: String)(block: => A): A = {\n  println(s\"Calling $name\")\n  val result = block\n  println(s\"Finished $name\")\n  result\n}\n```\n\n## Pattern Matching\n\n```python\n# Python (3.10+)\ndef describe(value):\n    match value:\n        case 0:\n            return \"zero\"\n        case int(x) if x > 0:\n            return \"positive int\"\n        case int(x):\n            return \"negative int\"\n        case [x, y]:\n            return f\"pair: {x}, {y}\"\n        case {\"name\": name, \"age\": age}:\n            return f\"{name} is {age}\"\n        case _:\n            return \"unknown\"\n```\n\n```scala\n\u002F\u002F Scala - pattern matching is more powerful\ndef describe(value: Any): String = value match {\n  case 0 => \"zero\"\n  case x: Int if x > 0 => \"positive int\"\n  case _: Int => \"negative int\"\n  case (x, y) => s\"pair: $x, $y\"\n  case List(x, y) => s\"list of two: $x, $y\"\n  case m: Map[_, _] if m.contains(\"name\") =>\n    s\"${m(\"name\")} is ${m(\"age\")}\"\n  case _ => \"unknown\"\n}\n\n\u002F\u002F Case class pattern matching (preferred)\nsealed trait Result\ncase class Success(value: Int) extends Result\ncase class Error(message: String) extends Result\n\ndef handle(result: Result): String = result match {\n  case Success(v) if v > 100 => s\"Big success: $v\"\n  case Success(v) => s\"Success: $v\"\n  case Error(msg) => s\"Failed: $msg\"\n}\n```\n\n## Option Handling (None\u002Fnull Safety)\n\n```python\n# Python\ndef find_user(user_id: int) -> Optional[User]:\n    user = db.get(user_id)\n    return user if user else None\n\ndef get_user_email(user_id: int) -> Optional[str]:\n    user = find_user(user_id)\n    if user is None:\n        return None\n    return user.email\n\n# Chained operations\ndef get_user_city(user_id: int) -> Optional[str]:\n    user = find_user(user_id)\n    if user is None:\n        return None\n    address = user.address\n    if address is None:\n        return None\n    return address.city\n```\n\n```scala\n\u002F\u002F Scala - Option monad\ndef findUser(userId: Int): Option[User] = db.get(userId)\n\ndef getUserEmail(userId: Int): Option[String] =\n  findUser(userId).map(_.email)\n\n\u002F\u002F Chained operations with flatMap\ndef getUserCity(userId: Int): Option[String] =\n  findUser(userId)\n    .flatMap(_.address)\n    .map(_.city)\n\n\u002F\u002F For-comprehension (cleaner for multiple operations)\ndef getUserCity(userId: Int): Option[String] = for {\n  user \u003C- findUser(userId)\n  address \u003C- user.address\n  city \u003C- Option(address.city)\n} yield city\n\n\u002F\u002F Getting values out\nval email = getUserEmail(1).getOrElse(\"no-email@example.com\")\nval emailOrThrow = getUserEmail(1).get  \u002F\u002F Throws if None\n```\n\n## Generators → Iterators\u002FLazyList\n\n```python\n# Python\ndef fibonacci():\n    a, b = 0, 1\n    while True:\n        yield a\n        a, b = b, a + b\n\n# Take first 10\nfibs = list(itertools.islice(fibonacci(), 10))\n```\n\n```scala\n\u002F\u002F Scala - LazyList (was Stream in Scala 2.12)\ndef fibonacci: LazyList[BigInt] = {\n  def loop(a: BigInt, b: BigInt): LazyList[BigInt] =\n    a #:: loop(b, a + b)\n  loop(0, 1)\n}\n\nval fibs = fibonacci.take(10).toList\n\n\u002F\u002F Alternative: Iterator\ndef fibonacciIterator: Iterator[BigInt] = new Iterator[BigInt] {\n  private var (a, b) = (BigInt(0), BigInt(1))\n  def hasNext: Boolean = true\n  def next(): BigInt = {\n    val result = a\n    val newB = a + b\n    a = b\n    b = newB\n    result\n  }\n}\n```\n\n## Try\u002FEither for Error Handling\n\n```python\n# Python - exceptions\ndef parse_int(s: str) -> int:\n    try:\n        return int(s)\n    except ValueError:\n        return 0\n\n# Python - Optional for errors\ndef safe_parse_int(s: str) -> Optional[int]:\n    try:\n        return int(s)\n    except ValueError:\n        return None\n```\n\n```scala\n\u002F\u002F Scala - Try monad\nimport scala.util.{Try, Success, Failure}\n\ndef parseInt(s: String): Try[Int] = Try(s.toInt)\n\nval result = parseInt(\"123\") match {\n  case Success(n) => s\"Got: $n\"\n  case Failure(e) => s\"Error: ${e.getMessage}\"\n}\n\n\u002F\u002F Chaining Try operations\nval doubled = parseInt(\"123\").map(_ * 2)\n\n\u002F\u002F Either for custom error types\ndef parsePositive(s: String): Either[String, Int] = {\n  Try(s.toInt).toEither\n    .left.map(_ => \"Not a number\")\n    .flatMap { n =>\n      if (n > 0) Right(n)\n      else Left(\"Must be positive\")\n    }\n}\n```\n\n## Function Composition\n\n```python\n# Python\ndef compose(f, g):\n    return lambda x: f(g(x))\n\ndef pipe(*functions):\n    def inner(x):\n        result = x\n        for f in functions:\n            result = f(result)\n        return result\n    return inner\n\n# Usage\nadd_one = lambda x: x + 1\ndouble = lambda x: x * 2\npipeline = pipe(add_one, double, add_one)  # (x + 1) * 2 + 1\n```\n\n```scala\n\u002F\u002F Scala - built-in composition\nval addOne: Int => Int = _ + 1\nval double: Int => Int = _ * 2\n\n\u002F\u002F compose: f.compose(g) = f(g(x))\nval composed = addOne.compose(double)  \u002F\u002F addOne(double(x))\n\n\u002F\u002F andThen: f.andThen(g) = g(f(x))\nval pipeline = addOne.andThen(double).andThen(addOne)  \u002F\u002F (x + 1) * 2 + 1\n```\n\n## Currying and Partial Application\n\n```python\n# Python\nfrom functools import partial\n\ndef add(a, b, c):\n    return a + b + c\n\nadd_5 = partial(add, 5)\nresult = add_5(3, 2)  # 10\n```\n\n```scala\n\u002F\u002F Scala - curried functions\ndef add(a: Int)(b: Int)(c: Int): Int = a + b + c\n\nval add5 = add(5) _  \u002F\u002F Partially applied\nval result = add5(3)(2)  \u002F\u002F 10\n\n\u002F\u002F Converting between curried and uncurried\nval uncurried = Function.uncurried(add _)\nval curried = (uncurried _).curried\n\n\u002F\u002F Multiple parameter lists\ndef fold[A, B](init: B)(list: List[A])(f: (B, A) => B): B =\n  list.foldLeft(init)(f)\n\nval sum = fold(0)(List(1, 2, 3))(_ + _)\n```\n\n## Tail Recursion\n\n```python\n# Python - no tail call optimization\ndef factorial(n):\n    if n \u003C= 1:\n        return 1\n    return n * factorial(n - 1)\n\n# Workaround: iterative\ndef factorial_iter(n):\n    result = 1\n    for i in range(2, n + 1):\n        result *= i\n    return result\n```\n\n```scala\n\u002F\u002F Scala - tail recursion with annotation\nimport scala.annotation.tailrec\n\ndef factorial(n: Int): BigInt = {\n  @tailrec\n  def loop(n: Int, acc: BigInt): BigInt = {\n    if (n \u003C= 1) acc\n    else loop(n - 1, n * acc)\n  }\n  loop(n, 1)\n}\n```\n\n## Implicit Conversions and Type Classes\n\n```python\n# Python - no direct equivalent\n# Duck typing provides flexibility\n```\n\n```scala\n\u002F\u002F Scala - type classes via implicits (Scala 2) or given\u002Fusing (Scala 3)\n\n\u002F\u002F Scala 3\ntrait Show[A]:\n  def show(a: A): String\n\ngiven Show[Int] with\n  def show(a: Int): String = s\"Int: $a\"\n\ndef display[A](a: A)(using s: Show[A]): String = s.show(a)\n\n\u002F\u002F Scala 2\ntrait Show[A] {\n  def show(a: A): String\n}\n\nimplicit val intShow: Show[Int] = new Show[Int] {\n  def show(a: Int): String = s\"Int: $a\"\n}\n\ndef display[A](a: A)(implicit s: Show[A]): String = s.show(a)\n```\n","# Python to Scala Functional Programming Translation\n\n\n## Numeric Formatting\n\nUse this translation when Python code formats floating-point or decimal values with fixed precision.\nThis Scala version preserves the same intent: rounding to the specified number of decimal places and returning a plain decimal string without scientific notation.\n\nPython:\n\n```python\nf\"{value:.{precision}f}\"\n```\n\nScala:\n```scala\nval strValue =\n  BigDecimal.decimal(value)\n    .setScale(precision, BigDecimal.RoundingMode.HALF_UP)\n    .bigDecimal\n    .toPlainString\n```\n\n\n## Higher-Order Functions\n\n```python\n# Python\ndef apply_twice(f, x):\n    return f(f(x))\n\ndef make_multiplier(n):\n    return lambda x: x * n\n\ndouble = make_multiplier(2)\nresult = apply_twice(double, 5)  # 20\n```\n\n```scala\n\u002F\u002F Scala\ndef applyTwice[A](f: A => A, x: A): A = f(f(x))\n\ndef makeMultiplier(n: Int): Int => Int = x => x * n\n\nval double = makeMultiplier(2)\nval result = applyTwice(double, 5)  \u002F\u002F 20\n```\n\n## Decorators → Function Composition\n\n```python\n# Python\ndef log_calls(func):\n    def wrapper(*args, **kwargs):\n        print(f\"Calling {func.__name__}\")\n        result = func(*args, **kwargs)\n        print(f\"Finished {func.__name__}\")\n        return result\n    return wrapper\n\n@log_calls\ndef add(a, b):\n    return a + b\n```\n\n```scala\n\u002F\u002F Scala - function composition\ndef logCalls[A, B](f: A => B, name: String): A => B = { a =>\n  println(s\"Calling $name\")\n  val result = f(a)\n  println(s\"Finished $name\")\n  result\n}\n\nval add = (a: Int, b: Int) => a + b\nval loggedAdd = logCalls(add.tupled, \"add\")\n\n\u002F\u002F Alternative: using by-name parameters\ndef withLogging[A](name: String)(block: => A): A = {\n  println(s\"Calling $name\")\n  val result = block\n  println(s\"Finished $name\")\n  result\n}\n```\n\n## Pattern Matching\n\n```python\n# Python (3.10+)\ndef describe(value):\n    match value:\n        case 0:\n            return \"zero\"\n        case int(x) if x > 0:\n            return \"positive int\"\n        case int(x):\n            return \"negative int\"\n        case [x, y]:\n            return f\"pair: {x}, {y}\"\n        case {\"name\": name, \"age\": age}:\n            return f\"{name} is {age}\"\n        case _:\n            return \"unknown\"\n```\n\n```scala\n\u002F\u002F Scala - pattern matching is more powerful\ndef describe(value: Any): String = value match {\n  case 0 => \"zero\"\n  case x: Int if x > 0 => \"positive int\"\n  case _: Int => \"negative int\"\n  case (x, y) => s\"pair: $x, $y\"\n  case List(x, y) => s\"list of two: $x, $y\"\n  case m: Map[_, _] if m.contains(\"name\") =>\n    s\"${m(\"name\")} is ${m(\"age\")}\"\n  case _ => \"unknown\"\n}\n\n\u002F\u002F Case class pattern matching (preferred)\nsealed trait Result\ncase class Success(value: Int) extends Result\ncase class Error(message: String) extends Result\n\ndef handle(result: Result): String = result match {\n  case Success(v) if v > 100 => s\"Big success: $v\"\n  case Success(v) => s\"Success: $v\"\n  case Error(msg) => s\"Failed: $msg\"\n}\n```\n\n## Option Handling (None\u002Fnull Safety)\n\n```python\n# Python\ndef find_user(user_id: int) -> Optional[User]:\n    user = db.get(user_id)\n    return user if user else None\n\ndef get_user_email(user_id: int) -> Optional[str]:\n    user = find_user(user_id)\n    if user is None:\n        return None\n    return user.email\n\n# Chained operations\ndef get_user_city(user_id: int) -> Optional[str]:\n    user = find_user(user_id)\n    if user is None:\n        return None\n    address = user.address\n    if address is None:\n        return None\n    return address.city\n```\n\n```scala\n\u002F\u002F Scala - Option monad\ndef findUser(userId: Int): Option[User] = db.get(userId)\n\ndef getUserEmail(userId: Int): Option[String] =\n  findUser(userId).map(_.email)\n\n\u002F\u002F Chained operations with flatMap\ndef getUserCity(userId: Int): Option[String] =\n  findUser(userId)\n    .flatMap(_.address)\n    .map(_.city)\n\n\u002F\u002F For-comprehension (cleaner for multiple operations)\ndef getUserCity(userId: Int): Option[String] = for {\n  user \u003C- findUser(userId)\n  address \u003C- user.address\n  city \u003C- Option(address.city)\n} yield city\n\n\u002F\u002F Getting values out\nval email = getUserEmail(1).getOrElse(\"no-email@example.com\")\nval emailOrThrow = getUserEmail(1).get  \u002F\u002F Throws if None\n```\n\n## Generators → Iterators\u002FLazyList\n\n```python\n# Python\ndef fibonacci():\n    a, b = 0, 1\n    while True:\n        yield a\n        a, b = b, a + b\n\n# Take first 10\nfibs = list(itertools.islice(fibonacci(), 10))\n```\n\n```scala\n\u002F\u002F Scala - LazyList (was Stream in Scala 2.12)\ndef fibonacci: LazyList[BigInt] = {\n  def loop(a: BigInt, b: BigInt): LazyList[BigInt] =\n    a #:: loop(b, a + b)\n  loop(0, 1)\n}\n\nval fibs = fibonacci.take(10).toList\n\n\u002F\u002F Alternative: Iterator\ndef fibonacciIterator: Iterator[BigInt] = new Iterator[BigInt] {\n  private var (a, b) = (BigInt(0), BigInt(1))\n  def hasNext: Boolean = true\n  def next(): BigInt = {\n    val result = a\n    val newB = a + b\n    a = b\n    b = newB\n    result\n  }\n}\n```\n\n## Try\u002FEither for Error Handling\n\n```python\n# Python - exceptions\ndef parse_int(s: str) -> int:\n    try:\n        return int(s)\n    except ValueError:\n        return 0\n\n# Python - Optional for errors\ndef safe_parse_int(s: str) -> Optional[int]:\n    try:\n        return int(s)\n    except ValueError:\n        return None\n```\n\n```scala\n\u002F\u002F Scala - Try monad\nimport scala.util.{Try, Success, Failure}\n\ndef parseInt(s: String): Try[Int] = Try(s.toInt)\n\nval result = parseInt(\"123\") match {\n  case Success(n) => s\"Got: $n\"\n  case Failure(e) => s\"Error: ${e.getMessage}\"\n}\n\n\u002F\u002F Chaining Try operations\nval doubled = parseInt(\"123\").map(_ * 2)\n\n\u002F\u002F Either for custom error types\ndef parsePositive(s: String): Either[String, Int] = {\n  Try(s.toInt).toEither\n    .left.map(_ => \"Not a number\")\n    .flatMap { n =>\n      if (n > 0) Right(n)\n      else Left(\"Must be positive\")\n    }\n}\n```\n\n## Function Composition\n\n```python\n# Python\ndef compose(f, g):\n    return lambda x: f(g(x))\n\ndef pipe(*functions):\n    def inner(x):\n        result = x\n        for f in functions:\n            result = f(result)\n        return result\n    return inner\n\n# Usage\nadd_one = lambda x: x + 1\ndouble = lambda x: x * 2\npipeline = pipe(add_one, double, add_one)  # (x + 1) * 2 + 1\n```\n\n```scala\n\u002F\u002F Scala - built-in composition\nval addOne: Int => Int = _ + 1\nval double: Int => Int = _ * 2\n\n\u002F\u002F compose: f.compose(g) = f(g(x))\nval composed = addOne.compose(double)  \u002F\u002F addOne(double(x))\n\n\u002F\u002F andThen: f.andThen(g) = g(f(x))\nval pipeline = addOne.andThen(double).andThen(addOne)  \u002F\u002F (x + 1) * 2 + 1\n```\n\n## Currying and Partial Application\n\n```python\n# Python\nfrom functools import partial\n\ndef add(a, b, c):\n    return a + b + c\n\nadd_5 = partial(add, 5)\nresult = add_5(3, 2)  # 10\n```\n\n```scala\n\u002F\u002F Scala - curried functions\ndef add(a: Int)(b: Int)(c: Int): Int = a + b + c\n\nval add5 = add(5) _  \u002F\u002F Partially applied\nval result = add5(3)(2)  \u002F\u002F 10\n\n\u002F\u002F Converting between curried and uncurried\nval uncurried = Function.uncurried(add _)\nval curried = (uncurried _).curried\n\n\u002F\u002F Multiple parameter lists\ndef fold[A, B](init: B)(list: List[A])(f: (B, A) => B): B =\n  list.foldLeft(init)(f)\n\nval sum = fold(0)(List(1, 2, 3))(_ + _)\n```\n\n## Tail Recursion\n\n```python\n# Python - no tail call optimization\ndef factorial(n):\n    if n \u003C= 1:\n        return 1\n    return n * factorial(n - 1)\n\n# Workaround: iterative\ndef factorial_iter(n):\n    result = 1\n    for i in range(2, n + 1):\n        result *= i\n    return result\n```\n\n```scala\n\u002F\u002F Scala - tail recursion with annotation\nimport scala.annotation.tailrec\n\ndef factorial(n: Int): BigInt = {\n  @tailrec\n  def loop(n: Int, acc: BigInt): BigInt = {\n    if (n \u003C= 1) acc\n    else loop(n - 1, n * acc)\n  }\n  loop(n, 1)\n}\n```\n\n## Implicit Conversions and Type Classes\n\n```python\n# Python - no direct equivalent\n# Duck typing provides flexibility\n```\n\n```scala\n\u002F\u002F Scala - type classes via implicits (Scala 2) or given\u002Fusing (Scala 3)\n\n\u002F\u002F Scala 3\ntrait Show[A]:\n  def show(a: A): String\n\ngiven Show[Int] with\n  def show(a: Int): String = s\"Int: $a\"\n\ndef display[A](a: A)(using s: Show[A]): String = s.show(a)\n\n\u002F\u002F Scala 2\ntrait Show[A] {\n  def show(a: A): String\n}\n\nimplicit val intShow: Show[Int] = new Show[Int] {\n  def show(a: Int): String = s\"Int: $a\"\n}\n\ndef display[A](a: A)(implicit s: Show[A]): String = s.show(a)\n```\n",{"name":5,"description":7},"main","726e1f79b96b0cb3d729d0e55a1c847e0b5353ae","skills\u002Fhuman_authored\u002Fpython-scala-translation\u002Fpython-scala-functional",8,"https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench","https:\u002F\u002Fcxcscmu.github.io\u002FSkillLearnBench","https:\u002F\u002Fgithub.com\u002Fcxcscmu","2026-10-02 22:55:36",{"source":8,"skillName":5,"commands":52,"prompt":62,"zipAvailable":63},[53,56,59],{"tool":54,"command":55},"npx","npx skills add cxcscmu\u002FSkillLearnBench --skill python-scala-functional",{"tool":57,"command":58},"bunx","bunx skills add cxcscmu\u002FSkillLearnBench --skill python-scala-functional",{"tool":60,"command":61},"pnpm","pnpm dlx skills add cxcscmu\u002FSkillLearnBench --skill python-scala-functional","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fhuman_authored\u002Fpython-scala-translation\u002Fpython-scala-functional\u002FSKILL.md",true,[],[66,84,108,126,145,157],{"skillNo":67,"name":68,"nameZh":6,"description":69,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":70,"categories":71,"keywords":77,"publishedAt":38},"01M6KM5KH175P5ABP5JMX2SBDQ","object_counter","Count occurrences of an object in the image using computer vision algorithm.","https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fhuman_authored\u002Fvideo-object-counting\u002Fobject_counter\u002FSKILL.md",[72],{"categoryNo":73,"categoryName":74,"taxonomyType":75,"taxonomyTypeDesc":76},"01JBSEEDCAT000000000000016","图像与多媒体","SCENARIO","使用场景",[78,79,80,81,82,83],"object counter","object","vision","computer","Computer Vision","image",{"skillNo":85,"name":86,"nameZh":6,"description":87,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":88,"categories":89,"keywords":93,"publishedAt":38},"01M6KM51TMVXG79MMPCS6Y8G86","travel-planning-workflow","Invoke this skill when performing travel planning. It defines a structured workflow for generating itineraries. Following this workflow is essential to ensure the final plan satisfies user requirements.","https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fhuman_authored\u002Ftravel-planning\u002Ftravel-planning-workflow\u002FSKILL.md",[90],{"categoryNo":91,"categoryName":92,"taxonomyType":75,"taxonomyTypeDesc":76},"01JBSEEDCAT000000000000023","Skill与智能体开发",[94,95,96,97,98,99,100,101,102,24,103,104,105,106,107],"workflow","planning","planning workflow","travel","travel planning","travel planning workflow","structured","performing","plan","user","it","requirements","essential","itineraries",{"skillNo":109,"name":110,"nameZh":6,"description":111,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":112,"categories":113,"keywords":114,"publishedAt":38},"01M6KM4DY820XHS9YTSK5QP5HD","bundled-dataset-search-tool","invoke this skill when you need to perform database search for travel planning. This skill provides some useful pre-packaged tools to look up accommodations, attractions, cities, driving distance, flights, and restaurants from the bundled dataset.","https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fhuman_authored\u002Ftravel-planning\u002Fbundled-dataset-search-tool\u002FSKILL.md",[],[115,116,117,118,119,120,121,97,122,123,98,124,24,125,95],"search","tool","dataset","bundled dataset search tool","restaurants","Tools","up","look","flights","you","database",{"skillNo":127,"name":128,"nameZh":6,"description":129,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":130,"categories":131,"keywords":132,"publishedAt":38},"01M6KM465BB9PQ0B548HQSVAWZ","glm-output","Output-processing guidance for GLM tasks. Especially useful after glm-basics and glm-calibration when you need verifier-matching metrics from output.nc and a final \u002Froot\u002Fmetrics.json.","https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fhuman_authored\u002Ftemperature-simulation\u002Fglm-output\u002FSKILL.md",[],[133,134,135,24,136,137,138,139,140,32,141,142,124,143,144],"glm output","output","glm","tasks","metrics","json","basics","guidance","verifier","processing","root","calibration",{"skillNo":146,"name":147,"nameZh":6,"description":148,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":149,"categories":150,"keywords":152,"publishedAt":38},"01M6KM40KY3QWDW5W97S39R2BC","glm-calibration","Calibration guidance for GLM tasks. Often most effective after glm-basics has clarified the setup; glm-output is the companion skill for exact final metric computation.","https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fhuman_authored\u002Ftemperature-simulation\u002Fglm-calibration\u002FSKILL.md",[151],{"categoryNo":91,"categoryName":92,"taxonomyType":75,"taxonomyTypeDesc":76},[153,144,135,134,140,139,136,154,155,24,156],"glm calibration","setup","companion","metric",{"skillNo":158,"name":159,"nameZh":6,"description":160,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":6,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":161,"categories":162,"keywords":163,"publishedAt":38},"01M6KM3VHHVSGMGHJQB3PPT6YG","glm-basics","A good starting point for GLM calibration tasks. Use to inspect glm3.nml, confirm how GLM runs, and identify the relevant files before moving on to calibration and output evaluation.","https:\u002F\u002Fgithub.com\u002Fcxcscmu\u002FSkillLearnBench\u002Fblob\u002Fmain\u002Fskills\u002Fhuman_authored\u002Ftemperature-simulation\u002Fglm-basics\u002FSKILL.md",[],[164,135,139,165,153,144,24,134,166,167,168,35,169,170,136],"glm basics","inspect","relevant","files","good","how","Evaluation"]