concatenate two Maybe String...

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
8 messages Options
Reply | Threaded
Open this post in threaded view
|

concatenate two Maybe String...

Damien Mattei
hello,

i have a variable resBDwords of type ( i expect) Maybe [String], for
info it is integer and fractional part of a number

example looks like this :
resBDwords =Just ["-04","3982"]

i want to concatanate "-04" and "3982" in the example, i begin to
understand fmap to use the functor hidden in the Maybe ,it worked
previously:

let resBDstr = fmap Tx.unpack resBDtxt
    putStr "resBDstr ="
    putStrLn (show resBDtxt)

    let resBDwords = fmap words resBDstr
    putStr "resBDwords ="
    putStrLn (show resBDwords)

which gives:

resBDtxt ="-04 3982"
resBDstr =Just "-04 3982"


just after in my code i have this to concatanate the two strings f and s
that are the first and second element of the array:


putStr "resBDwords ="
    putStrLn (show resBDwords)

    let lgBDwords = length resBDwords

    let resBDstrFloat = if lgBDwords == 0
                           then trace "WARNING: BD contains no words"
Nothing
                           else
                               if lgBDwords == 1
                                  then trace "WARNING: BD contains only
one word" fmap head resBDwords
                                  else let f = fmap head resBDwords
                                           s = fmap (head . tail) resBDwords
                                       in f ++ "." ++ S

but i do not know how to concatanate the Maybe String in an elegant way,
using somethin like fmap variable which have handled Nothing (from
Maybe) automatically i need the counter part for multipe variable

i do not want to do it using the hard way with case... of Just x ->
nothing .........

i got this error :
*Main> :load UpdateSidonie
[1 of 1] Compiling Main             ( UpdateSidonie.hs, interpreted )

UpdateSidonie.hs:339:43: error:
    • Couldn't match expected type ‘[Char]’
                  with actual type ‘Maybe String’
    • In the first argument of ‘(++)’, namely ‘f’
      In the expression: f ++ "." ++ s
      In the expression:
        let
          f = fmap head resBDwords
          s = fmap (head . tail) resBDwords
        in f ++ "." ++ s
    |
339 |                                        in f ++ "." ++ s
    |                                           ^

UpdateSidonie.hs:339:43: error:
    • Couldn't match expected type ‘Maybe String’
                  with actual type ‘[Char]’
    • In the expression: f ++ "." ++ s
      In the expression:
        let
          f = fmap head resBDwords
          s = fmap (head . tail) resBDwords
        in f ++ "." ++ s
      In the expression:
        if lgBDwords == 1 then
            trace "WARNING: BD contains only one word" fmap head resBDwords
        else
            let
              f = fmap head resBDwords
              s = fmap (head . tail) resBDwords
            in f ++ "." ++ s
    |
339 |                                        in f ++ "." ++ s
    |                                           ^^^^^^^^^^^^^

UpdateSidonie.hs:339:55: error:
    • Couldn't match expected type ‘[Char]’
                  with actual type ‘Maybe String’
    • In the second argument of ‘(++)’, namely ‘s’
      In the second argument of ‘(++)’, namely ‘"." ++ s’
      In the expression: f ++ "." ++ s
    |
339 |                                        in f ++ "." ++ s
    |                                                       ^
Failed, no modules loaded.

for now this page has been of valuable help:

https://pbrisbin.com/posts/maybe_is_just_awesome/

i'm sure it's an obvious question but.... :-)

_______________________________________________
Haskell-Cafe mailing list
To (un)subscribe, modify options or view archives go to:
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Only members subscribed via the mailman list are allowed to post.
Reply | Threaded
Open this post in threaded view
|

Re: concatenate two Maybe String...

joshchia
Firstly, because "resBDwords :: Maybe String", not "resBDwords :: String", "lgBDwords = length resBDwords" probably is not what you want -- it does not give you the number of words in the String that may be in there.

Second, for the problem you asked about, you could just use a function that takes a String and do it "the hard way" like you said, using case outside before calling the function. Another way is to use an applicative functor to allow you to have a "Maybe String -> Maybe String -> Maybe String". This is used once for each "++" that you want to do.

I don't know exactly what you need to accomplish but I would just write a function "f :: String -> Maybe String" implementing the logic you listed in the second code snippet but operating on String instead of "Maybe String" and do "join . fmap f $ resBDwords".

