Haskell, liste de nombre naturel

Je suis un débutant absolu en Haskell, tout en essayant de comprendre comment il fonctionne.

Je veux écrire mon propre paresseux liste d'entiers tels que [1,2,3,4,5...].

Pour la liste de celles que j'ai écrit

ones = 1 : ones

et lorsqu'on l'a essayé, fonctionne très bien:

*Main> take 10 ones
[1,1,1,1,1,1,1,1,1,1]

Comment puis-je faire de même pour l'augmentation des entiers ?

J'ai essayé ceci mais en effet, elle échoue:

int  = 1 : head[ int + 1]

Et après comment puis-je faire une méthode qui multiplie deux ruisseaux? tels que:

mulstream s1 s2 = head[s1] * head[s2] : mulstream [tail s1] [tail s2]
  • Vous pourriez être confus au sujet de la différence entre () et [], depuis votre dernier exemple fonctionne (pour l'infini listes) si vous remplacez tous les [] par ().
InformationsquelleAutor Hellnar | 2010-03-21
  1. 21

    Les raisons qui int = 1 : head [ int + 1] ne fonctionne pas sont:

    • tête renvoie à un élément unique, mais le deuxième argument de : doit être une liste.
    • int + 1 essaie d'ajouter une liste et un certain nombre, ce qui n'est pas possible.

    La façon la plus simple pour créer la liste de comptage de 1 à l'infini est [1..]

    Compter dans les étapes autres que 1, vous pouvez utiliser [firstElement, secondElement ..], par exemple pour créer une liste de tous positifs entiers impairs: [1, 3 ..]

    Pour obtenir de l'infini listes de la forme [x, f x, f (f x), f (f (f x)),...] vous pouvez utiliser iterate f x, par exemple iterate (*2) 1 sera de retour la liste [1, 2, 4, 16,...].

    Pour appliquer une opération par paires sur chaque paire d'éléments de deux listes, l'utilisation zipWith:

    mulstream s1 s2 = zipWith (*) s1 s2

    Pour faire de cette définition plus concise, vous pouvez utiliser le point-forme libre:

    mulstream = zipWith (*)
    InformationsquelleAutor sepp2k
  2. 18

    Pour les nombres naturels, vous devez utiliser la carte:

    num1 = 1 : map (+1) num1

    Ou des inclusions:

    num2 = 1 : [x+1 | x <- num2]

    Ou de cours:

    num3 = [1..]
    • ou aussi nat = 1 : map succ nat
    InformationsquelleAutor Łukasz Lew
  3. 4

    Je ne suis pas sûr si c'est ce que vous demandez, mais il me semble que vous vouliez construire une liste de l'augmentation des nombres naturels, sans s'appuyer sur aucune autre liste. Donc, par là même, vous pouvez faire des choses comme

    incr a = a : inrc (a+1)
lst = inrc 1

take 3 lst
=> [1,2,3]

    Que, techniquement, est appelé une accumulation de fonction (je crois) et puis tout nous l'avons fait, c'est de faire d'un cas particulier de il facilement utilisable avec 'lst'

    Vous pouvez aller fou à partir de là, faire des choses comme:

    lst = 1 : incr lst where incr a = (head a) + 1 : incr (tail a)

take 3 lst
=> [1,2,3]

    et ainsi de suite, bien que, probablement, s'appuie sur des choses que vous n'avez pas encore appris (où) - à en juger par l'OP - mais il faut toujours lire assez facilement.

    Ah, oui, et puis la liste de multiplication. Eh bien, vous pouvez utiliser zipWith (*) comme mentionné ci-dessus, ou vous pouvez réinventer la roue comme ça (c'est plus amusant, faites-moi confiance 🙂

    lmul a b = (head a * head b) : lmul (tail a) (tail b) 
safemul a b = take (minimum [len a, len b]) (lmul a b)

    La raison pour safemul, je crois, vous pouvez trouver de l'expérimentation de la fonction, mais il a à voir avec la "queue". Le problème est, il n'y a pas de cas de la liste vide, dépareillées, des listes, et ainsi de suite, de sorte que vous êtes soit va avoir à pirater les différentes définitions (lmul _ [] = []) ou d'utiliser les gardes et les ou de où et ainsi de suite ... ou un bâton avec zipWith 🙂

    InformationsquelleAutor Hiato
  4. 3

    Il y a de la syntaxe dans la langue:

    take 10 [1,2..]

=> [1,2,3,4,5,6,7,8,9,10]

    Vous pouvez même faire les différents progrès:

    take 10 [1,3..]
=> [1,3,5,7,9,11,13,15,17,19]
    InformationsquelleAutor clord