
On Tue, May 12, 2015 at 10:00 AM, Roelof Wobben
init' (x:xs) = Just (x: (init' xs))
Remember that your init' produces Maybe [a], not [a]. -- brandon s allbery kf8nh sine nomine associates allbery.b@gmail.com ballbery@sinenomine.net unix, openafs, kerberos, infrastructure, xmonad http://sinenomine.net

On Tue, May 12, 2015 at 10:11 AM, Roelof Wobben
I do not understand what you are saying to me.
I know that init produces a Maybe [a] . That is why I did put a Just before it.
You are invoking it again though, and using its result as if it produces [a] instead of Maybe [a]. -- brandon s allbery kf8nh sine nomine associates allbery.b@gmail.com ballbery@sinenomine.net unix, openafs, kerberos, infrastructure, xmonad http://sinenomine.net

Before cons'ing the result of init', you should check whether it's Just or
Nothing. What you're doing now is something along the line with 5 : Just 3
-- this won't typecheck.
On Tue, May 12, 2015 at 5:22 PM Roelof Wobben
Brandon Allbery schreef op 12-5-2015 om 16:16:
On Tue, May 12, 2015 at 10:11 AM, Roelof Wobben
wrote: I do not understand what you are saying to me.
I know that init produces a Maybe [a] . That is why I did put a Just before it.
You are invoking it again though, and using its result as if it produces [a] instead of Maybe [a].
-- brandon s allbery kf8nh sine nomine associates allbery.b@gmail.com ballbery@sinenomine.net unix, openafs, kerberos, infrastructure, xmonad http://sinenomine.net
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
What is then the right way to do. I still do not understand what you are trying to make clear to me.
Roelof
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners

Try fromMaybe [1]. Examples
Prelude Data.Maybe> fromMaybe [] (Just [1,2,3])
[1,2,3]
Prelude Data.Maybe> fromMaybe [1,2,3] Nothing
[1,2,3]
[1]:
https://hackage.haskell.org/package/base-4.8.0.0/docs/Data-Maybe.html#v:from...
On Tue, May 12, 2015 at 5:28 PM Roelof Wobben
Oke,
And how do I do this. Haskell is a difficult one to learn,
Roelof
Alexey Shmalko schreef op 12-5-2015 om 16:24:
Before cons'ing the result of init', you should check whether it's Just or Nothing. What you're doing now is something along the line with 5 : Just 3 -- this won't typecheck.
On Tue, May 12, 2015 at 5:22 PM Roelof Wobben
wrote: Brandon Allbery schreef op 12-5-2015 om 16:16:
On Tue, May 12, 2015 at 10:11 AM, Roelof Wobben
wrote: I do not understand what you are saying to me.
I know that init produces a Maybe [a] . That is why I did put a Just before it.
You are invoking it again though, and using its result as if it produces [a] instead of Maybe [a].
-- brandon s allbery kf8nh sine nomine associates allbery.b@gmail.com ballbery@sinenomine.net unix, openafs, kerberos, infrastructure, xmonad http://sinenomine.net
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
What is then the right way to do. I still do not understand what you are trying to make clear to me.
Roelof
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners

On 12 May 2015 at 20:14, Roelof Wobben
Thanks,
The right solution was this :
init' (x:xs) = Just (x:fromMaybe xs (init' xs))
if I understand it right x:fromMaybe xs takes care that from xs the just or Nothing is removed ?
Trying it out in ghci, fromMaybe [1,2] Nothing == [1,2] fromMaybe [1,2] Just [3] == [3] It seems like that should indeed work. Roelof
Alexey Shmalko schreef op 12-5-2015 om 16:33:
Try fromMaybe [1]. Examples
Prelude Data.Maybe> fromMaybe [] (Just [1,2,3]) [1,2,3] Prelude Data.Maybe> fromMaybe [1,2,3] Nothing [1,2,3]
[1]: https://hackage.haskell.org/package/base-4.8.0.0/docs/Data-Maybe.html#v:from...
On Tue, May 12, 2015 at 5:28 PM Roelof Wobben
wrote: Oke,
And how do I do this. Haskell is a difficult one to learn,
Roelof
Alexey Shmalko schreef op 12-5-2015 om 16:24:
Before cons'ing the result of init', you should check whether it's Just or Nothing. What you're doing now is something along the line with 5 : Just 3 -- this won't typecheck.
On Tue, May 12, 2015 at 5:22 PM Roelof Wobben
wrote: Brandon Allbery schreef op 12-5-2015 om 16:16:
On Tue, May 12, 2015 at 10:11 AM, Roelof Wobben
wrote: I do not understand what you are saying to me.
I know that init produces a Maybe [a] . That is why I did put a Just before it.
You are invoking it again though, and using its result as if it produces [a] instead of Maybe [a].
-- brandon s allbery kf8nh sine nomine associates allbery.b@gmail.com ballbery@sinenomine.net unix, openafs, kerberos, infrastructure, xmonad http://sinenomine.net
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
What is then the right way to do. I still do not understand what you are trying to make clear to me.
Roelof
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
-- Regards Sumit Sahrawat

