Scala function to Json

Question

Can I map Scala functions to JSON; or perhaps via a different way than JSON?

I know I can map data types, which is fine. But I'd like to create a function, map it to JSON send it via a REST method to another server, then add that function to a list of functions in another application and apply it.

For instance:

def apply(f: Int => String, v: Int) = f(v)

I want to make a list of functions that can be applied within an application, over different physical locations. Now I want to add and remove functions to the list. By means of REST calls.

Let's assume I understand security problems...

ps.. If you downvote, you might as well have the decency to explain why

Answer 1

If I understand correctly, you want to be able to send Scala code to be executed on different physical machines. I can think of a few different ways of achieving that

1. Using tools for distributed computing e.g. Spark. You can set up Spark clusters on different machines and then select to which cluster you want to submit Spark jobs. There are a lot of other tools for distributed computing that might also be worth looking into.
2. Pass scala code as a string and compile it either within your server side code (here's an example) or by invoking scalac as an external process.
3. Send the functions as byte code and execute the byte code on the remote machine.

If it fits with what you want to do, I'd recommend option #1.

Make sure that you can really trust the code that you want to execute, to not expose yourself to malicious code.

Answer 2

The answer is you can't do this, and even if you could you shouldn't!

You should never, never, never write a REST API that allows the client to execute arbitrary code in your application.

What you can do is create a number of named operations that can be executed. The client can then pass the name of the operation which the server can look up in a Map[String, <function>] and execute the result.

Answer 3

As mentioned in my comment, here is an example of how to turn a case class into JSON. Things to note: don't question the implicit val format line (it's magic); each case class requires a companion object in order to work; if you have Optional fields in your case class and define them as None when turning it into JSON, those fields will be ignored (if you define them as Some(whatever), they will look like any other field). If you don't know much about Scala Play, ignore the extra stuff for now - this is just inside the default Controller you're given when you make a new Project in IntelliJ.

package controllers

import javax.inject._
import play.api.libs.json.{Json, OFormat}
import play.api.mvc._

import scala.concurrent.Future

@Singleton
class HomeController @Inject()(cc: ControllerComponents) extends AbstractController(cc) {

  case class Attributes(heightInCM: Int, weightInKG: Int, eyeColour: String)

  object Attributes {
    implicit val format: OFormat[Attributes] = Json.format[Attributes]
  }

  case class Person(name: String, age: Int, attributes: Attributes)

  object Person {
    implicit val format: OFormat[Person] = Json.format[Person]
  }

  def index: Action[AnyContent] = Action.async {

    val newPerson = Person("James", 24, Attributes(192, 83, "green"))

    Future.successful(Ok(Json.toJson(newPerson)))

  }

}

When you run this app with sbt run and hit localhost:9000 through a browser, the output you see on-screen is below (formatted for better reading). This is also an example of how you might send JSON as a response to a GET request. It isn't the cleanest example but it works.

{
    "name":"James",
    "age":24,
    "attributes":
    {
        "heightInCM":187,
        "weightInKG":83,
        "eyeColour":"green"
    }
}

Once more though, I would never recommend passing actual functions between services. If you insist though, maybe store them as a String in a Case Class and turn it into JSON like this. Even if you are okay with passing functions around, it might even be a good exercise to practice security by validating the functions you receive to make sure they're not malicious.

I also have no idea how you'll convert them back into a function either - maybe write the String you receive to a *.scala file and try to run them with a Bash script? Idk. I'll let you figure that one out.