How do I match types in Haskell so the expected type matches the actual type?

Question

Attempting to implement fizzBuzz with some command line using optparse-applicative.

import Options.Applicative
data Args = Args { firstDivisor :: Int,
                 secondDivisor :: Int,
                 upperBound :: Int }
fizzBuzz :: Args -> IO ()
fizzBuzz opts i
    | i `mod` firstDivisor opts == 0 && i `mod` secondDivisor opts == 0 = "fizzBuzz"
    | i `mod` firstDivisor opts == 0 = "fizz"
    | i `mod` secondDivisor opts == 0 = "buzz"
    | otherwise = show i
main :: IO ()
main = print fizzBuzz

I have it set up to take in three command line arguments; two divisors(in fizzBuzz usually 3 and 5), and the third being the upper limit(usually 100), but when I go to compile I get an error saying:

Couldn't match expected type ‘Int -> [Char]’
            with actual type ‘IO ()’
The equation(s) for ‘fizzBuzz’ have two arguments,
but its type ‘Args -> IO ()’ has only one

My main goal is to just print out the fizzBuzz series with the three command line args. From what I understand, it isn't liking that I supplied fizzBuzz with an extra parameter. Trying to understand why 'i' wouldn't work here.

---

UPDATE:

This code I feel is closer, as it addresses the command line with getArgs instead of optparse. Also added a list to run against fizzBuzz.

import System.Environment

main :: IO ()
main = do
    [s1,s2,s3] <- getArgs
    print m
m = [ fizzBuzz i| i <-[1..s3]]
fizzBuzz i
  | i `mod` s1 == 0 && s1 `mod` s2 == 0 = "fizzBuzz"
  | i `mod` s1 == 0 = "fizz"
  | i `mod` s2 == 0 = "buzz"
  | otherwise = show i

So my problem is that I cannot access the s1 and s2 variables in order to get my fizzBuzz goin. How can I access those args outside of the scope of main? Maybe there is another function that can help?

Answer 1

How can I access those args outside of the scope of main?

You can't. That precisely the point of a scope: variables inside stay inside, nicely encapsulated, preventing any hard-to-trace data dependencies.

The easiest way to accomplish the goal of accessing s1 s2 s3 is to simply define fizzbuzz in the scope of main:

main :: IO ()
main = do
   [s1,s2,s3] <- map read<$>getArgs  -- more on this later
   let fizzBuzz i
         | i `mod` s1 == 0 && s1 `mod` s2 == 0 = "fizzBuzz"
         | i `mod` s1 == 0 = "fizz"
         | i `mod` s2 == 0 = "buzz"
         | otherwise = show i
       m = [fizzBuzz i| i <-[1..s3]]
   print m

However, that's not necessarily the best approach – you'd essentially create one big pseudo-global IO scope. Mind, this is nowhere as dangerous as global variables in imperative languages, but at least if you want to also use fizzBuzz in some other context, this is clearly not optimal.

The correct way is, of course, to pass in those variables as function arguments. Quite like you already had it – I find it strange that you removed this again.

So, first of all figure out the signature of fizzBuzz. What does it need, and what does it yield? Well, it needs all those divisors. Hence it actually made a lot of sense to give it an Args argument. But it also needs the number i, which is simply an Int. As for the result... why would it be IO ()? fizzBuzz is a perfectly good pure function, yielding a string. So...

fizzBuzz :: Args -> Int -> String

Well, now you're fine. The definition actually looks completely right the way you've originally had it. (But generally, it's much more sensible to first get the type signature right, then worry about how to actually implement it.)

Now you just need to invoke this function. I'd first play around with it in GHCi a bit before writing any main function at all:

$ ghci FizzBuzz.hs
GHCi, version 7.10.2: http://www.haskell.org/ghc/  :? for help
[1 of 1] Compiling Main             ( FizzBuzz.hs, interpreted )
Ok, modules loaded: Main.
*Main> fizzBuzz (Args 3 4 9) 3
"fizz"
*Main> fizzBuzz (Args 3 4 9) 5
"5"
...

If you think that it works right, you may wrap it into an actual program.

Note that the Args data structure doesn't really have anything to do with the OptParse library. That library makes sense to use for proper command-line programs, but it's overkill here. Nevertheless, it makes a lot of sense to use the Args type for passing those divisors into the function, as I've already showed.

I'd now just use getArgs for fetching the arguments, and manually wrap them into the Args structure:

module Main where

import System.Environment (getArgs)

main :: IO ()
main = do
   [s₁,s₂,s₃] <- getArgs
   let divisors = Args (read s₁) (read s₂) (read s₃)
   m = [fizzBuzz divisors i | i<-[1..read s₃]]
   print m

You may wonder what's up with all that read. Well, getArgs gives you the command-line parameters as they come from the shell: as strings. But you need to interpret, i.e. read those strings as integers. Note that read is pretty unsafe: if the input is not a valid integer literal, the program will crash. Probably not a problem for you right now, but this is one of the things that optparse would nicely solve for you.

Since you don't really need the parameters in string form at all, you might just as well read all of them before even matching out the individual parameters:

main :: IO ()
main = do
   [s₁,s₂,s₃] <- map read <$> getArgs
   let divisors = Args s₁ s₂ s₃
   m = [fizzBuzz divisors i | i<-[1..s₃]]
   print m