Why not just?
==================
init' [] = Nothing
init' xs = Just xs
==================
Meets your type sig and is also has a time complexity of O(1) instead of
O(n) which will be the time complexity in the solution involving
fromMaybe. Maybe I'm missing something.
Perhaps it'd help us help you if you'd be a bit more clear on what you want
to achieve.
On Tue, May 12, 2015 at 9:01 PM, Sumit Sahrawat, Maths & Computing, IIT
(BHU)
On 12 May 2015 at 20:14, Roelof Wobben
wrote: Thanks,
The right solution was this :
init' (x:xs) = Just (x:fromMaybe xs (init' xs))
if I understand it right x:fromMaybe xs takes care that from xs the just or Nothing is removed ?
Trying it out in ghci,
fromMaybe [1,2] Nothing == [1,2] fromMaybe [1,2] Just [3] == [3]
It seems like that should indeed work.
Roelof
Alexey Shmalko schreef op 12-5-2015 om 16:33:
Try fromMaybe [1]. Examples
Prelude Data.Maybe> fromMaybe [] (Just [1,2,3]) [1,2,3] Prelude Data.Maybe> fromMaybe [1,2,3] Nothing [1,2,3]
[1]: https://hackage.haskell.org/package/base-4.8.0.0/docs/Data-Maybe.html#v:from...
On Tue, May 12, 2015 at 5:28 PM Roelof Wobben
wrote: Oke,
And how do I do this. Haskell is a difficult one to learn,
Roelof
Alexey Shmalko schreef op 12-5-2015 om 16:24:
Before cons'ing the result of init', you should check whether it's Just or Nothing. What you're doing now is something along the line with 5 : Just 3 -- this won't typecheck.
On Tue, May 12, 2015 at 5:22 PM Roelof Wobben
wrote: Brandon Allbery schreef op 12-5-2015 om 16:16:
On Tue, May 12, 2015 at 10:11 AM, Roelof Wobben
wrote: I do not understand what you are saying to me.
I know that init produces a Maybe [a] . That is why I did put a Just before it.
You are invoking it again though, and using its result as if it produces [a] instead of Maybe [a].
-- brandon s allbery kf8nh sine nomine associates allbery.b@gmail.com ballbery@sinenomine.net unix, openafs, kerberos, infrastructure, xmonad http://sinenomine.net
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
What is then the right way to do. I still do not understand what you are trying to make clear to me.
Roelof
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
-- Regards
Sumit Sahrawat
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners

