Téléchargement du code source FSharpApiSearch - FSharpApiSearch Téléchargement du code source

FSharpApiSearch

Le moteur de recherche de l'API F# est un moteur de recherche qui vous permet de rechercher des API F# par signature ou par nom.

Liste des projets

nom du projet	aperçu
FSharpApiSearch	Corps du moteur de recherche
FSharpApiSearch.Base de données	Outil de création de base de données de moteur de recherche
FSharpApiSearch.Console	Front-end du moteur de recherche (application console)

Comment installer

Téléchargez le fichier zip depuis la page de version et extrayez-le.

Comment utiliser

Tout d’abord, exécutez FSharpApiSearch.Database.exe pour créer une base de données.

 FSharpApiSearch.Database.exe

Les assemblys qui peuvent être recherchés par défaut sont FSharp.Core , mscorlib , System et System.Core . Vous pouvez ajouter des cibles de recherche en spécifiant un assembly lors de la création d'une base de données. Vous pouvez spécifier le répertoire dans lequel rechercher les assemblys avec l'option --lib . Veuillez également préciser les assemblys dont dépend l'assembly spécifié.

 FSharpApiSearch.Database.exe --lib:TargetAssemblyDirectory TargetAssembly1 TargetAssembly2 DependentAssembly

Si vous exécutez FSharpApiSearch.Console.exe sans lui envoyer de requête, il démarrera en mode interactif. Tapez #q pour quitter le mode interactif.

 FSharpApiSearch.Console.exe

Si vous passez une requête en argument, la recherche ne sera effectuée qu'une seule fois.

 FSharpApiSearch.Console.exe "int -> int"

Utilisez --target pour utiliser réellement la base de données créée pour la recherche.

 FSharpApiSearch.Console.exe --target:TargetAssembly1 --target:TargetAssembly2

Si vous utilisez --target , les FSharp.Core , mscorlib , System et System.Core par défaut ne seront pas inclus dans la cible de recherche, donc si vous souhaitez les inclure dans la cible de recherche, spécifiez-les explicitement.

 FSharpApiSearch.Console.exe --target:TargetAssembly1 --target:TargetAssembly2 --target:FSharp.Core --target:mscorlib --target:System --target:System.Core

Options de recherche

option `respect-name-difference`

Si respect-name-difference est activée, la recherche respecte les différences dans les noms des différents types de variables et les caractères génériques nommés dans la requête. Différents noms ne correspondent pas au même type. Par exemple, la requête ?a -> ?a correspond à la signature int -> int , mais la requête ?a -> ?b ne correspond pas int -> int .

Si cette option est désactivée, la requête ?a -> ?b correspondra int -> int .

option `greedy-matching`

Si l'option greedy-matching est activée, les variables de type et les autres types seront mis en correspondance individuellement, et les résultats seront triés et affichés par ordre décroissant de correspondance. De plus, les contraintes de type sont désormais prises en compte dans les recherches.

option `ignore-param-style`

Il existe deux types de formats d'arguments pour les fonctions et les méthodes : le format curry ( arg1 -> arg2 -> returnType ) et le format tuple ( arg1 * arg2 -> returnType ). Si ignore-param-style est activée, la correspondance ignore les formats curry et tuple.

option `ignore-case`

Si l'option ignore-case est activée, la casse est ignorée lors de la correspondance des noms d'API et des noms de type.

option `substring`

Si substring est activée, recherche par sous-chaîne.

option `swap-order`

Si swap-order est activée, la recherche permutera l'ordre des arguments et des tuples. Par exemple, la requête a -> b -> c correspond à b -> a -> c .

option `complement`

Si complement est activée, complète et recherche les arguments manquants et les éléments de tuple. Par exemple, la requête a * c correspond a * b * c .

option `single-letter-as-variable`

Si single-letter-as-variable est activée, les noms de types à une seule lettre sont traités comme des noms de variables de type. Par exemple, la requête t list est la même que 't list .

