Working with Data.Sequence in Haskell

Question

I wrote a program that turned out to be far too slow using lists so I'm trying to switch over to sequences. However, I can't seem to figure out the correct syntax after looking at the documentation.

So far I'm trying to learn with this simple code:

import Control.Monad
import qualified Data.Sequence as S

main :: IO ()
main = do 
       let testSeq = S.empty
       testSeq S.|> 5
       testSeq S.|> 20
       testSeq S.|> 3
       let newSeq = S.update 2 3 testSeq
       let x = lookup 2 testSeq
       print x

I've played around with the syntax for a while with no luck but it still has a ton of errors:

test.hs:9:8:
    Couldn't match expected type ‘IO a0’
                with actual type ‘S.Seq Integer’
    In a stmt of a 'do' block: testSeq S.|> 5
    In the expression:
      do { let testSeq = S.empty;
           testSeq S.|> 5;
           testSeq S.|> 20;
           testSeq S.|> 3;
           .... }
    In an equation for ‘main’:
        main
          = do { let testSeq = ...;
                 testSeq S.|> 5;
                 testSeq S.|> 20;
                 .... }

test.hs:10:8:
    Couldn't match expected type ‘IO a1’
                with actual type ‘S.Seq Integer’
    In a stmt of a 'do' block: testSeq S.|> 20
    In the expression:
      do { let testSeq = S.empty;
           testSeq S.|> 5;
           testSeq S.|> 20;
           testSeq S.|> 3;
           .... }
    In an equation for ‘main’:
        main
          = do { let testSeq = ...;
                 testSeq S.|> 5;
                 testSeq S.|> 20;
                 .... }

test.hs:11:8:
    Couldn't match expected type ‘IO a2’
                with actual type ‘S.Seq Integer’
    In a stmt of a 'do' block: testSeq S.|> 3
    In the expression:
      do { let testSeq = S.empty;
           testSeq S.|> 5;
           testSeq S.|> 20;
           testSeq S.|> 3;
           .... }
    In an equation for ‘main’:
        main
          = do { let testSeq = ...;
                 testSeq S.|> 5;
                 testSeq S.|> 20;
                 .... }

test.hs:13:25:
    Couldn't match expected type ‘[(Integer, b)]’
                with actual type ‘S.Seq a3’
    Relevant bindings include x :: Maybe b (bound at test.hs:13:12)
    In the second argument of ‘lookup’, namely ‘testSeq’
    In the expression: lookup 2 testSeq

I'm new to Haskell so any help would be greatly appreciated!

Trying to force a Haskell program into the "sequence of statements" model of other languages doesn't usually lead to A Good Place. — molbdnilo
– molbdnilo, Commented Apr 11, 2018 at 13:31
Your last edit completely changed the question, please don't do that. — leftaroundabout
– leftaroundabout, Commented Apr 11, 2018 at 13:32

leftaroundabout · Accepted Answer · 2018-04-11 13:35:46Z

7

Like almost everything in Haskell, Seq is a purely functional data structure. It's not like an imperative stack where you push stuff to, mutating the original structure. Rather, like ordinary lists, you just generate new container-values which have the extra elements, but this does not affect the old shorter seqs in any way. So, the program you've asked about should just be

testSeq :: S.Seq Int
testSeq = S.update 2 3 $ S.empty S.|> 5 S.|> 20 S.|> 30

main :: IO ()
main = print $ S.lookup 2 testSeq

(It has to be S.lookup, or equivalently S.!?. By itself, lookup is a function that works on plain lists!)

Note that this doesn't really give you any advantage over

testSeq = S.update 2 3 $ S.fromList [5,20,30]

In fact, lists are usually faster than Seq, they just don't allow efficient random access.

edited Apr 11, 2018 at 13:35

answered Apr 11, 2018 at 13:23

leftaroundabout

121k6 gold badges185 silver badges337 bronze badges

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

6 Comments

Strobe00 Over a year ago

Thank you! This makes sense. I'm getting a not in scope error though, on the S.lookup. I was getting the same in the question code I edited (sorry about that).

leftaroundabout Over a year ago

Hm, what version of the package are you using? (cabal info containers) lookup has only been added quite recently to the Sequence module (0.5.8), before it had only index, which you can also use (but it doesn't have a safe length-check).

Thomas M. DuBuisson Over a year ago

This still feels like an x/y issue. If @Strobe00 desires fast random access/update of elements in an ordered set then they'll probably be better served by a map structure.

Strobe00 Over a year ago

@ThomasM.DuBuisson I ended up going with IO Arrays and it's so much faster now.

leftaroundabout Over a year ago

@Strobe00 though there are use cases where mutable arrays give you better performance than any alternative, I would recommend you only use them as a last-resort optimisation. Many algorithms can be implemented just as efficiently using only purely-functional tools (most I daresay, if you include immutable packed vectors) and only that way do you actually profit from Haskell's great safety guarantees. Using Haskell with mutable arrays is more like writing C with needlessly clunky syntax. Especially, while learning Haskell it makes sense to stick completely to lists to get a feel for it.

|

Collectives™ on Stack Overflow

Working with Data.Sequence in Haskell

1 Answer 1

6 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

6 Comments

Your Answer

Sign up or log in

Post as a guest

Related