On Tue, Jan 8, 2019 at 12:13 AM Damien Mattei <[hidden email]> wrote:
hello,

i have a variable resBDwords of type ( i expect) Maybe [String], for
info it is integer and fractional part of a number

example looks like this :
resBDwords =Just ["-04","3982"]

i want to concatanate "-04" and "3982" in the example, i begin to
understand fmap to use the functor hidden in the Maybe ,it worked
previously:

let resBDstr = fmap Tx.unpack resBDtxt
    putStr "resBDstr ="
    putStrLn (show resBDtxt)

    let resBDwords = fmap words resBDstr
    putStr "resBDwords ="
    putStrLn (show resBDwords)

which gives:

resBDtxt ="-04 3982"
resBDstr =Just "-04 3982"


just after in my code i have this to concatanate the two strings f and s
that are the first and second element of the array:


putStr "resBDwords ="
    putStrLn (show resBDwords)

    let lgBDwords = length resBDwords

    let resBDstrFloat = if lgBDwords == 0
                           then trace "WARNING: BD contains no words"
Nothing
                           else
                               if lgBDwords == 1
                                  then trace "WARNING: BD contains only
one word" fmap head resBDwords
                                  else let f = fmap head resBDwords
                                           s = fmap (head . tail) resBDwords
                                       in f ++ "." ++ S

but i do not know how to concatanate the Maybe String in an elegant way,
using somethin like fmap variable which have handled Nothing (from
Maybe) automatically i need the counter part for multipe variable

i do not want to do it using the hard way with case... of Just x ->
nothing .........

i got this error :
*Main> :load UpdateSidonie
[1 of 1] Compiling Main             ( UpdateSidonie.hs, interpreted )

UpdateSidonie.hs:339:43: error:
    • Couldn't match expected type ‘[Char]’
                  with actual type ‘Maybe String’
    • In the first argument of ‘(++)’, namely ‘f’
      In the expression: f ++ "." ++ s
      In the expression:
        let
          f = fmap head resBDwords
          s = fmap (head . tail) resBDwords
        in f ++ "." ++ s
    |
339 |                                        in f ++ "." ++ s
    |                                           ^

UpdateSidonie.hs:339:43: error:
    • Couldn't match expected type ‘Maybe String’
                  with actual type ‘[Char]’
    • In the expression: f ++ "." ++ s
      In the expression:
        let
          f = fmap head resBDwords
          s = fmap (head . tail) resBDwords
        in f ++ "." ++ s
      In the expression:
        if lgBDwords == 1 then
            trace "WARNING: BD contains only one word" fmap head resBDwords
        else
            let
              f = fmap head resBDwords
              s = fmap (head . tail) resBDwords
            in f ++ "." ++ s
    |
339 |                                        in f ++ "." ++ s
    |                                           ^^^^^^^^^^^^^

UpdateSidonie.hs:339:55: error:
    • Couldn't match expected type ‘[Char]’
                  with actual type ‘Maybe String’
    • In the second argument of ‘(++)’, namely ‘s’
      In the second argument of ‘(++)’, namely ‘"." ++ s’
      In the expression: f ++ "." ++ s
    |
339 |                                        in f ++ "." ++ s
    |                                                       ^
Failed, no modules loaded.

for now this page has been of valuable help:

https://pbrisbin.com/posts/maybe_is_just_awesome/

i'm sure it's an obvious question but.... :-)

_______________________________________________
Haskell-Cafe mailing list
To (un)subscribe, modify options or view archives go to:
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Only members subscribed via the mailman list are allowed to post.

_______________________________________________
Haskell-Cafe mailing list
To (un)subscribe, modify options or view archives go to:
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Only members subscribed via the mailman list are allowed to post.
Reply | Threaded
Open this post in threaded view
|

concatenate two Maybe String...

Jake


On Mon, Jan 7, 2019 at 5:55 PM Jake <[hidden email]> wrote:
Like Josh mentioned, Applicative Functors are what you want. There are two idiomatic ways to do it:
  • You can just use liftA2, which has type (a -> b -> c) -> f a -> f b -> f c. That means it lifts a binary function to some applicative functor like maybe, so liftA2 (++) :: Maybe String -> Maybe String -> Maybe String
  • In general, for any arity f that you want to lift to an applicative functor. So you have a function g that takes a bunch of arguments of types a, b, c, ... and gives you back an r and you want to get a function that takes an f a, f b, f c, ... and gives you back an f r, you can write f <$> a <*> b <*> c ... This works because <$> let's you apply g to type f a and gives you an f (b -> c ..) -> f r, and <*> basically let's you take the function back out of the f and apply it to the b to get a f (c ..) -> f r and so on. tl;dr you can write (++) <$> s1 <*> s2. In fact, liftA2 must satisfy the equation liftA2 f x y = f <$> x <*>so these are the same thing.