choix `language`

Bascule les requêtes, les recherches et l'affichage des résultats vers le langage de programmation spécifié par language . Cette option accepte F# et C#.

options `xmldoc`

Si xmldoc est activée, affiche les documents XML dans les résultats de recherche.

Spécification de requête F#

Les requêtes F# sont fondamentalement les mêmes que les signatures F#. Seule l'extension de FSharpApiSearch sera expliquée en détail.

> est l'invite lorsque vous démarrez FSharpApiSearch.Console.exe en mode interactif.

API consultable

API	Exemple de requête
Fonctions et valeurs du module	`int -> string`
enregistrement, champ de structure	`Ref<'a> -> 'a`
syndicat discriminé	`'a -> Option<'a>`
membre	`'a list -> int`
constructeur	`Uri : _` `Uri.new : _` `Uri..ctor : _`
Nom (nom de la fonction, nom du membre, etc.)	`head : 'a list -> 'a` `head`
modèle actif	`(\|\|) : ... -> Expr -> ?`
Types, abréviations de types, modules	`List<'T>`
expression de calcul	`{ let! } : Async<'T>`
Recherche de sous-type	`#seq<'a> -> 'a`

recherche de nom

Pour rechercher par nom, écrivez name : signature ou name . Si vous ne spécifiez pas de signature, spécifiez _ dans la partie signature.

 > id : 'a -> 'a
Microsoft.FSharp.Core.Operators.id: 'T -> 'T, module value, FSharp.Core

> choose
Microsoft.FSharp.Collections.Array.Parallel.choose: ('T -> option<'U>) -> 'T[] -> 'U[], module value, FSharp.Core
Microsoft.FSharp.Collections.Array.choose: ('T -> option<'U>) -> 'T[] -> 'U[], module value, FSharp.Core
Microsoft.FSharp.Collections.List.choose: ('T -> option<'U>) -> list<'T> -> list<'U>, module value, FSharp.Core
Microsoft.FSharp.Collections.Seq.choose: ('T -> option<'U>) -> seq<'T> -> seq<'U>, module value, FSharp.Core
Microsoft.FSharp.Control.Event.choose: ('T -> option<'U>) -> IEvent<'Del, 'T> -> IEvent<'U>, module value, FSharp.Core
  when 'Del : delegate and 'Del :> Delegate
Microsoft.FSharp.Control.Observable.choose: ('T -> option<'U>) -> IObservable<'T> -> IObservable<'U>, module value, FSharp.Core

> choose : _
Microsoft.FSharp.Collections.Array.Parallel.choose: ('T -> option<'U>) -> 'T[] -> 'U[], module value, FSharp.Core
Microsoft.FSharp.Collections.Array.choose: ('T -> option<'U>) -> 'T[] -> 'U[], module value, FSharp.Core
Microsoft.FSharp.Collections.List.choose: ('T -> option<'U>) -> list<'T> -> list<'U>, module value, FSharp.Core
Microsoft.FSharp.Collections.Seq.choose: ('T -> option<'U>) -> seq<'T> -> seq<'U>, module value, FSharp.Core
Microsoft.FSharp.Control.Event.choose: ('T -> option<'U>) -> IEvent<'Del, 'T> -> IEvent<'U>, module value, FSharp.Core
  when 'Del : delegate and 'Del :> Delegate
Microsoft.FSharp.Control.Observable.choose: ('T -> option<'U>) -> IObservable<'T> -> IObservable<'U>, module value, FSharp.Core

Utilisez l'astérisque ( * ) pour rechercher des correspondances partielles. Par exemple, FSharp.Core.String.* : _ affiche toutes les API du module FSharp.Core.String .

 > FSharp.Core.String.* : _
Microsoft.FSharp.Core.String.collect: (char -> string) -> string -> string, module value, FSharp.Core
Microsoft.FSharp.Core.String.concat: string -> seq<string> -> string, module value, FSharp.Core
Microsoft.FSharp.Core.String.exists: (char -> bool) -> string -> bool, module value, FSharp.Core
Microsoft.FSharp.Core.String.filter: (char -> bool) -> string -> string, module value, FSharp.Core
...

