Haskell types frustrant un simple "moyen" de la fonction

Je suis en train de jouer autour avec débutant Haskell, et j'ai voulu écrire une fonction moyenne. Cela semblait être la chose la plus simple du monde, non?

Mal.

Il semble que Haskell type de système interdit moyen de travailler sur un générique de type numérique - je peux le faire fonctionner sur une liste d'Intégrales, ou une liste de Fractionals, mais pas les deux.

Je veux:

average :: (Num a, Fractional b) => [a] -> b
average xs = ...

Mais je ne peux faire:

averageInt :: (Integral a, Fractional b) => [a] -> b
averageInt xs = fromIntegral (sum xs) / fromIntegral (length xs)

averageFrac :: (Fractional a) => [a] -> a
averageFrac xs = sum xs / fromIntegral (length xs)

et le second semble fonctionner. Jusqu'à ce que j'essaie de passer une variable.

*Main> averageFrac [1,2,3]
2.0
*Main> let x = [1,2,3]
*Main> :t x
x :: [Integer]
*Main> averageFrac x

<interactive>:1:0:
    No instance for (Fractional Integer)
      arising from a use of `averageFrac ' at <interactive>:1:0-8
    Possible fix: add an instance declaration for (Fractional Integer)
    In the expression: average x
    In the definition of `it': it = averageFrac x

Apparemment, Haskell est vraiment pointilleux à propos de ses types. Qui fait sens. Mais pas quand ils pourraient à la fois être [Num]

Je manque d'une application évidente de RealFrac?

Est-il moyen de forcer les Intégrales en Fractionals qui ne veut pas s'étouffer quand il obtient une fraction d'entrée?

Est-il un moyen d'utiliser Either et either de faire une sorte de polymorphe fonction moyenne qui serait à l'œuvre sur tout type de tableau numérique?

Ne Haskell type de système de carrément interdire cette fonction déjà existante?

Apprendre Haskell, c'est comme apprendre le Calcul. C'est vraiment compliqué et basé sur les montagnes de la théorie, et parfois, le problème est donc mindbogglingly complexe que je ne sais même pas assez pour une phrase correctement à la question, de sorte que toute la perspicacité seront chaleureusement accueillis.

