Question

I’m used to being able to define optional arguments like so in Python:

def product(a, b=2):
    return a * b

Haskell doesn’t have default arguments, but I was able to get something similar by using a Maybe:

product a (Just b) = a * b
product a Nothing = a * 2

This becomes cumbersome very quickly if you have more than multiple parameters though. For example, what if I want to do something like this:

def multiProduct (a, b=10, c=20, d=30):
    return a * b * c * d

I would have to have eight definitions of multiProduct to account for all cases.

Instead, I decided to go with this:

multiProduct req1 opt1 opt2 opt3 = req1 * opt1' * opt2' * opt3'
    where opt1' = if isJust opt1 then (fromJust opt1) else 10
    where opt2' = if isJust opt2 then (fromJust opt2) else 20
    where opt3' = if isJust opt3 then (fromJust opt3) else 30

That looks very inelegant to me. Is there an idiomatic way to do this in Haskell that is cleaner?

Answer 1

Here’s yet another way to do optional arguments in Haskell:

{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, FlexibleContexts #-}
module Optional where

class Optional1 a b r where 
  opt1 :: (a -> b) -> a -> r

instance Optional1 a b b where
  opt1 = id

instance Optional1 a b (a -> b) where
  opt1 = const

class Optional2 a b c r where 
  opt2 :: (a -> b -> c) -> a -> b -> r

instance Optional2 a b c c where
  opt2 = id

instance (Optional1 b c r) => Optional2 a b c (a -> r) where
  opt2 f _ b = \a -> opt1 (f a) b

{- Optional3, Optional4, etc defined similarly -}

Then

{-# LANGUAGE FlexibleContexts #-}
module Main where
import Optional

foo :: (Optional2 Int Char String r) => r
foo = opt2 replicate 3 'f'

_5 :: Int
_5 = 5

main = do
  putStrLn $ foo        -- prints "fff"
  putStrLn $ foo _5     -- prints "fffff"
  putStrLn $ foo _5 'y' -- prints "yyyyy"

---

Update: Whoops, I got accepted. I honestly think that luqui’s answer is the best one here:

• the type is clear, and easy to read, even for beginners
• same for type errors
• GHC doesn’t need hints to do type inference with it (try opt2 replicate 3 'f' in ghci to see what I mean)
• the optional arguments are order-independent