Given a function g :: a -> b -> … -> z, how can I use it like h :: (a, b, …) -> z?

Question

Background: I'm working with wxHaskell's fileOpenDialog, which takes 6 non-obvious parameters (curried). My code is currently:

maybePath <- fileOpenDialog w useLastSelectedDir canSelectReadOnly
                frameName possibleFiles initialDir defaultFilename

with a let statement above that to define all my parameters. What I would love to do though, is save my parameters somewhere. I somewhat understand why Haskell would't support something like say:

myParams = ( ... ) -- tuple of params
maybePath <- fileOpenDialog myParams

However, is there something close to this in the spirit of not repeating myself?

Answer 1

It seems like you would naturally like the input to this function to be a record of parameters:

{-# LANGUAGE RecordWildCards #-} 

-- Defined by your library 
foo :: String -> Int -> IO () 
foo = ... 

data Opts = Opts { optString :: String, optInt :: Int } 
bar :: Opts -> IO () 
bar Opts{..} = foo optString optInt 

Now, you can use any of the following equivalent syntaxes (some use RecordWildCards):

main = do 
  let optString = <...>
      optInt    = <...>
  bar Opts{..} 

main = do 
  let x = <...>
      y = <...>
      myParams = Opts x y 
  bar myParams 

main = do 
  bar $ Opts 
    { optString = <...> 
    , optInt    = <...> 
    } 

main = do 
  let optString = <...>
      optInt    = <...>
      myParams  = Opts{..} 
  bar myParams 

Answer 2

There is also the (less clean) possibility of writing an uncurry variant (see here ) having more arguments:

uncurry6 :: (a -> b -> c -> d -> e -> f -> g) -> ((a,b,c,d,e,f) -> g)
uncurry6 fun (a,b,c,d,e,f) = fun a b c d e f 

Having that, uncurry6 fileOpenDialog will make fileOpenDialog accept a 6-tuple.