1
votes

comment obtenir cette signature dans f #: val sigF: int -> bool -> float -> string

J'utilise FSI, comment passer de booléen à float?

  • have: let sigF 1 = 1 = 1 obtient: val sigF: int -> bool
  • besoin de la fonction qui a la signature: val sigF: int -> bool -> float -> string

ne pouvez-vous pas convertir bool en float? y a-t-il des ressources sur la compréhension des signatures?, Je ne trouve pas d'exemples où bool va à autre chose, dois-je mieux comprendre le «curry»? (Je suis complètement nouveau dans la programmation fonctionnelle)

f#

3 commentaires

Pouvez-vous clarifier la question? Le problème que vous essayez de résoudre n'est pas clair. Si c'est une question générique sur le curry, alors c'est hors sujet pour SO


D'accord avec Sergey. C'est génial, mais ce n'est pas le genre de questions que nous voulons ici. Au lieu de cela, rejoignez-nous sur fsharp.slack.com - nous avons une chaîne réservée aux débutants, et vous obtiendrez toute l'aide dont vous pourriez avoir besoin sur F #. Aussi beaucoup d'autres canaux intéressants sur des sujets F #.


merci, si vous ne savez pas ce que vous ne savez pas ... ce slack est un très bon groupe de personnes, un merci spécial à ( fsharp.slack.com/messages/@U42NK7T8C ), Alan Ball ... let f 7 true 0.3 =" done ";;


3 Réponses :


0
votes

Une fonction ayant la signature val sigF: int -> bool -> float -> string pourrait être par exemple let sigF (i: int) (b: bool) (f: float) = "" . Le dernier symbole de la ligne -> est la sortie, tous les autres sont des entrées.


5 commentaires

merci mais la sortie pour cela est (> let sigF (i: int) (b: bool) (f: float) = "" ;; val sigF: i: int -> b: bool -> f: float -> string ), J'en ai besoin en tant que variables ... c'est un problème matériel qui m'a posé des problèmes. (Q2. Pour chacune des signatures suivantes, créez une fonction qui sera déduite pour avoir cette signature. Évitez d'utiliser des annotations de type explicite! ) (6. Val sigF = int -> bool -> float -> string)


Ah, je vois ce que vous voulez maintenant ... Vous voulez vous débarrasser des noms d'arguments ... Essayez une application partielle avec sprintf. let sigF = sprintf "% d% b% f" Vous devrez vérifier vous-même les chaînes de format pour sprintf.


attendez cependant, il n'est pas possible d'utiliser sprintf sans (en utilisant des annotations de type explicite) bien que non?, sinon il le convertit simplement en une chaîne, aussi je ne pense pas que je peux le faire de cette façon car tout est contenu dans une chaîne de retour fonction qui donne des parenthèses, sortie: val sigF: (int -> bool -> float -> string)


Pas vrai. Le dernier -> ne signifie pas la sortie . vous pouvez avoir une fonction qui renvoie la fonction float -> string . Par exemple. let sigF (i: int) (b: bool) = fun (f: float) -> f.ToString () et la signature sera la même int -> bool -> float -> chaîne .


> let test (i: int) (b: bool) = fun (f: float) -> f.ToString () ;; test val: i: int -> b: bool -> f: float -> string> test 1 true 3.4 ;; val it: string = "3,4" Il me semble que la sortie est une chaîne ... Mais bien sûr, cette explication n'est pas très sophistiquée ...



2
votes

let f 7 true 0.3 = "done" ;;

  • 7 true et .03 (tous impliquent des entrées de fonction) tandis qu'après le = est une sortie

val f: int -> bool -> float -> string


0 commentaires

3
votes

Sauf s'il s'agit d'un casse-tête ou d'un défi, vous pouvez supposer que i: int -> b: bool -> f: float -> string est identique à int -> bool -> float -> chaîne . La seule différence est que le premier inclut également les noms des paramètres de la fonction - qui ne sont que des informations supplémentaires que vous pouvez ignorer et qui ne changent pas beaucoup la signification.

Vous obtenez les noms des paramètres si vous faites quelque chose comme ceci:

> let sigF (_:int) (_:bool) (_:float) = "";;
val sigF : int -> bool -> float -> string

La solution ingénieuse de Michael évite de nommer les paramètres en utilisant à la place des motifs (correspondant à des valeurs concrètes), ce qui vous donne la bonne signature, mais aussi beaucoup d'avertissement car le la fonction échouera si elle est appelée avec une autre valeur comme argument:

> let sigF 7 true 0.3 = "done";;

warning FS0025: Incomplete pattern matches on this expression. 
  For example, the value '0.0' may indicate a case not covered by the pattern(s).
warning FS0025: Incomplete pattern matches on this expression. 
  For example, the value 'false' may indicate a case not covered by the pattern(s).
warning FS0025: Incomplete pattern matches on this expression. 
  For example, the value '0' may indicate a case not covered by the pattern(s).

val sigF : int -> bool -> float -> string

Une autre solution qui vous donne la bonne signature, mais sans les avertissements est d'utiliser _ code > motif avec une annotation de type - cela indique que vous ignorez l'argumnet, mais cela lui donne un type explicite:

> let sigF (i:int) (b:bool) (f:float) = "";;
val sigF : i:int -> b:bool -> f:float -> string


0 commentaires