Caractéristiques cachées de F#

il s'agit de la tentative non écrasée d'une question similaire C# .

alors quelles sont vos fonctionnalités préférées de f# hidden (ou non)?

la plupart des fonctionnalités que j'ai utilisées jusqu'à présent ne sont pas exactement cachées mais ont été assez rafraîchissantes. Comme il est trivial de surcharger les opérateurs par rapport à dire C# ou VB.NET.

et Async<T> m'ont aidé à enlever un vrai code laid.

je suis tout à fait nouveau à la langue encore si ce serait génial d'apprendre quelles autres fonctionnalités sont utilisées dans la nature.

23
demandé sur Fung 2008-10-08 11:05:58
la source

11 ответов

littérales numériques définies par L'utilisateur peut être défini en fournissant un module dont le nom commence par NumericLiteral et qui définit certaines méthodes ( FromZero , FromOne , etc.).

en particulier, vous pouvez l'utiliser pour fournir une syntaxe beaucoup plus lisible pour l'appel LanguagePrimitives.GenericZero et LanguagePrimitives.GenericOne :

module NumericLiteralG = begin
  let inline FromZero() = LanguagePrimitives.GenericZero
  let inline FromOne() = LanguagePrimitives.GenericOne
end

let inline genericFactorial n =
  let rec fact n = if (n = 0G) then 1G else n * (fact (n - 1G))
  fact n

let flt = genericFactorial 30.
let bigI = genericFactorial 30I
29
répondu kvb 2009-12-04 15:43:32
la source

f# a une fonctionnalité peu utilisée appelée"signature files". Vous pouvez avoir un grand fichier d'implémentation rempli de public types/méthodes/modules/fonctions, mais alors vous pouvez cacher et exposer sélectivement cette fonctionnalité à la suite du programme via un fichier de signature. C'est, un fichier de signature agit comme une sorte d'écran/filtre qui vous permet de faire des entités "public à ce dossier", mais "privé pour le reste du programme".

j'ai l'impression que c'est une fonctionnalité assez tueuse sur la plateforme .Net, parce que le seul autre outil/prior que vous avez pour ce genre d'encapsulation est les assemblages. Si vous avez un petit composant avec quelques types apparentés qui veulent être en mesure de voir les détails internes de l'autre, mais ne veulent pas que ces types aient tous ces bits publics à tout le monde , que pouvez-vous faire? Vous pouvez faire deux choses:

  1. , Vous pouvez mettre ce composant dans un séparer l'assemblée, et faire les membres que ces types partagent être "interne", et faire la partie étroite que vous voulez que tout le monde voit être "public", ou
  2. vous marquez juste les choses internes "internes" mais vous laissez ces types dans votre assemblée gigantesque et espérez juste que tous les autres codes dans l'Assemblée choisissent de ne pas appeler ces membres qui ont été seulement marqués "internes" parce qu'un autre type avait besoin de le voir.

d'après mon expérience, grands projets logiciels, tout le monde fait toujours #2, parce que #1 est un non-démarreur pour diverses raisons (les gens ne veulent pas 50 petits assemblages, ils veulent 1 ou 2 ou 3 grands assemblages, pour d'autres peut-être-de bonnes raisons sans rapport avec le point d'encapsulation que je soulève (à part: tout le monde mentionne ILMerge mais personne ne l'utilise)).

donc vous avez choisi l'option #2. Puis un an plus tard, vous décidez finalement de refactoriser que composant, et vous découvrez qu'au cours de la dernière année, les 17 autres lieux appelez dans cette méthode "interne" qui était vraiment seulement destinée à ce qu'un autre type appelle, ce qui rend vraiment difficile de prendre en compte ce peu parce que maintenant tout le monde dépend de ces détails de mise en œuvre. La poisse.

le point est, il n'y a pas de bonne façon de créer une portée/limite d'encapsulation intra-assemblage de taille moyenne .Net. Souvent " interne "est trop grand et" privé " est trop petit.

... jusqu'à F#. Avec F # signature files, vous pouvez créer un encapsulation portée de "ce fichier de code source" en marquant un tas de choses comme publique dans le fichier de mise en œuvre, de sorte que tous les autres code dans le fichier peuvent le voir et la partie sur elle, mais ensuite utiliser un fichier de signature pour cacher tous les détails s'attendent à l'interface publique étroite que le composant expose au reste du monde. C'est heureux. Définissez trois types fortement liés dans un fichier, laissez-les voir les détails d'implémentation les uns les autres, mais n'exposez que les choses vraiment publiques à tout le monde. De gagner!

