Write Genric function that takes function signature of varying length of argument as argument in type level

Question

I want to create a function, that takes function as varying argument, the only thing i know about the funtion argument(which is a function itself) is they are wrapped in the same Monad....

myFunc :: forall arguments output m. 
                      MonadEffect m 
                   => (arguments -> m output)
                   ->  m (argument -> m output)
myFunc fn = do
            -- getting function's name using FFI and other stuff...
            pure fn 

I'm able to write the function, when I explicitly specify the argument length like,

-- for function with ONE argument
myFunc1 :: forall argument1 output m
                   . MonadEffect m 
                   => (argument1 -> m output)
                   -> m (argument1 -> m output)
myFunc1 fn = do 
              -- do something 
              pure fn


-- for function with TWO argument
myFunc2 :: forall argument1 argument2 output m. 
                   MonadEffect m => 
                   (argument1 -> argument2 -> m output) ->
                   m (argument1 -> argument2 ->  m output)
myFunc2 fn = do 
             -- do something 
             pure fn

How can I write argument1 -> argument2 -> m output as argument -> m output in type level?

is there any type/Constraint that helps in doing so?

ps: I just want to understand whether it's possible

Answer 1

In Haskell, you can define type families that calculate the return type of a function:

type family Result f where
  Result (a -> b) = Result b
  Result b = b

and a type-level list of the types of its arguments (in reverse order):

type Arguments f = Arguments' '[] f
type family Arguments' args f where
  Arguments' args (a -> b) = Arguments' (a ': args) b
  Arguments' args b = args

This would allow you to write:

myFunc :: forall f arguments output m.
  ( Monad m
  , Result f ~ m output
  , Arguments f ~ arguments
  ) => f -> m f
myFunc fn = pure fn

which would make available type variables output and arguments within the body of your function:

myFunc :: forall f arguments output m.
  ( MonadIO m
  , Result f ~ m output
  , Arguments f ~ arguments
  , Typeable arguments, Typeable output
  ) => f -> m f
myFunc fn = do
  liftIO . putStrLn $ "Result: " ++ show (typeRep (Proxy @output))
  liftIO . putStrLn $ "Arguments: " ++ show (typeRep (Proxy @arguments))
  pure fn

This may or may not be suitable for what you're trying to do, and it may or may not work in Purescript.

Anyway, here's a self-contained Haskell example:

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}

import Control.Monad.IO.Class
import Data.Typeable

type family Result f where
  Result (a -> b) = Result b
  Result b = b

type Arguments f = Arguments' '[] f
type family Arguments' args f where
  Arguments' args (a -> b) = Arguments' (a ': args) b
  Arguments' args b = args

myFunc :: forall f arguments output m.
  ( MonadIO m
  , Result f ~ m output
  , Arguments f ~ arguments
  , Typeable arguments, Typeable output
  ) => f -> m f
myFunc fn = do
  liftIO . putStrLn $ "Result: " ++ show (typeRep (Proxy @output))
  liftIO . putStrLn $ "Arguments: " ++ show (typeRep (Proxy @arguments))
  liftIO . putStrLn $ ""
  pure fn

resultType :: forall f r. (Result f ~ r, Typeable r) => f -> String
resultType _ = show $ typeRep (Proxy @r)

main :: IO ()
main = do
  _ <- myFunc (pure . length :: String -> IO Int)
  _ <- myFunc ((\x y -> pure (x+y)) :: Double -> Double -> IO Double)
  putStrLn "done"