בתאריך יום ב׳, 7 בינו׳ 2019, 17:41, מאת ☂Josh Chia (謝任中) <[hidden email]>:
Firstly, because "resBDwords :: Maybe String", not "resBDwords :: String", "lgBDwords = length resBDwords" probably is not what you want -- it does not give you the number of words in the String that may be in there.

Second, for the problem you asked about, you could just use a function that takes a String and do it "the hard way" like you said, using case outside before calling the function. Another way is to use an applicative functor to allow you to have a "Maybe String -> Maybe String -> Maybe String". This is used once for each "++" that you want to do.

I don't know exactly what you need to accomplish but I would just write a function "f :: String -> Maybe String" implementing the logic you listed in the second code snippet but operating on String instead of "Maybe String" and do "join . fmap f $ resBDwords".

On Tue, Jan 8, 2019 at 12:13 AM Damien Mattei <[hidden email]> wrote:
hello,

i have a variable resBDwords of type ( i expect) Maybe [String], for
info it is integer and fractional part of a number

example looks like this :
resBDwords =Just ["-04","3982"]

i want to concatanate "-04" and "3982" in the example, i begin to
understand fmap to use the functor hidden in the Maybe ,it worked
previously:

let resBDstr = fmap Tx.unpack resBDtxt
    putStr "resBDstr ="
    putStrLn (show resBDtxt)

    let resBDwords = fmap words resBDstr
    putStr "resBDwords ="
    putStrLn (show resBDwords)

which gives:

resBDtxt ="-04 3982"
resBDstr =Just "-04 3982"


just after in my code i have this to concatanate the two strings f and s
that are the first and second element of the array:


putStr "resBDwords ="
    putStrLn (show resBDwords)

    let lgBDwords = length resBDwords

    let resBDstrFloat = if lgBDwords == 0
                           then trace "WARNING: BD contains no words"
Nothing
                           else
                               if lgBDwords == 1
                                  then trace "WARNING: BD contains only
one word" fmap head resBDwords
                                  else let f = fmap head resBDwords
                                           s = fmap (head . tail) resBDwords
                                       in f ++ "." ++ S

but i do not know how to concatanate the Maybe String in an elegant way,
using somethin like fmap variable which have handled Nothing (from
Maybe) automatically i need the counter part for multipe variable

i do not want to do it using the hard way with case... of Just x ->
nothing .........

i got this error :
*Main> :load UpdateSidonie
[1 of 1] Compiling Main             ( UpdateSidonie.hs, interpreted )

UpdateSidonie.hs:339:43: error:
    • Couldn't match expected type ‘[Char]’
                  with actual type ‘Maybe String’
    • In the first argument of ‘(++)’, namely ‘f’
      In the expression: f ++ "." ++ s
      In the expression:
        let
          f = fmap head resBDwords
          s = fmap (head . tail) resBDwords
        in f ++ "." ++ s
    |
339 |                                        in f ++ "." ++ s
    |                                           ^

UpdateSidonie.hs:339:43: error:
    • Couldn't match expected type ‘Maybe String’
                  with actual type ‘[Char]’
    • In the expression: f ++ "." ++ s
      In the expression:
        let
          f = fmap head resBDwords
          s = fmap (head . tail) resBDwords
        in f ++ "." ++ s
      In the expression:
        if lgBDwords == 1 then
            trace "WARNING: BD contains only one word" fmap head resBDwords
        else
            let
              f = fmap head resBDwords
              s = fmap (head . tail) resBDwords
            in f ++ "." ++ s
    |
339 |                                        in f ++ "." ++ s
    |                                           ^^^^^^^^^^^^^

UpdateSidonie.hs:339:55: error:
    • Couldn't match expected type ‘[Char]’
                  with actual type ‘Maybe String’
    • In the second argument of ‘(++)’, namely ‘s’
      In the second argument of ‘(++)’, namely ‘"." ++ s’
      In the expression: f ++ "." ++ s
    |
339 |                                        in f ++ "." ++ s
    |                                                       ^
