nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-25 16:24:46 +00:00
Code Issues Packages Projects Releases Wiki Activity
75661c535f
rust/tests/rustdoc-js-std/parser-hof.js

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

695 lines
19 KiB
JavaScript
Raw Normal View History

rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
const PARSED = [
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
// ML-style HOF
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
{
query: "(-> F<P>)",
elems: [{
name: "->",
fullPath: ["->"],
pathWithoutLast: [],
pathLast: "->",
generics: [],
bindings: [
[
"output",
[{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "F",
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
fullPath: ["f"],
pathWithoutLast: [],
pathLast: "f",
generics: [
{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "P",
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
fullPath: ["p"],
pathWithoutLast: [],
pathLast: "p",
generics: [],
},
],
typeFilter: -1,
}],
],
],
typeFilter: -1,
}],
foundElems: 1,
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
userQuery: "(-> F<P>)",
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
returned: [],
error: null,
},
{
query: "(-> P)",
elems: [{
name: "->",
fullPath: ["->"],
pathWithoutLast: [],
pathLast: "->",
generics: [],
bindings: [
[
"output",
[{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "P",
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
fullPath: ["p"],
pathWithoutLast: [],
pathLast: "p",
generics: [],
typeFilter: -1,
}],
],
],
typeFilter: -1,
}],
foundElems: 1,
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
userQuery: "(-> P)",
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
returned: [],
error: null,
},
{
query: "(->,a)",
elems: [{
name: "->",
fullPath: ["->"],
pathWithoutLast: [],
pathLast: "->",
generics: [],
bindings: [
[
"output",
[{
name: "a",
fullPath: ["a"],
pathWithoutLast: [],
pathLast: "a",
generics: [],
typeFilter: -1,
}],
],
],
typeFilter: -1,
}],
foundElems: 1,
userQuery: "(->,a)",
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
returned: [],
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
error: null,
},
{
query: "(F<P> ->)",
elems: [{
name: "->",
fullPath: ["->"],
pathWithoutLast: [],
pathLast: "->",
generics: [{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "F",
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
fullPath: ["f"],
pathWithoutLast: [],
pathLast: "f",
generics: [
{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "P",
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
fullPath: ["p"],
pathWithoutLast: [],
pathLast: "p",
generics: [],
},
],
typeFilter: -1,
}],
bindings: [
[
"output",
[],
],
],
typeFilter: -1,
}],
foundElems: 1,
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
userQuery: "(F<P> ->)",
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
returned: [],
error: null,
},
{
query: "(P ->)",
elems: [{
name: "->",
fullPath: ["->"],
pathWithoutLast: [],
pathLast: "->",
generics: [{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "P",
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
fullPath: ["p"],
pathWithoutLast: [],
pathLast: "p",
generics: [],
typeFilter: -1,
}],
bindings: [
[
"output",
[],
],
],
typeFilter: -1,
}],
foundElems: 1,
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
userQuery: "(P ->)",
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
returned: [],
error: null,
},
{
query: "(,a->)",
elems: [{
name: "->",
fullPath: ["->"],
pathWithoutLast: [],
pathLast: "->",
generics: [{
name: "a",
fullPath: ["a"],
pathWithoutLast: [],
pathLast: "a",
generics: [],
typeFilter: -1,
}],
bindings: [
[
"output",
[],
],
],
typeFilter: -1,
}],
foundElems: 1,
userQuery: "(,a->)",
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
returned: [],
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
error: null,
},
{
query: "(aaaaa->a)",
elems: [{
name: "->",
fullPath: ["->"],
pathWithoutLast: [],
pathLast: "->",
generics: [{
name: "aaaaa",
fullPath: ["aaaaa"],
pathWithoutLast: [],
pathLast: "aaaaa",
generics: [],
typeFilter: -1,
}],
bindings: [
[
"output",
[{
name: "a",
fullPath: ["a"],
pathWithoutLast: [],
pathLast: "a",
generics: [],
typeFilter: -1,
}],
],
],
typeFilter: -1,
}],
foundElems: 1,
userQuery: "(aaaaa->a)",
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
returned: [],
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
error: null,
},
{
query: "(aaaaa, b -> a)",
elems: [{
name: "->",
fullPath: ["->"],
pathWithoutLast: [],
pathLast: "->",
generics: [
{
name: "aaaaa",
fullPath: ["aaaaa"],
pathWithoutLast: [],
pathLast: "aaaaa",
generics: [],
typeFilter: -1,
},
{
name: "b",
fullPath: ["b"],
pathWithoutLast: [],
pathLast: "b",
generics: [],
typeFilter: -1,
},
],
bindings: [
[
"output",
[{
name: "a",
fullPath: ["a"],
pathWithoutLast: [],
pathLast: "a",
generics: [],
typeFilter: -1,
}],
],
],
typeFilter: -1,
}],
foundElems: 1,
userQuery: "(aaaaa, b -> a)",
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
returned: [],
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
error: null,
},
{
query: "primitive:(aaaaa, b -> a)",
elems: [{
name: "->",
fullPath: ["->"],
pathWithoutLast: [],
pathLast: "->",
generics: [
{
name: "aaaaa",
fullPath: ["aaaaa"],
pathWithoutLast: [],
pathLast: "aaaaa",
generics: [],
typeFilter: -1,
},
{
name: "b",
fullPath: ["b"],
pathWithoutLast: [],
pathLast: "b",
generics: [],
typeFilter: -1,
},
],
bindings: [
[
"output",
[{
name: "a",
fullPath: ["a"],
pathWithoutLast: [],
pathLast: "a",
generics: [],
typeFilter: -1,
}],
],
],
typeFilter: 1,
}],
foundElems: 1,
userQuery: "primitive:(aaaaa, b -> a)",
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
returned: [],
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
error: null,
},
{
query: "x, trait:(aaaaa, b -> a)",
elems: [
{
name: "x",
fullPath: ["x"],
pathWithoutLast: [],
pathLast: "x",
generics: [],
typeFilter: -1,
},
{
name: "->",
fullPath: ["->"],
pathWithoutLast: [],
pathLast: "->",
generics: [
{
name: "aaaaa",
fullPath: ["aaaaa"],
pathWithoutLast: [],
pathLast: "aaaaa",
generics: [],
typeFilter: -1,
},
{
name: "b",
fullPath: ["b"],
pathWithoutLast: [],
pathLast: "b",
generics: [],
typeFilter: -1,
},
],
bindings: [
[
"output",
[{
name: "a",
fullPath: ["a"],
pathWithoutLast: [],
pathLast: "a",
generics: [],
typeFilter: -1,
}],
],
],
typeFilter: 10,
}
],
foundElems: 2,
userQuery: "x, trait:(aaaaa, b -> a)",
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
returned: [],
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
error: null,
},
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
// Rust-style HOF
{
query: "Fn () -> F<P>",
elems: [{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "Fn",
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
fullPath: ["fn"],
pathWithoutLast: [],
pathLast: "fn",
generics: [],
bindings: [
[
"output",
[{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "F",
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
fullPath: ["f"],
pathWithoutLast: [],
pathLast: "f",
generics: [
{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "P",
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
fullPath: ["p"],
pathWithoutLast: [],
pathLast: "p",
generics: [],
},
],
typeFilter: -1,
}],
],
],
typeFilter: -1,
}],
foundElems: 1,
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
userQuery: "Fn () -> F<P>",
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
returned: [],
error: null,
},
{
query: "FnMut() -> P",
elems: [{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "FnMut",
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
fullPath: ["fnmut"],
pathWithoutLast: [],
pathLast: "fnmut",
generics: [],
bindings: [
[
"output",
[{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "P",
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
fullPath: ["p"],
pathWithoutLast: [],
pathLast: "p",
generics: [],
typeFilter: -1,
}],
],
],
typeFilter: -1,
}],
foundElems: 1,
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
userQuery: "FnMut() -> P",
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
returned: [],
error: null,
},
{
query: "(FnMut() -> P)",
elems: [{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "FnMut",
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
fullPath: ["fnmut"],
pathWithoutLast: [],
pathLast: "fnmut",
generics: [],
bindings: [
[
"output",
[{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "P",
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
fullPath: ["p"],
pathWithoutLast: [],
pathLast: "p",
generics: [],
typeFilter: -1,
}],
],
],
typeFilter: -1,
}],
foundElems: 1,
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
userQuery: "(FnMut() -> P)",
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
returned: [],
error: null,
},
{
query: "Fn(F<P>)",
elems: [{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "Fn",
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
fullPath: ["fn"],
pathWithoutLast: [],
pathLast: "fn",
generics: [{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "F",
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
fullPath: ["f"],
pathWithoutLast: [],
pathLast: "f",
generics: [
{
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
name: "P",
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
fullPath: ["p"],
pathWithoutLast: [],
pathLast: "p",
generics: [],
},
],
typeFilter: -1,
}],
bindings: [
[
"output",
[],
],
],
typeFilter: -1,
}],
foundElems: 1,
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
userQuery: "Fn(F<P>)",
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
returned: [],
error: null,
},
{
query: "primitive:fnonce(aaaaa, b) -> a",
elems: [{
name: "fnonce",
fullPath: ["fnonce"],
pathWithoutLast: [],
pathLast: "fnonce",
generics: [
{
name: "aaaaa",
fullPath: ["aaaaa"],
pathWithoutLast: [],
pathLast: "aaaaa",
generics: [],
typeFilter: -1,
},
{
name: "b",
fullPath: ["b"],
pathWithoutLast: [],
pathLast: "b",
generics: [],
typeFilter: -1,
},
],
bindings: [
[
"output",
[{
name: "a",
fullPath: ["a"],
pathWithoutLast: [],
pathLast: "a",
generics: [],
typeFilter: -1,
}],
],
],
typeFilter: 1,
}],
foundElems: 1,
userQuery: "primitive:fnonce(aaaaa, b) -> a",
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
returned: [],
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
error: null,
},
{
query: "primitive:fnonce(aaaaa, keyword:b) -> trait:a",
elems: [{
name: "fnonce",
fullPath: ["fnonce"],
pathWithoutLast: [],
pathLast: "fnonce",
generics: [
{
name: "aaaaa",
fullPath: ["aaaaa"],
pathWithoutLast: [],
pathLast: "aaaaa",
generics: [],
typeFilter: -1,
},
{
name: "b",
fullPath: ["b"],
pathWithoutLast: [],
pathLast: "b",
generics: [],
typeFilter: 0,
},
],
bindings: [
[
"output",
[{
name: "a",
fullPath: ["a"],
pathWithoutLast: [],
pathLast: "a",
generics: [],
typeFilter: 10,
}],
],
],
typeFilter: 1,
}],
foundElems: 1,
userQuery: "primitive:fnonce(aaaaa, keyword:b) -> trait:a",
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
returned: [],
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
error: null,
},
{
query: "x, trait:fn(aaaaa, b -> a)",
elems: [
{
name: "x",
fullPath: ["x"],
pathWithoutLast: [],
pathLast: "x",
generics: [],
typeFilter: -1,
},
{
name: "fn",
fullPath: ["fn"],
pathWithoutLast: [],
pathLast: "fn",
generics: [
{
name: "->",
fullPath: ["->"],
pathWithoutLast: [],
pathLast: "->",
generics: [
{
name: "aaaaa",
fullPath: ["aaaaa"],
pathWithoutLast: [],
pathLast: "aaaaa",
generics: [],
typeFilter: -1,
},
{
name: "b",
fullPath: ["b"],
pathWithoutLast: [],
pathLast: "b",
generics: [],
typeFilter: -1,
},
],
bindings: [
[
"output",
[{
name: "a",
fullPath: ["a"],
pathWithoutLast: [],
pathLast: "a",
generics: [],
typeFilter: -1,
}],
],
],
typeFilter: -1,
},
],
bindings: [
[
"output",
[],
]
],
typeFilter: 10,
}
],
foundElems: 2,
userQuery: "x, trait:fn(aaaaa, b -> a)",
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
returned: [],
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
error: null,
},
{
query: 'a,b(c)',
elems: [
{
name: "a",
fullPath: ["a"],
pathWithoutLast: [],
pathLast: "a",
generics: [],
typeFilter: -1,
},
{
name: "b",
fullPath: ["b"],
pathWithoutLast: [],
pathLast: "b",
generics: [{
name: "c",
fullPath: ["c"],
pathWithoutLast: [],
pathLast: "c",
generics: [],
typeFilter: -1,
}],
bindings: [
[
"output",
[],
]
],
typeFilter: -1,
}
],
foundElems: 2,
userQuery: "a,b(c)",
rustdoc-search: pass original names through AST
2024-09-24 19:33:09 +00:00
returned: [],
rustdoc-search: add search query syntax `Fn(T) -> U` This is implemented, in addition to the ML-style one, because Rust does it. If we don't, we'll never hear the end of it. This commit also refactors some duplicate parts of the parser into a dedicated function.
2024-01-06 23:01:10 +00:00
error: null,
},
rustdoc-search: parse and search with ML-style HOF Option::map, for example, looks like this: option<t>, (t -> u) -> option<u> This syntax searches all of the HOFs in Rust: traits Fn, FnOnce, and FnMut, and bare fn primitives.
2024-01-06 20:17:51 +00:00
];
Reference in New Issue Copy Permalink