Use list comprehension to build a function

Question

I wrote a function with Haskell to extract some values from this data type :

data Result = ResuVal Double     
              | ResuValIdx Double (Maybe Int)   
              | ResuValCpt Double Int           
              | NoResu                  
              deriving (Show)

This function extract the Int values in the Result data type and concatenate them in a list.

catIdxCpt :: [Result] -> [Int]
catIdxCpt [] = []
catIdxCpt (x:xs) = case x of
                ResuValIdx v (Just i) -> i:catIdxCpt xs
                ResuValCpt v c -> c:catIdxCpt xs      
                _ -> catIdxCpt xs

This function is working well but I first tried to wrote it with a comprehension list such as :

catIdxCpt ls = [i | ResuValIdx v (Just i)  <- ls  ]

or

catIdxCpt ls = [i | ResuValIdx v (Just i)  <- ls | ResuValCpt v i  <- ls ]

and other combinations. But I didn't managed to have the expected result.

Do you know how to built (if it is possible) the catIdxCpt function with a list comprehension ?

Interesting side note: The last version of the comprehension ([i | ... | ... ]) can actually be used to zipWithN several lists via the ParallelListComprehension extension. Doesn't help here, but it has its uses. — MarLinn
– MarLinn, Commented Aug 17, 2016 at 7:29

ErikR · Accepted Answer · 2016-08-16 14:59:02Z

4

Your function involves both mapping and filtering, so consider this technique:

foo xs = [ y | Just y <- map go xs ]
  where go (ResuValIdx _ (Just i)) = Just i
        go (ResuValCpt v c)        = Just c
        go _                       = Nothing

The helper function go returns Nothing for elements you want to remove.

The pattern Just y <- zs will select only those elements from the list zs which match the pattern Just y.

answered Aug 16, 2016 at 14:59

ErikR

52.2k9 gold badges78 silver badges136 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Gurkenglas · Accepted Answer · 2016-08-16 14:45:06Z

1

[x | l <- ls, x <- [i | ResuValIdx v (Just i) <- [l]] ++ [i | ResuValCpt v i <- [l]]]

Alternatively, consider:

{-# LANGUAGE LambdaCase #-}

catIdxCpt :: [Result] -> [Int]
catIdxCpt = mapMaybe $ \case
  ResuValIdx v (Just i) -> Just i
  ResuValCpt v c -> Just c
  _ -> Nothing

answered Aug 16, 2016 at 14:45

Gurkenglas

2,31712 silver badges17 bronze badges

1 Comment

MarLinn Over a year ago

The first answer manages to make the code half as efficient and a third as readable for the sake of ... ummm...

Collectives™ on Stack Overflow

Use list comprehension to build a function

2 Answers 2

Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related