@enjoys/context-engine 1.1.0 → 1.1.1

package/data/completion/scala.json

@@ -0,0 +1,1076 @@
+{
+  "language": "scala",
+  "completions": [
+    {
+      "label": "def",
+      "kind": 17,
+      "detail": "Method definition",
+      "documentation": {"value": "```scala\ndef name(param: Type): ReturnType = {\n  // body\n}\n```\nDefines a method or function."},
+      "insertText": "def ${1:name}(${2:params}): ${3:Unit} = {\n  $0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_def"
+    },
+    {
+      "label": "val",
+      "kind": 17,
+      "detail": "Immutable value",
+      "documentation": {"value": "```scala\nval name: Type = value\n```\nDeclares an immutable binding."},
+      "insertText": "val ${1:name}: ${2:Type} = ${3:value}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_val"
+    },
+    {
+      "label": "var",
+      "kind": 17,
+      "detail": "Mutable variable",
+      "documentation": {"value": "```scala\nvar name: Type = value\n```\nDeclares a mutable variable."},
+      "insertText": "var ${1:name}: ${2:Type} = ${3:value}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_var"
+    },
+    {
+      "label": "class",
+      "kind": 17,
+      "detail": "Class declaration",
+      "documentation": {"value": "```scala\nclass MyClass(val field: Type) {\n  // body\n}\n```\nDefines a class."},
+      "insertText": "class ${1:Name}(${2:params}) {\n  $0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_class"
+    },
+    {
+      "label": "object",
+      "kind": 17,
+      "detail": "Singleton object",
+      "documentation": {"value": "```scala\nobject MyObject {\n  // body\n}\n```\nDefines a singleton object."},
+      "insertText": "object ${1:Name} {\n  $0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_object"
+    },
+    {
+      "label": "trait",
+      "kind": 17,
+      "detail": "Trait declaration",
+      "documentation": {"value": "```scala\ntrait MyTrait {\n  def method: Type\n}\n```\nDefines a trait (interface with optional implementations)."},
+      "insertText": "trait ${1:Name} {\n  $0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_trait"
+    },
+    {
+      "label": "abstract",
+      "kind": 17,
+      "detail": "Abstract modifier",
+      "documentation": {"value": "```scala\nabstract class Base {\n  def abstractMethod: Unit\n}\n```\nMarks a class or member as abstract."},
+      "insertText": "abstract",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_abstract"
+    },
+    {
+      "label": "case",
+      "kind": 17,
+      "detail": "Case clause / case class modifier",
+      "documentation": {"value": "```scala\nx match {\n  case pattern => result\n}\n```\nUsed in pattern matching or to define case classes."},
+      "insertText": "case ${1:pattern} => ${2:result}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_case"
+    },
+    {
+      "label": "catch",
+      "kind": 17,
+      "detail": "Catch block",
+      "documentation": {"value": "```scala\ntry { ... } catch {\n  case e: Exception => ...\n}\n```\nCatches exceptions in a try block."},
+      "insertText": "catch {\n  case ${1:e}: ${2:Exception} => $0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_catch"
+    },
+    {
+      "label": "do",
+      "kind": 17,
+      "detail": "Do-while loop",
+      "documentation": {"value": "```scala\ndo {\n  // body\n} while (condition)\n```\nExecutes body then checks condition."},
+      "insertText": "do {\n  $0\n} while (${1:condition})",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_do"
+    },
+    {
+      "label": "else",
+      "kind": 17,
+      "detail": "Else branch",
+      "documentation": {"value": "```scala\nif (cond) expr1 else expr2\n```\nAlternative branch in conditional expression."},
+      "insertText": "else {\n  $0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_else"
+    },
+    {
+      "label": "extends",
+      "kind": 17,
+      "detail": "Inheritance keyword",
+      "documentation": {"value": "```scala\nclass Child extends Parent\n```\nSpecifies superclass or trait."},
+      "insertText": "extends ${1:Parent}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_extends"
+    },
+    {
+      "label": "false",
+      "kind": 17,
+      "detail": "Boolean literal false",
+      "documentation": {"value": "Boolean literal representing the false value."},
+      "insertText": "false",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_false"
+    },
+    {
+      "label": "final",
+      "kind": 17,
+      "detail": "Final modifier",
+      "documentation": {"value": "```scala\nfinal class Sealed\nfinal val x = 42\n```\nPrevents overriding or subclassing."},
+      "insertText": "final",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_final"
+    },
+    {
+      "label": "finally",
+      "kind": 17,
+      "detail": "Finally block",
+      "documentation": {"value": "```scala\ntry { ... } finally { cleanup() }\n```\nExecutes cleanup code regardless of exceptions."},
+      "insertText": "finally {\n  $0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_finally"
+    },
+    {
+      "label": "for",
+      "kind": 17,
+      "detail": "For loop / comprehension",
+      "documentation": {"value": "```scala\nfor (x <- xs) yield x * 2\nfor {\n  x <- xs\n  y <- ys\n} yield (x, y)\n```\nFor loop or for-comprehension."},
+      "insertText": "for (${1:x} <- ${2:xs}) {\n  $0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_for"
+    },
+    {
+      "label": "forSome",
+      "kind": 17,
+      "detail": "Existential type qualifier",
+      "documentation": {"value": "```scala\nList[T] forSome { type T }\n```\nExistential type quantifier (Scala 2)."},
+      "insertText": "forSome { type ${1:T} }",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_forSome"
+    },
+    {
+      "label": "if",
+      "kind": 17,
+      "detail": "Conditional expression",
+      "documentation": {"value": "```scala\nif (condition) expr1 else expr2\n```\nConditional expression. Returns a value."},
+      "insertText": "if (${1:condition}) {\n  $0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_if"
+    },
+    {
+      "label": "implicit",
+      "kind": 17,
+      "detail": "Implicit modifier",
+      "documentation": {"value": "```scala\nimplicit val ord: Ordering[Int] = ...\nimplicit def convert(x: A): B = ...\n```\nMarks a value, method, or class as implicit."},
+      "insertText": "implicit",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_implicit"
+    },
+    {
+      "label": "import",
+      "kind": 17,
+      "detail": "Import declaration",
+      "documentation": {"value": "```scala\nimport scala.collection.mutable.ListBuffer\nimport java.util.{List, Map}\n```\nImports packages, classes, or members."},
+      "insertText": "import ${1:package.Name}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_import"
+    },
+    {
+      "label": "lazy",
+      "kind": 17,
+      "detail": "Lazy evaluation modifier",
+      "documentation": {"value": "```scala\nlazy val expensive = computeValue()\n```\nDefers evaluation until first access."},
+      "insertText": "lazy val ${1:name} = ${2:value}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_lazy"
+    },
+    {
+      "label": "match",
+      "kind": 17,
+      "detail": "Pattern matching",
+      "documentation": {"value": "```scala\nx match {\n  case Some(v) => v\n  case None => default\n}\n```\nPattern matching expression."},
+      "insertText": "match {\n  case ${1:pattern} => $0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_match"
+    },
+    {
+      "label": "new",
+      "kind": 17,
+      "detail": "Object instantiation",
+      "documentation": {"value": "```scala\nnew MyClass(args)\n```\nCreates a new instance."},
+      "insertText": "new ${1:ClassName}(${2:args})",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_new"
+    },
+    {
+      "label": "null",
+      "kind": 17,
+      "detail": "Null reference",
+      "documentation": {"value": "The null reference. Use Option instead when possible."},
+      "insertText": "null",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_null"
+    },
+    {
+      "label": "override",
+      "kind": 17,
+      "detail": "Override modifier",
+      "documentation": {"value": "```scala\noverride def toString: String = ...\n```\nOverrides a member from a parent class or trait."},
+      "insertText": "override",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_override"
+    },
+    {
+      "label": "package",
+      "kind": 17,
+      "detail": "Package declaration",
+      "documentation": {"value": "```scala\npackage com.example.myapp\n```\nDeclares the package namespace."},
+      "insertText": "package ${1:com.example}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_package"
+    },
+    {
+      "label": "private",
+      "kind": 17,
+      "detail": "Private access modifier",
+      "documentation": {"value": "```scala\nprivate val secret = 42\nprivate[this] val instanceOnly = 1\n```\nRestricts access to the enclosing class."},
+      "insertText": "private",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_private"
+    },
+    {
+      "label": "protected",
+      "kind": 17,
+      "detail": "Protected access modifier",
+      "documentation": {"value": "```scala\nprotected def helper(): Unit = ...\n```\nRestricts access to the class and its subclasses."},
+      "insertText": "protected",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_protected"
+    },
+    {
+      "label": "return",
+      "kind": 17,
+      "detail": "Return statement",
+      "documentation": {"value": "```scala\ndef f(): Int = { return 42 }\n```\nExplicitly returns from a method. Rarely needed in Scala."},
+      "insertText": "return ${1:value}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_return"
+    },
+    {
+      "label": "sealed",
+      "kind": 17,
+      "detail": "Sealed modifier",
+      "documentation": {"value": "```scala\nsealed trait Shape\ncase class Circle(r: Double) extends Shape\n```\nRestricts subtypes to the same file for exhaustive matching."},
+      "insertText": "sealed",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_sealed"
+    },
+    {
+      "label": "super",
+      "kind": 17,
+      "detail": "Superclass reference",
+      "documentation": {"value": "```scala\nsuper.method()\nsuper[TraitName].method()\n```\nRefers to the parent class or trait."},
+      "insertText": "super",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_super"
+    },
+    {
+      "label": "this",
+      "kind": 17,
+      "detail": "Current instance reference",
+      "documentation": {"value": "```scala\nthis.field\ndef this(x: Int) = this(x, 0)\n```\nRefers to the current instance."},
+      "insertText": "this",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_this"
+    },
+    {
+      "label": "throw",
+      "kind": 17,
+      "detail": "Throw expression",
+      "documentation": {"value": "```scala\nthrow new IllegalArgumentException(\"msg\")\n```\nThrows an exception."},
+      "insertText": "throw new ${1:Exception}(\"${2:message}\")",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_throw"
+    },
+    {
+      "label": "true",
+      "kind": 17,
+      "detail": "Boolean literal true",
+      "documentation": {"value": "Boolean literal representing the true value."},
+      "insertText": "true",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_true"
+    },
+    {
+      "label": "try",
+      "kind": 17,
+      "detail": "Try block",
+      "documentation": {"value": "```scala\ntry {\n  riskyOp()\n} catch {\n  case e: Exception => handle(e)\n} finally {\n  cleanup()\n}\n```\nException handling block."},
+      "insertText": "try {\n  $0\n} catch {\n  case ${1:e}: ${2:Exception} => ${3:???}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_try"
+    },
+    {
+      "label": "type",
+      "kind": 17,
+      "detail": "Type alias / abstract type",
+      "documentation": {"value": "```scala\ntype Name = String\ntype F[A] = List[A]\n```\nDefines a type alias or abstract type member."},
+      "insertText": "type ${1:Name} = ${2:Type}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_type"
+    },
+    {
+      "label": "while",
+      "kind": 17,
+      "detail": "While loop",
+      "documentation": {"value": "```scala\nwhile (condition) {\n  // body\n}\n```\nRepeats while condition is true."},
+      "insertText": "while (${1:condition}) {\n  $0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_while"
+    },
+    {
+      "label": "with",
+      "kind": 17,
+      "detail": "Mixin composition",
+      "documentation": {"value": "```scala\nclass A extends B with C with D\n```\nMixes in additional traits."},
+      "insertText": "with ${1:Trait}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_with"
+    },
+    {
+      "label": "yield",
+      "kind": 17,
+      "detail": "For-comprehension yield",
+      "documentation": {"value": "```scala\nfor (x <- xs) yield x * 2\n```\nProduces a value in a for-comprehension."},
+      "insertText": "yield ${1:expr}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_yield"
+    },
+    {
+      "label": "given",
+      "kind": 17,
+      "detail": "Given instance (Scala 3)",
+      "documentation": {"value": "```scala\ngiven ord: Ordering[Int] = Ordering.Int\ngiven Ordering[Int] with { ... }\n```\nDeclares a given instance for contextual abstraction."},
+      "insertText": "given ${1:name}: ${2:Type} = ${3:value}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_given"
+    },
+    {
+      "label": "using",
+      "kind": 17,
+      "detail": "Using clause (Scala 3)",
+      "documentation": {"value": "```scala\ndef f(using ord: Ordering[Int]): Unit = ...\n```\nDeclares contextual parameters."},
+      "insertText": "using ${1:name}: ${2:Type}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_using"
+    },
+    {
+      "label": "enum",
+      "kind": 17,
+      "detail": "Enum declaration (Scala 3)",
+      "documentation": {"value": "```scala\nenum Color {\n  case Red, Green, Blue\n}\nenum Planet(mass: Double, radius: Double) {\n  case Mercury extends Planet(3.3e23, 2.4e6)\n}\n```\nDefines an enumeration type."},
+      "insertText": "enum ${1:Name} {\n  case ${2:Value1}, ${3:Value2}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_enum"
+    },
+    {
+      "label": "export",
+      "kind": 17,
+      "detail": "Export clause (Scala 3)",
+      "documentation": {"value": "```scala\nexport myObj.{member1, member2}\n```\nRe-exports members from another object."},
+      "insertText": "export ${1:obj}.{${2:members}}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_export"
+    },
+    {
+      "label": "then",
+      "kind": 17,
+      "detail": "Then keyword (Scala 3)",
+      "documentation": {"value": "```scala\nif condition then expr1 else expr2\n```\nOptional keyword after if condition in Scala 3."},
+      "insertText": "then",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_then"
+    },
+    {
+      "label": "end",
+      "kind": 17,
+      "detail": "End marker (Scala 3)",
+      "documentation": {"value": "```scala\ndef longMethod =\n  ...\nend longMethod\n```\nOptional end marker for long definitions."},
+      "insertText": "end ${1:name}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_end"
+    },
+    {
+      "label": "extension",
+      "kind": 17,
+      "detail": "Extension method (Scala 3)",
+      "documentation": {"value": "```scala\nextension (s: String)\n  def greet: String = s\"Hello, $s\"\n```\nAdds methods to existing types."},
+      "insertText": "extension (${1:x}: ${2:Type})\n  def ${3:method}: ${4:ReturnType} = $0",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_extension"
+    },
+    {
+      "label": "transparent",
+      "kind": 17,
+      "detail": "Transparent modifier (Scala 3)",
+      "documentation": {"value": "```scala\ntransparent inline def f: Any = ...\n```\nAllows the compiler to specialize the return type."},
+      "insertText": "transparent",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_transparent"
+    },
+    {
+      "label": "inline",
+      "kind": 17,
+      "detail": "Inline modifier (Scala 3)",
+      "documentation": {"value": "```scala\ninline def power(x: Double, inline n: Int): Double = ...\n```\nInlines the method at call sites."},
+      "insertText": "inline",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_inline"
+    },
+    {
+      "label": "opaque",
+      "kind": 17,
+      "detail": "Opaque type alias (Scala 3)",
+      "documentation": {"value": "```scala\nopaque type UserId = Int\n```\nDefines a type alias whose underlying type is hidden outside its scope."},
+      "insertText": "opaque type ${1:Name} = ${2:Type}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_opaque"
+    },
+    {
+      "label": "open",
+      "kind": 17,
+      "detail": "Open modifier (Scala 3)",
+      "documentation": {"value": "```scala\nopen class Base\n```\nExplicitly allows a class to be extended."},
+      "insertText": "open",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_open"
+    },
+    {
+      "label": "derives",
+      "kind": 17,
+      "detail": "Derives clause (Scala 3)",
+      "documentation": {"value": "```scala\ncase class Point(x: Int, y: Int) derives Eq, Show\n```\nAutomatically derives type class instances."},
+      "insertText": "derives ${1:TypeClass}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_derives"
+    },
+    {
+      "label": "println",
+      "kind": 1,
+      "detail": "Print with newline",
+      "documentation": {"value": "```scala\nprintln(\"Hello, World!\")\nprintln(s\"Value: $x\")\n```\nPrints a value followed by a newline to stdout."},
+      "insertText": "println(${1:\"message\"})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_println"
+    },
+    {
+      "label": "print",
+      "kind": 1,
+      "detail": "Print without newline",
+      "documentation": {"value": "```scala\nprint(\"Hello\")\n```\nPrints a value to stdout without a trailing newline."},
+      "insertText": "print(${1:\"message\"})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_print"
+    },
+    {
+      "label": "require",
+      "kind": 1,
+      "detail": "Precondition check",
+      "documentation": {"value": "```scala\nrequire(x > 0, \"x must be positive\")\n```\nThrows IllegalArgumentException if condition is false."},
+      "insertText": "require(${1:condition}, \"${2:message}\")",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_require"
+    },
+    {
+      "label": "assert",
+      "kind": 1,
+      "detail": "Assertion check",
+      "documentation": {"value": "```scala\nassert(list.nonEmpty, \"list must not be empty\")\n```\nThrows AssertionError if condition is false."},
+      "insertText": "assert(${1:condition}, \"${2:message}\")",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_assert"
+    },
+    {
+      "label": "sys.exit",
+      "kind": 1,
+      "detail": "Exit program",
+      "documentation": {"value": "```scala\nsys.exit(0)\n```\nTerminates the JVM with the given status code."},
+      "insertText": "sys.exit(${1:0})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_sys_exit"
+    },
+    {
+      "label": "sys.error",
+      "kind": 1,
+      "detail": "Throw runtime exception",
+      "documentation": {"value": "```scala\nsys.error(\"something went wrong\")\n```\nThrows a RuntimeException with the given message."},
+      "insertText": "sys.error(\"${1:message}\")",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_sys_error"
+    },
+    {
+      "label": "Some",
+      "kind": 1,
+      "detail": "Some(value) constructor",
+      "documentation": {"value": "```scala\nval x: Option[Int] = Some(42)\n```\nWraps a value in an Option."},
+      "insertText": "Some(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Some"
+    },
+    {
+      "label": "None",
+      "kind": 1,
+      "detail": "None value",
+      "documentation": {"value": "```scala\nval x: Option[Int] = None\n```\nRepresents the absence of a value."},
+      "insertText": "None",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_None"
+    },
+    {
+      "label": "Left",
+      "kind": 1,
+      "detail": "Left(value) constructor",
+      "documentation": {"value": "```scala\nval result: Either[String, Int] = Left(\"error\")\n```\nCreates the left (typically error) side of an Either."},
+      "insertText": "Left(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Left"
+    },
+    {
+      "label": "Right",
+      "kind": 1,
+      "detail": "Right(value) constructor",
+      "documentation": {"value": "```scala\nval result: Either[String, Int] = Right(42)\n```\nCreates the right (typically success) side of an Either."},
+      "insertText": "Right(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Right"
+    },
+    {
+      "label": "Nil",
+      "kind": 1,
+      "detail": "Empty list",
+      "documentation": {"value": "```scala\nval empty: List[Int] = Nil\nval list = 1 :: 2 :: 3 :: Nil\n```\nThe empty list."},
+      "insertText": "Nil",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Nil"
+    },
+    {
+      "label": "List",
+      "kind": 1,
+      "detail": "List constructor",
+      "documentation": {"value": "```scala\nval xs = List(1, 2, 3)\nval ys = List.empty[String]\n```\nCreates an immutable linked list."},
+      "insertText": "List(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_List"
+    },
+    {
+      "label": "Map",
+      "kind": 1,
+      "detail": "Map constructor",
+      "documentation": {"value": "```scala\nval m = Map(\"a\" -> 1, \"b\" -> 2)\n```\nCreates an immutable map."},
+      "insertText": "Map(${1:key} -> ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Map"
+    },
+    {
+      "label": "Set",
+      "kind": 1,
+      "detail": "Set constructor",
+      "documentation": {"value": "```scala\nval s = Set(1, 2, 3)\n```\nCreates an immutable set."},
+      "insertText": "Set(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Set"
+    },
+    {
+      "label": "Vector",
+      "kind": 1,
+      "detail": "Vector constructor",
+      "documentation": {"value": "```scala\nval v = Vector(1, 2, 3)\n```\nCreates an immutable indexed sequence with efficient random access."},
+      "insertText": "Vector(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Vector"
+    },
+    {
+      "label": "Array",
+      "kind": 1,
+      "detail": "Array constructor",
+      "documentation": {"value": "```scala\nval arr = Array(1, 2, 3)\nval arr2 = new Array[Int](10)\n```\nCreates a mutable indexed sequence backed by a Java array."},
+      "insertText": "Array(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Array"
+    },
+    {
+      "label": "Option",
+      "kind": 1,
+      "detail": "Option type",
+      "documentation": {"value": "```scala\nval opt: Option[Int] = Option(maybeNull)\nopt.getOrElse(0)\n```\nRepresents an optional value: either Some(value) or None."},
+      "insertText": "Option(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Option"
+    },
+    {
+      "label": "Either",
+      "kind": 1,
+      "detail": "Either type",
+      "documentation": {"value": "```scala\ndef divide(a: Int, b: Int): Either[String, Int] =\n  if (b == 0) Left(\"div by zero\") else Right(a / b)\n```\nRepresents a value of two possible types: Left or Right."},
+      "insertText": "Either[${1:L}, ${2:R}]",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Either"
+    },
+    {
+      "label": "Try",
+      "kind": 1,
+      "detail": "Try container",
+      "documentation": {"value": "```scala\nimport scala.util.Try\nval result = Try(riskyOperation())\n```\nWraps a computation that may throw, yielding Success or Failure."},
+      "insertText": "Try(${1:expr})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Try"
+    },
+    {
+      "label": "Future",
+      "kind": 1,
+      "detail": "Future computation",
+      "documentation": {"value": "```scala\nimport scala.concurrent.Future\nimport scala.concurrent.ExecutionContext.Implicits.global\nval f = Future { expensiveComputation() }\n```\nRepresents an asynchronous computation."},
+      "insertText": "Future {\n  $0\n}",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Future"
+    },
+    {
+      "label": "Promise",
+      "kind": 1,
+      "detail": "Promise for Future",
+      "documentation": {"value": "```scala\nimport scala.concurrent.Promise\nval p = Promise[Int]()\np.success(42)\np.future\n```\nA writable, single-assignment container that completes a Future."},
+      "insertText": "Promise[${1:Type}]()",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Promise"
+    },
+    {
+      "label": "Stream",
+      "kind": 1,
+      "detail": "Lazy stream (Scala 2)",
+      "documentation": {"value": "```scala\nval s = Stream.from(1)\n```\nLazily evaluated stream (deprecated in Scala 2.13, use LazyList)."},
+      "insertText": "Stream(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Stream"
+    },
+    {
+      "label": "LazyList",
+      "kind": 1,
+      "detail": "Lazy list",
+      "documentation": {"value": "```scala\nval naturals = LazyList.from(1)\nval fibs: LazyList[Int] = 0 #:: 1 #:: fibs.zip(fibs.tail).map(_ + _)\n```\nLazily evaluated immutable linked list (replaces Stream in 2.13+)."},
+      "insertText": "LazyList(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_LazyList"
+    },
+    {
+      "label": "Range",
+      "kind": 1,
+      "detail": "Range of integers",
+      "documentation": {"value": "```scala\nval r = 1 to 10\nval r2 = 0 until 100 by 2\n```\nRepresents an ordered sequence of integers."},
+      "insertText": "${1:1} to ${2:10}",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Range"
+    },
+    {
+      "label": "Seq",
+      "kind": 1,
+      "detail": "Sequence trait",
+      "documentation": {"value": "```scala\nval s: Seq[Int] = Seq(1, 2, 3)\n```\nGeneral sequence type. Default implementation is List."},
+      "insertText": "Seq(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Seq"
+    },
+    {
+      "label": "IndexedSeq",
+      "kind": 1,
+      "detail": "Indexed sequence",
+      "documentation": {"value": "```scala\nval is: IndexedSeq[Int] = IndexedSeq(1, 2, 3)\n```\nA sequence with efficient indexed access. Default implementation is Vector."},
+      "insertText": "IndexedSeq(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_IndexedSeq"
+    },
+    {
+      "label": "Iterator",
+      "kind": 1,
+      "detail": "Iterator",
+      "documentation": {"value": "```scala\nval it = Iterator(1, 2, 3)\nwhile (it.hasNext) println(it.next())\n```\nA one-time traversable collection of elements."},
+      "insertText": "Iterator(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Iterator"
+    },
+    {
+      "label": "Tuple",
+      "kind": 1,
+      "detail": "Tuple literal",
+      "documentation": {"value": "```scala\nval t = (1, \"hello\", true)\nval (a, b, c) = t\n```\nHeterogeneous fixed-size collection."},
+      "insertText": "(${1:a}, ${2:b})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Tuple"
+    },
+    {
+      "label": "main method",
+      "kind": 27,
+      "detail": "Scala main entry point",
+      "documentation": {"value": "```scala\n@main def run(): Unit =\n  println(\"Hello, World!\")\n```\nScala 3 main method entry point."},
+      "insertText": "@main def ${1:run}(): Unit =\n  ${2:println(\"Hello, World!\")}",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_main"
+    },
+    {
+      "label": "main object (Scala 2)",
+      "kind": 27,
+      "detail": "Scala 2 App object",
+      "documentation": {"value": "```scala\nobject Main extends App {\n  println(\"Hello, World!\")\n}\n```\nScala 2 entry point using App trait."},
+      "insertText": "object ${1:Main} extends App {\n  ${2:println(\"Hello, World!\")}\n}",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_main_object"
+    },
+    {
+      "label": "case class",
+      "kind": 27,
+      "detail": "Case class definition",
+      "documentation": {"value": "```scala\ncase class Person(name: String, age: Int)\n```\nDefines an immutable data class with auto-generated equals, hashCode, toString, copy, and unapply."},
+      "insertText": "case class ${1:Name}(${2:field}: ${3:Type})",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_case_class"
+    },
+    {
+      "label": "sealed trait ADT",
+      "kind": 27,
+      "detail": "Sealed trait with case classes",
+      "documentation": {"value": "```scala\nsealed trait Shape\ncase class Circle(radius: Double) extends Shape\ncase class Rectangle(w: Double, h: Double) extends Shape\n```\nAlgebraic data type pattern."},
+      "insertText": "sealed trait ${1:Base}\ncase class ${2:Variant1}(${3:field}: ${4:Type}) extends ${1:Base}\ncase class ${5:Variant2}(${6:field}: ${7:Type}) extends ${1:Base}",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_sealed_trait"
+    },
+    {
+      "label": "for comprehension",
+      "kind": 27,
+      "detail": "For-comprehension with yield",
+      "documentation": {"value": "```scala\nfor {\n  x <- xs\n  y <- ys\n  if x > 0\n} yield (x, y)\n```\nMonadic for-comprehension."},
+      "insertText": "for {\n  ${1:x} <- ${2:xs}\n  ${3:y} <- ${4:ys}\n} yield ${5:(${1:x}, ${3:y})}",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_for_comp"
+    },
+    {
+      "label": "pattern match",
+      "kind": 27,
+      "detail": "Pattern matching block",
+      "documentation": {"value": "```scala\nvalue match {\n  case Some(x) => x\n  case None    => default\n}\n```\nExhaustive pattern matching."},
+      "insertText": "${1:value} match {\n  case ${2:pattern1} => ${3:result1}\n  case ${4:pattern2} => ${5:result2}\n  case _ => ${6:default}\n}",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_pattern_match"
+    },
+    {
+      "label": "implicit class",
+      "kind": 27,
+      "detail": "Implicit class (Scala 2 extension)",
+      "documentation": {"value": "```scala\nimplicit class RichInt(val n: Int) extends AnyVal {\n  def isEven: Boolean = n % 2 == 0\n}\n```\nAdds extension methods via implicit conversion."},
+      "insertText": "implicit class ${1:Rich}${2:Type}(val ${3:x}: ${2:Type}) extends AnyVal {\n  def ${4:method}: ${5:ReturnType} = $0\n}",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_implicit_class"
+    },
+    {
+      "label": "extension method (Scala 3)",
+      "kind": 27,
+      "detail": "Extension method definition",
+      "documentation": {"value": "```scala\nextension (s: String)\n  def greet: String = s\"Hello, $s!\"\n  def exclaim: String = s + \"!\"\n```\nScala 3 extension methods."},
+      "insertText": "extension (${1:x}: ${2:Type})\n  def ${3:method}: ${4:ReturnType} = $0",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_extension"
+    },
+    {
+      "label": "given/using",
+      "kind": 27,
+      "detail": "Given instance and using clause",
+      "documentation": {"value": "```scala\ngiven intOrd: Ordering[Int] with\n  def compare(x: Int, y: Int) = x - y\n\ndef sort[T](xs: List[T])(using ord: Ordering[T]) = xs.sorted\n```\nScala 3 contextual abstractions."},
+      "insertText": "given ${1:name}: ${2:TypeClass}[${3:Type}] with\n  def ${4:method}(${5:params}): ${6:ReturnType} = $0",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_given_using"
+    },
+    {
+      "label": "Future with map/flatMap",
+      "kind": 27,
+      "detail": "Future composition",
+      "documentation": {"value": "```scala\nimport scala.concurrent.Future\nimport scala.concurrent.ExecutionContext.Implicits.global\n\nval result = for {\n  a <- Future(computeA())\n  b <- Future(computeB(a))\n} yield combine(a, b)\n```\nComposing Futures with for-comprehension."},
+      "insertText": "import scala.concurrent.Future\nimport scala.concurrent.ExecutionContext.Implicits.global\n\nval ${1:result} = for {\n  ${2:a} <- Future(${3:computeA()})\n  ${4:b} <- Future(${5:computeB(${2:a})})\n} yield ${6:combine(${2:a}, ${4:b})}",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_future_comp"
+    },
+    {
+      "label": "actor (Akka)",
+      "kind": 27,
+      "detail": "Akka typed actor",
+      "documentation": {"value": "```scala\nimport akka.actor.typed.Behavior\nimport akka.actor.typed.scaladsl.Behaviors\n\nobject MyActor {\n  sealed trait Command\n  case class Greet(name: String) extends Command\n\n  def apply(): Behavior[Command] =\n    Behaviors.receive { (ctx, msg) =>\n      msg match {\n        case Greet(name) =>\n          ctx.log.info(s\"Hello, $name!\")\n          Behaviors.same\n      }\n    }\n}\n```\nAkka typed actor pattern."},
+      "insertText": "object ${1:MyActor} {\n  sealed trait Command\n  case class ${2:Msg}(${3:field}: ${4:String}) extends Command\n\n  def apply(): Behavior[Command] =\n    Behaviors.receive { (ctx, msg) =>\n      msg match {\n        case ${2:Msg}(${3:field}) =>\n          ctx.log.info(s\"Received: $$${3:field}\")\n          Behaviors.same\n      }\n    }\n}",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_actor"
+    },
+    {
+      "label": "case object",
+      "kind": 27,
+      "detail": "Case object",
+      "documentation": {"value": "```scala\ncase object Singleton\n```\nDefines a singleton case object, often used in ADTs."},
+      "insertText": "case object ${1:Name}",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_case_object"
+    },
+    {
+      "label": "implicit val",
+      "kind": 27,
+      "detail": "Implicit value",
+      "documentation": {"value": "```scala\nimplicit val ec: ExecutionContext = ExecutionContext.global\n```\nProvides an implicit value."},
+      "insertText": "implicit val ${1:name}: ${2:Type} = ${3:value}",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_implicit_val"
+    },
+    {
+      "label": "implicit def",
+      "kind": 27,
+      "detail": "Implicit conversion",
+      "documentation": {"value": "```scala\nimplicit def intToString(i: Int): String = i.toString\n```\nDefines an implicit conversion."},
+      "insertText": "implicit def ${1:name}(${2:param}: ${3:From}): ${4:To} = $0",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_implicit_def"
+    },
+    {
+      "label": "object companion",
+      "kind": 27,
+      "detail": "Companion object with apply",
+      "documentation": {"value": "```scala\nclass Foo(val x: Int)\nobject Foo {\n  def apply(x: Int): Foo = new Foo(x)\n}\n```\nCompanion object pattern."},
+      "insertText": "object ${1:Name} {\n  def apply(${2:params}): ${1:Name} = new ${1:Name}(${3:args})\n}",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_companion"
+    },
+    {
+      "label": "trait with abstract",
+      "kind": 27,
+      "detail": "Trait with abstract members",
+      "documentation": {"value": "```scala\ntrait Repository[T] {\n  def findById(id: Long): Option[T]\n  def findAll: List[T]\n  def save(entity: T): Unit\n}\n```\nTrait with abstract method signatures."},
+      "insertText": "trait ${1:Name}[${2:T}] {\n  def ${3:method}(${4:params}): ${5:ReturnType}\n  $0\n}",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_trait_abstract"
+    },
+    {
+      "label": "enum (Scala 3)",
+      "kind": 27,
+      "detail": "Scala 3 enum with parameters",
+      "documentation": {"value": "```scala\nenum Color(val rgb: Int) {\n  case Red   extends Color(0xFF0000)\n  case Green extends Color(0x00FF00)\n  case Blue  extends Color(0x0000FF)\n}\n```\nParameterized enum in Scala 3."},
+      "insertText": "enum ${1:Name}(val ${2:field}: ${3:Type}) {\n  case ${4:Value1} extends ${1:Name}(${5:arg})\n  case ${6:Value2} extends ${1:Name}(${7:arg})\n}",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_enum"
+    },
+    {
+      "label": "opaque type",
+      "kind": 27,
+      "detail": "Opaque type alias (Scala 3)",
+      "documentation": {"value": "```scala\nobject Types {\n  opaque type UserId = Long\n  object UserId {\n    def apply(id: Long): UserId = id\n  }\n  extension (id: UserId)\n    def value: Long = id\n}\n```\nType-safe wrapper without runtime overhead."},
+      "insertText": "opaque type ${1:Name} = ${2:Underlying}\nobject ${1:Name} {\n  def apply(value: ${2:Underlying}): ${1:Name} = value\n}\nextension (x: ${1:Name})\n  def value: ${2:Underlying} = x",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_opaque_type"
+    },
+    {
+      "label": "given with typeclass",
+      "kind": 27,
+      "detail": "Type class instance with given",
+      "documentation": {"value": "```scala\ntrait Show[A]:\n  extension (a: A) def show: String\n\ngiven Show[Int] with\n  extension (i: Int) def show: String = i.toString\n```\nType class pattern in Scala 3."},
+      "insertText": "trait ${1:TypeClass}[${2:A}]:\n  extension (a: ${2:A}) def ${3:method}: ${4:String}\n\ngiven ${1:TypeClass}[${5:ConcreteType}] with\n  extension (a: ${5:ConcreteType}) def ${3:method}: ${4:String} = $0",
+      "insertTextRules": 4,
+      "sortText": "03_snippet_typeclass"
+    },
+    {
+      "label": "Success",
+      "kind": 1,
+      "detail": "Success case of Try",
+      "documentation": {"value": "```scala\nimport scala.util.Success\nresult match { case Success(v) => v }\n```\nRepresents the successful result of a Try."},
+      "insertText": "Success(${1:value})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Success"
+    },
+    {
+      "label": "Failure",
+      "kind": 1,
+      "detail": "Failure case of Try",
+      "documentation": {"value": "```scala\nimport scala.util.Failure\nresult match { case Failure(e) => handle(e) }\n```\nRepresents a failed Try containing an exception."},
+      "insertText": "Failure(${1:exception})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Failure"
+    },
+    {
+      "label": "ListBuffer",
+      "kind": 1,
+      "detail": "Mutable list buffer",
+      "documentation": {"value": "```scala\nimport scala.collection.mutable.ListBuffer\nval buf = ListBuffer(1, 2, 3)\nbuf += 4\n```\nA mutable buffer backed by a list."},
+      "insertText": "ListBuffer(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_ListBuffer"
+    },
+    {
+      "label": "ArrayBuffer",
+      "kind": 1,
+      "detail": "Mutable array buffer",
+      "documentation": {"value": "```scala\nimport scala.collection.mutable.ArrayBuffer\nval buf = ArrayBuffer(1, 2, 3)\nbuf += 4\n```\nA mutable buffer backed by an array."},
+      "insertText": "ArrayBuffer(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_ArrayBuffer"
+    },
+    {
+      "label": "HashMap",
+      "kind": 1,
+      "detail": "Mutable hash map",
+      "documentation": {"value": "```scala\nimport scala.collection.mutable.HashMap\nval m = HashMap(\"a\" -> 1, \"b\" -> 2)\n```\nA mutable map backed by a hash table."},
+      "insertText": "HashMap(${1:key} -> ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_HashMap"
+    },
+    {
+      "label": "TreeMap",
+      "kind": 1,
+      "detail": "Sorted immutable map",
+      "documentation": {"value": "```scala\nimport scala.collection.immutable.TreeMap\nval m = TreeMap(\"a\" -> 1, \"b\" -> 2)\n```\nAn immutable sorted map backed by a red-black tree."},
+      "insertText": "TreeMap(${1:key} -> ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_TreeMap"
+    },
+    {
+      "label": "SortedSet",
+      "kind": 1,
+      "detail": "Sorted set",
+      "documentation": {"value": "```scala\nimport scala.collection.immutable.SortedSet\nval s = SortedSet(3, 1, 2)\n```\nAn immutable sorted set."},
+      "insertText": "SortedSet(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_SortedSet"
+    },
+    {
+      "label": "Queue",
+      "kind": 1,
+      "detail": "Immutable queue",
+      "documentation": {"value": "```scala\nimport scala.collection.immutable.Queue\nval q = Queue(1, 2, 3)\n```\nAn immutable FIFO queue."},
+      "insertText": "Queue(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Queue"
+    },
+    {
+      "label": "Stack",
+      "kind": 1,
+      "detail": "Immutable stack (deprecated)",
+      "documentation": {"value": "```scala\nval s = List(1, 2, 3) // use List as stack\nval head :: tail = s\n```\nUse List as a stack with :: and pattern matching."},
+      "insertText": "List(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Stack"
+    },
+    {
+      "label": "Using",
+      "kind": 1,
+      "detail": "Resource management",
+      "documentation": {"value": "```scala\nimport scala.util.Using\nUsing(new FileReader(\"file.txt\")) { reader =>\n  reader.read()\n}\n```\nAutomatically manages resource cleanup."},
+      "insertText": "Using(${1:resource}) { ${2:r} =>\n  $0\n}",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Using"
+    },
+    {
+      "label": "Source",
+      "kind": 1,
+      "detail": "File/URL source",
+      "documentation": {"value": "```scala\nimport scala.io.Source\nval lines = Source.fromFile(\"file.txt\").getLines().toList\n```\nReads data from files, URLs, or other sources."},
+      "insertText": "Source.fromFile(\"${1:path}\")",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Source"
+    },
+    {
+      "label": "Await",
+      "kind": 1,
+      "detail": "Future await",
+      "documentation": {"value": "```scala\nimport scala.concurrent.Await\nimport scala.concurrent.duration._\nval result = Await.result(future, 10.seconds)\n```\nBlocks until a Future completes."},
+      "insertText": "Await.result(${1:future}, ${2:10}.seconds)",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Await"
+    },
+    {
+      "label": "Duration",
+      "kind": 1,
+      "detail": "Time duration",
+      "documentation": {"value": "```scala\nimport scala.concurrent.duration._\nval d = 5.seconds\nval d2 = Duration(10, MILLISECONDS)\n```\nRepresents a time duration."},
+      "insertText": "${1:5}.${2:seconds}",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Duration"
+    },
+    {
+      "label": "mutable.Map",
+      "kind": 1,
+      "detail": "Mutable map",
+      "documentation": {"value": "```scala\nimport scala.collection.mutable\nval m = mutable.Map(\"a\" -> 1)\nm += (\"b\" -> 2)\n```\nA mutable map."},
+      "insertText": "mutable.Map(${1:key} -> ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_mutableMap"
+    },
+    {
+      "label": "mutable.Set",
+      "kind": 1,
+      "detail": "Mutable set",
+      "documentation": {"value": "```scala\nimport scala.collection.mutable\nval s = mutable.Set(1, 2, 3)\ns += 4\n```\nA mutable set."},
+      "insertText": "mutable.Set(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_mutableSet"
+    },
+    {
+      "label": "StringBuilder",
+      "kind": 1,
+      "detail": "Mutable string builder",
+      "documentation": {"value": "```scala\nval sb = new StringBuilder\nsb.append(\"Hello\")\nsb.append(\" World\")\nsb.toString\n```\nEfficiently builds strings from parts."},
+      "insertText": "new StringBuilder",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_StringBuilder"
+    },
+    {
+      "label": "Regex",
+      "kind": 1,
+      "detail": "Regular expression",
+      "documentation": {"value": "```scala\nimport scala.util.matching.Regex\nval pattern = \"\"\"(\\d+)\"\"\".r\npattern.findFirstIn(\"abc 123\")\n```\nRegular expression pattern."},
+      "insertText": "\"\"\"${1:pattern}\"\"\".r",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Regex"
+    },
+    {
+      "label": "ClassTag",
+      "kind": 1,
+      "detail": "Runtime class info",
+      "documentation": {"value": "```scala\nimport scala.reflect.ClassTag\ndef create[T: ClassTag]: Array[T] = new Array[T](10)\n```\nProvides runtime class information for generic types."},
+      "insertText": "ClassTag",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_ClassTag"
+    },
+    {
+      "label": "PartialFunction",
+      "kind": 1,
+      "detail": "Partial function",
+      "documentation": {"value": "```scala\nval pf: PartialFunction[Int, String] = {\n  case 1 => \"one\"\n  case 2 => \"two\"\n}\n```\nA function defined only for certain inputs."},
+      "insertText": "val ${1:pf}: PartialFunction[${2:Input}, ${3:Output}] = {\n  case ${4:pattern} => $0\n}",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_PartialFunction"
+    },
+    {
+      "label": "Ordering",
+      "kind": 1,
+      "detail": "Ordering type class",
+      "documentation": {"value": "```scala\nimplicit val ord: Ordering[Person] =\n  Ordering.by(_.name)\n```\nType class for ordering/comparison."},
+      "insertText": "Ordering.by(_.${1:field})",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Ordering"
+    },
+    {
+      "label": "Numeric",
+      "kind": 1,
+      "detail": "Numeric type class",
+      "documentation": {"value": "```scala\ndef sum[T: Numeric](xs: List[T]): T = xs.sum\n```\nType class for numeric operations."},
+      "insertText": "Numeric[${1:T}]",
+      "insertTextRules": 4,
+      "sortText": "02_builtin_Numeric"
+    }
+  ]
+}