Bdtjtk

As an example, given a list xs = [1..10], the thing I want is:

[(1,2),(2,3),(3,4),(4,5),(5,6),(6,7),(7,8),(8,9),(9,10),(10,1)]

my solution is

zip xs (tail xs ++ [head xs])     -- solution (1)

and someone suggests that

zip xs (tail . cycle $ xs)        -- solution (2)

but I don't know whether the solution (2) is more efficient? or two solutions are equivalent?

Unexpected! Solution (1) is faster. I just test it using GHC Runtime System statistics. The test case is [1..10^7], here is code:

Solution (1):

xs   = [1..10^7]

main = print $ last $ zip xs (tail xs ++ [head xs])

Solution (2):

xs   = [1..10^7]

main = print $ last $ zip xs (tail . cycle $ xs )

Compile option:

ghc -O2 -rtsopts ZipCycleList1.hs

Run option:

ZipCycleList1.exe +RTS -s

Result of Solution (1):

   1,520,081,768 bytes allocated in the heap

         603,912 bytes copied during GC

          42,960 bytes maximum residency (2 sample(s))

          26,672 bytes maximum slop

               2 MB total memory in use (0 MB lost due to fragmentation)



                                     Tot time (elapsed)  Avg pause  Max pause

  Gen  0      1459 colls,     0 par    0.000s   0.004s     0.0000s    0.0006s

  Gen  1         2 colls,     0 par    0.000s   0.000s     0.0001s    0.0002s



  INIT    time    0.000s  (  0.001s elapsed)

  MUT     time    0.312s  (  0.305s elapsed)

  GC      time    0.000s  (  0.004s elapsed)

  EXIT    time    0.000s  (  0.000s elapsed)

  Total   time    0.312s  (  0.310s elapsed)



  %GC     time       0.0%  (1.3% elapsed)



  Alloc rate    4,872,025,717 bytes per MUT second



  Productivity 100.0% of total user, 98.5% of total elapsed

Result of Solution (2):

   1,520,081,832 bytes allocated in the heap

     992,426,304 bytes copied during GC

     250,935,040 bytes maximum residency (12 sample(s))

      42,981,632 bytes maximum slop

             569 MB total memory in use (0 MB lost due to fragmentation)



                                     Tot time (elapsed)  Avg pause  Max pause

  Gen  0      1449 colls,     0 par    0.296s   0.301s     0.0002s    0.0006s

  Gen  1        12 colls,     0 par    0.406s   0.622s     0.0518s    0.2284s



  INIT    time    0.000s  (  0.001s elapsed)

  MUT     time    0.328s  (  0.305s elapsed)

  GC      time    0.702s  (  0.922s elapsed)

  EXIT    time    0.000s  (  0.000s elapsed)

  Total   time    1.030s  (  1.228s elapsed)



  %GC     time      68.2%  (75.1% elapsed)



  Alloc rate    4,640,024,688 bytes per MUT second



  Productivity  31.8% of total user, 24.9% of total elapsed

My intuition is that they will have identical performance. If you prefer an empirical answer to one based on experience, then you should build yourself a small benchmark; the criterion or timeit packages are popular choices here. Be sure to compile and use -O2, because the interpreter has famously unreliable performance and GHC's optimizer is very clever.