les fichiers de Signature ne sont peut-être pas la caractéristique ideal pour les limites d'encapsulation intra-assemblée, mais ce sont les seulement une telle caractéristique je sais, et donc je m'accroche à eux comme un radeau de sauvetage dans l'océan.

TL; DR

la Complexité est l'ennemi. Les limites d'Encapsulation sont une arme contre cet ennemi. "privé" est une grande arme mais parfois trop petite pour être applicable, et "interne" est souvent trop faible parce qu'il y a tellement de code (ensemble et tous les périphériques internes) qui peuvent voir des choses internes. F # offre une portée plus grande que" privé à un type "mais plus petite que" l'ensemble", et c'est très utile.

10
répondu Brian 2009-12-04 07:33:29
la source

je me demande ce qui se passe si vous ajoutez

<appSettings>
  <add key="fsharp-navigationbar-enabled" value="true" />
</appSettings>

à votre devenv.EXE.fichier de config? (Utilisez à vos propres risques.)

9
répondu Brian 2010-10-06 09:47:04
la source

passer --warnon:1182 au compilateur déclenche des avertissements sur les variables inutilisées; les noms de variables qui commencent par un trait de soulignement sont immunisés.

8
répondu Brian 2010-06-29 10:28:06
la source

fonctions de comparaison générées automatiquement pour les types de données algébriques (basées sur l'ordre lexicographique) est une belle caractéristique qui est relativement inconnue; voir

http://lorgonblog.spaces.live.com/blog/cns-oui.701679AD17B6D310!38.entrée

pour un exemple.

7
répondu Brian 2008-10-17 14:46:51
la source

Oui, F# n'ont pas de "caché", mais ils ont beaucoup de pouvoir, emballé dans le langage simple. Une caractéristique moins connue de la langue, est où vous pouvez fondamentalement activer canard Dactylographie malgré le fait F# est staticaly dactylographié.

6
répondu Chris Smith 2008-10-09 09:19:22
la source

voir cette question

F# opérateur "?"

pour des informations sur l'opérateur de point d'interrogation et comment il fournit le mécanisme de langage de base pour construire une caractéristique semblable à "dynamique" dans C#.

6
répondu Brian 2017-05-23 15:26:29
la source

pas vraiment caché , mais comme une personne non-ML cela m'a échappé pendant un certain temps:

Pattern matching peut se décomposer arbitrairement "profondes 151970920" dans des structures de données.

voici un exemple de tuple imbriqué [incroyablement arbitraire]; cela fonctionne sur des listes ou des unions ou toute combinaison de valeurs imbriquées:

let listEven =
  "Manipulating strings can be intriguing using F#".Split ' '
  |> List.ofArray
  |> List.map (fun x -> (x.Length % 2 = 0, x.Contains "i"), x)
  |> List.choose 
     ( function (true, true), s -> Some s 
              | _, "F#"         -> Some "language" 
              | _               -> None ) 
5
répondu Dan Fitch 2010-06-29 18:33:16
la source

L'utilisation de F# comme langage de script utilitaire peut être sous-estimée. Les enthousiastes ont tendance à être des quants. Parfois vous voulez quelque chose pour sauvegarder votre MP3s (ou des douzaines de serveurs de base de données) qui est un peu plus robuste que le lot. J'ai cherché un remplaçant moderne pour jscript / vbscript. Récemment, J'ai utilisé IronPython, mais F # peut être plus complet et l'interaction.net est moins encombrante.

j'aime au curry fonctions pour la valeur de divertissement. Montrer une fonction curried à un programme procédural / OOP pur pour au moins trois WTFs. Commencer par ceci est une mauvaise façon d'obtenir F # converts, bien que:)

3
répondu Precipitous 2017-05-23 13:29:41
la source

opérateurs Inlined sur les types génériques peuvent avoir différentes contraintes génériques:

type 'a Wrapper = Wrapper of 'a with
  static member inline (+)(Wrapper(a),Wrapper(b)) = Wrapper(a + b)
  static member inline Exp(Wrapper(a)) = Wrapper(exp a)

let objWrapper = Wrapper(obj())
let intWrapper = (Wrapper 1) + (Wrapper 2)
let fltWrapper = exp (Wrapper 1.0)

(* won''t compile *)
let _ = exp (Wrapper 1)
2
répondu kvb 2009-12-04 15:31:45
la source

il n'y a pas de fonctionnalités cachées, car F# est en mode design. Tout ce que nous avons, c'est un aperçu technique, qui change tous les deux mois.

voir http://research.microsoft.com/fsharp /

1
répondu ChaosSpeeder 2008-10-08 11:14:32
la source

Autres questions sur hidden-features f# language-features