(Également, note de bas de page: c'est un problème. Tout le monde est d'accord que averageFrac, ci-dessus, obtient la totalité des points, mais j'ai l'intuition qu'il existe un moyen de le faire fonctionner sur les deux Intégrales ET de la fraction de tableaux)

stackoverflow.com/questions/1816993/haskell-dividing-num
Je pense que Haskel est pour le show-off.

InformationsquelleAutor jakebman | 2010-03-04

93

Donc, fondamentalement, vous êtes limité par le type de (/):
```
(/) :: (Fractional a) => a -> a -> a
```
BTW, vous aussi vous voulez de Données.Liste.genericLength
```
genericLength :: (Num i) => [b] -> i
```
Alors comment sur la suppression de la fromIntegral pour quelque chose de plus général:
```
import Data.List

average xs = realToFrac (sum xs) / genericLength xs
```
qui a seulement une contrainte Réelle (Int, Integer, Float, Double)...
```
average :: (Real a, Fractional b) => [a] -> b
```
De sorte que vais prendre tout Réel dans toute fraction d'.

Et de noter toutes les affiches de se faire attraper par le polymorphe littéraux numériques en Haskell. 1 n'est pas un entier, il est un certain nombre.

La Vraie classe ne fournit qu'une seule méthode: la capacité de transformer une valeur dans la classe Num de façon rationnelle. Ce qui est exactement ce dont nous avons besoin ici.

Et donc,
```
Prelude> average ([1 .. 10] :: [Double])
5.5
Prelude> average ([1 .. 10] :: [Int])
5.5
Prelude> average ([1 .. 10] :: [Float])
5.5
Prelude> average ([1 .. 10] :: [Data.Word.Word8])
5.5
```
- mais que faire si je veux appeler moyenne sur une liste de, disons, Doubles? Est-il une fonction qui est comme numToFrac qui prend un Réel ou d'une fraction et renvoie une fraction? Pourrions-nous en écrire un?
- Vous pouvez nourrir une liste de Doubles, depuis le Double est Réel. "average ([1 .. 10] :: [Double])". La Vraie classe ajoute précisément dans la possibilité de construire une valeur rationnelle de choses dans Num. C'est exactement ce dont vous avez besoin.
- Vous avez raison! Merci pour préciser que! Existe-il des types de sous Num qui realToFrac ne fonctionne pas? Je ne vois pas pourquoi il n'est pas numToFrac.
- Il n'est pas possible d'écrire numToFrac, depuis le Num ne pas fournir toutes les fonctions de conversion. Le réel est la chose la plus proche que nous avons (Num types qui peuvent être convertis à un Rationnel) ou Intégrale (Num types qui peuvent être converties en illimité Entiers).
- Merci! J'ai été induit en erreur par le tableau de la dernière page de cs.ut.ee/~varmo/MFP2004/PreludeTour.pdf qui montre Flottant de ne PAS hériter des propriétés de Vrai, et j'ai alors supposé qu'ils n'aient pas de types en commun. Au moins j'arrive à apprendre de mes erreurs.
- un point supplémentaire est que votre averageFrac n'a pas manqué parce que vous avez passé à une variable de liaison, il a échoué parce que la variable de liaison que vous avez passé qu'il a été défini plus haut niveau. Cela fonctionne: f = let x = [1,2,3] dans averageFrac x Voir Le Haskell Rapport, Monomorphism Restriction
InformationsquelleAutor Don Stewart
25

La question a été très bien répondu par des Dons, j'ai pensé que je pourrais ajouter quelque chose.

Lors du calcul de la moyenne de cette façon :

average xs = realToFrac (sum xs) /genericLength xs

Ce que votre code est le parcours de la liste, une fois pour calculer la somme de ses éléments, et une fois pour obtenir sa longueur.
Autant que je sache, GHC n'est pas encore en mesure d'optimiser ce et de calculer à la fois la somme et de la longueur en un seul passage.

Il ne fait pas de mal, même en tant que débutant à penser à ce sujet et les solutions possibles, par exemple la moyenne de la fonction peut être écrite à l'aide d'un pli qui calcule à la fois la somme et de la longueur; sur ghci :
```
:set -XBangPatterns

import Data.List

let avg l=let (t,n) = foldl' (\(!b,!c) a -> (a+b,c+1)) (0,0) l in realToFrac(t)/realToFrac(n)

avg ([1,2,3,4]::[Int])
2.5
avg ([1,2,3,4]::[Double])
2.5
```
La fonction n'a pas l'air aussi élégante, mais la performance est meilleure.

Plus d'informations sur les Dons blog:

http://donsbot.wordpress.com/2008/06/04/haskell-as-fast-as-c-working-at-a-high-altitude-for-low-level-performance/
- +1 pour suggérant une fois pour obtenir un meilleur gain de performance, mais je ne le recommande en essayant de la performance une fois que vous comprenez Haskell entièrement et le polymorphisme d'entiers est un jeu d'enfant pour vous.
- +1 pour Robert Massaioli commentaire, car ce avg est en fait très mal... foldl' est stricte dans l'accumulateur, qui pour Haskell, signifie "la faiblesse de la tête à la forme normale de" fondamentalement, la stricte jusqu'à la première des données Constructeur. Ainsi, par exemple, ici, foldl' permettra de garantir que l'accumulateur sera évalué suffisante pour déterminer, c'est une paire (premières données constructeur), mais le contenu ne sera pas évalué, et ainsi accumuler des thunks. À l'aide de foldl' (\(!b,!c) a -> ... ou un strict paire de type data P a = P !a !a est la clé pour obtenir de bonnes performances dans ce cas.
- +1 pour Jedai commentaire, j'ai édité le post en conséquence.
InformationsquelleAutor David V.
7

Depuis enfile a fait un bon travail pour répondre à votre question, je vais travailler sur le questionnement de votre question....

Par exemple, dans votre question, lorsque vous exécutez une moyenne sur une liste donnée, l'obtention d'une bonne réponse. Ensuite, vous prenez ce qui ressemble exactement la même liste, l'affecter à une variable, puis d'utiliser la fonction de la variable...qui ensuite exploser.

Ce que vous avez ici est un set-up dans le compilateur, appelé le DMR: le D lus M onomorphic R estriction. Lorsque vous avez franchi la liste directement dans la fonction, le compilateur fait aucune hypothèse sur le type les chiffres étaient, il vient de déduire quels types il pourrait être basé sur l'utilisation, puis repris, une fois qu'il ne pouvait pas réduire le champ de plus. C'est un peu comme le contraire de canard-typage, là.

Toute façon, une fois que vous avez attribué à la liste à une variable, le DMR des coups de pied. Depuis que vous avez mis la liste dans une variable, mais étant donné aucune indication sur la façon dont vous voulez l'utiliser, le DMR fait le compilateur de choisir un type, dans ce cas, il en pris un et qui correspondent à la forme et semble s'adapter: Integer. Depuis votre fonction ne pouvais pas utiliser un nombre Entier dans son / opération (il a besoin d'un type dans le Fractional classe), il le fait très plainte: il n'y a pas d'instance de Integer dans le Fractional classe. Il y a des options que vous pouvez définir dans GHC, de sorte qu'il n'a pas la force de vos valeurs dans un formulaire unique ("mono-morphiques", l'obtenir?) jusqu'à ce qu'il doit, mais il en fait des messages d'erreur légèrement plus difficile à comprendre.

Maintenant, sur une autre note, vous avez eu une réponse à des dons de réponse qui a attiré mon attention:

Ai été induit en erreur par le tableau de la dernière page de cs.ut.ee/~varmo/MFP2004/PreludeTour.pdf
qui montre Flottant de ne PAS hériter des propriétés de Vrai, et j'ai alors supposé que
ils n'aient pas de types en commun.

Haskell n'types différemment de ce que vous êtes habitué. Real et Floating sont les classes de type, qui fonctionnent plus comme des interfaces de classes d'objets. Ils vous disent ce que vous pouvez faire avec un type qui est dans la classe, mais cela ne veut pas dire qu'un certain type ne peut pas faire d'autres choses, plus que d'avoir une interface signifie que a(n OO-style) de classe ne peut pas avoir toute les autres.

Apprendre Haskell, c'est comme apprendre le Calcul

Je dirais apprendre Haskell, c'est comme apprendre le suédois - il y a beaucoup de petites choses simples (lettres, chiffres) qui fonctionnent de la même, mais il y a aussi les mots qui se ressemblent, ils devraient signifier qu'une chose, quand ils signifient réellement quelque chose d'autre. Mais une fois que vous obtenez connaissant bien, vos amis seront surpris à la façon dont vous pouvez le bec hors de cette excentrique choses qui les rend magnifiques beautés faire des trucs incroyables. Curieusement, il ya beaucoup de gens impliqués dans Haskell, dès les commencements, qui savent aussi suédois. Peut-être que la métaphore est plus qu'une métaphore...

InformationsquelleAutor BMeph

:m Data.List
let list = [1..10]
let average = div (sum list) (genericLength list)
average

InformationsquelleAutor had same problem

-6

Ouais, Haskell type de système est très pointilleux. Le problème ici est le type de fromIntegral:
```
Prelude> :t fromIntegral
fromIntegral :: (Integral a, Num b) => a -> b
```
fromIntegral sera seulement accepter Intégrante comme un, pas un autre genre de Num. (/), d'autre part accepte uniquement les fractions. Comment allez-vous faire les deux fonctionnent ensemble?

Bien, la fonction somme est un bon début:
```
Prelude> :t sum
sum :: (Num a) => [a] -> a
```
Somme prend une liste de Num et renvoie un Num.

Votre prochain problème est la longueur de la liste. La longueur est un Int:
```
Prelude> :t length
length :: [a] -> Int
```
Vous avez besoin de les convertir Int dans un Num ainsi. C'est ce que fromIntegral n'.

Alors maintenant, vous avez une fonction qui renvoie un nombre et une autre fonction qui renvoie un Nombre. Il y a quelques règles pour la promotion du type de numéros vous pouvez consulter, mais, fondamentalement, à ce stade, vous êtes bon pour aller:
```
Prelude> let average xs = (sum xs) / (fromIntegral (length xs))
Prelude> :t average
average :: (Fractional a) => [a] -> a
```
Nous allons lui donner un essai:
```
Prelude> average [1,2,3,4,5]
3.0
Prelude> average [1.2,3.4,5.6,7.8,9.0]
5.4
Prelude> average [1.2,3,4.5,6,7.8,9]
5.25
```
- Vous avez aussi craqué pour le même piège que Michael. Numérique surcharge! 5 est pas intégrante de la valeur. C'est aucun Num. Ici, la valeur par défaut est une valeur fractionnaire -- vous ne pouvez pas passer en Int ou Entier. -- comme vous l'aurez Aucune instance pour la (les Fractions Int)
- Ouais, mon mauvais il. Je n'étais pas prêter assez d'attention. Je suppose que c'est précisément la raison pour laquelle je n'ai jamais réussi à faire beaucoup plus que le jouet de programmation Haskell. Même en tant que fan de bondage et discipline langues je trouve Haskell un peu brutal d'un maître.
- Haskell n'est pas B&D. de l'Approcher comme B&D va être douloureux. Si vous voulez apprendre Haskell, vous devrez maîtriser le système de type. C'est tout là est à lui. Votre confusion auront disparu par le temps que vous obtenez comment utiliser les types de pour vous.
InformationsquelleAutor JUST MY correct OPINION

Vous devez vous connecter pour publier un commentaire.