Ah, but it doesn't. Since this is a functional language, we have a pointer
to it. In fact, all it does is rap it around in the Maybe type.
Also, my version doesn't do what you want. One way to do that would be
what you have. Or something like this.
The following turns the partial function in the Prelude to one that is safe
==========
import Data.List
init' :: [a] -> Maybe [a]
init' [] = Nothing -- Base case
init' xs = Just $ tail xs -- Inductive case
==========
On Wed, May 13, 2015 at 2:47 PM, Roelof Wobben
Hello,
What my intention was to make a safe version of the init function found in Data.list so it procudes a list without the last item. At first look your function procudes the whole list again.
Roelof
akash g schreef op 13-5-2015 om 10:57:
Why not just?
================== init' [] = Nothing init' xs = Just xs ==================
Meets your type sig and is also has a time complexity of O(1) instead of O(n) which will be the time complexity in the solution involving fromMaybe. Maybe I'm missing something.
Perhaps it'd help us help you if you'd be a bit more clear on what you want to achieve.
On Tue, May 12, 2015 at 9:01 PM, Sumit Sahrawat, Maths & Computing, IIT (BHU)
wrote: On 12 May 2015 at 20:14, Roelof Wobben
wrote: Thanks,
The right solution was this :
init' (x:xs) = Just (x:fromMaybe xs (init' xs))
if I understand it right x:fromMaybe xs takes care that from xs the just or Nothing is removed ?
Trying it out in ghci,
fromMaybe [1,2] Nothing == [1,2] fromMaybe [1,2] Just [3] == [3]
It seems like that should indeed work.
Roelof
Alexey Shmalko schreef op 12-5-2015 om 16:33:
Try fromMaybe [1]. Examples
Prelude Data.Maybe> fromMaybe [] (Just [1,2,3]) [1,2,3] Prelude Data.Maybe> fromMaybe [1,2,3] Nothing [1,2,3]
[1]: https://hackage.haskell.org/package/base-4.8.0.0/docs/Data-Maybe.html#v:from...
On Tue, May 12, 2015 at 5:28 PM Roelof Wobben
wrote: Oke,
And how do I do this. Haskell is a difficult one to learn,
Roelof
Alexey Shmalko schreef op 12-5-2015 om 16:24:
Before cons'ing the result of init', you should check whether it's Just or Nothing. What you're doing now is something along the line with 5 : Just 3 -- this won't typecheck.
On Tue, May 12, 2015 at 5:22 PM Roelof Wobben
wrote: Brandon Allbery schreef op 12-5-2015 om 16:16:
On Tue, May 12, 2015 at 10:11 AM, Roelof Wobben
wrote: I do not understand what you are saying to me.
I know that init produces a Maybe [a] . That is why I did put a Just before it.
You are invoking it again though, and using its result as if it produces [a] instead of Maybe [a].
-- brandon s allbery kf8nh sine nomine associates allbery.b@gmail.com ballbery@sinenomine.net unix, openafs, kerberos, infrastructure, xmonad http://sinenomine.net
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
What is then the right way to do. I still do not understand what you are trying to make clear to me.
Roelof
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
-- Regards
Sumit Sahrawat
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners

*wrap, not rap. In my previous mail.
Also, there is already a library that does list operations in a safe way,
though they have used monads. Give a look at the source code and see if it
helps.
https://hackage.haskell.org/package/listsafe-0.1.0.0/docs/Data-List-Safe.htm...
On Wed, May 13, 2015 at 3:19 PM, akash g
Ah, but it doesn't. Since this is a functional language, we have a pointer to it. In fact, all it does is rap it around in the Maybe type.
Also, my version doesn't do what you want. One way to do that would be what you have. Or something like this.
The following turns the partial function in the Prelude to one that is safe
========== import Data.List
init' :: [a] -> Maybe [a] init' [] = Nothing -- Base case init' xs = Just $ tail xs -- Inductive case ==========
On Wed, May 13, 2015 at 2:47 PM, Roelof Wobben
wrote: Hello,
What my intention was to make a safe version of the init function found in Data.list so it procudes a list without the last item. At first look your function procudes the whole list again.
Roelof
akash g schreef op 13-5-2015 om 10:57:
Why not just?
================== init' [] = Nothing init' xs = Just xs ==================
Meets your type sig and is also has a time complexity of O(1) instead of O(n) which will be the time complexity in the solution involving fromMaybe. Maybe I'm missing something.
Perhaps it'd help us help you if you'd be a bit more clear on what you want to achieve.
On Tue, May 12, 2015 at 9:01 PM, Sumit Sahrawat, Maths & Computing, IIT (BHU)
wrote: On 12 May 2015 at 20:14, Roelof Wobben
wrote: Thanks,
The right solution was this :
init' (x:xs) = Just (x:fromMaybe xs (init' xs))
if I understand it right x:fromMaybe xs takes care that from xs the just or Nothing is removed ?
Trying it out in ghci,
fromMaybe [1,2] Nothing == [1,2] fromMaybe [1,2] Just [3] == [3]
It seems like that should indeed work.
Roelof
Alexey Shmalko schreef op 12-5-2015 om 16:33:
Try fromMaybe [1]. Examples
Prelude Data.Maybe> fromMaybe [] (Just [1,2,3]) [1,2,3] Prelude Data.Maybe> fromMaybe [1,2,3] Nothing [1,2,3]
[1]: https://hackage.haskell.org/package/base-4.8.0.0/docs/Data-Maybe.html#v:from...
On Tue, May 12, 2015 at 5:28 PM Roelof Wobben
wrote: Oke,
And how do I do this. Haskell is a difficult one to learn,
Roelof
Alexey Shmalko schreef op 12-5-2015 om 16:24:
Before cons'ing the result of init', you should check whether it's Just or Nothing. What you're doing now is something along the line with 5 : Just 3 -- this won't typecheck.
On Tue, May 12, 2015 at 5:22 PM Roelof Wobben
wrote: Brandon Allbery schreef op 12-5-2015 om 16:16:
On Tue, May 12, 2015 at 10:11 AM, Roelof Wobben
wrote: > I do not understand what you are saying to me. > > I know that init produces a Maybe [a] . That is why I did put a Just > before it. >
You are invoking it again though, and using its result as if it produces [a] instead of Maybe [a].
-- brandon s allbery kf8nh sine nomine associates allbery.b@gmail.com ballbery@sinenomine.net unix, openafs, kerberos, infrastructure, xmonad http://sinenomine.net
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
What is then the right way to do. I still do not understand what you are trying to make clear to me.
Roelof
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
-- Regards
Sumit Sahrawat
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners

