%{
  implemented: [
    %{
      name: "*",
      description: "Multiplication",
      binding: :variadic,
      category: :core,
      dispatch: :env,
      signatures: ["(* x y ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "*",
      divergences: nil
    },
    %{
      name: "+",
      description: "Addition",
      binding: :variadic,
      category: :core,
      dispatch: :env,
      signatures: ["(+ x y ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "+",
      divergences: nil
    },
    %{
      name: "-",
      description: "Subtraction",
      binding: :variadic,
      category: :core,
      dispatch: :env,
      signatures: ["(- x y ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "-",
      divergences: nil
    },
    %{
      name: ".getTime",
      description: "Return Unix timestamp in milliseconds (**DateTime only**)",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.getTime date)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".getTime",
      divergences: nil
    },
    %{
      name: ".contains",
      description: "Returns true if string contains substring",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.contains s substr)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".contains",
      divergences: nil
    },
    %{
      name: ".indexOf",
      description: "Index of first occurrence starting from position",
      binding: :multi_arity,
      category: :interop,
      dispatch: :env,
      signatures: ["(.indexOf s substr)", "(.indexOf s substr from)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".indexOf",
      divergences: nil
    },
    %{
      name: ".lastIndexOf",
      description: "Index of last occurrence, or -1 if not found",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.lastIndexOf s substr)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".lastIndexOf",
      divergences: nil
    },
    %{
      name: ".toLowerCase",
      description: "Convert string to lower case",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.toLowerCase s)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".toLowerCase",
      divergences: nil
    },
    %{
      name: ".toUpperCase",
      description: "Convert string to upper case",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.toUpperCase s)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".toUpperCase",
      divergences: nil
    },
    %{
      name: ".startsWith",
      description: "Returns true if string starts with prefix",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.startsWith s prefix)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".startsWith",
      divergences: nil
    },
    %{
      name: ".endsWith",
      description: "Returns true if string ends with suffix",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.endsWith s suffix)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ".endsWith",
      divergences: nil
    },
    %{
      name: ".isBefore",
      description: "Returns true if date/datetime comes strictly before another (same-type only)",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.isBefore a b)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: "Works on both LocalDate and DateTime. Mixed types raise an error.",
      see_also: [".isAfter"],
      clojure_var: ".isBefore",
      divergences: nil
    },
    %{
      name: ".isAfter",
      description: "Returns true if date/datetime comes strictly after another (same-type only)",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(.isAfter a b)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: "Works on both LocalDate and DateTime. Mixed types raise an error.",
      see_also: [".isBefore"],
      clojure_var: ".isAfter",
      divergences: nil
    },
    %{
      name: "/",
      description: "Division (always returns float)",
      binding: :variadic_nonempty,
      category: :core,
      dispatch: :env,
      signatures: ["(/ x y)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "/",
      divergences: nil
    },
    %{
      name: "<",
      description: "Less than",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(< x y)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "<",
      divergences: nil
    },
    %{
      name: "<=",
      description: "Less or equal",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(<= x y)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "<=",
      divergences: nil
    },
    %{
      name: "=",
      description: "Equality",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(= x y)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "=",
      divergences: nil
    },
    %{
      name: ">",
      description: "Greater than",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(> x y)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ">",
      divergences: nil
    },
    %{
      name: ">=",
      description: "Greater or equal",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(>= x y)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: ">=",
      divergences: nil
    },
    %{
      name: "NEGATIVE_INFINITY",
      description: "Negative infinity constant (Double/NEGATIVE_INFINITY)",
      binding: :constant,
      category: :interop,
      dispatch: :env,
      signatures: ["NEGATIVE_INFINITY"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "NEGATIVE_INFINITY",
      divergences: nil
    },
    %{
      name: "NaN",
      description: "Not-a-Number constant (Double/NaN)",
      binding: :constant,
      category: :interop,
      dispatch: :env,
      signatures: ["NaN"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "NaN",
      divergences: nil
    },
    %{
      name: "NaN?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(NaN? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "NaN?",
      divergences: nil
    },
    %{
      name: "POSITIVE_INFINITY",
      description: "Positive infinity constant (Double/POSITIVE_INFINITY)",
      binding: :constant,
      category: :interop,
      dispatch: :env,
      signatures: ["POSITIVE_INFINITY"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "POSITIVE_INFINITY",
      divergences: nil
    },
    %{
      name: "abs",
      description: "Absolute value",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(abs x)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "abs",
      divergences: nil
    },
    %{
      name: "apply",
      description: "Applies function `f` to the argument sequence `coll`",
      binding: :special,
      category: :core,
      dispatch: :env,
      signatures: ["(apply f coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "apply",
      divergences: nil
    },
    %{
      name: "assoc",
      description: "Add/update key",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(assoc m key val)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "assoc",
      divergences: nil
    },
    %{
      name: "assoc-in",
      description: "Add/update nested",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(assoc-in m path val)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "assoc-in",
      divergences: nil
    },
    %{
      name: "associative?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(associative? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "associative?",
      divergences: nil
    },
    %{
      name: "avg",
      description: "Average of numbers",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(avg coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "avg",
      divergences: nil
    },
    %{
      name: "avg-by",
      description: "Average field values",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(avg-by key coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "avg-by",
      divergences: nil
    },
    %{
      name: "boolean",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(boolean ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "boolean",
      divergences: nil
    },
    %{
      name: "boolean?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(boolean? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "boolean?",
      divergences: nil
    },
    %{
      name: "butlast",
      description: "All but last (empty list if none)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(butlast coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "butlast",
      divergences: nil
    },
    %{
      name: "ceil",
      description: "Round toward +∞",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(ceil x)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "ceil",
      divergences: nil
    },
    %{
      name: "char?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(char? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "char?",
      divergences: nil
    },
    %{
      name: "coll?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(coll? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "coll?",
      divergences: nil
    },
    %{
      name: "combinations",
      description: "Generate all n-combinations",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(combinations coll n)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "combinations",
      divergences: nil
    },
    %{
      name: "comp",
      description: "Returns a function composing fns right-to-left; `(comp)` returns `identity`",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(comp f1 f2 ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "comp",
      divergences: nil
    },
    %{
      name: "compare",
      description:
        "Numeric comparison: `-1` if `x < y`, `0` if `x == y`, `1` if `x > y`. Only supports numbers in PTC-Lisp.",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(compare x y)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "compare",
      divergences: nil
    },
    %{
      name: "complement",
      description: "Returns a function with the opposite truth value (always boolean)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(complement f)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "complement",
      divergences: nil
    },
    %{
      name: "concat",
      description: "Join collections",
      binding: :variadic,
      category: :core,
      dispatch: :env,
      signatures: ["(concat coll1 coll2 ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "concat",
      divergences: nil
    },
    %{
      name: "conj",
      description: "Add elements to collection",
      binding: :variadic_nonempty,
      category: :core,
      dispatch: :env,
      signatures: ["(conj coll x ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "conj",
      divergences: nil
    },
    %{
      name: "cons",
      description: "Prepend item to sequence",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(cons x seq)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "cons",
      divergences: nil
    },
    %{
      name: "constantly",
      description: "Returns a function that always returns `x`, ignoring its arguments",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(constantly x)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "constantly",
      divergences: nil
    },
    %{
      name: "contains?",
      description: "True if key/element exists (maps, sets, lists)",
      binding: :normal,
      category: :set,
      dispatch: :env,
      signatures: ["(contains? coll key)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "contains?",
      divergences: nil
    },
    %{
      name: "count",
      description: "Number of items",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(count coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "count",
      divergences: nil
    },
    %{
      name: "counted?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(counted? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "counted?",
      divergences: nil
    },
    %{
      name: "currentTimeMillis",
      description: "Return current time in milliseconds since epoch",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(System/currentTimeMillis)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "currentTimeMillis",
      divergences: nil
    },
    %{
      name: "dec",
      description: "Subtract 1",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(dec x)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "dec",
      divergences: nil
    },
    %{
      name: "decimal?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(decimal? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "decimal?",
      divergences: nil
    },
    %{
      name: "dedupe",
      description: "Remove consecutive duplicates",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(dedupe coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "dedupe",
      divergences: nil
    },
    %{
      name: "difference",
      description: "Returns the difference of one or more sets",
      binding: :variadic_nonempty,
      category: :set,
      dispatch: :env,
      signatures: ["(clojure.set/difference & sets)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "difference",
      divergences: nil
    },
    %{
      name: "disj",
      description: "Remove elements from set",
      binding: :variadic_nonempty,
      category: :set,
      dispatch: :env,
      signatures: ["(disj set x ...)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "disj",
      divergences: nil
    },
    %{
      name: "dissoc",
      description: "Remove key",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(dissoc m key)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "dissoc",
      divergences: nil
    },
    %{
      name: "distinct",
      description: "Remove duplicates",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(distinct coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "distinct",
      divergences: nil
    },
    %{
      name: "distinct-by",
      description: "Items with unique field values",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(distinct-by key coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "distinct-by",
      divergences: nil
    },
    %{
      name: "distinct?",
      description: "True if all arguments are distinct",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(distinct? x y ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "distinct?",
      divergences: nil
    },
    %{
      name: "double",
      description: "Type coercion (to float)",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(double x)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "double",
      divergences: nil
    },
    %{
      name: "double?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(double? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "double?",
      divergences: nil
    },
    %{
      name: "downcase",
      description: "",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(downcase ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "downcase",
      divergences: nil
    },
    %{
      name: "drop",
      description: "Skip first n items",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(drop n coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "drop",
      divergences: nil
    },
    %{
      name: "drop-last",
      description: "",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(drop-last coll)", "(drop-last n coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "drop-last",
      divergences: nil
    },
    %{
      name: "drop-while",
      description: "Drop while pred is true",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(drop-while pred coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "drop-while",
      divergences: nil
    },
    %{
      name: "empty",
      description: "Return empty collection of same type",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(empty coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "empty",
      divergences: nil
    },
    %{
      name: "empty?",
      description: "True if empty or nil",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(empty? coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "empty?",
      divergences: nil
    },
    %{
      name: "ends-with?",
      description: "Check if string ends with suffix",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(ends-with? s suffix)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "ends-with?",
      divergences: nil
    },
    %{
      name: "entries",
      description: "Get all `[key value]` pairs as a list",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(entries m)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "entries",
      divergences: nil
    },
    %{
      name: "even?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(even? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "even?",
      divergences: nil
    },
    %{
      name: "every-pred",
      description: "Returns a predicate true when all preds are satisfied (always boolean)",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(every-pred p1 p2 ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "every-pred",
      divergences: nil
    },
    %{
      name: "every?",
      description: "True if all have truthy `:key`",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(every? :key coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "every?",
      divergences: nil
    },
    %{
      name: "extract",
      description: "Extract capture group n (0 = full match)",
      binding: :multi_arity,
      category: :string,
      dispatch: :env,
      signatures: ["(extract pattern s)", "(extract pattern s n)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "extract",
      divergences: nil
    },
    %{
      name: "extract-int",
      description: "Extract group n, parse as int, return default on failure",
      binding: :multi_arity,
      category: :string,
      dispatch: :env,
      signatures: [
        "(extract-int pattern s)",
        "(extract-int pattern s n)",
        "(extract-int pattern s n default)"
      ],
      since: nil,
      section: "String Functions",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "extract-int",
      divergences: nil
    },
    %{
      name: "false?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(false? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "false?",
      divergences: nil
    },
    %{
      name: "ffirst",
      description: "First of first",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(ffirst coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "ffirst",
      divergences: nil
    },
    %{
      name: "filter",
      description: "Keep items where pred is truthy",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(filter pred coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "filter",
      divergences: nil
    },
    %{
      name: "filterv",
      description: "Same as filter (vectors are the default)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(filterv pred coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "filterv",
      divergences: nil
    },
    %{
      name: "find",
      description: "First item where pred is truthy, or nil",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(find pred coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "find",
      divergences: nil
    },
    %{
      name: "first",
      description: "First item or nil",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(first coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "first",
      divergences: nil
    },
    %{
      name: "flatten",
      description: "Flatten nested collections",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(flatten coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "flatten",
      divergences: nil
    },
    %{
      name: "float",
      description: "Alias for double (Clojure compat)",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(float x)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "float",
      divergences: nil
    },
    %{
      name: "float?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(float? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "float?",
      divergences: nil
    },
    %{
      name: "floor",
      description: "Round toward -∞",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(floor x)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "floor",
      divergences: nil
    },
    %{
      name: "fn?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(fn? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "fn?",
      divergences: nil
    },
    %{
      name: "fnext",
      description: "First of next",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(fnext coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "fnext",
      divergences: nil
    },
    %{
      name: "fnil",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(fnil ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "fnil",
      divergences: nil
    },
    %{
      name: "format",
      description: "Java-style format string",
      binding: :collect,
      category: :string,
      dispatch: :env,
      signatures: ["(format fmt-string & args)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "format",
      divergences: nil
    },
    %{
      name: "frequencies",
      description: "Count occurrences of each item",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(frequencies coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "frequencies",
      divergences: nil
    },
    %{
      name: "get",
      description: "Get with default",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(get m key)", "(get m key default)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "get",
      divergences: nil
    },
    %{
      name: "get-in",
      description: "Get nested with default",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(get-in m path)", "(get-in m path default)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "get-in",
      divergences: nil
    },
    %{
      name: "group-by",
      description: "Group items by key",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(group-by keyfn coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "group-by",
      divergences: nil
    },
    %{
      name: "identity",
      description: "Returns argument unchanged",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(identity x)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "identity",
      divergences: nil
    },
    %{
      name: "ifn?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(ifn? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "ifn?",
      divergences: nil
    },
    %{
      name: "inc",
      description: "Add 1",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(inc x)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "inc",
      divergences: nil
    },
    %{
      name: "includes?",
      description: "Check if string contains substring",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(includes? s substring)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "includes?",
      divergences: nil
    },
    %{
      name: "index-of",
      description: "Index of first occurrence from position",
      binding: :multi_arity,
      category: :string,
      dispatch: :env,
      signatures: ["(index-of s value)", "(index-of s value from-index)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "index-of",
      divergences: nil
    },
    %{
      name: "indexed?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(indexed? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "indexed?",
      divergences: nil
    },
    %{
      name: "infinite?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(infinite? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "infinite?",
      divergences: nil
    },
    %{
      name: "int",
      description: "Type coercion (to integer)",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(int x)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "int",
      divergences: nil
    },
    %{
      name: "int?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(int? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "int?",
      divergences: nil
    },
    %{
      name: "integer?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(integer? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "integer?",
      divergences: nil
    },
    %{
      name: "interleave",
      description: "Interleave collections",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(interleave c1 c2)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "interleave",
      divergences: nil
    },
    %{
      name: "interpose",
      description: "Insert separator between elements",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(interpose sep coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "interpose",
      divergences: nil
    },
    %{
      name: "intersection",
      description: "Returns the intersection of one or more sets",
      binding: :variadic_nonempty,
      category: :set,
      dispatch: :env,
      signatures: ["(clojure.set/intersection & sets)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "intersection",
      divergences: nil
    },
    %{
      name: "into",
      description: "Pour from into to",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(into to from)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "into",
      divergences: nil
    },
    %{
      name: "java.util.Date.",
      description: "Current UTC time",
      binding: :multi_arity,
      category: :interop,
      dispatch: :env,
      signatures: ["(java.util.Date.)", "(java.util.Date. millis)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "java.util.Date.",
      divergences: nil
    },
    %{
      name: "join",
      description: "Join collection elements (no separator)",
      binding: :multi_arity,
      category: :string,
      dispatch: :env,
      signatures: ["(join coll)", "(join separator coll)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "join",
      divergences: nil
    },
    %{
      name: "keep",
      description: "Non-nil results of (f item). false is kept.",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(keep f coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "keep",
      divergences: nil
    },
    %{
      name: "keep-indexed",
      description: "Non-nil results of (f index item). false is kept.",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(keep-indexed f coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "keep-indexed",
      divergences: nil
    },
    %{
      name: "key",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(key ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "key",
      divergences: nil
    },
    %{
      name: "keys",
      description: "Get all keys",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(keys m)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "keys",
      divergences: nil
    },
    %{
      name: "keyword",
      description: "Type coercion (string to keyword)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(keyword x)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "keyword",
      divergences: nil
    },
    %{
      name: "keyword?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(keyword? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "keyword?",
      divergences: nil
    },
    %{
      name: "last",
      description: "Last item or nil",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(last coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "last",
      divergences: nil
    },
    %{
      name: "last-index-of",
      description: "Index of last occurrence up to position",
      binding: :multi_arity,
      category: :string,
      dispatch: :env,
      signatures: ["(last-index-of s value)", "(last-index-of s value from-index)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "last-index-of",
      divergences: nil
    },
    %{
      name: "lower-case",
      description: "",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(lower-case ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "lower-case",
      divergences: nil
    },
    %{
      name: "map",
      description: "Apply f to triples",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(map f coll)", "(map f c1 c2)", "(map f c1 c2 c3)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "map",
      divergences: nil
    },
    %{
      name: "map-entry?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(map-entry? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "map-entry?",
      divergences: nil
    },
    %{
      name: "map-indexed",
      description: "Apply f to index and item",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(map-indexed f coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "map-indexed",
      divergences: nil
    },
    %{
      name: "map?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(map? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "map?",
      divergences: nil
    },
    %{
      name: "mapcat",
      description: "Apply f to each item, concatenate results",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(mapcat f coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "mapcat",
      divergences: nil
    },
    %{
      name: "mapv",
      description: "Like map with three collections",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(mapv f coll)", "(mapv f c1 c2)", "(mapv f c1 c2 c3)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "mapv",
      divergences: nil
    },
    %{
      name: "max",
      description: "Maximum value",
      binding: :variadic_nonempty,
      category: :math,
      dispatch: :env,
      signatures: ["(max x y ...)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "max",
      divergences: nil
    },
    %{
      name: "max-by",
      description: "Item with maximum field",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(max-by f x)", "(max-by f x y & more)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "max-by",
      divergences: nil
    },
    %{
      name: "max-key",
      description: "Return x for which (f x) is greatest",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(max-key f x)", "(max-key f x y & more)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "max-key",
      divergences: nil
    },
    %{
      name: "merge",
      description: "Merge maps (later wins)",
      binding: :variadic,
      category: :core,
      dispatch: :env,
      signatures: ["(merge m1 m2 ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "merge",
      divergences: nil
    },
    %{
      name: "merge-with",
      description: "Merge maps with combining function for duplicates",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(merge-with f m1 m2 ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "merge-with",
      divergences: nil
    },
    %{
      name: "min",
      description: "Minimum value",
      binding: :variadic_nonempty,
      category: :math,
      dispatch: :env,
      signatures: ["(min x y ...)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "min",
      divergences: nil
    },
    %{
      name: "min-by",
      description: "Item with minimum field",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(min-by f x)", "(min-by f x y & more)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "min-by",
      divergences: nil
    },
    %{
      name: "min-key",
      description: "Return x for which (f x) is least",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(min-key f x)", "(min-key f x y & more)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "min-key",
      divergences: nil
    },
    %{
      name: "mod",
      description: "Modulo (floored division, result sign matches divisor)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(mod x y)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "mod",
      divergences: nil
    },
    %{
      name: "name",
      description: "Returns name string of keyword or string",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(name x)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "name",
      divergences: nil
    },
    %{
      name: "nat-int?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(nat-int? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "nat-int?",
      divergences: nil
    },
    %{
      name: "neg-int?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(neg-int? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "neg-int?",
      divergences: nil
    },
    %{
      name: "neg?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(neg? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "neg?",
      divergences: nil
    },
    %{
      name: "next",
      description: "All but first (nil if none)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(next coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "next",
      divergences: nil
    },
    %{
      name: "nfirst",
      description: "Next of first",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(nfirst coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "nfirst",
      divergences: nil
    },
    %{
      name: "nil?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(nil? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "nil?",
      divergences: nil
    },
    %{
      name: "nnext",
      description: "Next of next",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(nnext coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "nnext",
      divergences: nil
    },
    %{
      name: "not",
      description: "Logical NOT",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(not x)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "not",
      divergences: nil
    },
    %{
      name: "not-any?",
      description: "True if none have truthy `:key`",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(not-any? :key coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "not-any?",
      divergences: nil
    },
    %{
      name: "not-empty",
      description: "`coll` if not empty, else `nil`",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(not-empty coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "not-empty",
      divergences: nil
    },
    %{
      name: "not-every?",
      description: "True if not all have truthy `:key`",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(not-every? :key coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "not-every?",
      divergences: nil
    },
    %{
      name: "not=",
      description: "Inequality",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(not= x y)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "not=",
      divergences: nil
    },
    %{
      name: "nth",
      description: "Item at index or nil",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(nth coll idx)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "nth",
      divergences: nil
    },
    %{
      name: "number?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(number? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "number?",
      divergences: nil
    },
    %{
      name: "odd?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(odd? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "odd?",
      divergences: nil
    },
    %{
      name: "parse",
      description: "Parse date string to DateTime",
      binding: :normal,
      category: :interop,
      dispatch: :env,
      signatures: ["(LocalDate/parse date-str)"],
      since: nil,
      section: "Interop",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "parse",
      divergences: nil
    },
    %{
      name: "parse-double",
      description: "",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(parse-double ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "parse-double",
      divergences: nil
    },
    %{
      name: "parse-int",
      description: "",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(parse-int ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "parse-int",
      divergences: nil
    },
    %{
      name: "parse-long",
      description: "",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(parse-long ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "parse-long",
      divergences: nil
    },
    %{
      name: "partial",
      description: "Returns a function with some arguments pre-filled",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(partial f arg1 ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "partial",
      divergences: nil
    },
    %{
      name: "partition",
      description: "Sliding window with pad collection for incomplete groups",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(partition n coll)", "(partition n step coll)", "(partition n step pad coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "partition",
      divergences: nil
    },
    %{
      name: "partition-all",
      description: "Sliding window chunks (incomplete included)",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(partition-all n coll)", "(partition-all n step coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "partition-all",
      divergences: nil
    },
    %{
      name: "partition-by",
      description: "Partition when f's return value changes",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(partition-by f coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "partition-by",
      divergences: nil
    },
    %{
      name: "peek",
      description: "Return last element without removing",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(peek coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "peek",
      divergences: nil
    },
    %{
      name: "pluck",
      description: "Extract single field from each item",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(pluck key coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "pluck",
      divergences: nil
    },
    %{
      name: "pop",
      description: "Return collection without last element",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(pop coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "pop",
      divergences: nil
    },
    %{
      name: "pos-int?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(pos-int? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "pos-int?",
      divergences: nil
    },
    %{
      name: "pos?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(pos? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "pos?",
      divergences: nil
    },
    %{
      name: "postwalk",
      description: "Transform tree bottom-up (post-order traversal)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(postwalk f form)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "postwalk",
      divergences: nil
    },
    %{
      name: "pow",
      description: "",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(pow ...)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "pow",
      divergences: nil
    },
    %{
      name: "pr-str",
      description:
        "Readable string representation (strings quoted, nil as \"nil\", space-separated)",
      binding: :collect,
      category: :string,
      dispatch: :env,
      signatures: ["(pr-str ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "pr-str",
      divergences: nil
    },
    %{
      name: "prewalk",
      description: "Transform tree top-down (pre-order traversal)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(prewalk f form)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "prewalk",
      divergences: nil
    },
    %{
      name: "println",
      description: "Prints arguments to the execution trace, separated by spaces. Returns `nil`.",
      binding: :special,
      category: :core,
      dispatch: :env,
      signatures: ["(println ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "println",
      divergences: nil
    },
    %{
      name: "quot",
      description: "Integer division (truncated toward zero)",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(quot x y)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "quot",
      divergences: nil
    },
    %{
      name: "range",
      description: "Returns sequence with specific step",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(range end)", "(range start end)", "(range start end step)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "range",
      divergences: nil
    },
    %{
      name: "ratio?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(ratio? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "ratio?",
      divergences: nil
    },
    %{
      name: "rational?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(rational? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "rational?",
      divergences: nil
    },
    %{
      name: "re-find",
      description: "Returns the first match of `re` in `s`",
      binding: :normal,
      category: :regex,
      dispatch: :env,
      signatures: ["(re-find re s)"],
      since: nil,
      section: "Regex Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "re-find",
      divergences: nil
    },
    %{
      name: "re-matches",
      description: "Returns match if `re` matches the **entire** string `s`",
      binding: :normal,
      category: :regex,
      dispatch: :env,
      signatures: ["(re-matches re s)"],
      since: nil,
      section: "Regex Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "re-matches",
      divergences: nil
    },
    %{
      name: "re-pattern",
      description: "Compile string `s` into an opaque regex object",
      binding: :normal,
      category: :regex,
      dispatch: :env,
      signatures: ["(re-pattern s)"],
      since: nil,
      section: "Regex Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "re-pattern",
      divergences: nil
    },
    %{
      name: "re-seq",
      description: "Returns all matches of `re` in `s` as a list",
      binding: :normal,
      category: :regex,
      dispatch: :env,
      signatures: ["(re-seq re s)"],
      since: nil,
      section: "Regex Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "re-seq",
      divergences: nil
    },
    %{
      name: "re-split",
      description: "Split string `s` by regex pattern `re`",
      binding: :normal,
      category: :regex,
      dispatch: :env,
      signatures: ["(re-split re s)"],
      since: nil,
      section: "Regex Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "re-split",
      divergences: nil
    },
    %{
      name: "reduce",
      description: "Fold collection",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(reduce f coll)", "(reduce f init coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "reduce",
      divergences: nil
    },
    %{
      name: "reduce-kv",
      description: "Reduce map with f receiving (acc, key, val)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(reduce-kv f init m)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "reduce-kv",
      divergences: nil
    },
    %{
      name: "regex?",
      description: "Returns true if `x` is a regex object",
      binding: :normal,
      category: :regex,
      dispatch: :env,
      signatures: ["(regex? x)"],
      since: nil,
      section: "Regex Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "regex?",
      divergences: nil
    },
    %{
      name: "rem",
      description: "Remainder (truncated division, result sign matches dividend)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(rem x y)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "rem",
      divergences: nil
    },
    %{
      name: "remove",
      description: "Remove items where pred is truthy",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(remove pred coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "remove",
      divergences: nil
    },
    %{
      name: "replace",
      description: "Replace all occurrences",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(replace s pattern replacement)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "replace",
      divergences: nil
    },
    %{
      name: "rest",
      description: "All but first (empty list if none)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(rest coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "rest",
      divergences: nil
    },
    %{
      name: "reverse",
      description: "Reverse order",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(reverse coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "reverse",
      divergences: nil
    },
    %{
      name: "reversible?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(reversible? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "reversible?",
      divergences: nil
    },
    %{
      name: "round",
      description: "Round to nearest integer",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(round x)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "round",
      divergences: nil
    },
    %{
      name: "second",
      description: "Second item or nil",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(second coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "second",
      divergences: nil
    },
    %{
      name: "select-keys",
      description: "Pick specific keys",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(select-keys m keys)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "select-keys",
      divergences: nil
    },
    %{
      name: "seq",
      description: "Convert to sequence (nil if empty)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(seq coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "seq",
      divergences: nil
    },
    %{
      name: "seq?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(seq? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "seq?",
      divergences: nil
    },
    %{
      name: "seqable?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(seqable? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "seqable?",
      divergences: nil
    },
    %{
      name: "sequential?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(sequential? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "sequential?",
      divergences: nil
    },
    %{
      name: "set",
      description: "Convert collection to set",
      binding: :normal,
      category: :set,
      dispatch: :env,
      signatures: ["(set coll)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "set",
      divergences: nil
    },
    %{
      name: "set?",
      description: "Returns true if x is a set",
      binding: :normal,
      category: :set,
      dispatch: :env,
      signatures: ["(set? x)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "set?",
      divergences: nil
    },
    %{
      name: "some",
      description: "First truthy `:key` value, or nil",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(some :key coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "some",
      divergences: nil
    },
    %{
      name: "some-fn",
      description: "Returns a function that returns the first truthy result from any fn",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(some-fn f1 f2 ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "some-fn",
      divergences: nil
    },
    %{
      name: "some?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(some? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "some?",
      divergences: nil
    },
    %{
      name: "sort",
      description: "Sort by natural order",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(sort coll)", "(sort comparator coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "sort",
      divergences: nil
    },
    %{
      name: "sort-by",
      description: "Sort with comparator",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(sort-by keyfn coll)", "(sort-by keyfn comparator coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "sort-by",
      divergences: nil
    },
    %{
      name: "sorted?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(sorted? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "sorted?",
      divergences: nil
    },
    %{
      name: "split",
      description: "Split string by separator",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(split s separator)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "split",
      divergences: nil
    },
    %{
      name: "split-at",
      description: "Split into `[(take n coll) (drop n coll)]`",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(split-at n coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "split-at",
      divergences: nil
    },
    %{
      name: "split-lines",
      description: "Split string into lines (\\n or \\r\\n)",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(split-lines s)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "split-lines",
      divergences: nil
    },
    %{
      name: "split-with",
      description: "Split into `[(take-while pred coll) (drop-while pred coll)]`",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(split-with pred coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "split-with",
      divergences: nil
    },
    %{
      name: "sqrt",
      description: "",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(sqrt ...)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "sqrt",
      divergences: nil
    },
    %{
      name: "starts-with?",
      description: "Check if string starts with prefix",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(starts-with? s prefix)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "starts-with?",
      divergences: nil
    },
    %{
      name: "str",
      description: "Convert and concatenate to string",
      binding: :collect,
      category: :string,
      dispatch: :env,
      signatures: ["(str ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "str",
      divergences: nil
    },
    %{
      name: "string?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(string? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "string?",
      divergences: nil
    },
    %{
      name: "subs",
      description: "Substring from start to end",
      binding: :multi_arity,
      category: :string,
      dispatch: :env,
      signatures: ["(subs s start)", "(subs s start end)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "subs",
      divergences: nil
    },
    %{
      name: "subvec",
      description: "",
      binding: :multi_arity,
      category: :core,
      dispatch: :env,
      signatures: ["(subvec v start)", "(subvec v start end)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "subvec",
      divergences: nil
    },
    %{
      name: "sum",
      description: "Sum of numbers",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(sum coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "sum",
      divergences: nil
    },
    %{
      name: "sum-by",
      description: "Sum field values",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(sum-by key coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "sum-by",
      divergences: nil
    },
    %{
      name: "symbol?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(symbol? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "symbol?",
      divergences: nil
    },
    %{
      name: "take",
      description: "First n items",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(take n coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "take",
      divergences: nil
    },
    %{
      name: "take-last",
      description: "Last n items",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(take-last n coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "take-last",
      divergences: nil
    },
    %{
      name: "take-while",
      description: "Take while pred is true",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(take-while pred coll)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "take-while",
      divergences: nil
    },
    %{
      name: "tree-seq",
      description: "Flatten tree to depth-first sequence",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(tree-seq branch? children root)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "tree-seq",
      divergences: nil
    },
    %{
      name: "trim",
      description: "Remove leading/trailing whitespace",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(trim s)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "trim",
      divergences: nil
    },
    %{
      name: "true?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(true? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "true?",
      divergences: nil
    },
    %{
      name: "trunc",
      description: "",
      binding: :normal,
      category: :math,
      dispatch: :env,
      signatures: ["(trunc ...)"],
      since: nil,
      section: "Math Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "trunc",
      divergences: nil
    },
    %{
      name: "type",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(type ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "type",
      divergences: nil
    },
    %{
      name: "union",
      description: "Returns the union of zero or more sets",
      binding: :variadic,
      category: :set,
      dispatch: :env,
      signatures: ["(clojure.set/union & sets)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "union",
      divergences: nil
    },
    %{
      name: "upcase",
      description: "",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(upcase ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "upcase",
      divergences: nil
    },
    %{
      name: "update",
      description: "Update with extra args passed to f",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(update m key f & args)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "update",
      divergences: nil
    },
    %{
      name: "update-in",
      description: "Update nested with extra args",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(update-in m path f & args)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "update-in",
      divergences: nil
    },
    %{
      name: "update-keys",
      description: "Apply f to each key (collision: retained value unspecified)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(update-keys m f)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "update-keys",
      divergences: nil
    },
    %{
      name: "update-vals",
      description: "Apply f to each value (matches Clojure 1.11)",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(update-vals m f)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "update-vals",
      divergences: nil
    },
    %{
      name: "upper-case",
      description: "",
      binding: :normal,
      category: :string,
      dispatch: :env,
      signatures: ["(upper-case ...)"],
      since: nil,
      section: "String Functions",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "upper-case",
      divergences: nil
    },
    %{
      name: "val",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(val ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "val",
      divergences: nil
    },
    %{
      name: "vals",
      description: "Get all values",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(vals m)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "vals",
      divergences: nil
    },
    %{
      name: "vec",
      description: "Convert collection to vector",
      binding: :normal,
      category: :set,
      dispatch: :env,
      signatures: ["(vec coll)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "vec",
      divergences: nil
    },
    %{
      name: "vector",
      description: "Create vector from arguments",
      binding: :collect,
      category: :set,
      dispatch: :env,
      signatures: ["(vector & args)"],
      since: nil,
      section: "Set Operations",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "vector",
      divergences: nil
    },
    %{
      name: "hash-map",
      description: "Create map from alternating key-value pairs",
      binding: :collect,
      category: :core,
      dispatch: :env,
      signatures: ["(hash-map & kvs)"],
      since: "0.9.0",
      section: "Core",
      ptc_extension?: false,
      examples: [
        {"(hash-map)", "%{}"},
        {"(hash-map :a 1 :b 2)", "{:a 1, :b 2}"}
      ],
      notes: "Requires an even number of arguments. Equivalent to map literal `{:a 1 :b 2}`.",
      see_also: ["assoc", "zipmap"],
      clojure_var: "hash-map",
      divergences: nil
    },
    %{
      name: "vector?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(vector? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "vector?",
      divergences: nil
    },
    %{
      name: "walk",
      description: "Generic tree walker - applies inner to children, outer to result",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(walk inner outer form)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "walk",
      divergences: nil
    },
    %{
      name: "zero?",
      description: "",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(zero? ...)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "zero?",
      divergences: nil
    },
    %{
      name: "zip",
      description: "Combine into pairs",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(zip c1 c2)"],
      since: nil,
      section: "Core",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "zip",
      divergences: nil
    },
    %{
      name: "zipmap",
      description: "Create map from keys and values seqs",
      binding: :normal,
      category: :core,
      dispatch: :env,
      signatures: ["(zipmap keys vals)"],
      since: nil,
      section: "Core",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "zipmap",
      divergences: nil
    },
    %{
      name: "->",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(-> ...)"],
      since: nil,
      section: "Threading Macros",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "->",
      divergences: nil
    },
    %{
      name: "->>",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(->> ...)"],
      since: nil,
      section: "Threading Macros",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "->>",
      divergences: nil
    },
    %{
      name: "all-of",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(all-of ...)"],
      since: nil,
      section: "Predicate Builders",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: nil,
      divergences: nil
    },
    %{
      name: "and",
      description: "Logical AND (short-circuits)",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(and x y ...)"],
      since: nil,
      section: "Control Flow",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "and",
      divergences: nil
    },
    %{
      name: "any-of",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(any-of ...)"],
      since: nil,
      section: "Predicate Builders",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: nil,
      divergences: nil
    },
    %{
      name: "as->",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(as-> ...)"],
      since: nil,
      section: "Threading Macros",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "as->",
      divergences: nil
    },
    %{
      name: "case",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(case ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "case",
      divergences: nil
    },
    %{
      name: "comment",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(comment ...)"],
      since: nil,
      section: "Control Flow",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "comment",
      divergences: nil
    },
    %{
      name: "cond",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(cond ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "cond",
      divergences: nil
    },
    %{
      name: "cond->",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(cond-> ...)"],
      since: nil,
      section: "Threading Macros",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "cond->",
      divergences: nil
    },
    %{
      name: "cond->>",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(cond->> ...)"],
      since: nil,
      section: "Threading Macros",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "cond->>",
      divergences: nil
    },
    %{
      name: "condp",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(condp ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "condp",
      divergences: nil
    },
    %{
      name: "def",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(def ...)"],
      since: nil,
      section: "Definitions & Bindings",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "def",
      divergences: nil
    },
    %{
      name: "defn",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(defn ...)"],
      since: nil,
      section: "Definitions & Bindings",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "defn",
      divergences: nil
    },
    %{
      name: "defonce",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(defonce ...)"],
      since: nil,
      section: "Definitions & Bindings",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "defonce",
      divergences: nil
    },
    %{
      name: "do",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(do ...)"],
      since: nil,
      section: "Control Flow",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "do",
      divergences: nil
    },
    %{
      name: "doseq",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(doseq ...)"],
      since: nil,
      section: "Iteration",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "doseq",
      divergences: nil
    },
    %{
      name: "fail",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(fail ...)"],
      since: nil,
      section: "Agent Control",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "fail",
      divergences: nil
    },
    %{
      name: "fn",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(fn ...)"],
      since: nil,
      section: "Definitions & Bindings",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "fn",
      divergences: nil
    },
    %{
      name: "for",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(for ...)"],
      since: nil,
      section: "Iteration",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "for",
      divergences: nil
    },
    %{
      name: "if",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(if ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "if",
      divergences: nil
    },
    %{
      name: "if-let",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(if-let ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "if-let",
      divergences: nil
    },
    %{
      name: "if-not",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(if-not ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "if-not",
      divergences: nil
    },
    %{
      name: "if-some",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(if-some ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "if-some",
      divergences: nil
    },
    %{
      name: "juxt",
      description:
        "Returns a function that applies all functions and returns a vector of results",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(juxt f1 f2 ...)"],
      since: nil,
      section: "Functional Tools",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "juxt",
      divergences: nil
    },
    %{
      name: "let",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(let ...)"],
      since: nil,
      section: "Definitions & Bindings",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "let",
      divergences: nil
    },
    %{
      name: "loop",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(loop ...)"],
      since: nil,
      section: "Definitions & Bindings",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "loop",
      divergences: nil
    },
    %{
      name: "none-of",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(none-of ...)"],
      since: nil,
      section: "Predicate Builders",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: nil,
      divergences: nil
    },
    %{
      name: "or",
      description: "Logical OR (short-circuits)",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(or x y ...)"],
      since: nil,
      section: "Control Flow",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "or",
      divergences: nil
    },
    %{
      name: "pcalls",
      description: "Execute thunks in parallel",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(pcalls f1 f2 ...)"],
      since: nil,
      section: "Functional Tools",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "pcalls",
      divergences: nil
    },
    %{
      name: "pmap",
      description: "Apply f to each item in parallel",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(pmap f coll)"],
      since: nil,
      section: "Functional Tools",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "pmap",
      divergences: nil
    },
    %{
      name: "recur",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(recur ...)"],
      since: nil,
      section: "Definitions & Bindings",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "recur",
      divergences: nil
    },
    %{
      name: "return",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(return ...)"],
      since: nil,
      section: "Agent Control",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "return",
      divergences: nil
    },
    %{
      name: "some->",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(some-> ...)"],
      since: nil,
      section: "Threading Macros",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "some->",
      divergences: nil
    },
    %{
      name: "some->>",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(some->> ...)"],
      since: nil,
      section: "Threading Macros",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "some->>",
      divergences: nil
    },
    %{
      name: "step-done",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(step-done ...)"],
      since: nil,
      section: "Agent Control",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: nil,
      divergences: nil
    },
    %{
      name: "task",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(task ...)"],
      since: nil,
      section: "Agent Control",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: nil,
      divergences: nil
    },
    %{
      name: "task-reset",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(task-reset ...)"],
      since: nil,
      section: "Agent Control",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: nil,
      divergences: nil
    },
    %{
      name: "when",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(when ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "when",
      divergences: nil
    },
    %{
      name: "when-first",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(when-first ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "when-first",
      divergences: nil
    },
    %{
      name: "when-let",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(when-let ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "when-let",
      divergences: nil
    },
    %{
      name: "when-not",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(when-not ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "when-not",
      divergences: nil
    },
    %{
      name: "when-some",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(when-some ...)"],
      since: nil,
      section: "Conditionals",
      ptc_extension?: false,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: "when-some",
      divergences: nil
    },
    %{
      name: "where",
      description: "",
      binding: nil,
      category: :core,
      dispatch: :analyze,
      signatures: ["(where ...)"],
      since: nil,
      section: "Predicate Builders",
      ptc_extension?: true,
      examples: [],
      notes: nil,
      see_also: [],
      clojure_var: nil,
      divergences: nil
    }
  ],
  clojure_core_audit: [
    %{
      name: "*",
      status: :supported,
      description: "Multiplies numbers; returns 1 with no args",
      notes: ""
    },
    %{
      name: "*'",
      status: :candidate,
      description: "Multiplies numbers with arbitrary precision",
      notes: "pure numerical operation"
    },
    %{
      name: "+",
      status: :supported,
      description: "Adds numbers; returns 0 with no args",
      notes: ""
    },
    %{
      name: "+'",
      status: :candidate,
      description: "Adds numbers with arbitrary precision",
      notes: "pure numerical operation"
    },
    %{
      name: "-",
      status: :supported,
      description: "Subtracts numbers or negates single argument",
      notes: ""
    },
    %{
      name: "-'",
      status: :candidate,
      description: "Subtracts numbers with arbitrary precision",
      notes: "pure numerical operation"
    },
    %{
      name: "->",
      status: :supported,
      description: "Threads expression as second argument through forms",
      notes: ""
    },
    %{
      name: "->>",
      status: :supported,
      description: "Threads expression as last argument through forms",
      notes: ""
    },
    %{
      name: ".",
      status: :not_relevant,
      description: "Java member access and method calls",
      notes: "Java interop"
    },
    %{
      name: "..",
      status: :not_relevant,
      description: "Chains member access operations",
      notes: "Java interop"
    },
    %{name: "/", status: :supported, description: "Divides numbers", notes: ""},
    %{
      name: "<",
      status: :supported,
      description: "Returns true if numbers monotonically increase",
      notes: ""
    },
    %{
      name: "<=",
      status: :supported,
      description: "Returns true if numbers non-decreasing",
      notes: ""
    },
    %{name: "=", status: :supported, description: "Equality comparison", notes: ""},
    %{
      name: "==",
      status: :candidate,
      description: "Type-independent numeric equality",
      notes: "pure numeric predicate"
    },
    %{
      name: ">",
      status: :supported,
      description: "Returns true if numbers monotonically decrease",
      notes: ""
    },
    %{
      name: ">=",
      status: :supported,
      description: "Returns true if numbers non-increasing",
      notes: ""
    },
    %{
      name: "abs",
      status: :supported,
      description: "Returns absolute value of number",
      notes: ""
    },
    %{
      name: "accessor",
      status: :candidate,
      description: "Returns function accessing structmap value at key",
      notes: "pure functional access to data"
    },
    %{
      name: "aclone",
      status: :not_relevant,
      description: "Returns clone of Java array",
      notes: "Java array manipulation"
    },
    %{
      name: "add-tap",
      status: :not_relevant,
      description: "Adds function to receive tap> values",
      notes: "I/O and global state side effects"
    },
    %{
      name: "add-watch",
      status: :not_relevant,
      description: "Adds watch function to reference",
      notes: "mutable state and referencing"
    },
    %{
      name: "agent",
      status: :not_relevant,
      description: "Creates agent with initial value",
      notes: "concurrency primitive (mutable state)"
    },
    %{
      name: "agent-error",
      status: :not_relevant,
      description: "Returns exception from failed agent",
      notes: "depends on agent state and exception handling"
    },
    %{
      name: "aget",
      status: :not_relevant,
      description: "Returns value at Java array index",
      notes: "Java interop (Java array access)"
    },
    %{
      name: "alength",
      status: :not_relevant,
      description: "Returns length of Java array",
      notes: "Java interop (Java array length)"
    },
    %{
      name: "alias",
      status: :not_relevant,
      description: "Adds namespace alias",
      notes: "namespace manipulation"
    },
    %{
      name: "all-ns",
      status: :not_relevant,
      description: "Returns all namespaces",
      notes: "namespace system"
    },
    %{
      name: "alter",
      status: :not_relevant,
      description: "Sets ref value in transaction",
      notes: "concurrency primitive (ref mutation)"
    },
    %{
      name: "alter-meta!",
      status: :not_relevant,
      description: "Atomically sets metadata via function",
      notes: "metadata and mutability"
    },
    %{
      name: "alter-var-root",
      status: :not_relevant,
      description: "Atomically alters var root binding",
      notes: "var root mutation"
    },
    %{
      name: "amap",
      status: :not_relevant,
      description: "Maps expression across Java array",
      notes: "Java interop (Java array iteration)"
    },
    %{
      name: "ancestors",
      status: :not_relevant,
      description: "Returns parents of tag via hierarchy",
      notes: "relies on Clojure's global hierarchy/multimethod system"
    },
    %{name: "and", status: :supported, description: "Short-circuit logical AND", notes: ""},
    %{
      name: "any?",
      status: :candidate,
      description: "Returns true for any argument",
      notes: "pure predicate function"
    },
    %{
      name: "apply",
      status: :supported,
      description: "Applies function to argument sequence",
      notes: ""
    },
    %{
      name: "areduce",
      status: :not_relevant,
      description: "Reduces expression across Java array",
      notes: "relies on Java array interoperability"
    },
    %{
      name: "array-map",
      status: :candidate,
      description: "Constructs array-map from key-value pairs",
      notes: "pure constructor for map data structure"
    },
    %{
      name: "as->",
      status: :supported,
      description: "Binds name to expr, threads through forms",
      notes: ""
    },
    %{
      name: "aset",
      status: :not_relevant,
      description: "Sets value in Java array at index",
      notes: "performs mutable operations on Java arrays"
    },
    %{
      name: "assert",
      status: :not_relevant,
      description: "Throws AssertionError if expr false",
      notes: "relies on exception handling/throwing"
    },
    %{
      name: "assoc",
      status: :supported,
      description: "Returns map/vector with added key-value pairs",
      notes: ""
    },
    %{
      name: "assoc!",
      status: :not_relevant,
      description: "Sets value in transient collection",
      notes: "relies on transient collections (mutability)"
    },
    %{
      name: "assoc-in",
      status: :supported,
      description: "Associates value in nested structure",
      notes: ""
    },
    %{
      name: "associative?",
      status: :supported,
      description: "Returns true if coll implements Associative",
      notes: ""
    },
    %{
      name: "atom",
      status: :not_relevant,
      description: "Creates atom with initial value",
      notes: "relies on mutable state"
    },
    %{
      name: "await",
      status: :not_relevant,
      description: "Blocks until agent actions complete",
      notes: "relies on agent state"
    },
    %{
      name: "await-for",
      status: :not_relevant,
      description: "Blocks with timeout for agent actions",
      notes: "relies on agent state"
    },
    %{
      name: "bases",
      status: :not_relevant,
      description: "Returns immediate superclass and interfaces",
      notes: "Java interop and class inspection"
    },
    %{
      name: "bean",
      status: :not_relevant,
      description: "Returns map based on JavaBean properties",
      notes: "Java interop (JavaBeans)"
    },
    %{
      name: "bigdec",
      status: :candidate,
      description: "Coerces to BigDecimal",
      notes: "pure numerical coercion"
    },
    %{
      name: "bigint",
      status: :candidate,
      description: "Coerces to BigInt",
      notes: "pure numerical coercion"
    },
    %{
      name: "biginteger",
      status: :candidate,
      description: "Coerces to BigInteger",
      notes: "pure numerical coercion"
    },
    %{
      name: "binding",
      status: :not_relevant,
      description: "Binds vars to new values for body duration",
      notes: "relies on thread-local var binding mechanism"
    },
    %{
      name: "bit-and",
      status: :candidate,
      description: "Bitwise AND",
      notes: "pure bitwise arithmetic"
    },
    %{
      name: "bit-and-not",
      status: :candidate,
      description: "Bitwise AND with complement",
      notes: "pure bitwise arithmetic"
    },
    %{
      name: "bit-clear",
      status: :candidate,
      description: "Clears bit at index",
      notes: "pure bitwise operation on integers"
    },
    %{
      name: "bit-flip",
      status: :candidate,
      description: "Flips bit at index",
      notes: "pure bitwise operation on integers"
    },
    %{
      name: "bit-not",
      status: :candidate,
      description: "Bitwise complement",
      notes: "pure bitwise operation on integers"
    },
    %{
      name: "bit-or",
      status: :candidate,
      description: "Bitwise OR",
      notes: "pure bitwise operation on integers"
    },
    %{
      name: "bit-set",
      status: :candidate,
      description: "Sets bit at index",
      notes: "pure bitwise operation on integers"
    },
    %{
      name: "bit-shift-left",
      status: :candidate,
      description: "Bitwise left shift",
      notes: "pure bitwise operation on integers"
    },
    %{
      name: "bit-shift-right",
      status: :candidate,
      description: "Bitwise right shift",
      notes: "pure bitwise operation on integers"
    },
    %{
      name: "bit-test",
      status: :candidate,
      description: "Tests bit at index",
      notes: "pure bitwise operation on integers"
    },
    %{
      name: "bit-xor",
      status: :candidate,
      description: "Bitwise exclusive OR",
      notes: "pure bitwise operation on integers"
    },
    %{name: "boolean", status: :supported, description: "Coerces to boolean", notes: ""},
    %{
      name: "boolean-array",
      status: :not_relevant,
      description: "Creates boolean Java array",
      notes: "creates Java array, incompatible with BEAM/non-JVM environments"
    },
    %{
      name: "boolean?",
      status: :supported,
      description: "Returns true if value is Boolean",
      notes: ""
    },
    %{
      name: "booleans",
      status: :not_relevant,
      description: "Casts to boolean array",
      notes: "Java array manipulation"
    },
    %{
      name: "bound-fn",
      status: :not_relevant,
      description: "Returns function with call-site bindings",
      notes: "relies on thread-local/dynamic scope bindings"
    },
    %{
      name: "bound-fn*",
      status: :not_relevant,
      description: "Returns function applying creation-context bindings",
      notes: "relies on thread-local/dynamic scope bindings"
    },
    %{
      name: "bound?",
      status: :not_relevant,
      description: "Returns true if all vars have bound value",
      notes: "relies on dynamic var binding state"
    },
    %{
      name: "bounded-count",
      status: :not_relevant,
      description: "Counts up to n elements",
      notes: "designed for lazy sequences"
    },
    %{name: "butlast", status: :supported, description: "Returns all but last item", notes: ""},
    %{
      name: "byte",
      status: :candidate,
      description: "Coerces to byte",
      notes: "pure numerical type coercion"
    },
    %{
      name: "byte-array",
      status: :not_relevant,
      description: "Creates byte Java array",
      notes: "Java array creation"
    },
    %{
      name: "bytes",
      status: :not_relevant,
      description: "Casts to byte array",
      notes: "Java array casting"
    },
    %{
      name: "bytes?",
      status: :not_relevant,
      description: "Returns true if value is byte array",
      notes: "Java array type check"
    },
    %{
      name: "case",
      status: :supported,
      description: "Constant-time dispatch on expression value",
      notes: ""
    },
    %{
      name: "cast",
      status: :not_relevant,
      description: "Throws ClassCastException if not instance",
      notes: "relies on Java type system and exception handling"
    },
    %{
      name: "cat",
      status: :candidate,
      description: "Transducer concatenating input collections",
      notes: "pure transducer for collection transformation"
    },
    %{
      name: "char",
      status: :candidate,
      description: "Coerces to char",
      notes: "pure data type coercion"
    },
    %{
      name: "char-array",
      status: :not_relevant,
      description: "Creates char Java array",
      notes: "creates Java array"
    },
    %{
      name: "char?",
      status: :supported,
      description: "Returns true if value is Character",
      notes: ""
    },
    %{
      name: "chars",
      status: :not_relevant,
      description: "Casts to char array",
      notes: "relies on Java char array types"
    },
    %{
      name: "class",
      status: :not_relevant,
      description: "Returns class of value",
      notes: "relies on Java class introspection"
    },
    %{
      name: "class?",
      status: :not_relevant,
      description: "Returns true if value is Class instance",
      notes: "relies on Java type system"
    },
    %{
      name: "clojure-version",
      status: :not_relevant,
      description: "Returns Clojure version string",
      notes: "environment info irrelevant to pure data transformation"
    },
    %{
      name: "coll?",
      status: :supported,
      description: "Returns true if implements IPersistentCollection",
      notes: ""
    },
    %{
      name: "comment",
      status: :not_relevant,
      description: "Ignores body, yields nil",
      notes: "REPL/source code construct"
    },
    %{
      name: "commute",
      status: :not_relevant,
      description: "Sets ref value via commutative function",
      notes: "mutable state primitive (refs)"
    },
    %{
      name: "comp",
      status: :supported,
      description: "Composes functions right-to-left",
      notes: ""
    },
    %{
      name: "comparator",
      status: :candidate,
      description: "Returns Comparator from predicate",
      notes: "pure function to create a comparison function"
    },
    %{
      name: "compare",
      status: :supported,
      description: "Compares values returning neg/zero/pos",
      notes: ""
    },
    %{
      name: "compare-and-set!",
      status: :not_relevant,
      description: "Atomically sets atom if current equals old",
      notes: "operates on mutable state (atoms)"
    },
    %{
      name: "compile",
      status: :not_relevant,
      description: "Compiles namespace into classfiles",
      notes: "compilation and class generation"
    },
    %{
      name: "complement",
      status: :supported,
      description: "Returns function with opposite truth value",
      notes: ""
    },
    %{
      name: "completing",
      status: :candidate,
      description: "Returns reducing function with completion",
      notes: "pure function for reducing transformations"
    },
    %{
      name: "concat",
      status: :supported,
      description: "Returns lazy seq concatenating collections",
      notes: ""
    },
    %{name: "cond", status: :supported, description: "Multi-way conditional", notes: ""},
    %{
      name: "cond->",
      status: :supported,
      description: "Threads through forms where tests true",
      notes: ""
    },
    %{
      name: "cond->>",
      status: :supported,
      description: "Threads as last arg where tests true",
      notes: ""
    },
    %{
      name: "condp",
      status: :supported,
      description: "Predicate dispatch against expression",
      notes: ""
    },
    %{
      name: "conj",
      status: :supported,
      description: "Returns collection with items added",
      notes: ""
    },
    %{
      name: "conj!",
      status: :not_relevant,
      description: "Adds item to transient collection",
      notes: "operates on transient collections (mutable)"
    },
    %{
      name: "cons",
      status: :supported,
      description: "Returns seq with item prepended",
      notes: ""
    },
    %{
      name: "constantly",
      status: :supported,
      description: "Returns function ignoring args, returning value",
      notes: ""
    },
    %{
      name: "contains?",
      status: :supported,
      description: "Returns true if key present in collection",
      notes: ""
    },
    %{
      name: "count",
      status: :supported,
      description: "Returns number of items in collection",
      notes: ""
    },
    %{
      name: "counted?",
      status: :supported,
      description: "Returns true if constant-time count",
      notes: ""
    },
    %{
      name: "create-ns",
      status: :not_relevant,
      description: "Creates or returns namespace",
      notes: "requires namespace system"
    },
    %{
      name: "create-struct",
      status: :not_relevant,
      description: "Returns structure basis object",
      notes: "relies on legacy fixed-key structure system"
    },
    %{
      name: "cycle",
      status: :not_relevant,
      description: "Returns infinite lazy seq repeating collection",
      notes: "relies on lazy sequences"
    },
    %{name: "dec", status: :supported, description: "Returns number minus one", notes: ""},
    %{
      name: "dec'",
      status: :candidate,
      description: "Decrements with arbitrary precision",
      notes: "pure arithmetic function"
    },
    %{name: "decimal?", status: :supported, description: "Returns true if BigDecimal", notes: ""},
    %{
      name: "declare",
      status: :not_relevant,
      description: "Defines var names with no bindings",
      notes: "relies on namespace/var system"
    },
    %{
      name: "dedupe",
      status: :supported,
      description: "Removes consecutive duplicates",
      notes: ""
    },
    %{name: "def", status: :supported, description: "Creates and interns global var", notes: ""},
    %{
      name: "definterface",
      status: :not_relevant,
      description: "Creates Java interface",
      notes: "Java interop"
    },
    %{
      name: "defmacro",
      status: :not_relevant,
      description: "Defines macro",
      notes: "macro system"
    },
    %{
      name: "defmethod",
      status: :not_relevant,
      description: "Creates multimethod implementation",
      notes: "multimethods"
    },
    %{
      name: "defmulti",
      status: :not_relevant,
      description: "Creates multimethod with dispatch function",
      notes: "multimethods"
    },
    %{name: "defn", status: :supported, description: "Defines named function", notes: ""},
    %{
      name: "defn-",
      status: :not_relevant,
      description: "Defines private function",
      notes: "namespacing/metadata"
    },
    %{
      name: "defonce",
      status: :supported,
      description: "Defines var only if not already defined",
      notes: ""
    },
    %{
      name: "defprotocol",
      status: :not_relevant,
      description: "Creates protocol with method signatures",
      notes: "protocols"
    },
    %{
      name: "defrecord",
      status: :not_relevant,
      description: "Creates record type with fields",
      notes: "custom types/Java-like classes"
    },
    %{
      name: "defstruct",
      status: :not_relevant,
      description: "Creates structure type",
      notes: "obsolete type system"
    },
    %{
      name: "deftype",
      status: :not_relevant,
      description: "Creates custom type with fields",
      notes: "custom types/Java interop"
    },
    %{
      name: "delay",
      status: :not_relevant,
      description: "Defers expression evaluation",
      notes: "lazy evaluation/stateful caching"
    },
    %{
      name: "delay?",
      status: :not_relevant,
      description: "Returns true if value is delay",
      notes: "relies on delay/concurrency which is not supported"
    },
    %{
      name: "deliver",
      status: :not_relevant,
      description: "Delivers result to promise",
      notes: "relies on promise/mutable state"
    },
    %{
      name: "denominator",
      status: :candidate,
      description: "Returns denominator of ratio",
      notes: "pure math operation"
    },
    %{
      name: "deref",
      status: :not_relevant,
      description: "Dereferences ref/delay/future/promise",
      notes: "relies on mutable state/concurrency types"
    },
    %{
      name: "derive",
      status: :not_relevant,
      description: "Establishes hierarchical relationship",
      notes: "relies on global namespace/hierarchy state"
    },
    %{
      name: "descendants",
      status: :not_relevant,
      description: "Returns all descendants of tag",
      notes: "relies on global namespace/hierarchy state"
    },
    %{name: "disj", status: :supported, description: "Returns set with item removed", notes: ""},
    %{
      name: "disj!",
      status: :not_relevant,
      description: "Removes from transient set",
      notes: "relies on transient/mutable data structures"
    },
    %{name: "dissoc", status: :supported, description: "Returns map with key removed", notes: ""},
    %{
      name: "dissoc!",
      status: :not_relevant,
      description: "Removes from transient map",
      notes: "relies on transient/mutable data structures"
    },
    %{
      name: "distinct",
      status: :supported,
      description: "Returns seq removing duplicates",
      notes: ""
    },
    %{
      name: "distinct?",
      status: :supported,
      description: "Returns true if all args distinct",
      notes: ""
    },
    %{
      name: "do",
      status: :supported,
      description: "Evaluates expressions, returns last",
      notes: ""
    },
    %{
      name: "doall",
      status: :not_relevant,
      description: "Realizes entire lazy seq",
      notes: "relies on lazy sequences"
    },
    %{
      name: "dorun",
      status: :not_relevant,
      description: "Realizes lazy seq, returns nil",
      notes: "relies on lazy sequences"
    },
    %{
      name: "doseq",
      status: :supported,
      description: "Iterates over sequences for side effects",
      notes: ""
    },
    %{
      name: "dosync",
      status: :not_relevant,
      description: "Executes body in STM transaction",
      notes: "relies on concurrency/STM primitives"
    },
    %{
      name: "dotimes",
      status: :not_relevant,
      description: "Executes body n times with counter",
      notes: "relies on side-effecting loops"
    },
    %{
      name: "doto",
      status: :not_relevant,
      description: "Calls methods on object, returns object",
      notes: "relies on Java interop"
    },
    %{name: "double", status: :supported, description: "Coerces to double", notes: ""},
    %{
      name: "double-array",
      status: :not_relevant,
      description: "Creates double Java array",
      notes: "relies on Java arrays"
    },
    %{name: "double?", status: :supported, description: "Returns true if Double", notes: ""},
    %{
      name: "doubles",
      status: :not_relevant,
      description: "Casts to double array",
      notes: "relies on Java arrays"
    },
    %{
      name: "drop",
      status: :supported,
      description: "Returns seq skipping first n items",
      notes: ""
    },
    %{
      name: "drop-last",
      status: :supported,
      description: "Returns seq without last n items",
      notes: ""
    },
    %{
      name: "drop-while",
      status: :supported,
      description: "Drops items while predicate true",
      notes: ""
    },
    %{
      name: "eduction",
      status: :not_relevant,
      description: "Returns reducible wrapper of transducer",
      notes: "relies on lazy/transducer abstractions"
    },
    %{
      name: "empty",
      status: :supported,
      description: "Returns empty collection of same type",
      notes: ""
    },
    %{
      name: "empty?",
      status: :supported,
      description: "Returns true if collection empty",
      notes: ""
    },
    %{
      name: "ensure",
      status: :not_relevant,
      description: "Ensures ref not written by other transaction",
      notes: "relies on software transactional memory (ref/transactional state)"
    },
    %{
      name: "ensure-reduced",
      status: :candidate,
      description: "Wraps in reduced if not already",
      notes: "pure utility for reduction flow control"
    },
    %{
      name: "enumeration-seq",
      status: :not_relevant,
      description: "Lazy seq from Java Enumeration",
      notes: "relies on lazy sequences and Java interop"
    },
    %{
      name: "error-handler",
      status: :not_relevant,
      description: "Returns agent error handler",
      notes: "relies on agent state"
    },
    %{
      name: "error-mode",
      status: :not_relevant,
      description: "Returns agent error mode",
      notes: "relies on agent state"
    },
    %{
      name: "eval",
      status: :not_relevant,
      description: "Evaluates form in current namespace",
      notes: "requires runtime compilation and namespace support"
    },
    %{
      name: "even?",
      status: :supported,
      description: "Returns true if number is even",
      notes: ""
    },
    %{
      name: "every-pred",
      status: :supported,
      description: "Returns combined predicate (all must be true)",
      notes: ""
    },
    %{
      name: "every?",
      status: :supported,
      description: "Returns true if pred true for all items",
      notes: ""
    },
    %{
      name: "ex-cause",
      status: :not_relevant,
      description: "Returns cause of exception",
      notes: "relies on exception handling"
    },
    %{
      name: "ex-data",
      status: :not_relevant,
      description: "Returns data map of exception",
      notes: "relies on exception handling"
    },
    %{
      name: "ex-info",
      status: :not_relevant,
      description: "Creates exception with message and data",
      notes: "relies on exception handling"
    },
    %{
      name: "ex-message",
      status: :not_relevant,
      description: "Returns exception message string",
      notes: "relies on exception handling"
    },
    %{
      name: "extend",
      status: :not_relevant,
      description: "Adds protocol implementations for type",
      notes: "relies on protocols"
    },
    %{
      name: "extend-protocol",
      status: :not_relevant,
      description: "Extends protocol to types",
      notes: "relies on protocols"
    },
    %{
      name: "extend-type",
      status: :not_relevant,
      description: "Extends type to implement protocol",
      notes: "relies on protocols"
    },
    %{
      name: "extenders",
      status: :not_relevant,
      description: "Returns types extending protocol",
      notes: "relies on protocols"
    },
    %{
      name: "extends?",
      status: :not_relevant,
      description: "Returns true if type extends protocol",
      notes: "relies on protocols"
    },
    %{
      name: "false?",
      status: :supported,
      description: "Returns true if value is false",
      notes: ""
    },
    %{name: "ffirst", status: :supported, description: "First of first item", notes: ""},
    %{
      name: "file-seq",
      status: :not_relevant,
      description: "Lazy seq of files in directory tree",
      notes: "relies on lazy sequences and file I/O"
    },
    %{
      name: "filter",
      status: :supported,
      description: "Returns items where predicate true",
      notes: ""
    },
    %{
      name: "filterv",
      status: :supported,
      description: "Returns vector of items where pred true",
      notes: ""
    },
    %{
      name: "find",
      status: :supported,
      description: "Returns map entry for key or nil",
      notes: ""
    },
    %{
      name: "find-keyword",
      status: :not_relevant,
      description: "Returns keyword with ns and name",
      notes: "relies on namespaces"
    },
    %{
      name: "find-ns",
      status: :not_relevant,
      description: "Returns namespace or nil",
      notes: "relies on namespace system"
    },
    %{
      name: "find-var",
      status: :not_relevant,
      description: "Returns var or nil",
      notes: "relies on vars/namespace system"
    },
    %{name: "first", status: :supported, description: "Returns first item", notes: ""},
    %{name: "flatten", status: :supported, description: "Flattens nested collections", notes: ""},
    %{name: "float", status: :supported, description: "Coerces to float", notes: ""},
    %{
      name: "float-array",
      status: :not_relevant,
      description: "Creates float Java array",
      notes: "creates Java array"
    },
    %{name: "float?", status: :supported, description: "Returns true if Float", notes: ""},
    %{
      name: "floats",
      status: :not_relevant,
      description: "Casts to float array",
      notes: "handles Java arrays"
    },
    %{
      name: "flush",
      status: :not_relevant,
      description: "Flushes output writer",
      notes: "I/O operation"
    },
    %{name: "fn", status: :supported, description: "Defines anonymous function", notes: ""},
    %{
      name: "fn?",
      status: :supported,
      description: "Returns true if value is function",
      notes: ""
    },
    %{name: "fnext", status: :supported, description: "First of next item", notes: ""},
    %{
      name: "fnil",
      status: :supported,
      description: "Returns function with nil defaults",
      notes: ""
    },
    %{
      name: "for",
      status: :supported,
      description: "List comprehension from nested iteration",
      notes: ""
    },
    %{
      name: "force",
      status: :not_relevant,
      description: "Forces evaluation of delay",
      notes: "relies on lazy evaluation/delays"
    },
    %{name: "format", status: :supported, description: "Returns formatted string", notes: ""},
    %{
      name: "frequencies",
      status: :supported,
      description: "Returns map of item frequencies",
      notes: ""
    },
    %{
      name: "future",
      status: :not_relevant,
      description: "Async computation",
      notes: "concurrency primitive"
    },
    %{
      name: "future-call",
      status: :not_relevant,
      description: "Calls function asynchronously",
      notes: "concurrency primitive"
    },
    %{
      name: "future-cancel",
      status: :not_relevant,
      description: "Cancels future",
      notes: "concurrency primitive"
    },
    %{
      name: "future-cancelled?",
      status: :not_relevant,
      description: "Returns true if future cancelled",
      notes: "concurrency primitive"
    },
    %{
      name: "future-done?",
      status: :not_relevant,
      description: "Returns true if future complete",
      notes: "concurrency primitive"
    },
    %{
      name: "future?",
      status: :not_relevant,
      description: "Returns true if value is future",
      notes: "concurrency primitive"
    },
    %{
      name: "gensym",
      status: :not_relevant,
      description: "Returns unique symbol",
      notes: "macro system utility"
    },
    %{name: "get", status: :supported, description: "Returns value for key or nil", notes: ""},
    %{
      name: "get-in",
      status: :supported,
      description: "Returns value at nested key path",
      notes: ""
    },
    %{
      name: "get-method",
      status: :not_relevant,
      description: "Returns multimethod implementation",
      notes: "multimethods not supported"
    },
    %{
      name: "get-proxy-class",
      status: :not_relevant,
      description: "Returns proxy class",
      notes: "Java interop"
    },
    %{
      name: "get-thread-bindings",
      status: :not_relevant,
      description: "Returns thread-local bindings",
      notes: "concurrency primitive / thread locals"
    },
    %{
      name: "get-validator",
      status: :not_relevant,
      description: "Returns reference validator",
      notes: "mutable state validator"
    },
    %{
      name: "group-by",
      status: :supported,
      description: "Groups items by function result",
      notes: ""
    },
    %{
      name: "halt-when",
      status: :not_relevant,
      description: "Transducer halting on predicate",
      notes:
        "relies on transducers which often involve stateful reduction and lazy-like sequence processing"
    },
    %{
      name: "hash",
      status: :candidate,
      description: "Returns hash code",
      notes: "pure function computing a value from data"
    },
    %{
      name: "hash-map",
      status: :supported,
      description: "Creates hash map from pairs",
      notes: ""
    },
    %{
      name: "hash-ordered-coll",
      status: :candidate,
      description: "Returns hash of ordered collection",
      notes: "pure function computing a hash"
    },
    %{
      name: "hash-set",
      status: :candidate,
      description: "Creates hash set from items",
      notes: "pure function creating a hash set data structure"
    },
    %{
      name: "hash-unordered-coll",
      status: :candidate,
      description: "Returns hash of unordered collection",
      notes: "pure function computing a hash"
    },
    %{
      name: "ident?",
      status: :candidate,
      description: "Returns true if keyword or symbol",
      notes: "pure predicate for data types"
    },
    %{
      name: "identical?",
      status: :not_relevant,
      description: "Returns true if same object",
      notes:
        "relies on object identity which is not meaningful for serializable data in a BEAM-based environment"
    },
    %{name: "identity", status: :supported, description: "Returns argument unchanged", notes: ""},
    %{name: "if", status: :supported, description: "Conditional branch", notes: ""},
    %{name: "if-let", status: :supported, description: "Conditional with binding", notes: ""},
    %{name: "if-not", status: :supported, description: "Negated conditional", notes: ""},
    %{name: "if-some", status: :supported, description: "Binds if not nil", notes: ""},
    %{name: "ifn?", status: :supported, description: "Returns true if invokable", notes: ""},
    %{
      name: "import",
      status: :not_relevant,
      description: "Imports Java classes",
      notes: "relies on Java interop"
    },
    %{
      name: "in-ns",
      status: :not_relevant,
      description: "Changes current namespace",
      notes: "relies on namespace support"
    },
    %{name: "inc", status: :supported, description: "Returns number plus one", notes: ""},
    %{
      name: "inc'",
      status: :candidate,
      description: "Increments with arbitrary precision",
      notes: "pure mathematical transformation"
    },
    %{
      name: "indexed?",
      status: :supported,
      description: "Returns true if supports indexed access",
      notes: ""
    },
    %{
      name: "infinite?",
      status: :supported,
      description: "Returns true if number infinite",
      notes: ""
    },
    %{
      name: "inst-ms",
      status: :candidate,
      description: "Milliseconds since epoch for instant",
      notes: "pure data extraction from date object"
    },
    %{
      name: "inst?",
      status: :candidate,
      description: "Returns true if instant",
      notes: "pure type predicate"
    },
    %{
      name: "instance?",
      status: :not_relevant,
      description: "Returns true if instance of class",
      notes: "relies on Java class system"
    },
    %{name: "int", status: :supported, description: "Coerces to int", notes: ""},
    %{
      name: "int-array",
      status: :not_relevant,
      description: "Creates int Java array",
      notes: "relies on Java array/mutability"
    },
    %{name: "int?", status: :supported, description: "Returns true if Integer", notes: ""},
    %{name: "integer?", status: :supported, description: "Returns true if integer", notes: ""},
    %{
      name: "interleave",
      status: :supported,
      description: "Interleaves items from collections",
      notes: ""
    },
    %{
      name: "intern",
      status: :not_relevant,
      description: "Creates or returns var in namespace",
      notes: "operates on namespaces"
    },
    %{
      name: "interpose",
      status: :supported,
      description: "Inserts separator between items",
      notes: ""
    },
    %{
      name: "into",
      status: :supported,
      description: "Conjoins items from source into target",
      notes: ""
    },
    %{
      name: "into-array",
      status: :not_relevant,
      description: "Creates Java array from items",
      notes: "Java interop"
    },
    %{
      name: "ints",
      status: :not_relevant,
      description: "Casts to int array",
      notes: "Java interop"
    },
    %{
      name: "isa?",
      status: :not_relevant,
      description: "Returns true if child is parent instance",
      notes: "relies on hierarchy/multimethods system"
    },
    %{
      name: "iterate",
      status: :not_relevant,
      description: "Lazy seq of repeated function application",
      notes: "creates lazy sequences"
    },
    %{
      name: "iteration",
      status: :not_relevant,
      description: "Reducible wrapper of iterator",
      notes: "wraps Java iterators"
    },
    %{
      name: "iterator-seq",
      status: :not_relevant,
      description: "Lazy seq from Java Iterator",
      notes: "creates lazy sequences from Java iterators"
    },
    %{
      name: "juxt",
      status: :supported,
      description: "Applies multiple functions, collects results",
      notes: ""
    },
    %{
      name: "keep",
      status: :supported,
      description: "Keeps non-nil results of function",
      notes: ""
    },
    %{
      name: "keep-indexed",
      status: :supported,
      description: "Keeps non-nil results with index",
      notes: ""
    },
    %{name: "key", status: :supported, description: "Returns key of map entry", notes: ""},
    %{name: "keys", status: :supported, description: "Returns map keys", notes: ""},
    %{name: "keyword", status: :supported, description: "Coerces to keyword", notes: ""},
    %{name: "keyword?", status: :supported, description: "Returns true if keyword", notes: ""},
    %{name: "last", status: :supported, description: "Returns last item", notes: ""},
    %{
      name: "lazy-cat",
      status: :not_relevant,
      description: "Lazy concatenation of expressions",
      notes: "relies on lazy sequences"
    },
    %{
      name: "lazy-seq",
      status: :not_relevant,
      description: "Creates lazy sequence from expression",
      notes: "relies on lazy sequences"
    },
    %{name: "let", status: :supported, description: "Local variable bindings", notes: ""},
    %{
      name: "letfn",
      status: :candidate,
      description: "Binds function names for mutual recursion",
      notes: "pure binding of functions for recursion"
    },
    %{
      name: "line-seq",
      status: :not_relevant,
      description: "Lazy seq of lines from reader",
      notes: "relies on lazy sequences and reader I/O"
    },
    %{
      name: "list",
      status: :candidate,
      description: "Creates list from items",
      notes: "pure data structure creation"
    },
    %{
      name: "list*",
      status: :candidate,
      description: "Creates list with seq appended",
      notes: "pure list constructor"
    },
    %{
      name: "list?",
      status: :candidate,
      description: "Returns true if list",
      notes: "pure predicate"
    },
    %{
      name: "load",
      status: :not_relevant,
      description: "Loads Clojure file from classpath",
      notes: "relies on file I/O and classpath"
    },
    %{
      name: "load-file",
      status: :not_relevant,
      description: "Loads Clojure file from path",
      notes: "relies on file I/O"
    },
    %{
      name: "load-reader",
      status: :not_relevant,
      description: "Loads code from reader",
      notes: "relies on reader I/O"
    },
    %{
      name: "load-string",
      status: :not_relevant,
      description: "Loads code from string",
      notes: "evaluates code/REPL feature"
    },
    %{
      name: "locking",
      status: :not_relevant,
      description: "Acquires monitor lock, executes body",
      notes: "concurrency primitive/locking"
    },
    %{
      name: "long",
      status: :candidate,
      description: "Coerces to long",
      notes: "type coercion, pure"
    },
    %{
      name: "long-array",
      status: :not_relevant,
      description: "Creates long Java array",
      notes: "Java interop/primitive array"
    },
    %{
      name: "longs",
      status: :not_relevant,
      description: "Casts to long array",
      notes: "Java interop/primitive array"
    },
    %{
      name: "loop",
      status: :supported,
      description: "Loop with recur for tail recursion",
      notes: ""
    },
    %{
      name: "macroexpand",
      status: :not_relevant,
      description: "Recursively expands macro",
      notes: "macro system"
    },
    %{
      name: "macroexpand-1",
      status: :not_relevant,
      description: "Expands macro one level",
      notes: "macro system"
    },
    %{
      name: "make-array",
      status: :not_relevant,
      description: "Creates Java array",
      notes: "Java interop/array creation"
    },
    %{
      name: "make-hierarchy",
      status: :not_relevant,
      description: "Returns empty hierarchy",
      notes: "relies on multimethods system"
    },
    %{name: "map", status: :supported, description: "Applies function to each item", notes: ""},
    %{
      name: "map-entry?",
      status: :supported,
      description: "Returns true if map entry",
      notes: ""
    },
    %{
      name: "map-indexed",
      status: :supported,
      description: "Applies function with index to items",
      notes: ""
    },
    %{name: "map?", status: :supported, description: "Returns true if map", notes: ""},
    %{
      name: "mapcat",
      status: :supported,
      description: "Maps then concatenates results",
      notes: ""
    },
    %{
      name: "mapv",
      status: :supported,
      description: "Returns vector from mapping function",
      notes: ""
    },
    %{name: "max", status: :supported, description: "Returns greatest number", notes: ""},
    %{
      name: "max-key",
      status: :supported,
      description: "Returns item with greatest function value",
      notes: ""
    },
    %{
      name: "memfn",
      status: :not_relevant,
      description: "Returns function calling Java method",
      notes: "relies on Java interop"
    },
    %{
      name: "memoize",
      status: :not_relevant,
      description: "Caches function results by arguments",
      notes: "relies on mutable state for caching"
    },
    %{name: "merge", status: :supported, description: "Merges maps", notes: ""},
    %{
      name: "merge-with",
      status: :supported,
      description: "Merges maps with combining function",
      notes: ""
    },
    %{
      name: "meta",
      status: :not_relevant,
      description: "Returns metadata",
      notes: "relies on metadata support"
    },
    %{
      name: "methods",
      status: :not_relevant,
      description: "Returns multimethod implementations",
      notes: "relies on multimethods"
    },
    %{name: "min", status: :supported, description: "Returns least number", notes: ""},
    %{
      name: "min-key",
      status: :supported,
      description: "Returns item with least function value",
      notes: ""
    },
    %{name: "mod", status: :supported, description: "Returns modulo", notes: ""},
    %{
      name: "name",
      status: :supported,
      description: "Returns name string of symbol/keyword",
      notes: ""
    },
    %{
      name: "namespace",
      status: :not_relevant,
      description: "Returns namespace of symbol/keyword",
      notes: "relies on namespace support"
    },
    %{
      name: "nat-int?",
      status: :supported,
      description: "Returns true if non-negative integer",
      notes: ""
    },
    %{
      name: "neg-int?",
      status: :supported,
      description: "Returns true if negative integer",
      notes: ""
    },
    %{
      name: "neg?",
      status: :supported,
      description: "Returns true if number negative",
      notes: ""
    },
    %{
      name: "newline",
      status: :not_relevant,
      description: "Writes newline to output",
      notes: "relies on I/O"
    },
    %{name: "next", status: :supported, description: "Returns seq after first item", notes: ""},
    %{name: "nfirst", status: :supported, description: "Next of first item", notes: ""},
    %{name: "nil?", status: :supported, description: "Returns true if nil", notes: ""},
    %{name: "nnext", status: :supported, description: "Next of next item", notes: ""},
    %{name: "not", status: :supported, description: "Logical complement", notes: ""},
    %{
      name: "not-any?",
      status: :supported,
      description: "Returns true if pred false for all",
      notes: ""
    },
    %{
      name: "not-empty",
      status: :supported,
      description: "Returns collection or nil if empty",
      notes: ""
    },
    %{
      name: "not-every?",
      status: :supported,
      description: "Returns true if pred false for some",
      notes: ""
    },
    %{name: "not=", status: :supported, description: "Returns true if not equal", notes: ""},
    %{name: "nth", status: :supported, description: "Returns item at index", notes: ""},
    %{
      name: "nthnext",
      status: :candidate,
      description: "Returns nth next",
      notes: "pure list/sequence navigation"
    },
    %{
      name: "nthrest",
      status: :candidate,
      description: "Returns rest after nth item",
      notes: "pure list/sequence navigation"
    },
    %{
      name: "num",
      status: :candidate,
      description: "Coerces to number",
      notes: "pure numeric coercion"
    },
    %{name: "number?", status: :supported, description: "Returns true if number", notes: ""},
    %{
      name: "numerator",
      status: :candidate,
      description: "Returns numerator of ratio",
      notes: "pure mathematical operation on ratios"
    },
    %{
      name: "object-array",
      status: :not_relevant,
      description: "Creates object Java array",
      notes: "relies on Java interop and host arrays"
    },
    %{name: "odd?", status: :supported, description: "Returns true if number odd", notes: ""},
    %{name: "or", status: :supported, description: "Short-circuit logical OR", notes: ""},
    %{
      name: "parents",
      status: :not_relevant,
      description: "Returns immediate parents of tag",
      notes: "metadata/hierarchy manipulation not supported in PTC-Lisp"
    },
    %{
      name: "parse-boolean",
      status: :candidate,
      description: "Parses string to boolean",
      notes: "pure string-to-data transformation"
    },
    %{
      name: "parse-double",
      status: :supported,
      description: "Parses string to double",
      notes: ""
    },
    %{name: "parse-long", status: :supported, description: "Parses string to long", notes: ""},
    %{
      name: "parse-uuid",
      status: :candidate,
      description: "Parses string to UUID",
      notes: "pure string-to-data transformation"
    },
    %{
      name: "partial",
      status: :supported,
      description: "Fixes supplied arguments to function",
      notes: ""
    },
    %{
      name: "partition",
      status: :supported,
      description: "Partitions items into groups of n",
      notes: ""
    },
    %{
      name: "partition-all",
      status: :supported,
      description: "Partitions without dropping partial group",
      notes: ""
    },
    %{
      name: "partition-by",
      status: :supported,
      description: "Partitions by change in function value",
      notes: ""
    },
    %{
      name: "pcalls",
      status: :supported,
      description: "Parallel calls to zero-arity functions",
      notes: ""
    },
    %{
      name: "peek",
      status: :supported,
      description: "Returns first/last without removing",
      notes: ""
    },
    %{
      name: "persistent!",
      status: :not_relevant,
      description: "Converts transient to persistent",
      notes: "transients are unsupported"
    },
    %{name: "pmap", status: :supported, description: "Parallel map over collection", notes: ""},
    %{
      name: "pop",
      status: :supported,
      description: "Returns collection without first/last",
      notes: ""
    },
    %{
      name: "pop!",
      status: :not_relevant,
      description: "Removes from transient collection",
      notes: "transients are unsupported"
    },
    %{
      name: "pos-int?",
      status: :supported,
      description: "Returns true if positive integer",
      notes: ""
    },
    %{
      name: "pos?",
      status: :supported,
      description: "Returns true if number positive",
      notes: ""
    },
    %{
      name: "pr",
      status: :not_relevant,
      description: "Prints value in readable form",
      notes: "I/O operation"
    },
    %{
      name: "pr-str",
      status: :supported,
      description: "Returns readable string of value",
      notes: ""
    },
    %{
      name: "prefer-method",
      status: :not_relevant,
      description: "Prefers multimethod implementation",
      notes: "multimethods are unsupported"
    },
    %{
      name: "prefers",
      status: :not_relevant,
      description: "Returns multimethod preferences",
      notes: "multimethods are unsupported"
    },
    %{
      name: "print",
      status: :not_relevant,
      description: "Prints value without quoting",
      notes: "I/O operation"
    },
    %{
      name: "print-str",
      status: :not_relevant,
      description: "Returns printed string of value",
      notes: "relies on printing logic/I/O"
    },
    %{
      name: "printf",
      status: :not_relevant,
      description: "Prints formatted output",
      notes: "performs stdout I/O"
    },
    %{name: "println", status: :supported, description: "Prints with newline", notes: ""},
    %{
      name: "promise",
      status: :not_relevant,
      description: "Creates promise",
      notes: "concurrency primitive"
    },
    %{
      name: "proxy",
      status: :not_relevant,
      description: "Creates proxy implementing interfaces",
      notes: "Java interop"
    },
    %{
      name: "push-thread-bindings",
      status: :not_relevant,
      description: "Installs thread-local bindings",
      notes: "thread-local mutability/state"
    },
    %{
      name: "qualified-ident?",
      status: :candidate,
      description: "Returns true if ident has namespace",
      notes: "pure predicate for data inspection"
    },
    %{
      name: "qualified-keyword?",
      status: :candidate,
      description: "Returns true if keyword has namespace",
      notes: "pure predicate for data inspection"
    },
    %{
      name: "qualified-symbol?",
      status: :candidate,
      description: "Returns true if symbol has namespace",
      notes: "pure predicate for data inspection"
    },
    %{
      name: "quot",
      status: :supported,
      description: "Returns integer division quotient",
      notes: ""
    },
    %{
      name: "quote",
      status: :candidate,
      description: "Returns form unevaluated",
      notes: "fundamental Lisp evaluation control"
    },
    %{
      name: "rand",
      status: :candidate,
      description: "Returns random float 0-1",
      notes: "pure data-generating function (if implemented as a pure seeded RNG)"
    },
    %{
      name: "rand-int",
      status: :not_relevant,
      description: "Returns random int less than arg",
      notes: "relies on non-deterministic side effects/state"
    },
    %{
      name: "rand-nth",
      status: :not_relevant,
      description: "Returns random item from seq",
      notes: "relies on non-deterministic side effects/state"
    },
    %{
      name: "random-sample",
      status: :not_relevant,
      description: "Returns random sample of items",
      notes: "relies on non-deterministic side effects/state"
    },
    %{
      name: "random-uuid",
      status: :not_relevant,
      description: "Returns random UUID",
      notes: "relies on non-deterministic side effects"
    },
    %{name: "range", status: :supported, description: "Returns sequence of numbers", notes: ""},
    %{name: "ratio?", status: :supported, description: "Returns true if ratio", notes: ""},
    %{
      name: "rational?",
      status: :supported,
      description: "Returns true if rational number",
      notes: ""
    },
    %{
      name: "rationalize",
      status: :candidate,
      description: "Coerces to ratio",
      notes: "pure mathematical transformation"
    },
    %{name: "re-find", status: :supported, description: "Returns first regex match", notes: ""},
    %{
      name: "re-groups",
      status: :candidate,
      description: "Returns regex match groups",
      notes: "pure string processing function"
    },
    %{
      name: "re-matcher",
      status: :not_relevant,
      description: "Returns matcher for pattern",
      notes: "returns an object maintaining mutable state/matcher position"
    },
    %{
      name: "re-matches",
      status: :supported,
      description: "Returns full regex match or nil",
      notes: ""
    },
    %{
      name: "re-pattern",
      status: :supported,
      description: "Returns compiled regex pattern",
      notes: ""
    },
    %{name: "re-seq", status: :supported, description: "Returns seq of regex matches", notes: ""},
    %{
      name: "read",
      status: :not_relevant,
      description: "Reads next form from reader",
      notes: "implies I/O and interaction with reader contexts"
    },
    %{
      name: "read-line",
      status: :not_relevant,
      description: "Reads line from input",
      notes: "I/O operation"
    },
    %{
      name: "read-string",
      status: :not_relevant,
      description: "Reads form from string",
      notes: "invokes reader/eval capabilities not supported in sandbox"
    },
    %{
      name: "realized?",
      status: :not_relevant,
      description: "Returns true if delay/future complete",
      notes: "relies on concurrency/lazy primitives not supported"
    },
    %{
      name: "record?",
      status: :not_relevant,
      description: "Returns true if record",
      notes: "relies on class/type system not supported"
    },
    %{
      name: "recur",
      status: :supported,
      description: "Rebinds loop vars and jumps to loop start",
      notes: ""
    },
    %{
      name: "reduce",
      status: :supported,
      description: "Reduces collection with function",
      notes: ""
    },
    %{
      name: "reduce-kv",
      status: :supported,
      description: "Reduces map with key-value function",
      notes: ""
    },
    %{
      name: "reduced",
      status: :candidate,
      description: "Wraps value indicating reduction complete",
      notes: "pure control flow mechanism for reduction interruption"
    },
    %{
      name: "reduced?",
      status: :candidate,
      description: "Returns true if wrapped in reduced",
      notes: "pure predicate for checking reduction status"
    },
    %{
      name: "reductions",
      status: :not_relevant,
      description: "Returns intermediate reduction results",
      notes: "returns a lazy sequence"
    },
    %{
      name: "ref",
      status: :not_relevant,
      description: "Creates STM reference",
      notes: "mutable state/concurrency primitive"
    },
    %{
      name: "ref-set",
      status: :not_relevant,
      description: "Sets ref value in transaction",
      notes: "mutable state/concurrency primitive"
    },
    %{
      name: "reify",
      status: :not_relevant,
      description: "Creates instance implementing protocols",
      notes: "relies on protocols and class generation"
    },
    %{name: "rem", status: :supported, description: "Returns remainder of division", notes: ""},
    %{
      name: "remove",
      status: :supported,
      description: "Returns items where predicate false",
      notes: ""
    },
    %{
      name: "remove-all-methods",
      status: :not_relevant,
      description: "Removes all multimethod impls",
      notes: "relies on multimethods"
    },
    %{
      name: "remove-method",
      status: :not_relevant,
      description: "Removes multimethod impl",
      notes: "relies on multimethods"
    },
    %{
      name: "remove-ns",
      status: :not_relevant,
      description: "Removes namespace",
      notes: "relies on namespaces"
    },
    %{
      name: "remove-tap",
      status: :not_relevant,
      description: "Removes function from tap set",
      notes: "relies on global mutable state/taps"
    },
    %{
      name: "remove-watch",
      status: :not_relevant,
      description: "Removes watch from reference",
      notes: "relies on mutable state references"
    },
    %{
      name: "repeat",
      status: :not_relevant,
      description: "Returns infinite seq repeating value",
      notes: "returns lazy sequences"
    },
    %{
      name: "repeatedly",
      status: :not_relevant,
      description: "Returns seq calling function repeatedly",
      notes: "returns lazy sequences"
    },
    %{
      name: "replace",
      status: :supported,
      description: "Replaces values by map mapping",
      notes: ""
    },
    %{
      name: "require",
      status: :not_relevant,
      description: "Requires namespace",
      notes: "relies on namespace/load system"
    },
    %{
      name: "requiring-resolve",
      status: :not_relevant,
      description: "Requires ns and resolves symbol",
      notes: "relies on namespace/load system"
    },
    %{
      name: "reset!",
      status: :not_relevant,
      description: "Sets atom value",
      notes: "mutable state (atoms)"
    },
    %{
      name: "reset-meta!",
      status: :not_relevant,
      description: "Sets metadata",
      notes: "metadata manipulation"
    },
    %{
      name: "reset-vals!",
      status: :not_relevant,
      description: "Sets atom, returns [old new]",
      notes: "mutable state (atoms)"
    },
    %{
      name: "resolve",
      status: :not_relevant,
      description: "Resolves symbol in namespace",
      notes: "namespace/symbol resolution"
    },
    %{name: "rest", status: :supported, description: "Returns seq after first item", notes: ""},
    %{
      name: "restart-agent",
      status: :not_relevant,
      description: "Restarts failed agent",
      notes: "concurrency primitives (agents)"
    },
    %{name: "reverse", status: :supported, description: "Reverses order of items", notes: ""},
    %{
      name: "reversible?",
      status: :supported,
      description: "Returns true if collection reversible",
      notes: ""
    },
    %{
      name: "rseq",
      status: :not_relevant,
      description: "Returns reverse seq of sorted collection",
      notes: "relies on lazy/sorted sequence implementation details"
    },
    %{
      name: "rsubseq",
      status: :not_relevant,
      description: "Returns reverse subseq of sorted coll",
      notes: "relies on lazy/sorted sequence implementation details"
    },
    %{
      name: "run!",
      status: :not_relevant,
      description: "Runs side effects, returns nil",
      notes: "relies on side effects"
    },
    %{
      name: "satisfies?",
      status: :not_relevant,
      description: "Returns true if type satisfies protocol",
      notes: "protocol/type system feature"
    },
    %{name: "second", status: :supported, description: "Returns second item", notes: ""},
    %{
      name: "select-keys",
      status: :supported,
      description: "Returns map with only specified keys",
      notes: ""
    },
    %{
      name: "send",
      status: :not_relevant,
      description: "Dispatches action to agent",
      notes: "relies on agent mutable state"
    },
    %{
      name: "send-off",
      status: :not_relevant,
      description: "Dispatches blocking action to agent",
      notes: "relies on agent mutable state"
    },
    %{
      name: "send-via",
      status: :not_relevant,
      description: "Sends action via executor to agent",
      notes: "relies on agent mutable state"
    },
    %{
      name: "seq",
      status: :supported,
      description: "Returns sequence or nil if empty",
      notes: ""
    },
    %{
      name: "seq?",
      status: :supported,
      description: "Returns true if value is sequence",
      notes: ""
    },
    %{
      name: "seqable?",
      status: :supported,
      description: "Returns true if implements Seqable",
      notes: ""
    },
    %{
      name: "sequence",
      status: :not_relevant,
      description: "Returns seq applying transducer",
      notes: "relies on lazy sequences"
    },
    %{
      name: "sequential?",
      status: :supported,
      description: "Returns true if sequential",
      notes: ""
    },
    %{name: "set", status: :supported, description: "Creates set from items", notes: ""},
    %{
      name: "set!",
      status: :not_relevant,
      description: "Sets thread-local var value",
      notes: "relies on mutable state"
    },
    %{name: "set?", status: :supported, description: "Returns true if set", notes: ""},
    %{
      name: "short",
      status: :candidate,
      description: "Coerces to short",
      notes: "pure numerical type coercion"
    },
    %{
      name: "short-array",
      status: :not_relevant,
      description: "Creates short Java array",
      notes: "relies on Java array instantiation"
    },
    %{
      name: "shorts",
      status: :not_relevant,
      description: "Casts to short array",
      notes: "relies on Java array interaction"
    },
    %{
      name: "shuffle",
      status: :not_relevant,
      description: "Returns items in random order",
      notes: "relies on non-deterministic side effects (randomness)"
    },
    %{
      name: "shutdown-agents",
      status: :not_relevant,
      description: "Shuts down agent thread pool",
      notes: "manages thread pools which is unsupported"
    },
    %{
      name: "simple-ident?",
      status: :candidate,
      description: "Returns true if ident has no namespace",
      notes: "pure predicate for data validation"
    },
    %{
      name: "simple-keyword?",
      status: :candidate,
      description: "Returns true if keyword has no ns",
      notes: "pure predicate for data validation"
    },
    %{
      name: "simple-symbol?",
      status: :candidate,
      description: "Returns true if symbol has no ns",
      notes: "pure predicate for data validation"
    },
    %{
      name: "slurp",
      status: :not_relevant,
      description: "Reads entire contents of file/URL",
      notes: "involves file/network I/O"
    },
    %{
      name: "some",
      status: :supported,
      description: "Returns first truthy result or nil",
      notes: ""
    },
    %{
      name: "some->",
      status: :supported,
      description: "Threads through forms while non-nil",
      notes: ""
    },
    %{
      name: "some->>",
      status: :supported,
      description: "Threads as last arg while non-nil",
      notes: ""
    },
    %{
      name: "some-fn",
      status: :supported,
      description: "Returns pred true if any fn truthy",
      notes: ""
    },
    %{name: "some?", status: :supported, description: "Returns true if not nil", notes: ""},
    %{name: "sort", status: :supported, description: "Returns sorted sequence", notes: ""},
    %{
      name: "sort-by",
      status: :supported,
      description: "Returns seq sorted by function result",
      notes: ""
    },
    %{
      name: "sorted-map",
      status: :candidate,
      description: "Creates sorted map from pairs",
      notes: "pure collection construction"
    },
    %{
      name: "sorted-map-by",
      status: :candidate,
      description: "Creates sorted map with comparator",
      notes: "pure collection construction with custom comparator"
    },
    %{
      name: "sorted-set",
      status: :candidate,
      description: "Creates sorted set from items",
      notes: "pure collection construction"
    },
    %{
      name: "sorted-set-by",
      status: :candidate,
      description: "Creates sorted set with comparator",
      notes: "pure collection construction with custom comparator"
    },
    %{
      name: "sorted?",
      status: :supported,
      description: "Returns true if collection sorted",
      notes: ""
    },
    %{
      name: "spit",
      status: :not_relevant,
      description: "Writes content to file",
      notes: "file I/O"
    },
    %{name: "split-at", status: :supported, description: "Splits seq at index", notes: ""},
    %{name: "split-with", status: :supported, description: "Splits seq by predicate", notes: ""},
    %{name: "str", status: :supported, description: "Converts to string", notes: ""},
    %{name: "string?", status: :supported, description: "Returns true if string", notes: ""},
    %{
      name: "struct",
      status: :not_relevant,
      description: "Creates structure instance",
      notes: "legacy structure system, discouraged/deprecated"
    },
    %{
      name: "struct-map",
      status: :not_relevant,
      description: "Creates structure map from basis",
      notes: "legacy structure system, discouraged/deprecated"
    },
    %{name: "subs", status: :supported, description: "Returns substring", notes: ""},
    %{
      name: "subseq",
      status: :candidate,
      description: "Returns subseq of sorted collection",
      notes: "pure operation on sorted collections"
    },
    %{name: "subvec", status: :supported, description: "Returns subvector", notes: ""},
    %{
      name: "supers",
      status: :not_relevant,
      description: "Returns all ancestors of class",
      notes: "relies on Java class hierarchy/interop"
    },
    %{
      name: "swap!",
      status: :not_relevant,
      description: "Updates atom with function",
      notes: "requires mutable state (atom)"
    },
    %{
      name: "swap-vals!",
      status: :not_relevant,
      description: "Updates atom, returns [old new]",
      notes: "requires mutable state (atom)"
    },
    %{
      name: "symbol",
      status: :candidate,
      description: "Coerces to symbol",
      notes: "pure data coercion"
    },
    %{name: "symbol?", status: :supported, description: "Returns true if symbol", notes: ""},
    %{name: "take", status: :supported, description: "Returns first n items", notes: ""},
    %{name: "take-last", status: :supported, description: "Returns last n items", notes: ""},
    %{
      name: "take-nth",
      status: :not_relevant,
      description: "Returns every nth item",
      notes: "returns a lazy sequence"
    },
    %{
      name: "take-while",
      status: :supported,
      description: "Takes items while predicate true",
      notes: ""
    },
    %{
      name: "tap>",
      status: :not_relevant,
      description: "Sends value to taps",
      notes: "side-effecting I/O mechanism"
    },
    %{
      name: "test",
      status: :not_relevant,
      description: "Runs tests for namespace",
      notes: "built-in testing framework/REPL tool"
    },
    %{
      name: "throw",
      status: :not_relevant,
      description: "Throws exception",
      notes: "exception handling"
    },
    %{
      name: "time",
      status: :not_relevant,
      description: "Evaluates and prints elapsed time",
      notes: "side-effecting I/O and timing"
    },
    %{
      name: "to-array",
      status: :not_relevant,
      description: "Converts to object array",
      notes: "Java interop for array creation"
    },
    %{
      name: "to-array-2d",
      status: :not_relevant,
      description: "Converts to 2D array",
      notes: "Java interop for array creation"
    },
    %{
      name: "trampoline",
      status: :candidate,
      description: "Mutual recursion without stack overflow",
      notes: "Pure mutual recursion utility"
    },
    %{
      name: "transduce",
      status: :candidate,
      description: "Reduces with transducer",
      notes: "Pure data transformation utility"
    },
    %{
      name: "transient",
      status: :not_relevant,
      description: "Creates transient collection",
      notes: "Mutable state/transients are not supported"
    },
    %{name: "tree-seq", status: :supported, description: "Depth-first seq from root", notes: ""},
    %{name: "true?", status: :supported, description: "Returns true if value is true", notes: ""},
    %{
      name: "try",
      status: :not_relevant,
      description: "Exception handling",
      notes: "Exception handling is not supported"
    },
    %{name: "type", status: :supported, description: "Returns type of value", notes: ""},
    %{
      name: "unchecked-add",
      status: :not_relevant,
      description: "Adds without overflow check",
      notes: "Java-specific math optimization"
    },
    %{
      name: "unchecked-add-int",
      status: :not_relevant,
      description: "Adds ints without overflow check",
      notes: "Java-specific math optimization"
    },
    %{
      name: "unchecked-byte",
      status: :not_relevant,
      description: "Casts to byte without check",
      notes: "Java-specific primitive casting"
    },
    %{
      name: "unchecked-char",
      status: :not_relevant,
      description: "Casts to char without check",
      notes: "Relies on Java primitive casting/low-level JVM semantics"
    },
    %{
      name: "unchecked-dec",
      status: :not_relevant,
      description: "Decrements without overflow check",
      notes: "Relies on Java primitive casting/low-level JVM semantics"
    },
    %{
      name: "unchecked-dec-int",
      status: :not_relevant,
      description: "Decrements int without check",
      notes: "Relies on Java primitive casting/low-level JVM semantics"
    },
    %{
      name: "unchecked-divide-int",
      status: :not_relevant,
      description: "Divides ints without check",
      notes: "Relies on Java primitive casting/low-level JVM semantics"
    },
    %{
      name: "unchecked-double",
      status: :not_relevant,
      description: "Casts to double without check",
      notes: "Relies on Java primitive casting/low-level JVM semantics"
    },
    %{
      name: "unchecked-float",
      status: :not_relevant,
      description: "Casts to float without check",
      notes: "Relies on Java primitive casting/low-level JVM semantics"
    },
    %{
      name: "unchecked-inc",
      status: :not_relevant,
      description: "Increments without overflow check",
      notes: "Relies on Java primitive casting/low-level JVM semantics"
    },
    %{
      name: "unchecked-inc-int",
      status: :not_relevant,
      description: "Increments int without check",
      notes: "Relies on Java primitive casting/low-level JVM semantics"
    },
    %{
      name: "unchecked-int",
      status: :not_relevant,
      description: "Casts to int without check",
      notes: "Relies on Java primitive casting/low-level JVM semantics"
    },
    %{
      name: "unchecked-long",
      status: :not_relevant,
      description: "Casts to long without check",
      notes: "Relies on Java primitive casting/low-level JVM semantics"
    },
    %{
      name: "unchecked-multiply",
      status: :not_relevant,
      description: "Multiplies without overflow check",
      notes: "relies on JVM-specific primitive behavior/overflow semantics"
    },
    %{
      name: "unchecked-multiply-int",
      status: :not_relevant,
      description: "Multiplies ints without check",
      notes: "relies on JVM-specific primitive behavior/overflow semantics"
    },
    %{
      name: "unchecked-negate",
      status: :not_relevant,
      description: "Negates without overflow check",
      notes: "relies on JVM-specific primitive behavior/overflow semantics"
    },
    %{
      name: "unchecked-negate-int",
      status: :not_relevant,
      description: "Negates int without check",
      notes: "relies on JVM-specific primitive behavior/overflow semantics"
    },
    %{
      name: "unchecked-remainder-int",
      status: :not_relevant,
      description: "Remainder without check",
      notes: "relies on JVM-specific primitive behavior/overflow semantics"
    },
    %{
      name: "unchecked-short",
      status: :not_relevant,
      description: "Casts to short without check",
      notes: "relies on Java type casting/interop"
    },
    %{
      name: "unchecked-subtract",
      status: :not_relevant,
      description: "Subtracts without overflow check",
      notes: "relies on JVM-specific primitive behavior/overflow semantics"
    },
    %{
      name: "unchecked-subtract-int",
      status: :not_relevant,
      description: "Subtracts ints without check",
      notes: "relies on JVM-specific primitive behavior/overflow semantics"
    },
    %{
      name: "underive",
      status: :not_relevant,
      description: "Removes hierarchical relationship",
      notes: "requires global hierarchy/multimethod infrastructure"
    },
    %{
      name: "unreduced",
      status: :candidate,
      description: "Unwraps from reduced",
      notes: "pure transformation used for handling reduced values in reductions"
    },
    %{
      name: "unsigned-bit-shift-right",
      status: :candidate,
      description: "Unsigned right shift",
      notes: "pure bitwise arithmetic operation"
    },
    %{
      name: "update",
      status: :supported,
      description: "Applies function to map value at key",
      notes: ""
    },
    %{
      name: "update-in",
      status: :supported,
      description: "Applies function to nested map value",
      notes: ""
    },
    %{
      name: "update-keys",
      status: :supported,
      description: "Applies function to map keys",
      notes: ""
    },
    %{
      name: "update-proxy",
      status: :not_relevant,
      description: "Updates proxy method implementations",
      notes: "relies on Java interop/proxy class system"
    },
    %{
      name: "update-vals",
      status: :supported,
      description: "Applies function to map values",
      notes: ""
    },
    %{name: "val", status: :supported, description: "Returns value of map entry", notes: ""},
    %{name: "vals", status: :supported, description: "Returns map values", notes: ""},
    %{
      name: "var-get",
      status: :not_relevant,
      description: "Gets value of var",
      notes: "relies on specific var/namespace system"
    },
    %{
      name: "var-set",
      status: :not_relevant,
      description: "Sets var in thread-local binding",
      notes: "relies on mutable thread-local bindings"
    },
    %{
      name: "var?",
      status: :not_relevant,
      description: "Returns true if var",
      notes: "relies on var data structure absent in PTC-Lisp"
    },
    %{
      name: "vary-meta",
      status: :not_relevant,
      description: "Returns value with transformed metadata",
      notes: "relies on metadata feature"
    },
    %{name: "vec", status: :supported, description: "Converts to vector", notes: ""},
    %{name: "vector", status: :supported, description: "Creates vector from items", notes: ""},
    %{name: "vector?", status: :supported, description: "Returns true if vector", notes: ""},
    %{
      name: "volatile!",
      status: :not_relevant,
      description: "Creates volatile with initial value",
      notes: "relies on mutable state"
    },
    %{
      name: "volatile?",
      status: :not_relevant,
      description: "Returns true if volatile",
      notes: "relies on mutable state"
    },
    %{
      name: "vreset!",
      status: :not_relevant,
      description: "Sets volatile value",
      notes: "relies on mutable state"
    },
    %{
      name: "vswap!",
      status: :not_relevant,
      description: "Updates volatile with function",
      notes: "involves mutable state (volatiles)"
    },
    %{name: "when", status: :supported, description: "Evaluates body if test true", notes: ""},
    %{
      name: "when-first",
      status: :supported,
      description: "Evaluates body if seq non-empty",
      notes: ""
    },
    %{
      name: "when-let",
      status: :supported,
      description: "Binds if truthy, evaluates body",
      notes: ""
    },
    %{
      name: "when-not",
      status: :supported,
      description: "Evaluates body if test false",
      notes: ""
    },
    %{
      name: "when-some",
      status: :supported,
      description: "Binds if not nil, evaluates body",
      notes: ""
    },
    %{
      name: "while",
      status: :not_relevant,
      description: "Repeats body while test true",
      notes: "imperative looping construct typically relying on side effects"
    },
    %{
      name: "with-bindings",
      status: :not_relevant,
      description: "Executes body with thread-local bindings",
      notes: "relies on thread-local state which is not supported in the BEAM model for PTC-Lisp"
    },
    %{
      name: "with-in-str",
      status: :not_relevant,
      description: "Evaluates body with string as input",
      notes: "relies on I/O streams"
    },
    %{
      name: "with-local-vars",
      status: :not_relevant,
      description: "Evaluates body with local var bindings",
      notes: "requires mutable local vars"
    },
    %{
      name: "with-meta",
      status: :not_relevant,
      description: "Returns value with new metadata",
      notes: "metadata is not supported"
    },
    %{
      name: "with-open",
      status: :not_relevant,
      description: "Opens resources, closes on exit",
      notes: "relies on I/O and resource management"
    },
    %{
      name: "with-out-str",
      status: :not_relevant,
      description: "Captures output to string",
      notes: "relies on capturing side-effecting I/O"
    },
    %{
      name: "with-precision",
      status: :not_relevant,
      description: "Sets decimal precision for body",
      notes:
        "relies on specific BigDecimal support and dynamic binding context not present in PTC-Lisp"
    },
    %{
      name: "with-redefs",
      status: :not_relevant,
      description: "Redefines vars for body duration",
      notes:
        "modifies global var bindings, which is not supported in a functional, immutable sandbox"
    },
    %{
      name: "xml-seq",
      status: :not_relevant,
      description: "Lazy seq of XML elements",
      notes: "relies on lazy sequences and I/O-related parsing"
    },
    %{
      name: "zero?",
      status: :supported,
      description: "Returns true if number is zero",
      notes: ""
    },
    %{
      name: "zipmap",
      status: :supported,
      description: "Creates map from keys and values seqs",
      notes: ""
    }
  ],
  clojure_string_audit: [
    %{
      name: "blank?",
      status: :candidate,
      description: "True if s is nil, empty, or contains only whitespace",
      notes: "pure string predicate"
    },
    %{
      name: "capitalize",
      status: :candidate,
      description: "Converts first character to upper-case, rest to lower-case",
      notes: "pure string transformation"
    },
    %{
      name: "ends-with?",
      status: :supported,
      description: "True if s ends with substr",
      notes: ""
    },
    %{
      name: "escape",
      status: :candidate,
      description: "Return a new string applying cmap to each character",
      notes: "pure character mapping"
    },
    %{name: "includes?", status: :supported, description: "True if s includes substr", notes: ""},
    %{
      name: "index-of",
      status: :supported,
      description: "Return index of value in string",
      notes: ""
    },
    %{
      name: "join",
      status: :supported,
      description: "Returns a string of elements joined by separator",
      notes: ""
    },
    %{
      name: "last-index-of",
      status: :supported,
      description: "Return last index of value in string",
      notes: ""
    },
    %{
      name: "lower-case",
      status: :supported,
      description: "Converts string to all lower-case",
      notes: ""
    },
    %{
      name: "re-quote-replacement",
      status: :not_relevant,
      description: "Escapes special characters in replacement string",
      notes: "Java regex-specific utility"
    },
    %{
      name: "replace",
      status: :supported,
      description: "Replaces all instances of match in s",
      notes: ""
    },
    %{
      name: "replace-first",
      status: :candidate,
      description: "Replaces first instance of match in s",
      notes: "pure string transformation"
    },
    %{
      name: "reverse",
      status: :candidate,
      description: "Returns s with characters reversed",
      notes: "pure string transformation"
    },
    %{
      name: "split",
      status: :supported,
      description: "Splits string on regex or string",
      notes: ""
    },
    %{
      name: "split-lines",
      status: :supported,
      description: "Splits string on \\n or \\r\\n",
      notes: ""
    },
    %{
      name: "starts-with?",
      status: :supported,
      description: "True if s starts with substr",
      notes: ""
    },
    %{
      name: "trim",
      status: :supported,
      description: "Removes whitespace from both ends of string",
      notes: ""
    },
    %{
      name: "trim-newline",
      status: :candidate,
      description: "Removes all trailing newline or return characters",
      notes: "pure string transformation"
    },
    %{
      name: "triml",
      status: :candidate,
      description: "Removes whitespace from the left side of string",
      notes: "pure string transformation"
    },
    %{
      name: "trimr",
      status: :candidate,
      description: "Removes whitespace from the right side of string",
      notes: "pure string transformation"
    },
    %{
      name: "upper-case",
      status: :supported,
      description: "Converts string to all upper-case",
      notes: ""
    }
  ],
  clojure_set_audit: [
    %{
      name: "difference",
      status: :supported,
      description: "Return a set that is the first set without elements of the remaining sets",
      notes: ""
    },
    %{
      name: "index",
      status: :candidate,
      description: "Returns a map of the distinct values of ks mapped to sets of maps",
      notes: "pure set/map operation"
    },
    %{
      name: "intersection",
      status: :supported,
      description: "Return a set that is the intersection of the input sets",
      notes: ""
    },
    %{
      name: "join",
      status: :candidate,
      description: "When passed 2 rels, returns the rel corresponding to the natural join",
      notes: "relational algebra operation"
    },
    %{
      name: "map-invert",
      status: :candidate,
      description: "Returns the map with vals mapped to keys",
      notes: "pure map transformation"
    },
    %{
      name: "project",
      status: :candidate,
      description: "Returns a rel of the elements of xrel with only the keys in ks",
      notes: "relational algebra operation"
    },
    %{
      name: "rename",
      status: :candidate,
      description: "Returns a rel with the keys in kmap renamed",
      notes: "relational algebra operation"
    },
    %{
      name: "rename-keys",
      status: :candidate,
      description: "Returns the map with keys renamed according to kmap",
      notes: "pure map transformation"
    },
    %{
      name: "select",
      status: :candidate,
      description: "Returns a set of the elements for which pred is true",
      notes: "pure set filtering"
    },
    %{
      name: "subset?",
      status: :candidate,
      description: "Is set1 a subset of set2?",
      notes: "pure set predicate"
    },
    %{
      name: "superset?",
      status: :candidate,
      description: "Is set1 a superset of set2?",
      notes: "pure set predicate"
    },
    %{
      name: "union",
      status: :supported,
      description: "Return a set that is the union of the input sets",
      notes: ""
    }
  ],
  java_math_audit: [
    %{name: "abs", status: :supported, description: "Returns the absolute value", notes: ""},
    %{
      name: "acos",
      status: :candidate,
      description: "Returns the arc cosine of a value",
      notes: "pure math"
    },
    %{
      name: "addExact",
      status: :not_relevant,
      description: "Returns sum, throwing on overflow",
      notes: "Java overflow semantics not applicable on BEAM"
    },
    %{
      name: "asin",
      status: :candidate,
      description: "Returns the arc sine of a value",
      notes: "pure math"
    },
    %{
      name: "atan",
      status: :candidate,
      description: "Returns the arc tangent of a value",
      notes: "pure math"
    },
    %{
      name: "atan2",
      status: :candidate,
      description: "Returns angle theta from (x,y) to polar (r,theta)",
      notes: "pure math"
    },
    %{
      name: "cbrt",
      status: :candidate,
      description: "Returns the cube root of a value",
      notes: "pure math"
    },
    %{
      name: "ceil",
      status: :supported,
      description: "Returns the smallest integer >= argument",
      notes: ""
    },
    %{
      name: "copySign",
      status: :not_relevant,
      description: "Returns first arg with sign of second arg",
      notes: "low-level IEEE 754 manipulation"
    },
    %{
      name: "cos",
      status: :candidate,
      description: "Returns the trigonometric cosine of an angle",
      notes: "pure math"
    },
    %{
      name: "cosh",
      status: :candidate,
      description: "Returns the hyperbolic cosine of a value",
      notes: "pure math"
    },
    %{
      name: "decrementExact",
      status: :not_relevant,
      description: "Returns argument decremented by one, throwing on overflow",
      notes: "Java overflow semantics not applicable on BEAM"
    },
    %{
      name: "exp",
      status: :candidate,
      description: "Returns Euler's number e raised to the power of a",
      notes: "pure math"
    },
    %{
      name: "expm1",
      status: :not_relevant,
      description: "Returns e^x - 1",
      notes: "specialized numerical precision, low demand"
    },
    %{
      name: "floor",
      status: :supported,
      description: "Returns the largest integer <= argument",
      notes: ""
    },
    %{
      name: "floorDiv",
      status: :not_relevant,
      description: "Returns floor of integer division",
      notes: "Java integer division semantics; use quot + floor"
    },
    %{
      name: "floorMod",
      status: :not_relevant,
      description: "Returns floor modulus of arguments",
      notes: "Java integer semantics; use mod"
    },
    %{
      name: "fma",
      status: :not_relevant,
      description: "Fused multiply-add",
      notes: "specialized numerical precision"
    },
    %{
      name: "getExponent",
      status: :not_relevant,
      description: "Returns unbiased exponent of a float/double",
      notes: "low-level IEEE 754 inspection"
    },
    %{
      name: "hypot",
      status: :candidate,
      description: "Returns sqrt(x^2 + y^2) without intermediate overflow",
      notes: "pure math"
    },
    %{
      name: "IEEEremainder",
      status: :not_relevant,
      description: "Returns IEEE 754 remainder",
      notes: "low-level IEEE 754 semantics; use rem/mod"
    },
    %{
      name: "incrementExact",
      status: :not_relevant,
      description: "Returns argument incremented by one, throwing on overflow",
      notes: "Java overflow semantics not applicable on BEAM"
    },
    %{
      name: "log",
      status: :candidate,
      description: "Returns the natural logarithm (base e) of a value",
      notes: "pure math"
    },
    %{
      name: "log10",
      status: :candidate,
      description: "Returns the base 10 logarithm of a value",
      notes: "pure math"
    },
    %{
      name: "log1p",
      status: :not_relevant,
      description: "Returns ln(1 + x)",
      notes: "specialized numerical precision, low demand"
    },
    %{
      name: "max",
      status: :supported,
      description: "Returns the greater of two values",
      notes: ""
    },
    %{
      name: "min",
      status: :supported,
      description: "Returns the smaller of two values",
      notes: ""
    },
    %{
      name: "multiplyExact",
      status: :not_relevant,
      description: "Returns product, throwing on overflow",
      notes: "Java overflow semantics not applicable on BEAM"
    },
    %{
      name: "multiplyHigh",
      status: :not_relevant,
      description: "Returns high 64 bits of 128-bit product",
      notes: "low-level 64-bit arithmetic"
    },
    %{
      name: "negateExact",
      status: :not_relevant,
      description: "Returns negation, throwing on overflow",
      notes: "Java overflow semantics not applicable on BEAM"
    },
    %{
      name: "nextAfter",
      status: :not_relevant,
      description: "Returns adjacent floating-point value",
      notes: "low-level IEEE 754 manipulation"
    },
    %{
      name: "nextDown",
      status: :not_relevant,
      description: "Returns adjacent floating-point value towards negative infinity",
      notes: "low-level IEEE 754 manipulation"
    },
    %{
      name: "nextUp",
      status: :not_relevant,
      description: "Returns adjacent floating-point value towards positive infinity",
      notes: "low-level IEEE 754 manipulation"
    },
    %{
      name: "pow",
      status: :supported,
      description: "Returns the value of a raised to the power of b",
      notes: ""
    },
    %{
      name: "random",
      status: :candidate,
      description: "Returns a pseudorandom double between 0.0 and 1.0",
      notes: "pure (non-deterministic but side-effect free)"
    },
    %{
      name: "rint",
      status: :not_relevant,
      description: "Returns closest double to argument that is a mathematical integer",
      notes: "use round instead"
    },
    %{
      name: "round",
      status: :supported,
      description: "Returns the closest long/int to the argument",
      notes: ""
    },
    %{
      name: "scalb",
      status: :not_relevant,
      description: "Returns d × 2^scaleFactor",
      notes: "low-level IEEE 754 manipulation"
    },
    %{
      name: "signum",
      status: :candidate,
      description: "Returns the signum function of the argument",
      notes: "pure math"
    },
    %{
      name: "sin",
      status: :candidate,
      description: "Returns the trigonometric sine of an angle",
      notes: "pure math"
    },
    %{
      name: "sinh",
      status: :candidate,
      description: "Returns the hyperbolic sine of a value",
      notes: "pure math"
    },
    %{
      name: "sqrt",
      status: :supported,
      description: "Returns the positive square root of a value",
      notes: ""
    },
    %{
      name: "subtractExact",
      status: :not_relevant,
      description: "Returns difference, throwing on overflow",
      notes: "Java overflow semantics not applicable on BEAM"
    },
    %{
      name: "tan",
      status: :candidate,
      description: "Returns the trigonometric tangent of an angle",
      notes: "pure math"
    },
    %{
      name: "tanh",
      status: :candidate,
      description: "Returns the hyperbolic tangent of a value",
      notes: "pure math"
    },
    %{
      name: "toDegrees",
      status: :candidate,
      description: "Converts an angle from radians to degrees",
      notes: "pure math"
    },
    %{
      name: "toIntExact",
      status: :not_relevant,
      description: "Returns long narrowed to int, throwing on overflow",
      notes: "Java type narrowing not applicable on BEAM"
    },
    %{
      name: "toRadians",
      status: :candidate,
      description: "Converts an angle from degrees to radians",
      notes: "pure math"
    },
    %{
      name: "ulp",
      status: :not_relevant,
      description: "Returns size of an ulp of the argument",
      notes: "low-level IEEE 754 inspection"
    }
  ],
  java_interop: [
    %{
      name: "java.util.Date.",
      class: "java.util.Date",
      kind: :constructor,
      description: "Construct current UTC time or from timestamp/ISO-8601/RFC-2822 string",
      signatures: ["(java.util.Date.)", "(java.util.Date. timestamp-or-string)"],
      notes:
        "Returns Elixir DateTime. Accepts integer (seconds or ms auto-detected), ISO-8601, RFC 2822."
    },
    %{
      name: ".getTime",
      class: "java.util.Date",
      kind: :method,
      description: "Return Unix timestamp in milliseconds from DateTime",
      signatures: ["(.getTime date)"],
      notes: ""
    },
    %{
      name: ".isBefore",
      class: "java.time.LocalDate / java.util.Date",
      kind: :method,
      description: "Returns true if receiver comes strictly before argument (same-type only)",
      signatures: ["(.isBefore a b)"],
      notes: "Works on both LocalDate and DateTime. Mixed types raise an error."
    },
    %{
      name: ".isAfter",
      class: "java.time.LocalDate / java.util.Date",
      kind: :method,
      description: "Returns true if receiver comes strictly after argument (same-type only)",
      signatures: ["(.isAfter a b)"],
      notes: "Works on both LocalDate and DateTime. Mixed types raise an error."
    },
    %{
      name: "LocalDate/parse",
      class: "java.time.LocalDate",
      kind: :static,
      description: "Parse ISO-8601 date string (YYYY-MM-DD) to Date",
      signatures: ["(LocalDate/parse date-string)"],
      notes: "Returns Elixir Date. Only supports ISO-8601 YYYY-MM-DD format."
    },
    %{
      name: "System/currentTimeMillis",
      class: "java.lang.System",
      kind: :static,
      description: "Return current time in milliseconds since Unix epoch",
      signatures: ["(System/currentTimeMillis)", "(currentTimeMillis)"],
      notes: ""
    },
    %{
      name: "Double/POSITIVE_INFINITY",
      class: "java.lang.Double",
      kind: :constant,
      description: "Positive infinity constant (##Inf)",
      signatures: ["Double/POSITIVE_INFINITY", "POSITIVE_INFINITY"],
      notes: ""
    },
    %{
      name: "Double/NEGATIVE_INFINITY",
      class: "java.lang.Double",
      kind: :constant,
      description: "Negative infinity constant (##-Inf)",
      signatures: ["Double/NEGATIVE_INFINITY", "NEGATIVE_INFINITY"],
      notes: ""
    },
    %{
      name: "Double/NaN",
      class: "java.lang.Double",
      kind: :constant,
      description: "Not-a-Number constant (##NaN)",
      signatures: ["Double/NaN", "NaN"],
      notes: ""
    },
    %{
      name: ".contains",
      class: "java.lang.String",
      kind: :method,
      description: "Returns true if string contains substring",
      signatures: ["(.contains s substr)"],
      notes: ""
    },
    %{
      name: ".indexOf",
      class: "java.lang.String",
      kind: :method,
      description: "Index of first occurrence of substring, or -1 if not found",
      signatures: ["(.indexOf s substr)", "(.indexOf s substr from-index)"],
      notes: "Uses grapheme indices (not byte offsets)."
    },
    %{
      name: ".lastIndexOf",
      class: "java.lang.String",
      kind: :method,
      description: "Index of last occurrence of substring, or -1 if not found",
      signatures: ["(.lastIndexOf s substr)"],
      notes: "Uses grapheme indices (not byte offsets)."
    },
    %{
      name: ".toLowerCase",
      class: "java.lang.String",
      kind: :method,
      description: "Convert string to lower case",
      signatures: ["(.toLowerCase s)"],
      notes: ""
    },
    %{
      name: ".toUpperCase",
      class: "java.lang.String",
      kind: :method,
      description: "Convert string to upper case",
      signatures: ["(.toUpperCase s)"],
      notes: ""
    }
  ]
}