Failed, no modules loaded.

for now this page has been of valuable help:

https://pbrisbin.com/posts/maybe_is_just_awesome/

i'm sure it's an obvious question but.... :-)

_______________________________________________
Haskell-Cafe mailing list
To (un)subscribe, modify options or view archives go to:
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Only members subscribed via the mailman list are allowed to post.
_______________________________________________
Haskell-Cafe mailing list
To (un)subscribe, modify options or view archives go to:
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Only members subscribed via the mailman list are allowed to post.

_______________________________________________
Haskell-Cafe mailing list
To (un)subscribe, modify options or view archives go to:
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Only members subscribed via the mailman list are allowed to post.
Reply | Threaded
Open this post in threaded view
|

Re: concatenate two Maybe String...

Steven Shaw
A quick and dirty answer might be:

  fmap (Data.Text.intercalate ".") resBDwords

I'd probably write it:

  Data.Text.intercalate "." <$> resBDwords

but you'd probably want to check your input has exactly two elements. You could use pattern matching:

  f (Just [a, b]) = Just $ a <> "." <> b
  f _             = Nothing

Then (f resBDwords) gives you what you want I think and avoids head and tail.

_______________________________________________
Haskell-Cafe mailing list
To (un)subscribe, modify options or view archives go to:
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Only members subscribed via the mailman list are allowed to post.
Reply | Threaded
Open this post in threaded view
|

Re: concatenate two Maybe String...

Tom Ellis-5
In reply to this post by Damien Mattei
On Mon, Jan 07, 2019 at 05:13:13PM +0100, Damien Mattei wrote:
> just after in my code i have this to concatanate the two strings f and s
> that are the first and second element of the array:
...
> i do not want to do it using the hard way with case... of Just x ->
> nothing .........

Just do it the hard way and get some code that works.  You can always
"improve" it later if you like.  "Hard" code that works is orders of
magnitude more valuable that "easy" code that doesn't.
_______________________________________________
Haskell-Cafe mailing list
To (un)subscribe, modify options or view archives go to:
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Only members subscribed via the mailman list are allowed to post.
Reply | Threaded
Open this post in threaded view
|

Re: concatenate two Maybe String...

Damien Mattei-2
In reply to this post by Jake
i had this solution for now:

let resBDstrFloat = if lgBDwords == Just 0
                           then trace "WARNING: BD contains no words" Nothing
                           else
                               if lgBDwords == Just 1
                                  then trace "WARNING: BD contains only one word" fmap head resBDwords
                                  else let f = fmap head resBDwords
                                           s = fmap (head . tail) resBDwords
                                           mp = Just "." :: Maybe String
                                           (+++) = liftM2 (++)
                                       in f +++ mp +++ s

still searching to express it with <*> ..., also there is the problem of if i define "." simply as it is not a Maybe String it fails, perheaps some viadic function that accept multi-type variable but this is complex to do.

On Mon, Jan 7, 2019 at 11:58 PM Jake <[hidden email]> wrote:


On Mon, Jan 7, 2019 at 5:55 PM Jake <[hidden email]> wrote:
Like Josh mentioned, Applicative Functors are what you want. There are two idiomatic ways to do it:
  • You can just use liftA2, which has type (a -> b -> c) -> f a -> f b -> f c. That means it lifts a binary function to some applicative functor like maybe, so liftA2 (++) :: Maybe String -> Maybe String -> Maybe String
  • In general, for any arity f that you want to lift to an applicative functor. So you have a function g that takes a bunch of arguments of types a, b, c, ... and gives you back an r and you want to get a function that takes an f a, f b, f c, ... and gives you back an f r, you can write f <$> a <*> b <*> c ... This works because <$> let's you apply g to type f a and gives you an f (b -> c ..) -> f r, and <*> basically let's you take the function back out of the f and apply it to the b to get a f (c ..) -> f r and so on. tl;dr you can write (++) <$> s1 <*> s2. In fact, liftA2 must satisfy the equation liftA2 f x y = f <$> x <*>so these are the same thing.
בתאריך יום ב׳, 7 בינו׳ 2019, 17:41, מאת ☂Josh Chia (謝任中) <[hidden email]>:
Firstly, because "resBDwords :: Maybe String", not "resBDwords :: String", "lgBDwords = length resBDwords" probably is not what you want -- it does not give you the number of words in the String that may be in there.

