How to validate string format with scala in compile time - scala

Question

My function has 1 parameter and type is string but lenght is 4, Can I validate this parameter in compile time?
In haskell and F# have type level and it can validation in compile time, like nonEmptyList.
How to make it in scala. I think shapless can do this but I don't understand
Thank you for advance suggestion

Answer 1

Yes, Shapeless can do this. Perhaps something like this:
def f(s: Sized[IndexedSeq[Char], Nat._4]): ...
You wouldn't be able to pass strings directly to this, though. You'd have to do something like f(Sized('a', 'b', 'c', 'd'))

Answer 2

You can't with vanilla Scala.
The best approach you can go is creating a special type for this -
case class SpecialString(string: String) {
require(string.length == 4)
}
Then, make your function receive SpecialString as a parameter instead of a String.

Answer 3

Using macros is also an option for compile-time validation. See this post by Arnout Engelen: http://blog.xebia.com/compile-time-evaluation-scala-macros/
I've modified his example to define a string-validating function:
object CompileTimeStringCheck {
import scala.language.experimental.macros
// This function exposed to consumers has a normal Scala type:
def stringCheck(s: String): String =
// but it is implemented as a macro:
macro CompileTimeStringCheck.stringCheck_impl
import scala.reflect.macros.blackbox.Context
// The macro implementation will receive a 'Context' and
// the AST's of the parameters passed to it:
def stringCheck_impl(c: Context)(s: c.Expr[String]): c.Expr[String] = {
import c.universe._
// We can pattern-match on the AST:
s match {
case Expr(Literal(Constant(nValue: String))) =>
// We perform the calculation:
val result = normalStringCheck(nValue)
// And produce an AST for the result of the computation:
c.Expr(Literal(Constant(result)))
case other =>
// Yes, this will be printed at compile time:
println("Yow!")
???
}
}
// The actual implementation is regular old-fashioned scala code:
private def normalStringCheck(s: String): String =
if (s.length == 4) return s
else throw new Exception("Baaaaaah!")
}
Here's the catch, though: This needs to be compiled before it can be used, i.e. put it into a utils jar or something. Then you can use it at a later compile time:
import CompileTimeStringCheck._
object Test extends App {
println(stringCheck("yes!"))
}
Again, see Arnout Engelen's post for more details and the original solution (http://blog.xebia.com/compile-time-evaluation-scala-macros/).