joker

Normalement, les variables de type telles que 'a et les noms de types tels que int ne correspondent pas. Cependant, vous souhaiterez peut-être rechercher les deux cas à la fois. Dans de tels cas, vous pouvez utiliser le caractère générique ? ou _ .

 > ? -> list<?> -> ?
Microsoft.FSharp.Collections.List.append: list<'T> -> list<'T> -> list<'T>, module value, FSharp.Core
Microsoft.FSharp.Collections.List.averageBy: ('T -> 'U) -> list<'T> -> 'U, module value, FSharp.Core
  when 'U : (static member op_Addition : 'U * 'U -> 'U) and 'U : (static member DivideByInt : 'U * int -> 'U) and 'U : (static member get_Zero : unit -> 'U)
Microsoft.FSharp.Collections.List.choose: ('T -> option<'U>) -> list<'T> -> list<'U>, module value, FSharp.Core
Microsoft.FSharp.Collections.List.chunkBySize: int -> list<'T> -> list<list<'T>>, module value, FSharp.Core
...

De plus, en nommant les caractères génériques, vous pouvez ajouter une condition selon laquelle le même nom de type apparaîtra dans les positions des caractères génériques portant le même nom. Par exemple, ? -> ? correspond à toutes les fonctions suivantes :

'a -> 'a
int -> int
'a -> int
int -> string

Cependant, si vous le nommez comme ?a -> ?a , l'exemple ci-dessus ne correspondra pas à 'a -> int ou int -> string .

Recherche de sous-type

Une recherche de sous-type est une contrainte qui spécifie les types compatibles avec un type de base ou une interface spécifié.

Pour utiliser la recherche de sous-type dans une requête, écrivez #type . Vous pouvez spécifier le nom du type et le nom de l'interface dans type . Les paramètres de type et les caractères génériques ne peuvent pas être spécifiés dans le nom du type.

Par exemple, ? -> #seq<'T> peut rechercher des fonctions qui héritent de seq<'T> renvoyer des types tels que List<'T> , IList<'T> et 'T[] .

Recherche de membres

membre de l'instance

Pour rechercher des membres d'instance, écrivez receiver -> signature .

Lors de la recherche d'une méthode, écrivez receiver -> arg -> returnType .

Pour rechercher des méthodes multi-arguments, écrivez receiver -> arg1 -> arg2 -> returnType ou receiver -> arg1 * arg2 -> returnType . Normalement, les arguments de la méthode sont recherchés au format tuple ( arg1 * arg2 ) et au format curry ( arg1 -> arg2 ) sans faire de distinction entre eux. Si vous souhaitez effectuer une recherche par format d'argument, désactivez ignore-param-style .

Pour rechercher une propriété, écrivez receiver -> propertyType . Les propriétés indexées sont écrites sous la forme receiver -> index -> propertyType .

membre statique

Les membres statiques peuvent être recherchés avec les mêmes requêtes que les valeurs et les fonctions dans les modules. Les méthodes multi-arguments sont écrites comme des méthodes d'instance arg1 -> arg2 -> returnType ou arg1 * arg2 -> returnType .

modèle actif

Pour rechercher un modèle actif, écrivez (||) : (args ->) inputType -> returnType . Pour rechercher un modèle partiellement actif, écrivez (|_|) : (args ->) inputType -> returnType .

Dans inputType , spécifiez le type géré par le modèle actif. Par exemple, si vous souhaitez rechercher des modèles actifs pour Expr écrivez (||) : ... -> Expr -> ?

Spécifiez les arguments du modèle actif dans args . Si vous souhaitez rechercher des modèles actifs avec des arguments, écrivez (||) : arg1 -> arg2 -> inputType -> returnType . Si vous souhaitez rechercher des modèles actifs sans arguments, écrivez (||) : inputType -> returnType . Si vous souhaitez effectuer une recherche sans faire la distinction entre la présence ou l'absence d'arguments, utilisez le mot-clé ... dans la partie argument et écrivez (||) : ... -> inputType -> returnType .

La partie retyrnType spécifie le type renvoyé par la fonction, qui est le modèle actif réel. La valeur de retour de la fonction de modèle actif est différente pour les modèles simples, multiples et partiellement actifs. Veuillez spécifier tout type correspondant, option<_> , Choice<_,...,_> . Il est généralement recommandé d'utiliser des caractères génériques ( ? ).

expression de calcul

Pour rechercher une expression de calcul, écrivez { syntax } : type . Recherche un générateur capable de gérer la syntaxe et le type spécifiés.

syntax peut inclure let! yield , yield! , return , return! use! use , if/then , for , while , try/with , try/finally et tout nom d'opération personnalisée. Si vous souhaitez spécifier plusieurs syntax , séparez-les par ; et écrivez { s1; s2 } : type

Spécification de requête C#

Les requêtes C# ont une syntaxe différente de celle des signatures C#.

API consultable

API	Exemple de requête
membre	`object -> () -> string` `string -> int`
constructeur	`Uri : _` `Uri..ctor : _`
paramètre de type	`List<T> -> int` `Dictionary<tkey, tvalue>` `<TKey, TValue> : Dictionary<TKey, TValue>`
Nom (nom du membre, etc.)	`Length : string -> int` `Length`
moule	`List`
Recherche de sous-type	`<T> : #IEnumerable<T> -> T`

recherche de nom

Pour rechercher un membre ou saisir par nom, écrivez name : signature ou name . Si vous ne spécifiez pas de signature, spécifiez _ dans la partie signature.

 > Length : string -> int
System.String.Length : int, instance property with get, mscorlib

> Length
int Array.Length { get; }, instance property, mscorlib
int BitArray.Length { get; set; }, instance property, mscorlib
long BufferedStream.Length { get; }, instance property, mscorlib
long FileInfo.Length { get; }, instance property, mscorlib
...

> Length : _
int Array.Length { get; }, instance property, mscorlib
int BitArray.Length { get; set; }, instance property, mscorlib
long BufferedStream.Length { get; }, instance property, mscorlib
long FileInfo.Length { get; }, instance property, mscorlib
...

Utilisez l'astérisque ( * ) pour rechercher des correspondances partielles. Par exemple, System.String.* : _ affiche toutes les API de type System.String .

 > System.String.* : _
System.Array.Length : int, instance property with get, mscorlib
System.Collections.BitArray.Length : int, instance property with get set, mscorlib
System.ComponentModel.DataObjectFieldAttribute.Length : int, instance property with get, System
System.ComponentModel.MaskedTextProvider.Length : int, instance property with get, System
...

paramètre de type

Il existe trois types de descriptions de paramètres de type :

format	exemple	paramètre de type	remarques
`<t> : signature`	`<TKey, TValue> : Dictionary<TKey, TValue>`	`TKey` , `TValue`	Les lettres majuscules peuvent être utilisées dans les paramètres de type sous une forme verbeuse
tout en minuscules	`Dictionary<tkey, tvalue>`	`tkey` , `tvalue`	Si toutes les lettres sont en minuscules, vous pouvez omettre la partie `<T>` .
un personnage	`List<T> -> int`	`T`	S'il s'agit d'un seul caractère, la partie `<T>` peut être omise.

Cependant, même s'ils sont tous en minuscules, les types intégrés tels que int et string ne sont pas traités comme des paramètres de type.

Le nom du paramètre de type dans la requête ne doit pas nécessairement correspondre au nom du paramètre de type recherché. Par exemple, la requête List<A> correspond au type System.Collections.Generics.List<T> .

joker

Normalement, les paramètres de type tels que T et les noms de types tels que int ne correspondent pas. Cependant, vous souhaiterez peut-être rechercher les deux cas à la fois. Dans de tels cas, vous pouvez utiliser ? .

 > <T> : List<T> -> ? -> int
System.Collections.Generic.List<T>.BinarySearch(T item) : int, instance method, mscorlib
System.Collections.Generic.List<T>.FindIndex(Predicate<T> match) : int, instance method, mscorlib
System.Collections.Generic.List<T>.FindLastIndex(Predicate<T> match) : int, instance method, mscorlib
System.Collections.Generic.List<T>.IndexOf(T item) : int, instance method, mscorlib
...

static T F1<T>(T x)
static int F2 (int x)
static T F3<T>(int x)
static int F4 (string x)

Cependant, si vous le nommez comme ?a -> ?a , l'exemple ci-dessus ne correspondra pas à F2 ou F4 .

Recherche de sous-type

Une recherche de sous-type est une contrainte qui spécifie les types compatibles avec un type de base ou une interface spécifié.

Par exemple, <T> : ? -> #IEnumerable<T> peut rechercher des méthodes qui héritent de IEnumerable<T> et renvoyer des types tels que List<T> , IList<T> et T[] .

Recherche de membres

membre de l'instance

Pour rechercher une méthode, écrivez receiver -> (arg) -> returnType . Les méthodes multi-arguments sont écrites sous la forme receiver -> (arg1, arg2) -> returnType . Les parenthèses dans la partie argument peuvent être omises. Si vous souhaitez rechercher des API sans arguments ni valeurs de retour, utilisez () et void .

 > <T> : List<T> -> T -> int
System.Collections.Generic.List<T>.BinarySearch(T item) : int, instance method, mscorlib
System.Collections.Generic.List<T>.IndexOf(T item) : int, instance method, mscorlib
...

Pour rechercher une propriété, écrivez receiver -> propertyType . Les propriétés indexées sont écrites sous la forme receiver -> index -> propertyType .

 > <T> : List<T> -> int
System.Collections.Generic.List<T>.Capacity : int, instance property with get set, mscorlib
System.Collections.Generic.List<T>.Count : int, instance property with get, mscorlib
...

membre statique

Pour rechercher une méthode, écrivez (arg) -> returnType . Lorsque vous recherchez une propriété, écrivez propertyType .

 > string -> int
System.Convert.ToInt32(string value) : int, static method, mscorlib
System.Int32.Parse(string s) : int, static method, mscorlib
...

De cette manière, le type auquel appartient le membre n’est pas indiqué dans la requête de membre statique.

API qui ne peuvent pas être prises en charge en raison des limitations de FSharp.Compiler.Service

Champs de classes et de structures définis en C#

Environnement opérationnel

.Net Framework 4.5
F#4.1

Bibliothèque utilisée

FSharp.Compiler.Service
FParsec
FSharp.Collections.ParallelSeq
MessagePack pour C#
MessagePack.FSharpExtensions

Développer

FSharpApiSearch

FSharpApiSearch

Liste des projets

Comment installer

Comment utiliser

Options de recherche

option respect-name-difference

option greedy-matching

option ignore-param-style

option ignore-case

option substring

option swap-order

option complement

option single-letter-as-variable

choix language

options xmldoc

Spécification de requête F#

API consultable

recherche de nom

joker

Recherche de sous-type

Recherche de membres

membre de l'instance

membre statique

modèle actif

expression de calcul

Spécification de requête C#

API consultable

recherche de nom

paramètre de type

joker

Recherche de sous-type

Recherche de membres

membre de l'instance

membre statique

API qui ne peuvent pas être prises en charge en raison des limitations de FSharp.Compiler.Service

Environnement opérationnel

Bibliothèque utilisée

option `respect-name-difference`

option `greedy-matching`

option `ignore-param-style`

option `ignore-case`

option `substring`

option `swap-order`

option `complement`

option `single-letter-as-variable`

choix `language`

options `xmldoc`