Perhaps a good place to start with functional programming is SICP :
http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html#%_toc_start
While it doesn't teach you via the Haskell language, it teaches you how to
construct functional programs and how the compiler/interpreter views it.
Also, it teaches higher order programming quite well, At least, it is much
better than every intro haskell book I've read.
On Wed, May 13, 2015 at 3:23 PM, akash g
*wrap, not rap. In my previous mail.
Also, there is already a library that does list operations in a safe way, though they have used monads. Give a look at the source code and see if it helps.
https://hackage.haskell.org/package/listsafe-0.1.0.0/docs/Data-List-Safe.htm...
On Wed, May 13, 2015 at 3:19 PM, akash g
wrote: Ah, but it doesn't. Since this is a functional language, we have a pointer to it. In fact, all it does is rap it around in the Maybe type.
Also, my version doesn't do what you want. One way to do that would be what you have. Or something like this.
The following turns the partial function in the Prelude to one that is safe
========== import Data.List
init' :: [a] -> Maybe [a] init' [] = Nothing -- Base case init' xs = Just $ tail xs -- Inductive case ==========
On Wed, May 13, 2015 at 2:47 PM, Roelof Wobben
wrote: Hello,
What my intention was to make a safe version of the init function found in Data.list so it procudes a list without the last item. At first look your function procudes the whole list again.
Roelof
akash g schreef op 13-5-2015 om 10:57:
Why not just?
================== init' [] = Nothing init' xs = Just xs ==================
Meets your type sig and is also has a time complexity of O(1) instead of O(n) which will be the time complexity in the solution involving fromMaybe. Maybe I'm missing something.
Perhaps it'd help us help you if you'd be a bit more clear on what you want to achieve.
On Tue, May 12, 2015 at 9:01 PM, Sumit Sahrawat, Maths & Computing, IIT (BHU)
wrote: On 12 May 2015 at 20:14, Roelof Wobben
wrote: Thanks,
The right solution was this :
init' (x:xs) = Just (x:fromMaybe xs (init' xs))
if I understand it right x:fromMaybe xs takes care that from xs the just or Nothing is removed ?
Trying it out in ghci,
fromMaybe [1,2] Nothing == [1,2] fromMaybe [1,2] Just [3] == [3]
It seems like that should indeed work.
Roelof
Alexey Shmalko schreef op 12-5-2015 om 16:33:
Try fromMaybe [1]. Examples
Prelude Data.Maybe> fromMaybe [] (Just [1,2,3]) [1,2,3] Prelude Data.Maybe> fromMaybe [1,2,3] Nothing [1,2,3]
[1]: https://hackage.haskell.org/package/base-4.8.0.0/docs/Data-Maybe.html#v:from...
On Tue, May 12, 2015 at 5:28 PM Roelof Wobben
wrote: Oke,
And how do I do this. Haskell is a difficult one to learn,
Roelof
Alexey Shmalko schreef op 12-5-2015 om 16:24:
Before cons'ing the result of init', you should check whether it's Just or Nothing. What you're doing now is something along the line with 5 : Just 3 -- this won't typecheck.
On Tue, May 12, 2015 at 5:22 PM Roelof Wobben
wrote: > Brandon Allbery schreef op 12-5-2015 om 16:16: > > On Tue, May 12, 2015 at 10:11 AM, Roelof Wobben
> wrote: > >> I do not understand what you are saying to me. >> >> I know that init produces a Maybe [a] . That is why I did put a >> Just before it. >> > > You are invoking it again though, and using its result as if it > produces [a] instead of Maybe [a]. > > -- > brandon s allbery kf8nh sine nomine > associates > allbery.b@gmail.com > ballbery@sinenomine.net > unix, openafs, kerberos, infrastructure, xmonad > http://sinenomine.net > > > _______________________________________________ > Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners > > > What is then the right way to do. I still do not understand what > you are trying to make clear to me. > > > Roelof > > > > > ------------------------------ > [image: Avast logo] http://www.avast.com/ > > Dit e-mailbericht is gecontroleerd op virussen met Avast > antivirussoftware. > www.avast.com > > _______________________________________________ > Beginners mailing list > Beginners@haskell.org > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners > _______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
-- Regards
Sumit Sahrawat
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners

