How can I add without having to use an arithmetic operator in Haskell?

I don't understand why you want all of this. What you're trying to implement is called variadic function. Haskell doesn't really support these, and I really don't believe it makes sense to use them for your application. What's wrong with cookies 1 + chocolate 2?

That said, the Haskell2010 / GHC-Haskell type system is sufficiently flexible to allow hacking together variadic functions:

{-# LANGUAGE TypeFamilies, FlexibleInstances #-}

class Crumbles c where
  crumble :: Int -> c
instance Crumbles Int where
  crumble = id
instance (f ~ (Int -> Int), i ~ Int, Crumbles c) => Crumbles (f -> i -> c) where
  crumble acc f i = crumble $ f i + acc

Now you can do

cookies :: Crumbles c => Int -> c
cookies n = crumble $ n*10

chocolate :: Crumbles c => Int -> c
chocolate n = crumble $ n*5

goodies :: [Int]
goodies = [ cookies 1  -- 10
          , cookies 1 chocolate 1   -- 15
          , cookies 1 chocolate 1 cookies 100000  -- 1000015
          ]

main :: IO ()
main = print goodies

...giving [10,15,1000015].

I don't know if Hugs supports the TypeFamilies extension that's needed for the equational constraints f ~ (Int -> Int) and i ~ Int.

What I suspect the task is going for is something entirely different, namely, how to implement cookies :: Int -> Int without using either addition nor multiplication, i.e. without writing *10 nor 10 + cookies (n-1). The answer they probably want should use only the succ and pred functions (which are equivalent to +1 and -1, respectively).

Don't try to write functions named cookies and chocolate which, when typed into the hugs interpreter, behave that way.

Instead, try to write an IO action which accepts input, parses it, and does the appropriate computation. You may like the interact function, which takes a function on Strings and runs it on things the user types:

interact :: (String -> String) -> IO ()

For example, with runhaskell (which is very similar to hugs), the following code:

main = interact $ \s ->
    "What is your name?\n" ++
    filter (/='\n') s ++ ", nice to meet you!\n"

produces the following interaction:

% runhaskell test.hs
What is your name?
Daniel
Daniel, nice to meet you!

Note that I pressed the EOF button after typing Daniel and pressing enter; on Linux this is ctrl-d but I believe on Windows it is ctrl-z. Note also that nowhere in the code is there a definition for Daniel -- this Daniel that I typed in is not a Haskell term, but rather is input read by running the Haskell term main.

Like Daniel Wagner, I suspect this question is misguided. I find it hard to believe that the assignment is asking for functions cookies and chocolate that can be combined in this way. Rather, it’s probably asking for a function calculate :: String -> Int which accepts the string "cookies 1 chocolate 2", parses it, and returns the result.

For that, a solution is pretty simple—so I won’t give it away. Break the problem down into small steps like these:

• "cookies 1 chocolate 2"

• ["cookies", "1", "chocolate", "2"]

• [("cookies", 1), ("chocolate", 2)]

• [10, 10]

• 20

Write a function for each step, and a main that asks for input and calls these functions to calculate the final result. Bonus points if you consider how to use Maybe or Either to handle errors in the input, such as an unknown item, a non-numeric quantity, a missing quantity, &c.