# Sequence differences

13 messages
Open this post in threaded view
|

## Sequence differences

 I have a Scheme function that calculates sequence differences, i.e., it returns a sequence that is the difference between the 2nd and the 1st element, the 3rd and the 2nd, the 4th and the 3rd, etc.(define s  (lambda (f l)    (cond ((null? (cdr l)) '())          (else (cons (f (cadr l) (car l))                      (s f (cdr l)))))))where(s - '(0,1,3,6,10,15,21,28)) => (1,2,3,4,5,6,7)I'm thinking the same function in Haskell would be something likes :: s f [] = []s f [x] = [x] s f l = [ a f b | (a,b) <- zip (init l) (tail l)]but can't figure out what the function typing would be.Michael

_______________________________________________
[hidden email]
Open this post in threaded view
|

## Re: Sequence differences

Open this post in threaded view
|

## Re: Sequence differences

In reply to this post by michael rice-3

_______________________________________________
[hidden email]
Open this post in threaded view
|

## Re: Sequence differences

 Hi Michael, michael rice wrote: > Clearly, there's more to the picture than meets the eye. Is there a good > tutorial on types? Have you seen Real World Haskell? http://book.realworldhaskell.org/read/Chapter 2 already dives into types. Hope this helps, Martijn. _______________________________________________ Haskell-Cafe mailing list [hidden email] http://www.haskell.org/mailman/listinfo/haskell-cafe
Open this post in threaded view
|

## Re: Sequence differences

Open this post in threaded view
|

## Re: Sequence differences

 In reply to this post by jfredett Joe Fredette gmail.com> writes: > We can write your original function in another, cleaner way though, too, > since zip will "zip" to the smaller of the two lengths, so you don't > need to worry about doing the init and the tail, so `s` is really: > > s _ []  = [] > s _ [x] = [x] > s f ls  = [f a b | (a,b) <- zip ls (tail ls)] > > but there is a function which does precisely what the third case does, > called "zipWith" which takes a > binary function and two lists and -- well -- does what that list > comprehension does. In fact, it does > what your whole function does... In fact, it _is_ your function, > specialized a little, eg: > > yourZipWith f ls = zipWith f ls (tail ls) A nice generalization of this that can be really useful is movingWindow :: Int -> [a] -> [[a]] movingWindow 1 xs = map (:[]) xs movingWindow n xs = zipWith (:) xs . tail \$ movingWindow (n-1) xs So for example, > movingWindow 3 [1..10] [[1,2,3],[2,3,4],[3,4,5],[4,5,6],[5,6,7],[6,7,8],[7,8,9],[8,9,10]] Then you can write diff :: (Num a) => [a] -> [a] diff = map (\[x,y] -> y - x) . movingWindow 2 Hopefully the intermediate lists are optimized away, but I haven't done any performance testing. Chad _______________________________________________ Haskell-Cafe mailing list [hidden email] http://www.haskell.org/mailman/listinfo/haskell-cafe
Open this post in threaded view
|

## Re: Sequence differences

Open this post in threaded view
|

## Re: Sequence differences

In reply to this post by michael rice-3
 No, I was unaware of this, but it looks good.Thanks.Michael--- On Fri, 4/10/09, Martijn van Steenbergen <[hidden email]> wrote:From: Martijn van Steenbergen <[hidden email]>Subject: Re: [Haskell-cafe] Sequence differencesTo: "michael rice" <[hidden email]>Cc: "haskell Cafe mailing list" <[hidden email]>, "Joe Fredette" <[hidden email]>Date: Friday, April 10, 2009, 11:38 AMHi Michael,michael rice wrote:> Clearly, there's more to the picture than meets the eye. Is there a good tutorial on types?Have you seen Real World Haskell?http://book.realworldhaskell.org/read/Chapter 2 already dives into types.Hope this helps,Martijn.

_______________________________________________
[hidden email]
Open this post in threaded view
|

## Re: Sequence differences

 In reply to this post by michael rice-3 michael rice <[hidden email]> writes: > map :: (a -> b) -> [a] -> [b]    <==  I'm assuming this is correct This is the type of 'map', yes.  Btw, ou can check types in GHCi with the :i command. > s f ls > > seems much like > > map f ls > > but instead looks like   > > s :: (a -> a -> a) -> [a] -> [a] If you look at the definition: >> s f [] = [] >> s f [x] = [x] >> s f l = [ a f b | (a,b) <- zip (init l) (tail l)] You'll notice that the second clause, namely    s f [x] = [x] produces the second parameter [x] (of type [a]) as its output, and thus the types must be the same as well. Also (assuming it is 'f a b' and not 'a f b' in the list comprehension), f is applied to two parameters, so it'll have to be of type (x -> y -> z), and since the two input parameters come from the originating list, x and y must be the same as a, and since we have seen the result list also has the same type, z must be the same as a, too.  Thus f must have type (a -> a -> a).  Unclear? Clear? Operating thetan? -k -- If I haven't seen further, it is by standing in the footprints of giants _______________________________________________ Haskell-Cafe mailing list [hidden email] http://www.haskell.org/mailman/listinfo/haskell-cafe
Open this post in threaded view
|

## Re: Re: Sequence differences

In reply to this post by michael rice-3

_______________________________________________
[hidden email]
Open this post in threaded view
|

## Re: Sequence differences

In reply to this post by michael rice-3
 Clearly, I have some reading to do.Thanks,Michael--- On Fri, 4/10/09, Ketil Malde <[hidden email]> wrote:From: Ketil Malde <[hidden email]>Subject: Re: [Haskell-cafe] Sequence differencesTo: "michael rice" <[hidden email]>Cc: "haskell Cafe mailing list" <[hidden email]>, "Joe Fredette" <[hidden email]>Date: Friday, April 10, 2009, 3:52 PMmichael rice writes:> map :: (a -> b) -> [a] -> [b]    <==  I'm assuming this is correctThis is the type of 'map', yes.  Btw, ou can check types in GHCi with the:i command.> s f ls >> seems much like>> map f ls>> but instead looks like   >> s :: (a -> a -> a) -> [a] -> [a]If you look at the definition:>> s f [] = []>> s f [x] = [x]>> s f l = [ a f b | (a,b) <- zip (init l) (tail l)]You'll notice that the second clause, namely   s f [x] = [x]produces the second parameter [x] (of type [a]) as its output, andthus the types must be the same as well. Also (assuming it is 'f a b' and not 'a f b' in the listcomprehension), f is applied to two parameters, so it'll have to beof type (x -> y -> z), and since the two input parameters come fromthe originating list, x and y must be the same as a, and since we haveseen the result list also has the same type, z must be the same as a,too.  Thus f must have type (a -> a -> a).  Unclear? Clear? Operatingthetan? -k-- If I haven't seen further, it is by standing in the footprints of giants

_______________________________________________
[hidden email]