Init returns all but the last element of a list. The idea behind the
recursive solution is to keep accepting elements till there is only one
left, and replace it with the empty list.
For example,
init [1, 2, 3]
== init (1 : 2 : 3 : []) { desugar list syntax }
== 1 : init (2 : 3 : []) { apply init }
== 1 : 2 : init (3 : []) { apply init }
== 1 : 2 : [] { init [x] = [] }
On 13 May 2015 at 15:32, akash g
Perhaps a good place to start with functional programming is SICP : http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html#%_toc_start
While it doesn't teach you via the Haskell language, it teaches you how to construct functional programs and how the compiler/interpreter views it. Also, it teaches higher order programming quite well, At least, it is much better than every intro haskell book I've read.
On Wed, May 13, 2015 at 3:23 PM, akash g
wrote: *wrap, not rap. In my previous mail.
Also, there is already a library that does list operations in a safe way, though they have used monads. Give a look at the source code and see if it helps.
https://hackage.haskell.org/package/listsafe-0.1.0.0/docs/Data-List-Safe.htm...
On Wed, May 13, 2015 at 3:19 PM, akash g
wrote: Ah, but it doesn't. Since this is a functional language, we have a pointer to it. In fact, all it does is rap it around in the Maybe type.
Also, my version doesn't do what you want. One way to do that would be what you have. Or something like this.
The following turns the partial function in the Prelude to one that is safe
========== import Data.List
init' :: [a] -> Maybe [a] init' [] = Nothing -- Base case init' xs = Just $ tail xs -- Inductive case ==========
On Wed, May 13, 2015 at 2:47 PM, Roelof Wobben
wrote: Hello,
What my intention was to make a safe version of the init function found in Data.list so it procudes a list without the last item. At first look your function procudes the whole list again.
Roelof
akash g schreef op 13-5-2015 om 10:57:
Why not just?
================== init' [] = Nothing init' xs = Just xs ==================
Meets your type sig and is also has a time complexity of O(1) instead of O(n) which will be the time complexity in the solution involving fromMaybe. Maybe I'm missing something.
Perhaps it'd help us help you if you'd be a bit more clear on what you want to achieve.
On Tue, May 12, 2015 at 9:01 PM, Sumit Sahrawat, Maths & Computing, IIT (BHU)
wrote: On 12 May 2015 at 20:14, Roelof Wobben
wrote: Thanks,
The right solution was this :
init' (x:xs) = Just (x:fromMaybe xs (init' xs))
if I understand it right x:fromMaybe xs takes care that from xs the just or Nothing is removed ?
Trying it out in ghci,
fromMaybe [1,2] Nothing == [1,2] fromMaybe [1,2] Just [3] == [3]
It seems like that should indeed work.
Roelof
Alexey Shmalko schreef op 12-5-2015 om 16:33:
Try fromMaybe [1]. Examples
Prelude Data.Maybe> fromMaybe [] (Just [1,2,3]) [1,2,3] Prelude Data.Maybe> fromMaybe [1,2,3] Nothing [1,2,3]
[1]: https://hackage.haskell.org/package/base-4.8.0.0/docs/Data-Maybe.html#v:from...
On Tue, May 12, 2015 at 5:28 PM Roelof Wobben
wrote: > Oke, > > And how do I do this. Haskell is a difficult one to learn, > > Roelof > > > > Alexey Shmalko schreef op 12-5-2015 om 16:24: > > Before cons'ing the result of init', you should check whether it's > Just or Nothing. What you're doing now is something along the line with 5 : > Just 3 -- this won't typecheck. > > On Tue, May 12, 2015 at 5:22 PM Roelof Wobben
> wrote: > >> Brandon Allbery schreef op 12-5-2015 om 16:16: >> >> On Tue, May 12, 2015 at 10:11 AM, Roelof Wobben >> wrote: >> >>> I do not understand what you are saying to me. >>> >>> I know that init produces a Maybe [a] . That is why I did put a >>> Just before it. >>> >> >> You are invoking it again though, and using its result as if it >> produces [a] instead of Maybe [a]. >> >> -- >> brandon s allbery kf8nh sine nomine >> associates >> allbery.b@gmail.com >> ballbery@sinenomine.net >> unix, openafs, kerberos, infrastructure, xmonad >> http://sinenomine.net >> >> >> _______________________________________________ >> Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners >> >> >> What is then the right way to do. I still do not understand what >> you are trying to make clear to me. >> >> >> Roelof >> >> >> >> >> ------------------------------ >> [image: Avast logo] http://www.avast.com/ >> >> Dit e-mailbericht is gecontroleerd op virussen met Avast >> antivirussoftware. >> www.avast.com >> >> _______________________________________________ >> Beginners mailing list >> Beginners@haskell.org >> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners >> > > > _______________________________________________ > Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners > > > > > ------------------------------ > [image: Avast logo] http://www.avast.com/ > > Dit e-mailbericht is gecontroleerd op virussen met Avast > antivirussoftware. > www.avast.com > > _______________________________________________ > Beginners mailing list > Beginners@haskell.org > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners > _______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
-- Regards
Sumit Sahrawat
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing listBeginners@haskell.orghttp://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
------------------------------ [image: Avast logo] http://www.avast.com/
Dit e-mailbericht is gecontroleerd op virussen met Avast antivirussoftware. www.avast.com
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
-- Regards Sumit Sahrawat