Second, for the problem you asked about, you could just use a function that takes a String and do it "the hard way" like you said, using case outside before calling the function. Another way is to use an applicative functor to allow you to have a "Maybe String -> Maybe String -> Maybe String". This is used once for each "++" that you want to do.

I don't know exactly what you need to accomplish but I would just write a function "f :: String -> Maybe String" implementing the logic you listed in the second code snippet but operating on String instead of "Maybe String" and do "join . fmap f $ resBDwords".

On Tue, Jan 8, 2019 at 12:13 AM Damien Mattei <[hidden email]> wrote:
hello,

i have a variable resBDwords of type ( i expect) Maybe [String], for
info it is integer and fractional part of a number

example looks like this :
resBDwords =Just ["-04","3982"]

i want to concatanate "-04" and "3982" in the example, i begin to
understand fmap to use the functor hidden in the Maybe ,it worked
previously:

let resBDstr = fmap Tx.unpack resBDtxt
    putStr "resBDstr ="
    putStrLn (show resBDtxt)

    let resBDwords = fmap words resBDstr
    putStr "resBDwords ="
    putStrLn (show resBDwords)

which gives:

resBDtxt ="-04 3982"
resBDstr =Just "-04 3982"


just after in my code i have this to concatanate the two strings f and s
that are the first and second element of the array:


putStr "resBDwords ="
    putStrLn (show resBDwords)

    let lgBDwords = length resBDwords

    let resBDstrFloat = if lgBDwords == 0
                           then trace "WARNING: BD contains no words"
Nothing
                           else
                               if lgBDwords == 1
                                  then trace "WARNING: BD contains only
one word" fmap head resBDwords
                                  else let f = fmap head resBDwords
                                           s = fmap (head . tail) resBDwords
                                       in f ++ "." ++ S

but i do not know how to concatanate the Maybe String in an elegant way,
using somethin like fmap variable which have handled Nothing (from
Maybe) automatically i need the counter part for multipe variable

i do not want to do it using the hard way with case... of Just x ->
nothing .........

i got this error :
*Main> :load UpdateSidonie
[1 of 1] Compiling Main             ( UpdateSidonie.hs, interpreted )

UpdateSidonie.hs:339:43: error:
    • Couldn't match expected type ‘[Char]’
                  with actual type ‘Maybe String’
    • In the first argument of ‘(++)’, namely ‘f’
      In the expression: f ++ "." ++ s
      In the expression:
        let
          f = fmap head resBDwords
          s = fmap (head . tail) resBDwords
        in f ++ "." ++ s
    |
339 |                                        in f ++ "." ++ s
    |                                           ^

UpdateSidonie.hs:339:43: error:
    • Couldn't match expected type ‘Maybe String’
                  with actual type ‘[Char]’
    • In the expression: f ++ "." ++ s
      In the expression:
        let
          f = fmap head resBDwords
          s = fmap (head . tail) resBDwords
        in f ++ "." ++ s
      In the expression:
        if lgBDwords == 1 then
            trace "WARNING: BD contains only one word" fmap head resBDwords
        else
            let
              f = fmap head resBDwords
              s = fmap (head . tail) resBDwords
            in f ++ "." ++ s
    |
339 |                                        in f ++ "." ++ s
    |                                           ^^^^^^^^^^^^^

UpdateSidonie.hs:339:55: error:
    • Couldn't match expected type ‘[Char]’
                  with actual type ‘Maybe String’
    • In the second argument of ‘(++)’, namely ‘s’
      In the second argument of ‘(++)’, namely ‘"." ++ s’
      In the expression: f ++ "." ++ s
    |
339 |                                        in f ++ "." ++ s
    |                                                       ^
Failed, no modules loaded.

for now this page has been of valuable help:

https://pbrisbin.com/posts/maybe_is_just_awesome/

i'm sure it's an obvious question but.... :-)

_______________________________________________
Haskell-Cafe mailing list
To (un)subscribe, modify options or view archives go to:
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Only members subscribed via the mailman list are allowed to post.
_______________________________________________
Haskell-Cafe mailing list
To (un)subscribe, modify options or view archives go to:
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Only members subscribed via the mailman list are allowed to post.
_______________________________________________
Haskell-Cafe mailing list
To (un)subscribe, modify options or view archives go to:
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Only members subscribed via the mailman list are allowed to post.

_______________________________________________
Haskell-Cafe mailing list
To (un)subscribe, modify options or view archives go to:
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Only members subscribed via the mailman list are allowed to post.
Reply | Threaded
Open this post in threaded view
|

