Comment obtenir le nième élément d'un 10-tuple dans Haskell?

- Je obtenir nième élément dans un Haskell tuple. Et les tuples sont comme ceci :
(3,5,"String1","String2","String3","String4","String5","String6","String7","String8","String9","String10"). Pouvez-vous me donner une idée pour que je puisse résoudre ce problème?
Merci.

source d'informationauteur jason

  1. 24

    Comme vous pouvez ou ne pouvez pas savoir fst et snd seulement pour les 2-élément n-uplets ie

    fst' (a,b) = a

    Vous devez écrire vous même autant que je sache

    get5th (_,_,_,_,a,_,_,_,_,_) = a

    Comme vous pouvez le voir, vous pouvez définir votre propre type.

  2. 37

    Vous pourriez le faire avec le pattern matching. Comme vous pouvez le match contre un deux - ou trois-valeur du tuple, vous pouvez faire correspondre à l'encontre d'un dix-valeur du tuple.

    let (_, _, _, _, _, _, _, _, _, x, _, _) = tuple in x

    Cependant, les chances sont que vous n'avez pas voulez de le faire. Si vous essayez d'obtenir le n-ième valeur d'un tuple, vous avez presque certainement utiliser le mauvais type. En Haskell, les n-uplets de différentes longueurs sont différentes types--ils sont fondamentalement incompatibles. Tout comme Int et String sont différents, (Int, Int) et (Int, Int, Int) sont également totalement différentes.

    Si vous voulez un type de données où vous pouvez obtenir le n-ième élément, vous voulez une liste: quelque chose comme [String]. Avec les listes, vous pouvez utiliser le !! opérateur d'indexation (qui commence à 0), de sorte que vous pourriez faire:

    myList !! 9

    pour obtenir le 10ème élément.

    Donné votre exemple, je suppose que vous voulez un type comme (Int, Int, [String]) plutôt qu'un gigantesque tuple. Cela vous permettra d'avoir deux numéros et le nombre de chaînes; vous pouvez obtenir les chaînes à l'index de l'aide de l' !! opérateur comme ci-dessus.

  4. 2

    Si vous avez seulement besoin de le faire une fois par tuple, et vous avez besoin de tous les éléments à la fois, vous pouvez simplement utiliser 

    let (x, y, s1, s2, s3, s4, s5, s6, s7, s8) = someTuple
in ...

    et utiliser directement les valeurs.

  5. -2

    J'ai vu votre question lorsque j'étais à la recherche d'une solution pour le même problème. J'ai lu les "!!" l'opérateur est une mauvaise solution. J'ai pensé à une solution:

    Par exemple, si vous avez trois éléments pour chaque tuple dans votre liste, vous pouvez le faire:

    nTuple :: [(a, a, a)] -> Integer -> Integer -> [a]
nTuple list group position = [ fst x | x <- (concat [ fst x | x <- (zip [(zip[t1, t2, t3][0..]) | (t1, t2, t3) <- list ] [0..]) , snd(x) == group ]) , snd(x) == position]

    Maintenant, certains cas de test:

    *Main> nTuple [("l","m","n"),("o","p","q"),("r","s","t")] 2 1
["s"]

*Main> nTuple [("l","m","n"),("o","p","q"),("r","s","t")] 0 2
["n"]

*Main> nTuple [("l","m","n"),("o","p","q"),("r","s","t")] 100 2
[]

*Main> nTuple [("l","m","n"),("o","p","q"),("r","s","t")] 2 100
[]

    Explication, étape par étape, de la fonction ci-dessus:

    1.Partager des éléments et de mettre un indice:

    [ zip[t1,t2,t3][0..] | (t1,t2,t3) <- [("l","m","n"),("o","p","q"),("r","s","t")]]

result: [[("l",0),("m",1),("n",2)],[("o",0),("p",1),("q",2)],[("r",0),("s",1),("t",2)]]

    2.Pour chaque liste, mettre un index. Maintenant, nous avons des groupes et à des postes au sein de chaque groupe.

    zip [[("l",0),("m",1),("n",2)],[("o",0),("p",1),("q",2)],[("r",0),("s",1),("t",2)]] [0..]

result: [([("l",0),("m",1),("n",2)],0),([("o",0),("p",1),("q",2)],1),([("r",0),("s",1),("t",2)],2)]

    3.On peut sélectionner un groupe. Par exemple, le numéro de groupe 1 (premier groupe est le 0) avec "snd(x)==1"

    [ fst x | x <- [([("l",0),("m",1),("n",2)],0),([("o",0),("p",1),("q",2)],1),([("r",0),("s",1),("t",2)],2)] , snd(x) == 1 ]

result: [[("o",0),("p",1),("q",2)]]

    4.Nous avons une liste de listes. Whe concaténer des tuples dans une seule liste de tuples

    concat [[("o",0),("p",1),("q",2)]]

result: [("o",0),("p",1),("q",2)]

    5.Enfin, nous obtenons un élément à l'index. Dans cet exemple, nous obtenons le 2ème élément (le premier élément est la position "0")

    [ fst x | x <- [("o",0),("p",1),("q",2)] , snd(x) == 2]

result ["q"]