使用隐式参数为部分函数定义新的TYPE

Question

I am trying to create a new TYPE that would have a pattern of a partial function. Example:

New Type :

type RouteFunc = (String, HttpServletRequest, HttpServletResponse) => Unit

Usage :

def myFunc(str: String, request: HttpServletRequest, response HttpServletResponse) myFunc("", Any, Any)

For explicitly passed parameters this works really well but I would like to change this type definition so that HttpServletRequest, HttpServletResponse would be passed in implicitly vs. explicitly

Expected result :

def myFunc(str: String)(implicit request: HttpServletRequest, response HttpServletResponse)

I can't find a way how to change the TYPE structure/definition to accomodate the intended pattern, is it possible or is that a language restraint?

EDIT :

Usage:

object Routes{
    type RouteFunc = (String, HttpServletRequest, HttpServletResponse) => Unit

    val routes = Map[String, RouteFunc](
        "/data" -> DataSets.dashboard
    )

    def evaluateRoute()(implicit request: HttpServletRequest, response: HttpServletResponse) = {
        val path = request.getPathInfo

        val route = routes(path)
        route(path, request, response)
    }
}
object DataSets{
    def dashboard(path: String, request: HttpServletRequest, response: HttpServletResponse) = {
        response.setContentType("text/html")
        response.setCharacterEncoding("UTF-8")

        response.getWriter.write("Hello World")
    }
}

I want the def dashboard to look like:

def dashboard(path: String)(implicit request: HttpServletRequest, response: HttpServletResponse)

EDIT 2 :

At the end I went with passing the parameters explicitly as it's impossible with the current version of Scala as explained by @SergGr and @slouc:

import javax.servlet.http.{HttpServletRequest, HttpServletResponse}
import controllers.data._
import Routes._

class RoutingController() extends JettyHttpServlet {

    type RouteFunc = (String, HttpServletRequest, HttpServletResponse) => Unit
    type HttpRequest = String
    type Path = String

    val routes = Map[(String, HttpRequest), RouteFunc](
        (GET,       "/data")                -> Data.dashboard,
        (GET,       "/assets/*")            -> Assets.getAsset

    )

    override def Get()(implicit request: HttpServletRequest, response: HttpServletResponse): Unit = {
        val path = request.getPathInfo
        val pathTerms = path.split("/")
        val getPaths = routes.filter(_._1._1 == request.getMethod.toUpperCase)

        val filteredList = getPaths.flatMap{
            route =>
                if(route._1._2 == path){
                    Option(route)
                }else {
                    val s = route._1._2.split("/")

                    if(route._1._2.startsWith("/assets")){
                        Option(route)
                    }else
                        None
                }
        }.toSeq

        filteredList.head._2(path, request, response)
    }

}

----------------------

import jetty.Routes
import jetty.Responses._

object Data {

    import javax.servlet.http.{HttpServletRequest, HttpServletResponse}

    def dashboard(path: String, eq: HttpServletRequest, qw: HttpServletResponse): Unit = {
            implicit val s = eq
            implicit val r = qw
        Ok(Routes.html, views.html.data.dashboard.render("Dashboard").toString())
    }

}

Answer 1

If I got your question correctly, you want to define a function with implicit parameters. This is not possible. Not only is it a language constraint, it's also a logical one. Functions are a mathematical concept and there's no such thing as "implicit parameters" there. There's no way to provide a subset of parameters, and take the rest "from the scope".

In Scala there's a way to transform a method into a function; the mechanism in question is called eta-expansion. Given some method fooMethod, then a corresponding function fooFunction can be defined as

def fooMethod(i: Input): Output
val fooFunction: Input => Output = (i: Input) => fooMethod(i)

// or

def fooMethod(i1: Input1, i2: Input2): Output
val fooFunction: Input1 => Input2 => Output = (i1: Input1) => (i: Input2) => fooMethod(i1, i2)

// or

def fooMethod(): Output
val fooFunction: Unit => Output = () => fooMethod()

Compiler will perform eta-expansion automatically if you provide a method where a function is expected. In cases where it doesn't do it automatically, you can do it manually:

val fooFunction = fooMethod _

But even that trick fails if you introduce implicit parameters, for reasons stated earlier.

Example:

trait HttpServletRequest
trait HttpServletResponse

type RouteFunc = String => (HttpServletRequest, HttpServletResponse) => Unit

implicit val request = new HttpServletRequest {}
implicit val response = new HttpServletResponse {}

def myMethod1(str: String)(request: HttpServletRequest, response: HttpServletResponse) = println("1")
def myMethod2(str: String)(implicit request: HttpServletRequest, response: HttpServletResponse) = println("2")

val myFunc1: RouteFunc = myMethod1 _ // compiles fine
val myFunc2: RouteFunc = myMethod2 _ // nope

EDIT:

Given your edit, this is how I would do it:

trait HttpServletRequest
trait HttpServletResponse

object Routes {

  implicit val request = new HttpServletRequest {}
  implicit val response = new HttpServletResponse {}

  type RouteFunc = String => Unit
  val routes = Map[String, RouteFunc]("/data" -> DataSets.dashboard())
}

object DataSets {

  def dashboard()(implicit request: HttpServletRequest, response: HttpServletResponse): RouteFunc =
    (path: String) => {
      // impl of dashboard, uses request and response
  }
}

You define a route as a function String => Unit , and you define the dashboard as a method which takes implicit request and response and constructs a route for you.

EDIT2:

Looks like support for functions with implicit parameters is coming in one of the future Scala versions. I don't like this and I won't use it, we have too much implicit hell in Scala even without it, but it's good to know about it so that I don't keep claiming it's impossible :)

Answer 2

Implicit functions are not supported as of Scala 2.12. It looks like they are planed for one of the later version when Dotty becomes the official Scala compiler