@enjoys/context-engine 1.1.0 → 1.1.1

package/data/hover/kotlin.json

@@ -0,0 +1,341 @@
+{
+  "language": "kotlin",
+  "hovers": {
+    "println": {
+      "contents": [{"value": "```kotlin\nfun println(message: Any?): Unit\n```\nPrints the given message and a newline to standard output."}]
+    },
+    "print": {
+      "contents": [{"value": "```kotlin\nfun print(message: Any?): Unit\n```\nPrints the given message to standard output without a newline."}]
+    },
+    "readLine": {
+      "contents": [{"value": "```kotlin\nfun readLine(): String?\n```\nReads a line from standard input, returns null if EOF reached."}]
+    },
+    "listOf": {
+      "contents": [{"value": "```kotlin\nfun <T> listOf(vararg elements: T): List<T>\n```\nReturns a new read-only list of given elements."}]
+    },
+    "mutableListOf": {
+      "contents": [{"value": "```kotlin\nfun <T> mutableListOf(vararg elements: T): MutableList<T>\n```\nReturns a new MutableList with the given elements."}]
+    },
+    "mapOf": {
+      "contents": [{"value": "```kotlin\nfun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>\n```\nReturns a new read-only map with the specified key-value pairs."}]
+    },
+    "mutableMapOf": {
+      "contents": [{"value": "```kotlin\nfun <K, V> mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>\n```\nReturns a new MutableMap with the specified key-value pairs."}]
+    },
+    "setOf": {
+      "contents": [{"value": "```kotlin\nfun <T> setOf(vararg elements: T): Set<T>\n```\nReturns a new read-only set with the given elements."}]
+    },
+    "mutableSetOf": {
+      "contents": [{"value": "```kotlin\nfun <T> mutableSetOf(vararg elements: T): MutableSet<T>\n```\nReturns a new MutableSet with the given elements."}]
+    },
+    "arrayOf": {
+      "contents": [{"value": "```kotlin\nfun <T> arrayOf(vararg elements: T): Array<T>\n```\nReturns an array containing the specified elements."}]
+    },
+    "intArrayOf": {
+      "contents": [{"value": "```kotlin\nfun intArrayOf(vararg elements: Int): IntArray\n```\nReturns an IntArray containing the specified elements."}]
+    },
+    "let": {
+      "contents": [{"value": "```kotlin\nfun <T, R> T.let(block: (T) -> R): R\n```\nCalls the specified function block with `this` value as its argument and returns its result. Often used for null checks and transformations."}]
+    },
+    "run": {
+      "contents": [{"value": "```kotlin\nfun <T, R> T.run(block: T.() -> R): R\n```\nCalls the specified function block with `this` value as its receiver and returns its result."}]
+    },
+    "with": {
+      "contents": [{"value": "```kotlin\nfun <T, R> with(receiver: T, block: T.() -> R): R\n```\nCalls the specified function block with the given receiver as `this` and returns its result."}]
+    },
+    "apply": {
+      "contents": [{"value": "```kotlin\nfun <T> T.apply(block: T.() -> Unit): T\n```\nCalls the specified function block with `this` as its receiver and returns `this`. Used for object configuration."}]
+    },
+    "also": {
+      "contents": [{"value": "```kotlin\nfun <T> T.also(block: (T) -> Unit): T\n```\nCalls the specified function block with `this` as its argument and returns `this`. Used for performing side effects."}]
+    },
+    "takeIf": {
+      "contents": [{"value": "```kotlin\nfun <T> T.takeIf(predicate: (T) -> Boolean): T?\n```\nReturns `this` if it satisfies the given predicate or null if it doesn't."}]
+    },
+    "takeUnless": {
+      "contents": [{"value": "```kotlin\nfun <T> T.takeUnless(predicate: (T) -> Boolean): T?\n```\nReturns `this` if it does NOT satisfy the given predicate or null if it does."}]
+    },
+    "repeat": {
+      "contents": [{"value": "```kotlin\nfun repeat(times: Int, action: (Int) -> Unit)\n```\nExecutes the given function action the specified number of times."}]
+    },
+    "require": {
+      "contents": [{"value": "```kotlin\nfun require(value: Boolean, lazyMessage: () -> Any): Unit\n```\nThrows an IllegalArgumentException if the value is false."}]
+    },
+    "check": {
+      "contents": [{"value": "```kotlin\nfun check(value: Boolean, lazyMessage: () -> Any): Unit\n```\nThrows an IllegalStateException if the value is false."}]
+    },
+    "error": {
+      "contents": [{"value": "```kotlin\nfun error(message: Any): Nothing\n```\nThrows an IllegalStateException with the given message."}]
+    },
+    "TODO": {
+      "contents": [{"value": "```kotlin\nfun TODO(reason: String): Nothing\n```\nAlways throws NotImplementedError stating that operation is not implemented."}]
+    },
+    "lazy": {
+      "contents": [{"value": "```kotlin\nfun <T> lazy(initializer: () -> T): Lazy<T>\n```\nCreates a new Lazy instance that uses the specified initialization function. Value computed on first access."}]
+    },
+    "sequence": {
+      "contents": [{"value": "```kotlin\nfun <T> sequence(block: suspend SequenceScope<T>.() -> Unit): Sequence<T>\n```\nBuilds a Sequence lazily yielding values one by one."}]
+    },
+    "buildList": {
+      "contents": [{"value": "```kotlin\nfun <E> buildList(builderAction: MutableList<E>.() -> Unit): List<E>\n```\nBuilds a new read-only List by populating a MutableList using the given builder action."}]
+    },
+    "buildMap": {
+      "contents": [{"value": "```kotlin\nfun <K, V> buildMap(builderAction: MutableMap<K, V>.() -> Unit): Map<K, V>\n```\nBuilds a new read-only Map by populating a MutableMap using the given builder action."}]
+    },
+    "buildSet": {
+      "contents": [{"value": "```kotlin\nfun <E> buildSet(builderAction: MutableSet<E>.() -> Unit): Set<E>\n```\nBuilds a new read-only Set by populating a MutableSet using the given builder action."}]
+    },
+    "emptyList": {
+      "contents": [{"value": "```kotlin\nfun <T> emptyList(): List<T>\n```\nReturns an empty read-only list."}]
+    },
+    "emptyMap": {
+      "contents": [{"value": "```kotlin\nfun <K, V> emptyMap(): Map<K, V>\n```\nReturns an empty read-only map."}]
+    },
+    "emptySet": {
+      "contents": [{"value": "```kotlin\nfun <T> emptySet(): Set<T>\n```\nReturns an empty read-only set."}]
+    },
+    "forEach": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.forEach(action: (T) -> Unit)\n```\nPerforms the given action on each element."}]
+    },
+    "map": {
+      "contents": [{"value": "```kotlin\nfun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>\n```\nReturns a list containing the results of applying the given transform function to each element."}]
+    },
+    "filter": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>\n```\nReturns a list containing only elements matching the given predicate."}]
+    },
+    "flatMap": {
+      "contents": [{"value": "```kotlin\nfun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R>\n```\nReturns a single list of all elements yielded from results of transform function on each element."}]
+    },
+    "reduce": {
+      "contents": [{"value": "```kotlin\nfun <S, T : S> Iterable<T>.reduce(operation: (acc: S, T) -> S): S\n```\nAccumulates value starting with the first element and applying operation from left to right."}]
+    },
+    "fold": {
+      "contents": [{"value": "```kotlin\nfun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R\n```\nAccumulates value starting with initial value and applying operation from left to right."}]
+    },
+    "groupBy": {
+      "contents": [{"value": "```kotlin\nfun <T, K> Iterable<T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>\n```\nGroups elements of the collection by the key returned by the given function."}]
+    },
+    "sortedBy": {
+      "contents": [{"value": "```kotlin\nfun <T, R : Comparable<R>> Iterable<T>.sortedBy(selector: (T) -> R?): List<T>\n```\nReturns a list of all elements sorted according to natural sort order of the value returned by the selector."}]
+    },
+    "associate": {
+      "contents": [{"value": "```kotlin\nfun <T, K, V> Iterable<T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>\n```\nReturns a Map containing key-value pairs provided by transform function applied to elements."}]
+    },
+    "first": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.first(): T\n```\nReturns the first element. Throws NoSuchElementException if the collection is empty."}]
+    },
+    "firstOrNull": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.firstOrNull(): T?\n```\nReturns the first element, or null if the collection is empty."}]
+    },
+    "any": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean\n```\nReturns true if at least one element matches the given predicate."}]
+    },
+    "all": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean\n```\nReturns true if all elements match the given predicate."}]
+    },
+    "none": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean\n```\nReturns true if no elements match the given predicate."}]
+    },
+    "count": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.count(): Int\n```\nReturns the number of elements in the collection."}]
+    },
+    "joinToString": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.joinToString(separator: CharSequence = \", \"): String\n```\nCreates a string from all the elements separated using separator."}]
+    },
+    "toList": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.toList(): List<T>\n```\nReturns a List containing all elements."}]
+    },
+    "toMutableList": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.toMutableList(): MutableList<T>\n```\nReturns a MutableList filled with all elements of this collection."}]
+    },
+    "toSet": {
+      "contents": [{"value": "```kotlin\nfun <T> Iterable<T>.toSet(): Set<T>\n```\nReturns a Set of all elements."}]
+    },
+    "toMap": {
+      "contents": [{"value": "```kotlin\nfun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V>\n```\nReturns a new map containing all key-value pairs from the given collection of pairs."}]
+    },
+    "toInt": {
+      "contents": [{"value": "```kotlin\nfun String.toInt(): Int\n```\nParses the string as a signed Int number and returns the result. Throws NumberFormatException if not valid."}]
+    },
+    "toDouble": {
+      "contents": [{"value": "```kotlin\nfun String.toDouble(): Double\n```\nParses the string as a Double number and returns the result. Throws NumberFormatException if not valid."}]
+    },
+    "toIntOrNull": {
+      "contents": [{"value": "```kotlin\nfun String.toIntOrNull(): Int?\n```\nParses the string as a signed Int number and returns the result or null if the string is not a valid integer."}]
+    },
+    "runBlocking": {
+      "contents": [{"value": "```kotlin\nfun <T> runBlocking(block: suspend CoroutineScope.() -> T): T\n```\nRuns a new coroutine and blocks the current thread until its completion."}]
+    },
+    "launch": {
+      "contents": [{"value": "```kotlin\nfun CoroutineScope.launch(block: suspend CoroutineScope.() -> Unit): Job\n```\nLaunches a new coroutine without blocking the current thread and returns a Job."}]
+    },
+    "async": {
+      "contents": [{"value": "```kotlin\nfun <T> CoroutineScope.async(block: suspend CoroutineScope.() -> T): Deferred<T>\n```\nCreates a coroutine and returns its future result as an implementation of Deferred."}]
+    },
+    "withContext": {
+      "contents": [{"value": "```kotlin\nsuspend fun <T> withContext(context: CoroutineContext, block: suspend CoroutineScope.() -> T): T\n```\nCalls the specified suspending block with a given coroutine context and returns the result."}]
+    },
+    "delay": {
+      "contents": [{"value": "```kotlin\nsuspend fun delay(timeMillis: Long)\n```\nDelays coroutine for a given time without blocking a thread."}]
+    },
+    "fun": {
+      "contents": [{"value": "```kotlin\nfun name(params): ReturnType { }\n```\n**Keyword** — Declares a function."}]
+    },
+    "val": {
+      "contents": [{"value": "```kotlin\nval name: Type = value\n```\n**Keyword** — Declares a read-only (immutable) property or local variable."}]
+    },
+    "var": {
+      "contents": [{"value": "```kotlin\nvar name: Type = value\n```\n**Keyword** — Declares a mutable property or local variable."}]
+    },
+    "class": {
+      "contents": [{"value": "```kotlin\nclass Name(params) { }\n```\n**Keyword** — Declares a class."}]
+    },
+    "object": {
+      "contents": [{"value": "```kotlin\nobject Name { }\n```\n**Keyword** — Declares a singleton object or object expression."}]
+    },
+    "interface": {
+      "contents": [{"value": "```kotlin\ninterface Name { }\n```\n**Keyword** — Declares an interface that classes can implement."}]
+    },
+    "when": {
+      "contents": [{"value": "```kotlin\nwhen (value) {\n    pattern -> result\n    else -> default\n}\n```\n**Keyword** — Pattern matching expression, similar to switch in other languages."}]
+    },
+    "if": {
+      "contents": [{"value": "```kotlin\nif (condition) { } else { }\n```\n**Keyword** — Conditional expression. Can also be used as an expression that returns a value."}]
+    },
+    "for": {
+      "contents": [{"value": "```kotlin\nfor (item in collection) { }\n```\n**Keyword** — For loop that iterates through anything that provides an iterator."}]
+    },
+    "while": {
+      "contents": [{"value": "```kotlin\nwhile (condition) { }\n```\n**Keyword** — Loop that executes body while condition is true."}]
+    },
+    "return": {
+      "contents": [{"value": "**Keyword** — Returns from the nearest enclosing function. Supports labeled returns with `return@label`."}]
+    },
+    "throw": {
+      "contents": [{"value": "```kotlin\nthrow Exception(\"message\")\n```\n**Keyword** — Throws an exception. Throw expression has type Nothing."}]
+    },
+    "try": {
+      "contents": [{"value": "```kotlin\ntry { } catch (e: Exception) { } finally { }\n```\n**Keyword** — Begins a try-catch exception handling block. Can also be used as an expression."}]
+    },
+    "catch": {
+      "contents": [{"value": "**Keyword** — Handles an exception type in a try block. Kotlin does not have checked exceptions."}]
+    },
+    "finally": {
+      "contents": [{"value": "**Keyword** — Block that always executes after try/catch, regardless of whether an exception was thrown."}]
+    },
+    "suspend": {
+      "contents": [{"value": "**Keyword** — Marks a function or lambda as suspending (callable from within coroutines)."}]
+    },
+    "data": {
+      "contents": [{"value": "```kotlin\ndata class Name(val prop: Type)\n```\n**Keyword** — Marks a class as a data class. Auto-generates equals(), hashCode(), toString(), copy(), and componentN()."}]
+    },
+    "sealed": {
+      "contents": [{"value": "```kotlin\nsealed class/interface Name { }\n```\n**Keyword** — Restricts class hierarchy. All direct subclasses must be in the same package."}]
+    },
+    "enum": {
+      "contents": [{"value": "```kotlin\nenum class Name { VALUE1, VALUE2 }\n```\n**Keyword** — Declares an enum class with a fixed set of instances."}]
+    },
+    "override": {
+      "contents": [{"value": "**Keyword** — Marks a member as overriding a superclass member or interface member. Required in Kotlin."}]
+    },
+    "open": {
+      "contents": [{"value": "**Keyword** — Allows a class to be inherited from or a member to be overridden. Classes are final by default."}]
+    },
+    "abstract": {
+      "contents": [{"value": "**Keyword** — Marks a class or member as abstract. Abstract members have no implementation and must be overridden."}]
+    },
+    "companion": {
+      "contents": [{"value": "```kotlin\ncompanion object { }\n```\n**Keyword** — Declares a companion object inside a class, providing static-like members."}]
+    },
+    "inline": {
+      "contents": [{"value": "**Keyword** — Requests the compiler to inline the function and its lambda parameters at call sites."}]
+    },
+    "infix": {
+      "contents": [{"value": "**Keyword** — Allows calling a function with infix notation: `a func b` instead of `a.func(b)`."}]
+    },
+    "operator": {
+      "contents": [{"value": "**Keyword** — Marks a function as an operator overload (e.g., plus, get, invoke)."}]
+    },
+    "typealias": {
+      "contents": [{"value": "```kotlin\ntypealias Name = ExistingType\n```\n**Keyword** — Provides alternative names for existing types."}]
+    },
+    "lateinit": {
+      "contents": [{"value": "```kotlin\nlateinit var name: Type\n```\n**Keyword** — Allows initializing a non-null var property outside of a constructor body."}]
+    },
+    "const": {
+      "contents": [{"value": "```kotlin\nconst val NAME = value\n```\n**Keyword** — Marks a property as a compile-time constant. Must be top-level or companion object val of primitive/String."}]
+    },
+    "Int": {
+      "contents": [{"value": "```kotlin\nclass Int : Number, Comparable<Int>\n```\nRepresents a 32-bit signed integer. Range: -2,147,483,648 to 2,147,483,647."}]
+    },
+    "Long": {
+      "contents": [{"value": "```kotlin\nclass Long : Number, Comparable<Long>\n```\nRepresents a 64-bit signed integer."}]
+    },
+    "Double": {
+      "contents": [{"value": "```kotlin\nclass Double : Number, Comparable<Double>\n```\nRepresents a double-precision 64-bit IEEE 754 floating point number."}]
+    },
+    "Float": {
+      "contents": [{"value": "```kotlin\nclass Float : Number, Comparable<Float>\n```\nRepresents a single-precision 32-bit IEEE 754 floating point number."}]
+    },
+    "Boolean": {
+      "contents": [{"value": "```kotlin\nclass Boolean : Comparable<Boolean>\n```\nRepresents a value which is either `true` or `false`."}]
+    },
+    "String": {
+      "contents": [{"value": "```kotlin\nclass String : Comparable<String>, CharSequence\n```\nRepresents an array of characters. Strings are immutable in Kotlin."}]
+    },
+    "Char": {
+      "contents": [{"value": "```kotlin\nclass Char : Comparable<Char>\n```\nRepresents a 16-bit Unicode character."}]
+    },
+    "Unit": {
+      "contents": [{"value": "```kotlin\nobject Unit\n```\nThe type with only one value: the Unit object. Corresponds to `void` in Java."}]
+    },
+    "Nothing": {
+      "contents": [{"value": "```kotlin\nclass Nothing\n```\nNothing has no instances. Used as return type of functions that never return (e.g., throw, infinite loops)."}]
+    },
+    "Any": {
+      "contents": [{"value": "```kotlin\nopen class Any\n```\nThe root of the Kotlin class hierarchy. Every Kotlin class has `Any` as a superclass."}]
+    },
+    "Array": {
+      "contents": [{"value": "```kotlin\nclass Array<T>\n```\nRepresents an array. Use `arrayOf()` to create an array."}]
+    },
+    "List": {
+      "contents": [{"value": "```kotlin\ninterface List<out E> : Collection<E>\n```\nA generic ordered collection of elements. Read-only; use MutableList for modification."}]
+    },
+    "MutableList": {
+      "contents": [{"value": "```kotlin\ninterface MutableList<E> : List<E>, MutableCollection<E>\n```\nA generic ordered mutable collection supporting add and remove operations."}]
+    },
+    "Map": {
+      "contents": [{"value": "```kotlin\ninterface Map<K, out V>\n```\nA collection that holds pairs of objects (keys and values). Read-only."}]
+    },
+    "MutableMap": {
+      "contents": [{"value": "```kotlin\ninterface MutableMap<K, V> : Map<K, V>\n```\nA modifiable collection that holds pairs of objects and supports adding/removing entries."}]
+    },
+    "Set": {
+      "contents": [{"value": "```kotlin\ninterface Set<out E> : Collection<E>\n```\nA generic unordered collection that does not support duplicate elements. Read-only."}]
+    },
+    "MutableSet": {
+      "contents": [{"value": "```kotlin\ninterface MutableSet<E> : Set<E>, MutableCollection<E>\n```\nA modifiable collection of unique elements supporting add and remove operations."}]
+    },
+    "Pair": {
+      "contents": [{"value": "```kotlin\ndata class Pair<out A, out B>(val first: A, val second: B)\n```\nRepresents a generic pair of two values. Create with `to` infix function."}]
+    },
+    "Triple": {
+      "contents": [{"value": "```kotlin\ndata class Triple<out A, out B, out C>(val first: A, val second: B, val third: C)\n```\nRepresents a triad of three values."}]
+    },
+    "Sequence": {
+      "contents": [{"value": "```kotlin\ninterface Sequence<out T>\n```\nA sequence that returns values lazily through its iterator."}]
+    },
+    "Regex": {
+      "contents": [{"value": "```kotlin\nclass Regex\n```\nRepresents an immutable regular expression. Create with `Regex(pattern)` or `\"pattern\".toRegex()`."}]
+    },
+    "Comparable": {
+      "contents": [{"value": "```kotlin\ninterface Comparable<in T>\n```\nClasses that implement this interface have a defined total ordering between their instances."}]
+    },
+    "Iterable": {
+      "contents": [{"value": "```kotlin\ninterface Iterable<out T>\n```\nClasses that inherit from this interface can be represented as a sequence of elements that can be iterated over."}]
+    },
+    "Collection": {
+      "contents": [{"value": "```kotlin\ninterface Collection<out E> : Iterable<E>\n```\nA generic collection of elements providing read-only methods."}]
+    }
+  }
+}