On Tue, May 12, 2015 at 10:21 AM, Roelof Wobben
What is then the right way to do. I still do not understand what you are trying to make clear to me.
Ask yourself: what is the type of (Just (x: (init' xs))) ? -- brandon s allbery kf8nh sine nomine associates allbery.b@gmail.com ballbery@sinenomine.net unix, openafs, kerberos, infrastructure, xmonad http://sinenomine.net

The type of the cons operator (:) is
(:) :: a -> [a] -> [a]
The way you are invoking it expects it to have the type
(:) :: a -> Maybe [a] -> [a] -- not valid
One solution is to write such a function yourself, while the other would be
to rewrite your code to invoke it correctly.
On 12 May 2015 at 19:46, Brandon Allbery
On Tue, May 12, 2015 at 10:11 AM, Roelof Wobben
wrote: I do not understand what you are saying to me.
I know that init produces a Maybe [a] . That is why I did put a Just before it.
You are invoking it again though, and using its result as if it produces [a] instead of Maybe [a].
-- brandon s allbery kf8nh sine nomine associates allbery.b@gmail.com ballbery@sinenomine.net unix, openafs, kerberos, infrastructure, xmonad http://sinenomine.net
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
-- Regards Sumit Sahrawat

Also remember that Just has the type Just :: a -> Maybe a Thus putting in a Just doesn't help with your issue. On 12 May 2015 at 19:54, Sumit Sahrawat, Maths & Computing, IIT (BHU) < sumit.sahrawat.apm13@iitbhu.ac.in> wrote:
The type of the cons operator (:) is
(:) :: a -> [a] -> [a]
The way you are invoking it expects it to have the type
(:) :: a -> Maybe [a] -> [a] -- not valid
One solution is to write such a function yourself, while the other would be to rewrite your code to invoke it correctly.
On 12 May 2015 at 19:46, Brandon Allbery
wrote: On Tue, May 12, 2015 at 10:11 AM, Roelof Wobben
wrote: I do not understand what you are saying to me.
I know that init produces a Maybe [a] . That is why I did put a Just before it.
You are invoking it again though, and using its result as if it produces [a] instead of Maybe [a].
-- brandon s allbery kf8nh sine nomine associates allbery.b@gmail.com ballbery@sinenomine.net unix, openafs, kerberos, infrastructure, xmonad http://sinenomine.net
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
-- Regards
Sumit Sahrawat
-- Regards Sumit Sahrawat
participants (5)
-
akash g
-
Alexey Shmalko
-
Brandon Allbery
-
Roelof Wobben
-
Sumit Sahrawat, Maths & Computing, IIT (BHU)