Send Beginners mailing list submissions to
[email protected]
To subscribe or unsubscribe via the World Wide Web, visit
http://www.haskell.org/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
[email protected]
You can reach the person managing the list at
[email protected]
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. Re: help with IO guards (Mike Meyer)
2. Re: help with IO guards (Marcin Mrotek)
3. Re: help with IO guards (Julian Birch)
4. Re: help with IO guards (Miro Karpis)
----------------------------------------------------------------------
Message: 1
Date: Thu, 15 Jan 2015 15:01:19 -0600
From: Mike Meyer <[email protected]>
To: Miro Karpis <[email protected]>, The Haskell-Beginners
Mailing List - Discussion of primarily beginner-level topics related
to Haskell <[email protected]>
Subject: Re: [Haskell-beginners] help with IO guards
Message-ID:
<CAD=7U2BSxAA6QZnEtP-ofMtbnRZPZ=vmqrtvasg2s_gudrz...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
f has the wrong type. It needs to return a value in the IO monad. For
instance:
f: String -> IO String
f s = return (s ++ "!")
g :: IO String
g = readLn >>= f
You could also let f return a value of a type other than String, say:
f :: String -> IO ()
f = print
The type of >>= tells you this: Monad m => m a -> (a -> m b) -> m b. The
second argument has type a -> m b. String -> IO () or String -> IO String
both match that.
As a warning, readLn expects a Haskell value, and f requires that it be a
string. So you have to type in a string the way you would in a program, as
"Hello" or ['H', 'e', 'l', 'l', 'o'] or you'll get a parse failure.
On Thu, Jan 15, 2015 at 2:44 PM, Miro Karpis <[email protected]>
wrote:
> Many thanks everyone,.. but I'm not so confident with monads. If I
> understand I could translate with them for example IO String to String? If
> this is true I'm having troubles to achieve this.
>
> Here is my simple test (only to test the logic), which ends with error:
>
> Couldn't match type ?[]? with ?IO?
> Expected type: IO Char
> Actual type: String
> In the expression: f a
> In the second argument of ?(>>=)?, namely ?(\ a -> f a)?
>
>
>
> g = readLn
> >>= (\a -> f a)
>
> f :: String -> String
> f s_ = s_ ++ "!"
>
>
>
> Cheers, Miro
>
> On Thu, Jan 15, 2015 at 5:42 PM, Mike Meyer <[email protected]> wrote:
>
>> On Thu, Jan 15, 2015 at 9:24 AM, Dimitri DeFigueiredo <
>> [email protected]> wrote:
>>
>>> I would not say that the problem is with the guard check. The problem
>>> is with 'null'. It's type is
>>>
>>> Prelude> :t null
>>> null :: [a] -> Bool
>>>
>>> So, it expects a list of something, rather than an IO of something,
>>> whence the complaint.
>>>
>>
>>
>> While that's the source of the error, the problem is the combination of
>> the guard check and where to bind a value in the IO monad.
>>
>> Guard checks must have a value of Bool. getDBRecord returns something of
>> type IO [Int]. Where just binds a name, so you either need a way to extract
>> the [Int] from the return value before binding it in the where, or a
>> function of type IO [Int] -> Bool for the guard.
>>
>> Note that this isn't an IO issue but a monad issue. There isn't a monad
>> method that returns a value not in the monad, so you can't write either of
>> the two options above using monad methods. The best solution is the one
>> already proposed - write a function from [Int] -> IO String, and use bind
>> (>>=) on that function to handle things. You could also use the do sugaring
>> of <- to get a less functional version.
>>
>> The last option is to use the IO-specific function unsafePerformIO to
>> write something like nullIO = null . unsafePerformIO. But it's called
>> UNSAFE and tucked away in a module of similar operations for a reason.
>> Using bind is much preferred.
>>
>>
>>> On 15/01/15 09:51, Miro Karpis wrote:
>>>
>>> Hi,
>>>
>>> please is there a way to have guards with 'where' that communicates
>>> with IO? Or is there some other more elegant way? I can do this with
>>> classic if/else,...but I just find it nicer with guards.
>>>
>>>
>>> I have something like this (just an example):
>>>
>>>
>>> f :: Int -> IO String
>>> f x
>>> | null dbOutput = return "no db record"
>>> | otherwise = return "we got some db records"
>>> where dbOutput = getDBRecord x
>>>
>>>
>>> getDBRecord :: Int -> IO [Int]
>>> getDBRecord recordId = do
>>> putStrLn $ "checking dbRecord" ++ show recordId
>>> --getting data from DB
>>> return [1,2]
>>>
>>>
>>> problem is that db dbOutput is IO and the guard check does not like it:
>>>
>>> Couldn't match expected type ?[a0]? with actual type ?IO [Int]?
>>> In the first argument of ?null?, namely ?dbOutput?
>>> In the expression: null dbOutput
>>>
>>>
>>>
>>> Cheers,
>>> Miro
>>>
>>>
>>> _______________________________________________
>>> Beginners mailing
>>> [email protected]http://www.haskell.org/mailman/listinfo/beginners
>>>
>>>
>>>
>>> _______________________________________________
>>> Beginners mailing list
>>> [email protected]
>>> http://www.haskell.org/mailman/listinfo/beginners
>>>
>>>
>>
>> _______________________________________________
>> Beginners mailing list
>> [email protected]
>> http://www.haskell.org/mailman/listinfo/beginners
>>
>>
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20150115/66ef96a9/attachment-0001.html>
------------------------------
Message: 2
Date: Thu, 15 Jan 2015 22:03:35 +0100
From: Marcin Mrotek <[email protected]>
To: [email protected], The Haskell-Beginners Mailing List -
Discussion of primarily beginner-level topics related to Haskell
<[email protected]>
Subject: Re: [Haskell-beginners] help with IO guards
Message-ID:
<CAJcfPz=k9d0gm-ff-7zzb05qvcdwdl1piyi6agc1dk7fygh...@mail.gmail.com>
Content-Type: text/plain; charset=UTF-8
Hello,
A list ([]) is also a monad, and a String is defined as a list of
characters ([Char]). So in your example, it's as if you were trying to
use (>>=) operator on two different monads ([] and IO), which is
impossible. To make a pure value a monadic value, you need to use
return:
g = readLn >>= (\a -> return (f a))
which is equivalent to composing f with return:
g = readLn >>= return.f
Regards,
Marcin
------------------------------
Message: 3
Date: Thu, 15 Jan 2015 21:12:11 +0000
From: Julian Birch <[email protected]>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Subject: Re: [Haskell-beginners] help with IO guards
Message-ID:
<CAB0TuzCTRNjphPKGuGKaL3Y8QeofGbZ=ohuxropbds1hwsf...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
Going back to an earlier question: a monad is a bit like a roach motel. You
can check in but you can't leave. (This isn't true of every Monad, but the
point is there's no guarantees.) In particular, you can't go from IO String
to String _at all_. But you can, through Functor, pass it to a function
that takes a plain String. And through Monad, you can turn IO (IO String)
back to IO String.
Hope this helps.
On Thursday, January 15, 2015, Marcin Mrotek <[email protected]>
wrote:
> Hello,
>
> A list ([]) is also a monad, and a String is defined as a list of
> characters ([Char]). So in your example, it's as if you were trying to
> use (>>=) operator on two different monads ([] and IO), which is
> impossible. To make a pure value a monadic value, you need to use
> return:
>
> g = readLn >>= (\a -> return (f a))
>
> which is equivalent to composing f with return:
>
> g = readLn >>= return.f
>
> Regards,
> Marcin
> _______________________________________________
> Beginners mailing list
> [email protected] <javascript:;>
> http://www.haskell.org/mailman/listinfo/beginners
>
--
Sent from an iPhone, please excuse brevity and typos.
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20150115/af1423e4/attachment-0001.html>
------------------------------
Message: 4
Date: Thu, 15 Jan 2015 22:26:05 +0100
From: Miro Karpis <[email protected]>
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Subject: Re: [Haskell-beginners] help with IO guards
Message-ID:
<CAJnnbxFMNS1DkgPY4SNy=9MH=zxmx9aqzs8u1tx5ceky01u...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"
many thanks,....but then I unfortunately don't understand how can I fix my
initial problem:
to use IO check in guards - is that possible?
Regards,
Miro
On Thu, Jan 15, 2015 at 10:12 PM, Julian Birch <[email protected]>
wrote:
> Going back to an earlier question: a monad is a bit like a roach motel.
> You can check in but you can't leave. (This isn't true of every Monad, but
> the point is there's no guarantees.) In particular, you can't go from IO
> String to String _at all_. But you can, through Functor, pass it to a
> function that takes a plain String. And through Monad, you can turn IO
> (IO String) back to IO String.
>
> Hope this helps.
>
>
> On Thursday, January 15, 2015, Marcin Mrotek <[email protected]>
> wrote:
>
>> Hello,
>>
>> A list ([]) is also a monad, and a String is defined as a list of
>> characters ([Char]). So in your example, it's as if you were trying to
>> use (>>=) operator on two different monads ([] and IO), which is
>> impossible. To make a pure value a monadic value, you need to use
>> return:
>>
>> g = readLn >>= (\a -> return (f a))
>>
>> which is equivalent to composing f with return:
>>
>> g = readLn >>= return.f
>>
>> Regards,
>> Marcin
>> _______________________________________________
>> Beginners mailing list
>> [email protected]
>> http://www.haskell.org/mailman/listinfo/beginners
>>
>
>
> --
> Sent from an iPhone, please excuse brevity and typos.
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20150115/ef3d45f8/attachment.html>
------------------------------
Subject: Digest Footer
_______________________________________________
Beginners mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/beginners
------------------------------
End of Beginners Digest, Vol 79, Issue 18
*****************************************