Re: concatenate two Maybe String...

S. Doaitse Swierstra
Something like:

resBDstrFloat =
  case resDBWords of
    Nothing       -> trace "WARNING: BD contains no words”      Nothing
    Just []       -> trace "WARNING: BD contains no words”      Nothing
    Just [v]      -> trace "WARNING: BD contains only one word” (Just v)
    Just [v1,v2]) -> Just (v1 ++ “.” ++ v2)
    -             -> trace “unexpected garbage” Nothing

seems optimal and easiest to understand to me,

 Doaitse

 

> Op 8 jan. 2019, om 11:40 heeft Damien Mattei <[hidden email]> het volgende geschreven:
>
> i had this solution for now:
>
> let resBDstrFloat = if lgBDwords == Just 0
>                            then trace "WARNING: BD contains no words" Nothing
>                            else
>                                if lgBDwords == Just 1
>                                   then trace "WARNING: BD contains only one word" fmap head resBDwords
>                                   else let f = fmap head resBDwords
>                                            s = fmap (head . tail) resBDwords
>                                            mp = Just "." :: Maybe String
>                                            (+++) = liftM2 (++)
>                                        in f +++ mp +++ s
>
> still searching to express it with <*> ..., also there is the problem of if i define "." simply as it is not a Maybe String it fails, perheaps some viadic function that accept multi-type variable but this is complex to do.
>
> On Mon, Jan 7, 2019 at 11:58 PM Jake <[hidden email]> wrote:
>
>
> On Mon, Jan 7, 2019 at 5:55 PM Jake <[hidden email]> wrote:
> Like Josh mentioned, Applicative Functors are what you want. There are two idiomatic ways to do it:
> • You can just use liftA2, which has type (a -> b -> c) -> f a -> f b -> f c. That means it lifts a binary function to some applicative functor like maybe, so liftA2 (++) :: Maybe String -> Maybe String -> Maybe String
> • In general, for any arity f that you want to lift to an applicative functor. So you have a function g that takes a bunch of arguments of types a, b, c, ... and gives you back an r and you want to get a function that takes an f a, f b, f c, ... and gives you back an f r, you can write f <$> a <*> b <*> c ... This works because <$> let's you apply g to type f a and gives you an f (b -> c ..) -> f r, and <*> basically let's you take the function back out of the f and apply it to the b to get a f (c ..) -> f r and so on. tl;dr you can write (++) <$> s1 <*> s2. In fact, liftA2 must satisfy the equation liftA2 f x y = f <$> x <*> y so these are the same thing.
> בתאריך יום ב׳, 7 בינו׳ 2019, 17:41, מאת ☂Josh Chia (謝任中) <[hidden email]>:
> Firstly, because "resBDwords :: Maybe String", not "resBDwords :: String", "lgBDwords = length resBDwords" probably is not what you want -- it does not give you the number of words in the String that may be in there.
>
> Second, for the problem you asked about, you could just use a function that takes a String and do it "the hard way" like you said, using case outside before calling the function. Another way is to use an applicative functor to allow you to have a "Maybe String -> Maybe String -> Maybe String". This is used once for each "++" that you want to do.
>
> I don't know exactly what you need to accomplish but I would just write a function "f :: String -> Maybe String" implementing the logic you listed in the second code snippet but operating on String instead of "Maybe String" and do "join . fmap f $ resBDwords".
>
> On Tue, Jan 8, 2019 at 12:13 AM Damien Mattei <[hidden email]> wrote:
> hello,
>
> i have a variable resBDwords of type ( i expect) Maybe [String], for
> info it is integer and fractional part of a number
>
> example looks like this :
> resBDwords =Just ["-04","3982"]
>
> i want to concatanate "-04" and "3982" in the example, i begin to
> understand fmap to use the functor hidden in the Maybe ,it worked
> previously:
>
> let resBDstr = fmap Tx.unpack resBDtxt
>     putStr "resBDstr ="
>     putStrLn (show resBDtxt)
>
>     let resBDwords = fmap words resBDstr
>     putStr "resBDwords ="
>     putStrLn (show resBDwords)
>
> which gives:
>
> resBDtxt ="-04 3982"
> resBDstr =Just "-04 3982"
>
>
> just after in my code i have this to concatanate the two strings f and s
> that are the first and second element of the array:
>
>
> putStr "resBDwords ="
>     putStrLn (show resBDwords)
>
>     let lgBDwords = length resBDwords
>
>     let resBDstrFloat = if lgBDwords == 0
>                            then trace "WARNING: BD contains no words"
> Nothing
>                            else
>                                if lgBDwords == 1
>                                   then trace "WARNING: BD contains only
> one word" fmap head resBDwords
>                                   else let f = fmap head resBDwords
>                                            s = fmap (head . tail) resBDwords
>                                        in f ++ "." ++ S
>
> but i do not know how to concatanate the Maybe String in an elegant way,
> using somethin like fmap variable which have handled Nothing (from
> Maybe) automatically i need the counter part for multipe variable
>
> i do not want to do it using the hard way with case... of Just x ->
> nothing .........
>
> i got this error :
> *Main> :load UpdateSidonie
> [1 of 1] Compiling Main             ( UpdateSidonie.hs, interpreted )
>
> UpdateSidonie.hs:339:43: error:
>     • Couldn't match expected type ‘[Char]’
>                   with actual type ‘Maybe String’
>     • In the first argument of ‘(++)’, namely ‘f’
>       In the expression: f ++ "." ++ s
>       In the expression:
>         let
>           f = fmap head resBDwords
>           s = fmap (head . tail) resBDwords
>         in f ++ "." ++ s
>     |
> 339 |                                        in f ++ "." ++ s
>     |                                           ^
>
> UpdateSidonie.hs:339:43: error:
>     • Couldn't match expected type ‘Maybe String’
>                   with actual type ‘[Char]’
>     • In the expression: f ++ "." ++ s
>       In the expression:
>         let
>           f = fmap head resBDwords
>           s = fmap (head . tail) resBDwords
>         in f ++ "." ++ s
>       In the expression:
>         if lgBDwords == 1 then
>             trace "WARNING: BD contains only one word" fmap head resBDwords
>         else
>             let
>               f = fmap head resBDwords
>               s = fmap (head . tail) resBDwords
>             in f ++ "." ++ s
>     |
> 339 |                                        in f ++ "." ++ s
>     |                                           ^^^^^^^^^^^^^
>
> UpdateSidonie.hs:339:55: error:
>     • Couldn't match expected type ‘[Char]’
>                   with actual type ‘Maybe String’
>     • In the second argument of ‘(++)’, namely ‘s’
>       In the second argument of ‘(++)’, namely ‘"." ++ s’
>       In the expression: f ++ "." ++ s
>     |
> 339 |                                        in f ++ "." ++ s
>     |                                                       ^
> Failed, no modules loaded.
>
> for now this page has been of valuable help:
>
> https://pbrisbin.com/posts/maybe_is_just_awesome/
>
> i'm sure it's an obvious question but.... :-)
>
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.