package/data/hover/scala.json

@@ -0,0 +1,209 @@
+{
+  "language": "scala",
+  "hovers": {
+    "println": {
+      "contents": [{"value": "```scala\ndef println(x: Any): Unit\n```\nPrints a value followed by a newline to standard output."}]
+    },
+    "print": {
+      "contents": [{"value": "```scala\ndef print(x: Any): Unit\n```\nPrints a value to standard output without a trailing newline."}]
+    },
+    "require": {
+      "contents": [{"value": "```scala\ndef require(requirement: Boolean, message: => Any): Unit\n```\nTests an expression, throwing an IllegalArgumentException if false."}]
+    },
+    "assert": {
+      "contents": [{"value": "```scala\ndef assert(assertion: Boolean, message: => Any): Unit\n```\nTests an expression, throwing an AssertionError if false."}]
+    },
+    "sys.exit": {
+      "contents": [{"value": "```scala\ndef exit(status: Int): Nothing\n```\nTerminates the currently running JVM with the given status code."}]
+    },
+    "sys.error": {
+      "contents": [{"value": "```scala\ndef error(message: String): Nothing\n```\nThrows a RuntimeException with the given message."}]
+    },
+    "Some": {
+      "contents": [{"value": "```scala\ncase class Some[+A](value: A) extends Option[A]\n```\nRepresents an Option that contains a value."}]
+    },
+    "None": {
+      "contents": [{"value": "```scala\nobject None extends Option[Nothing]\n```\nRepresents the absence of a value in an Option."}]
+    },
+    "Left": {
+      "contents": [{"value": "```scala\ncase class Left[+A, +B](value: A) extends Either[A, B]\n```\nThe left side of an Either, conventionally used for errors."}]
+    },
+    "Right": {
+      "contents": [{"value": "```scala\ncase class Right[+A, +B](value: B) extends Either[A, B]\n```\nThe right side of an Either, conventionally used for success values."}]
+    },
+    "Nil": {
+      "contents": [{"value": "```scala\nobject Nil extends List[Nothing]\n```\nThe empty list."}]
+    },
+    "List": {
+      "contents": [{"value": "```scala\nsealed abstract class List[+A] extends AbstractSeq[A]\n```\nAn immutable linked list. Optimal for sequential access patterns."}]
+    },
+    "Map": {
+      "contents": [{"value": "```scala\ntrait Map[K, +V] extends Iterable[(K, V)]\n```\nAn immutable collection of key-value pairs with unique keys."}]
+    },
+    "Set": {
+      "contents": [{"value": "```scala\ntrait Set[A] extends Iterable[A]\n```\nAn immutable collection of unique elements."}]
+    },
+    "Vector": {
+      "contents": [{"value": "```scala\nclass Vector[+A] extends AbstractSeq[A] with IndexedSeq[A]\n```\nAn immutable indexed sequence with effectively constant random access."}]
+    },
+    "Array": {
+      "contents": [{"value": "```scala\nfinal class Array[T] extends Serializable with Cloneable\n```\nA mutable, indexed sequence backed by a Java array."}]
+    },
+    "Option": {
+      "contents": [{"value": "```scala\nsealed abstract class Option[+A] extends IterableOnce[A]\n```\nRepresents an optional value: either Some(value) or None."}]
+    },
+    "Either": {
+      "contents": [{"value": "```scala\nsealed abstract class Either[+A, +B]\n```\nRepresents a value of one of two possible types: Left[A] or Right[B]."}]
+    },
+    "Try": {
+      "contents": [{"value": "```scala\nsealed abstract class Try[+T]\n```\nWraps a computation that may throw. Either Success(value) or Failure(exception)."}]
+    },
+    "Success": {
+      "contents": [{"value": "```scala\ncase class Success[+T](value: T) extends Try[T]\n```\nRepresents the successful result of a Try computation."}]
+    },
+    "Failure": {
+      "contents": [{"value": "```scala\ncase class Failure[+T](exception: Throwable) extends Try[T]\n```\nRepresents a failed Try computation containing the thrown exception."}]
+    },
+    "Future": {
+      "contents": [{"value": "```scala\ntrait Future[+T] extends Awaitable[T]\n```\nRepresents a value which may not yet be available. Provides combinators for asynchronous programming."}]
+    },
+    "Promise": {
+      "contents": [{"value": "```scala\ntrait Promise[T]\n```\nA writable, single-assignment container that completes a Future."}]
+    },
+    "Stream": {
+      "contents": [{"value": "```scala\nabstract class Stream[+A] extends AbstractSeq[A] with LazyList[A]\n```\nA lazily evaluated list (deprecated since 2.13, use LazyList)."}]
+    },
+    "LazyList": {
+      "contents": [{"value": "```scala\nclass LazyList[+A] extends AbstractSeq[A]\n```\nA lazily evaluated immutable linked list. Elements are computed on demand."}]
+    },
+    "Range": {
+      "contents": [{"value": "```scala\nclass Range(start: Int, end: Int, step: Int) extends AbstractSeq[Int] with IndexedSeq[Int]\n```\nAn ordered sequence of integers defined by start, end, and step."}]
+    },
+    "Seq": {
+      "contents": [{"value": "```scala\ntrait Seq[+A] extends Iterable[A]\n```\nA general sequence type. Default implementation is List."}]
+    },
+    "IndexedSeq": {
+      "contents": [{"value": "```scala\ntrait IndexedSeq[+A] extends Seq[A]\n```\nA sequence with efficient indexed access. Default implementation is Vector."}]
+    },
+    "Iterator": {
+      "contents": [{"value": "```scala\ntrait Iterator[+A] extends IterableOnce[A]\n```\nA data structure for iterating lazily over a collection of elements."}]
+    },
+    "Tuple": {
+      "contents": [{"value": "```scala\n(A, B, C, ...)\n```\nA tuple is a heterogeneous, fixed-size container holding elements of different types."}]
+    },
+    "Int": {
+      "contents": [{"value": "```scala\nabstract final class Int extends AnyVal\n```\n32-bit signed integer. Range: -2,147,483,648 to 2,147,483,647."}]
+    },
+    "Long": {
+      "contents": [{"value": "```scala\nabstract final class Long extends AnyVal\n```\n64-bit signed integer."}]
+    },
+    "Short": {
+      "contents": [{"value": "```scala\nabstract final class Short extends AnyVal\n```\n16-bit signed integer."}]
+    },
+    "Byte": {
+      "contents": [{"value": "```scala\nabstract final class Byte extends AnyVal\n```\n8-bit signed integer."}]
+    },
+    "Float": {
+      "contents": [{"value": "```scala\nabstract final class Float extends AnyVal\n```\n32-bit IEEE 754 single-precision float."}]
+    },
+    "Double": {
+      "contents": [{"value": "```scala\nabstract final class Double extends AnyVal\n```\n64-bit IEEE 754 double-precision float."}]
+    },
+    "Boolean": {
+      "contents": [{"value": "```scala\nabstract final class Boolean extends AnyVal\n```\nRepresents true/false values."}]
+    },
+    "Char": {
+      "contents": [{"value": "```scala\nabstract final class Char extends AnyVal\n```\n16-bit unsigned Unicode character."}]
+    },
+    "String": {
+      "contents": [{"value": "```scala\ntype String = java.lang.String\n```\nAn immutable sequence of characters."}]
+    },
+    "Unit": {
+      "contents": [{"value": "```scala\nabstract final class Unit extends AnyVal\n```\nThe unit value (). Similar to void in Java."}]
+    },
+    "Nothing": {
+      "contents": [{"value": "```scala\nabstract final class Nothing\n```\nThe bottom type. Subtype of every other type. No instances exist."}]
+    },
+    "Null": {
+      "contents": [{"value": "```scala\nabstract final class Null\n```\nThe type of the null reference. Subtype of all reference types."}]
+    },
+    "Any": {
+      "contents": [{"value": "```scala\nabstract class Any\n```\nThe root of the Scala type hierarchy. Every type is a subtype of Any."}]
+    },
+    "AnyRef": {
+      "contents": [{"value": "```scala\ntype AnyRef = java.lang.Object\n```\nThe root of all reference types. Equivalent to java.lang.Object."}]
+    },
+    "AnyVal": {
+      "contents": [{"value": "```scala\nabstract class AnyVal extends Any\n```\nThe root of all value types (Int, Double, Boolean, etc.)."}]
+    },
+    "implicitly": {
+      "contents": [{"value": "```scala\ndef implicitly[T](implicit e: T): T\n```\nSummons an implicit value of the given type from scope."}]
+    },
+    "summon": {
+      "contents": [{"value": "```scala\ndef summon[T](using x: T): T\n```\nSummons a given instance of the specified type (Scala 3)."}]
+    },
+    "identity": {
+      "contents": [{"value": "```scala\ndef identity[A](x: A): A\n```\nThe identity function; returns its argument unchanged."}]
+    },
+    "classOf": {
+      "contents": [{"value": "```scala\ndef classOf[T]: Class[T]\n```\nReturns the runtime Class object for the given type."}]
+    },
+    "isInstanceOf": {
+      "contents": [{"value": "```scala\ndef isInstanceOf[T]: Boolean\n```\nTests whether the object is an instance of the given type at runtime."}]
+    },
+    "asInstanceOf": {
+      "contents": [{"value": "```scala\ndef asInstanceOf[T]: T\n```\nCasts the object to the given type. Throws ClassCastException if invalid."}]
+    },
+    "toString": {
+      "contents": [{"value": "```scala\ndef toString: String\n```\nReturns a string representation of the object."}]
+    },
+    "hashCode": {
+      "contents": [{"value": "```scala\ndef hashCode: Int\n```\nReturns a hash code value for the object."}]
+    },
+    "equals": {
+      "contents": [{"value": "```scala\ndef equals(that: Any): Boolean\n```\nCompares this object with another for equality."}]
+    },
+    "Future.apply": {
+      "contents": [{"value": "```scala\ndef apply[T](body: => T)(implicit executor: ExecutionContext): Future[T]\n```\nStarts an asynchronous computation and returns a Future holding the result."}]
+    },
+    "Future.sequence": {
+      "contents": [{"value": "```scala\ndef sequence[A](in: IterableOnce[Future[A]])(implicit executor: ExecutionContext): Future[List[A]]\n```\nTransforms a collection of Futures into a Future of a collection."}]
+    },
+    "Future.successful": {
+      "contents": [{"value": "```scala\ndef successful[T](result: T): Future[T]\n```\nCreates an already completed Future with the given value."}]
+    },
+    "Future.failed": {
+      "contents": [{"value": "```scala\ndef failed[T](exception: Throwable): Future[T]\n```\nCreates an already failed Future with the given exception."}]
+    },
+    "Await.result": {
+      "contents": [{"value": "```scala\ndef result[T](awaitable: Awaitable[T], atMost: Duration): T\n```\nBlocks until the awaitable completes or the timeout expires."}]
+    },
+    "Source.fromFile": {
+      "contents": [{"value": "```scala\ndef fromFile(name: String)(implicit codec: Codec): BufferedSource\n```\nCreates a source from the given filename for reading text."}]
+    },
+    "Using": {
+      "contents": [{"value": "```scala\nobject Using\ndef apply[R: Releasable, A](resource: => R)(f: R => A): Try[A]\n```\nPerforms an operation using a resource, ensuring cleanup."}]
+    },
+    "Ordering": {
+      "contents": [{"value": "```scala\ntrait Ordering[T] extends Comparator[T]\n```\nType class for defining comparison/ordering on types."}]
+    },
+    "Ordering.by": {
+      "contents": [{"value": "```scala\ndef by[T, S](f: T => S)(implicit ord: Ordering[S]): Ordering[T]\n```\nCreates an ordering based on a mapping function."}]
+    },
+    "locally": {
+      "contents": [{"value": "```scala\ndef locally[T](x: T): T\n```\nUsed to create a local block for clarity without introducing a new scope."}]
+    },
+    "PartialFunction": {
+      "contents": [{"value": "```scala\ntrait PartialFunction[-A, +B] extends (A => B)\n```\nA function defined only for certain input values. Supports isDefinedAt."}]
+    },
+    "ListBuffer": {
+      "contents": [{"value": "```scala\nclass ListBuffer[A] extends AbstractBuffer[A]\n```\nA mutable buffer backed by a list. Efficient for sequential building."}]
+    },
+    "ArrayBuffer": {
+      "contents": [{"value": "```scala\nclass ArrayBuffer[A] extends AbstractBuffer[A] with IndexedSeq[A]\n```\nA mutable buffer backed by a resizable array."}]
+    },
+    "StringBuilder": {
+      "contents": [{"value": "```scala\nclass StringBuilder extends AbstractSeq[Char]\n```\nA mutable builder for efficiently constructing strings."}]
+    }
+  }
+}