[Haskell-beginners] exercises/examples for streams
Carl Eyeinsky
eyeinsky9 at gmail.com
Mon Dec 15 20:46:27 UTC 2014
Hi Pascal,
for the 2., yes, the first member of the tuple is the list index in the
list-of-lists (i.e for [[1], [2,3], [4,5,6]], the 0th is [1], and 2nd is
[4,5,6]).
The other questions in order:
* Yes the sublists themselves have ascending order elements in themselves
(you can just 'map sort' if otherwise).
* I think the computation is non-blocking, even if the sublists themselves
are infinite. The conditions for non-blocking'ness are that (1) the
sublists are in ascending oreder, and (2) the outer list is finite. I think
these are enough.
* The list-of-lists (=outer list) is not sorted. I presume you mean by its
sub-lists' heads?
The main idea (which you probably get, but to spell it out :) ) is that in
previously we had Left for index 0 and Right for index 1, but now we use
tuples as it fits better than using nested Either's.
And on the typing of 'sorts ls rs = ls ++ rs' -- yes, its about types.
There was a simila remark some moths ago in the lines of if say you have a
function:
f :: Either Int Integer -> Either Int String
then why doesn't this work:
f (Right x) = Right (show x)
f left = left
The trouble is the second definition where 'left' on both sides of the
definition is a Left with an Int in it, but the types the lhs and rhs are
different. The solution is to spell out both the input and output Left's:
f (Left i) = Left i
The same would go for the lists -- if you expect both of them to be empty,
then 'sorts ls rs = []' would work.
Happy hacking,
On Sun, Dec 14, 2014 at 11:52 PM, Pascal Knodel <pascal.knodel at mail.com>
wrote:
>
> Hi Carl,
>
> --------------------------------------- snip
> ---------------------------------------
> module BeginnerStreams where
>
> -- 1. First try:
>
> -- Contract: Input lists are sorted.
> --
> -- Notes:
> --
> -- (!) Duplicate elements are allowed.
> -- (!) Sort `Left` before `Right`.
>
>
> sorts :: Ord a => [a] -> [a] -> [Either a a]
> sorts (l : ls) (r : rs)
>
> | l <= r = Left l : sorts ls (r : rs)
>
> | otherwise = Right r : sorts (l : ls) rs
> -- l > r
>
> sorts [] (r : rs) = Right r : sorts' Right rs
> sorts (l : ls) [] = Left l : sorts' Left ls
> sorts [] [] = []
>
> sorts' e (i : is) = e i : sorts' e is
> sorts' _ [] = []
>
>
> -- The difficulty for me was: "Either".
> -- I forgot about it while defining and
> -- did wrong in defining the empty list
> -- cases in my first definition:
> --
> -- sorts ls rs = ls ++ rs
> --
> -- That isn't possible without constructor application,
> -- because of the output type "[Either a a]". Is it?
> --
> -- Wish there would be GHCi in the exam.
>
> -- Where else did I fail and didn't notice it?
> -- What higher order functions would you use to define "sorts"?
>
>
> -- 2. First try:
>
> -- I'm not sure, what do you mean by 'value itself'?
> -- Why is the second tuple (2,1)? Ah, I see, is it sth. like:
> --
> -- [1,3] is index 0 and becomes (0,1), (03)
> -- [2,3] 1 (1,2), (1,3)
> -- ...
> --
> -- And those sorted in ascending order by the sum of the components?
> -- Is it possible to stream this computation without blocking?
> -- Is the list-of-lists sorted?
> --------------------------------------- snip
> ---------------------------------------
>
> The exercises from old exams that I have solved are at:
> https://github.com/pascal-knodel/Programming-Paradigms-
> KIT-2014-2015/tree/master/3
>
>
>
> Pascal
>
>
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://www.haskell.org/mailman/listinfo/beginners
>
--
Carl Eyeinsky
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/beginners/attachments/20141215/e6a2199c/attachment.html>
More information about the Beginners
mailing list