_______________________________________________
Haskell-Cafe mailing list
To (un)subscribe, modify options or view archives go to:
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Only members subscribed via the mailman list are allowed to post.
Reply | Threaded
Open this post in threaded view
|

Re: concatenate two Maybe String...

Damien Mattei
In reply to this post by Tom Ellis-5
from the previous solution and posts i can deduce this solution to
concatanate N Maybe String, the function could be written:

(+++) = \x y -> (++) <$> x <*> y

this is basically equivalent to the previous one:

(+++) = liftM2 (++)

on f +++ mp +++ s i get results like:
resBDstrFloat =Just "-04.3982"
i will stay with those solutions.
Le 08/01/2019 08:47, Tom Ellis a écrit :

> On Mon, Jan 07, 2019 at 05:13:13PM +0100, Damien Mattei wrote:
>> just after in my code i have this to concatanate the two strings f and s
>> that are the first and second element of the array:
> ...
>> i do not want to do it using the hard way with case... of Just x ->
>> nothing .........
>
> Just do it the hard way and get some code that works.  You can always
> "improve" it later if you like.  "Hard" code that works is orders of
> magnitude more valuable that "easy" code that doesn't.
> _______________________________________________
> Haskell-Cafe mailing list
> To (un)subscribe, modify options or view archives go to:
> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
> Only members subscribed via the mailman list are allowed to post.
>

--
[hidden email], [hidden email], UNS / OCA / CNRS
_______________________________________________
Haskell-Cafe mailing list
To (un)subscribe, modify options or view archives go to:
http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe
Only members subscribed via the mailman list are allowed to post.