Haskell beginner how did I get to IO ( IO String ) - haskell

Question

So I got it into my head to learn me some Haskell (boriing night shifts), and I put together a program that can ease my vacation planning by being able to calculate my shift for any giving period.
import System.Environment
import Data.List
import Data.List.Split
import Data.Time
import Data.Time.Calendar.WeekDate (toWeekDate)
-- merge xs and ys lists alternating value from each [ xs(0),ys(0),(xs(1),ys(1)..xs(n),ys(n) ]
merge :: [a] -> [a] -> [a]
merge xs [] = xs
merge [] ys = ys
merge (x:xs) (y:ys) = x : y : merge xs ys
-- get part of list from index 'start' to 'stop'
slice :: Int -> Int -> [a] -> [a]
slice start_from stop_at xs = fst $ splitAt (stop_at - start_from) (snd $ splitAt start_from xs)
timeFormat = "%d-%m-%Y"
timeFormatOut :: Day -> String
timeFormatOut = formatTime defaultTimeLocale "%d-%m-%Y"
-- parses Strings to DateTime Day1
parseMyDate :: String -> Day
parseMyDate = parseTimeOrError True defaultTimeLocale timeFormat
-- 8 week shift rotation
shiftRotation = cycle ["NAT","NAT","NAT","NAT","NAT","NAT","NAT","-","-","-","-","-","-","-","DAG","DAG","DAG","DAG","-","AFT","AFT","-","-","DAG","DAG","DAG","-","-","DAG","DAG","DAG","-","DAG","DAG","DAG","DAG","DAG","-","DAG","DAG","-","-","AFT","AFT","AFT","AFT","AFT","-","-","DAG(r)","DAG(r)","DAG(r)","DAG(r)","DAG(r)","(r)","(r)"]
hs_findshift :: String -> String -> String -> IO String
hs_findshift anchor start end = do
let dayZero = parseMyDate anchor
let startDate = parseMyDate start
let endDate = parseMyDate end
let startPos = fromIntegral (diffDays startDate dayZero)
let endPos = fromIntegral (diffDays endDate dayZero) + 1
let period = slice startPos endPos shiftRotation
let dates = map (timeFormatOut) [startDate..endDate]
let listStr = (concat(intersperse "," (merge dates period)))
putStrLn listStr
This works nicely. Now I throught I'd try and export it to a C# app so I could make a nice interface. I'm having some trouble with the it. I added
module Shiftlib where
import Foreign.C.String
import Foreign.C.Types
to the top. Right under the imports I added a block to convert inputs and outputs to C types.
foreign export ccall findshift :: CString -> CString -> CString -> IO CString
findshift :: CString -> CString -> CString -> IO CString
findshift a s e = do
anchor <- peekCString a
start <- peekCString s
end <- peekCString e
result <- hs_findshift anchor start end
return $ newCString result
now it doesn't compile. It seems that "return $ newCString result" returns an IO ( IO CString ) which the "foreign" call wont accept.
:l shiftlib
[1 of 1] Compiling Shiftlib ( shiftlib.hs, interpreted )
shiftlib.hs:53:1: error:
* Illegal foreign declaration: requires unregisterised, llvm (-fllvm) or native code generation (-fasm)
* When checking declaration:
foreign export ccall "findshift" findshift
:: CString -> CString -> CString -> IO CString
|
53 | foreign export ccall findshift :: CString -> CString -> CString -> IO CString
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
shiftlib.hs:61:5: error:
* Couldn't match type `IO CString' with `GHC.Ptr.Ptr CChar'
Expected type: IO CString
Actual type: IO (IO CString)
* In a stmt of a 'do' block: return $ newCString result
In the expression:
do anchor <- peekCString a
start <- peekCString s
end <- peekCString e
result <- hs_findshift anchor start end
....
In an equation for `findshift':
findshift a s e
= do anchor <- peekCString a
start <- peekCString s
end <- peekCString e
....
|
61 | return $ newCString result
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
Failed, no modules loaded.
I cant seem to get around it. How can I return a CString from my little module?

Answer 1

newCString :: String -> IO String
result :: String
newCString result :: IO String
return :: a -> IO a
return $ newCString result :: IO (IO String)
Simply stop when you already have the thing you want, newCString result.

Answer 2

When you work inside the IO monad, in a function of type foo :: .. -> .. -> IO T
the last entry in a do block must have type IO T.
return exists so that, if you only have T, you can wrap it inside IO. Essentially, an expression of type T evaluates to a value of type T without any side effects (e.g. printing messages, or mutating IORefs). return turns that value into an IO computation of type IO T. The type IO T is for expressions that could have side effects before returning T. return creates a computation that does no side effects, as a trivial subcase of IO T.
newCString result is already of type IO CString, so if you use return you get it wrapped too many times, as something of type IO (IO CString). This is a computation which does not return a string, but another computation to run (which will eventually produce a string).
The obvious solution here is to remove the return to avoid the redundant wrapping.
Another, not recommended, solution would be
do ...
...
string <- newCString result
return string
This would work since string would have type String, not IO CString. This is not recommended because it's redundant. Indeed, we could even add more redundancy as
do ...
...
string <- newCString result
string2 <- return string
string3 <- return string2
return string3
which would have the same effect. But this serves no purpose, and impacts readability.
Your code is perfectly fine as it is. Perhaps you also want to consider some alternatives using the "applicative style".
findshift :: CString -> CString -> CString -> IO CString
findshift a s e = do
result <- hs_findshift <$> peekCString a <*> peekCString s <*> peekCString e
newCString result
or even
findshift :: CString -> CString -> CString -> IO CString
findshift a s e =
hs_findshift <$> peekCString a <*> peekCString s <*> peekCString e >>= newCString
(I'm not a fan of this last one, though.)