Haskell equivalent to Clojure's partition fn

Is there a Haskell equivalent to Clojure's partition http://clojuredocs.org/clojure.core/partition function? I'm particularly interested in the stepwise feature, where we can select a certain `n` size of the list, then step `m` and take again. What's returned is a list of lists. Each list being a sublist incremented by `m`. I didn't see anything in the below packages. And I wanted to check before I go about writing my own. - Prelude https://hackage.haskell.org/package/base-4.8.0.0/docs/Prelude.html#g:13 - Data.List https://hackage.haskell.org/package/base-4.8.1.0/docs/Data-List.html - Data.Array http://hackage.haskell.org/package/array-0.5.0.0/docs/Data-Array.html - Data.Vector http://hackage.haskell.org/package/vector-0.11.0.0/docs/Data-Vector.html Thanks Tim

On Sat, Jul 25, 2015, at 10:30 AM, Timothy Washington wrote:
Is there a Haskell equivalent to Clojure's partition[1] function? I'm particularly interested in the stepwise feature, where we can select a certain `n` size of the list, then step `m` and take again.
This is a great use case for a type-based search engine. Luckily, we have some of those! Here is a search that matches your question, I think: http://hayoo.fh-wedel.de/?query=Int+-%3E+Int+-%3E+%5Ba%5D+-%3E+%5B%5Ba%5D%5D At this moment, there is one result, which appears to be exactly the thing you want. Unfortunately, it's an auxiliary function of a music theory package, which you may not want to install for that one function. There's a package called "split" that contains a bunch of useful tools for splitting lists. It doesn't have exactly what you want, but it does have a function called "chop" that will get you most of the way there: http://hackage.haskell.org/package/split-0.2.2/docs/Data-List-Split.html#v:c... -Karl Links: 1. http://clojuredocs.org/clojure.core/partition

It looks like chunksOf will take you most of the way there. Here's my quick and dirty GHCi session output: λ> import Data.List.Split λ> λ> let clojurePartition n m = map (take n) $ chunksOf (n+m) [0..] λ> λ> take 3 $ clojurePartition 4 6 [[0,1,2,3],[10,11,12,13],[20,21,22,23]]

While I can say A), what I really need is B) *A)* > *take 5 $ chunksOf 10 [0..]* [[0,1,2,3,4,5,6,7,8,9],[10,11,12,13,14,15,16,17,18,19],[20,21,22,23,24,25,26,27,28,29],[30,31,32,33,34,35,36,37,38,39],[40,41,42,43,44,45,46,47,48,49]] *B)* > take 5 $ someFn 10 1 [0..] [[0,1,2,3,4,5,6,7,8,9],[1,2,3,4,5,6,7,8,9,10],[2,3,4,5,6,7,8,9,10,11],[3,4,5,6,7,8,9,10,11,12],[4,5,6,7,8,9,10,11,12,13]] The music theory package indeed has a working partition function (source here http://rd.slavepianos.org/sw/hmt/Music/Theory/List.hs). The implementation simply *i)* takes `n` from the source list, *ii)* drops by `m` then recurses. segments :: Int -> Int -> [a] -> [[a]] segments n m p = let q = take n p p' = drop m p in if length q /= n then [] else q : segments n m p' But that's rather manual. So I played around with this using *chop*, and came up with the *divvy* function. It does exactly what I need. divvy :: Int -> Int -> [a] -> [[a]] divvy n m lst = chop (\xs -> (take n xs , drop m xs)) lst
*take 5 $ partitionClojure 10 1 [0..]* [[0,1,2,3,4,5,6,7,8,9],[1,2,3,4,5,6,7,8,9,10],[2,3,4,5,6,7,8,9,10,11],[3,4,5,6,7,8,9,10,11,12],[4,5,6,7,8,9,10,11,12,13]]
Thanks guys. This helped a lot :)
Tim
On Sat, Jul 25, 2015 at 10:56 AM, Dan Serban
It looks like chunksOf will take you most of the way there. Here's my quick and dirty GHCi session output:
λ> import Data.List.Split λ> λ> let clojurePartition n m = map (take n) $ chunksOf (n+m) [0..] λ> λ> take 3 $ clojurePartition 4 6 [[0,1,2,3],[10,11,12,13],[20,21,22,23]] _______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners

Hi Timothy,
You might want to check out the split package.
Here's the link: http://hackage.haskell.org/package/split
On 7/25/15, Timothy Washington
While I can say A), what I really need is B)
*A)* > *take 5 $ chunksOf 10 [0..]* [[0,1,2,3,4,5,6,7,8,9],[10,11,12,13,14,15,16,17,18,19],[20,21,22,23,24,25,26,27,28,29],[30,31,32,33,34,35,36,37,38,39],[40,41,42,43,44,45,46,47,48,49]]
*B)* > take 5 $ someFn 10 1 [0..] [[0,1,2,3,4,5,6,7,8,9],[1,2,3,4,5,6,7,8,9,10],[2,3,4,5,6,7,8,9,10,11],[3,4,5,6,7,8,9,10,11,12],[4,5,6,7,8,9,10,11,12,13]]
The music theory package indeed has a working partition function (source here http://rd.slavepianos.org/sw/hmt/Music/Theory/List.hs). The implementation simply *i)* takes `n` from the source list, *ii)* drops by `m` then recurses.
segments :: Int -> Int -> [a] -> [[a]] segments n m p = let q = take n p p' = drop m p in if length q /= n then [] else q : segments n m p'
But that's rather manual. So I played around with this using *chop*, and came up with the *divvy* function. It does exactly what I need.
divvy :: Int -> Int -> [a] -> [[a]] divvy n m lst = chop (\xs -> (take n xs , drop m xs)) lst
*take 5 $ partitionClojure 10 1 [0..]* [[0,1,2,3,4,5,6,7,8,9],[1,2,3,4,5,6,7,8,9,10],[2,3,4,5,6,7,8,9,10,11],[3,4,5,6,7,8,9,10,11,12],[4,5,6,7,8,9,10,11,12,13]]
Thanks guys. This helped a lot :)
Tim
On Sat, Jul 25, 2015 at 10:56 AM, Dan Serban
wrote: It looks like chunksOf will take you most of the way there. Here's my quick and dirty GHCi session output:
λ> import Data.List.Split λ> λ> let clojurePartition n m = map (take n) $ chunksOf (n+m) [0..] λ> λ> take 3 $ clojurePartition 4 6 [[0,1,2,3],[10,11,12,13],[20,21,22,23]] _______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners

Hey Jacek,
Thanks very much for this. I took a look around, and ended up using the
*chop* function from that package. So there looks to be a lot of goodies in
that package.
Cheers
Tim
On Sun, Jul 26, 2015 at 2:01 PM, Jacek Dudek
Hi Timothy,
You might want to check out the split package. Here's the link: http://hackage.haskell.org/package/split
On 7/25/15, Timothy Washington
wrote: While I can say A), what I really need is B)
*A)* > *take 5 $ chunksOf 10 [0..]*
[[0,1,2,3,4,5,6,7,8,9],[10,11,12,13,14,15,16,17,18,19],[20,21,22,23,24,25,26,27,28,29],[30,31,32,33,34,35,36,37,38,39],[40,41,42,43,44,45,46,47,48,49]]
*B)* > take 5 $ someFn 10 1 [0..]
[[0,1,2,3,4,5,6,7,8,9],[1,2,3,4,5,6,7,8,9,10],[2,3,4,5,6,7,8,9,10,11],[3,4,5,6,7,8,9,10,11,12],[4,5,6,7,8,9,10,11,12,13]]
The music theory package indeed has a working partition function (source here http://rd.slavepianos.org/sw/hmt/Music/Theory/List.hs). The implementation simply *i)* takes `n` from the source list, *ii)* drops by `m` then recurses.
segments :: Int -> Int -> [a] -> [[a]] segments n m p = let q = take n p p' = drop m p in if length q /= n then [] else q : segments n m p'
But that's rather manual. So I played around with this using *chop*, and came up with the *divvy* function. It does exactly what I need.
divvy :: Int -> Int -> [a] -> [[a]] divvy n m lst = chop (\xs -> (take n xs , drop m xs)) lst
*take 5 $ partitionClojure 10 1 [0..]*
[[0,1,2,3,4,5,6,7,8,9],[1,2,3,4,5,6,7,8,9,10],[2,3,4,5,6,7,8,9,10,11],[3,4,5,6,7,8,9,10,11,12],[4,5,6,7,8,9,10,11,12,13]]
Thanks guys. This helped a lot :)
Tim
On Sat, Jul 25, 2015 at 10:56 AM, Dan Serban
wrote:
It looks like chunksOf will take you most of the way there. Here's my quick and dirty GHCi session output:
λ> import Data.List.Split λ> λ> let clojurePartition n m = map (take n) $ chunksOf (n+m) [0..] λ> λ> take 3 $ clojurePartition 4 6 [[0,1,2,3],[10,11,12,13],[20,21,22,23]]
participants (4)
-
Dan Serban
-
Jacek Dudek
-
Karl Voelker
-
Timothy Washington