The Lightbend website has a nice article about SBT development titled, Berlin Scala Spree and sbt 1.1.6. That article also references this Contributing to SBT page, which is a nice document about how to contribute to SBT development.
I was looking for something else today and came across a collection of Scala style guides:
The reduceLeft method on the Scala collections is fun. Just start with a collection:
scala> val a = Array(20, 12, 6, 15, 2, 9) a: Array[Int] = Array(20, 12, 6, 15, 2, 9)
Then give reduceLeft a simple function to work with, and let it do its thing:
As a quick tip, this method shows one way you can find the keys that are common to two Scala Maps:
/** * Find the list of keys that are common to two Maps. */ def commonMapKeys[A, B](a: Map[A, B], b: Map[A, B]): Set[A] = a.keySet.intersect(b.keySet)
This typesafe.com chart shows the results of the efforts to make the Scala compiler faster over the last several years.
After yesterday’s Scala nested Option + flatMap/for example, here’s another example of plowing through nested Options with flatMap. First, start with some nested options:
val o1 = Option(1) val oo1 = Option(o1) val ooo1 = Option(oo1)
Here are those same three lines, with the data type for each instance shown in the comments:
val o1 = Option(1) // Option[Int] val oo1 = Option(o1) // Option[Option[Int]] val ooo1 = Option(oo1) // Option[Option[Option[Int]]]
With this setup, just like yesterday, I can dig my way through the Options to get to the enclosed value using flatMap calls:
ooo1 flatMap { oo1 =>
oo1 flatMap { o1 =>
o1
}
}
Here’s what that code looks like in the Scala REPL:
scala> val o1 = Option(1)
o1: Option[Int] = Some(1)
scala> val oo1 = Option(o1)
oo1: Option[Option[Int]] = Some(Some(1))
scala> val ooo1 = Option(oo1)
ooo1: Option[Option[Option[Int]]] = Some(Some(Some(1)))
scala> ooo1 flatMap { oo1 =>
| oo1 flatMap { o1 =>
| o1
| }
| }
res0: Option[Int] = Some(1)
As that shows, the final result of the flatMap calls is an Option[Int], specifically a Some(1).
Just like yesterday, you can also use for-expressions to get to the enclosed value, but for today I just wanted to show this as another flatMap example.
I’ll keep trying to make monads, flatMap, and for-expressions as easy as I can, but for now I hope that’s a simple example you can experiment. (At least the setup portion of it is simple.)
An interesting story on the Scala phrase, “flatMap that sh*t”, from SO.
If you’re interested in metaprogramming with Scala, Scalameta is “a modern metaprogramming library for Scala that supports a wide range of language versions and execution platforms. Originally, Scalameta was founded to become a better macro system for Scala, but over time we shifted focus to developer tools and spun off the new macro system into a separate project.”
If you’re interested in the future of Scala, specifically Scala 3, the official Scala blog has an interesting article titled, Macros: The Plan for Scala 3. A beneficial part of reading at least part of the article is that you can learn a little bit about Tasty, “the high-level interchange format for Scala 3.”
Under the covers — and sometimes above the covers — Scala is changing. These notes about Scala 2.13.0-M4 describe some of the changes coming to the Scala collections classes.
A few things not shown in the image are:
def m() { ... }) is deprecatedSee the Scala 2.13.0-M4 release notes for more details.
Via Kelley Robinson, one of Martin Odersky’s slides at ScalaDays (May, 2018) is titled, “Realizing Scala’s Potential,” with these bullet points:
As Ms. Robinson writes, “Scala was a language toolbox, and that leads to fragmentation. Scala 3 wants to become more opinionated.”
I haven’t tried it yet, but as a note to self, Scala 2.12.5 introduced a new -Ybackend-parallelism N compiler flag with which “the backend can now run in parallel on N threads.”
If you ever need definitions of scalac compiler options (up to Scala 2.12.2), here you go.
As a short “note to self,” the quickSort function in the following code is from the “Scala By Example” PDF, and it shows a Scala version of a Quicksort algorithm:
Without an example it can be hard to understand how user authentication works in a Play Framework application, so I just created a project on Github named PlayFrameworkLoginAuthenticationExample that demonstrates one way to implement login authentication in a Play Framework 2.6 application.
Just a quick note here today on how to show methods from the String class in the Scala REPL, as well as methods from the StringOps class, which aren't seen as easily.
First, if you've used tab completion in the REPL, you may already know that you can show many String class methods in the REPL. If you hit the [Tab] key once you'll see a short list of String methods:
If you need to handle a unique constraint in a database table field when writing an add or edit process in a Play Framework application, I hope this example will be helpful. In the end I’ll show:
Form after you catch that exceptionIf you need to see any of those things, I hope the following example is helpful.
In my case I’m writing a URL-shortening application and I have a unique constraint on a table column named short_uri, so I wrote my database-insert method with Anorm to look like this:
// uses Try b/c `short_uri` has a unique constraint, which can cause an exception
def insertNewUrl(u: Url): Try[Option[Long]] = db.withConnection { implicit c =>
Try {
val q = SQL"""
insert into urls (user_id,long_url,short_uri,notes)
values (1,${u.longUrl},${u.shortUrl},${u.notes})
"""
q.executeInsert() //returns the primary key as an Option
}
}
I catch the possible unique constraint exception with Try. Because executeInsert returns the primary key inside an Option, this method returns the type Try[Option[Long]]. The key here for the purpose of this example is that the SQL INSERT can fail because of the unique constraint, so I handle the possible exception with Try.
For me, the harder part in this case is to know what to do in your controller action code. I’m not going to try to explain it all, I’m just going to show my code, and then offer a little explanation:
def handleAddFormSubmission = authenticatedUserAction { implicit request =>
val formDidNotValidateFunction = { formWithErrors: Form[Url] =>
BadRequest(views.html.editUrl(0, formWithErrors, addFormSubmitUrl))
}
val formValidatedFunction = { data: Url =>
// form data is valid, try saving to the database
val url = Url(
data.id,
data.longUrl,
data.shortUrl,
data.notes
)
// there’s a Try here b/c a SQL INSERT can fail due to database constraints
val pkInOptionInTry: Try[Option[Long]] = urlDao.insertNewUrl(url)
pkInOptionInTry match {
case Success(maybePk) => {
// no exception was throw, so `maybePk` probably has the primary key
Redirect(routes.UrlAdminController.list())
.flashing("info" -> s"URL '${data.shortUrl}' was added.")
}
case Failure(e) => {
// an exception was thrown, so the SQL INSERT failed, probably a duplicate key error
val formBuiltFromRequest: Form[Url] = form.bindFromRequest()
val newForm = formBuiltFromRequest.copy(
errors = formBuiltFromRequest.errors ++ Seq(
FormError("short_uri", "Probably have a duplicate URI in the database."),
FormError("short_uri", e.getMessage)
)
)
BadRequest(views.html.editUrl(0, newForm, addFormSubmitUrl))
}
}
}
val formValidationResult: Form[Url] = form.bindFromRequest
formValidationResult.fold(
formDidNotValidateFunction,
formValidatedFunction
)
}
One big key in this method is knowing that you can use Try to easily handle the exception that can be returned by the database access method.
A second big key is knowing that you can rebuild a Form with either of these two approaches:
val newForm: Form[Url] = form.bindFromRequest()
val newForm: Form[Url] = form.fill(data)
I haven’t looked into the differences between those two possible approaches, but it took me a while to figure out those approaches, so hopefully that knowledge will save someone else time in the future. The key here is that you need to build a new form after the exception that you can pass to your template, and this is how you do that.
Another big key was find out that methods like form.withError(...) and form.withGlobalError(...) don’t work as expected, so I had to write code like this to get my custom error messages to show up in the Play template:
val newForm = formBuiltFromRequest.copy(
errors = formBuiltFromRequest.errors ++ Seq(
FormError("short_uri", "Probably have a duplicate URI in the database."),
FormError("short_uri", e.getMessage)
)
)
You probably only need one error message there, but since I’m writing this application for myself I don’t mind seeing the output from e.getMessage. Note that this approach binds those error messages to the short_uri field in the template.
You might not need to see the Play Framework template to understand what I just showed, but it may help to see the template code, so here it is:
@(
urlId: Long,
form: Form[Url],
postUrl: Call
)(implicit request: RequestHeader, messagesProvider: MessagesProvider)
<!DOCTYPE html>
<html lang="en">
<head>
<link rel="stylesheet" media="screen" href="@routes.Assets.versioned("stylesheets/main.css")">
<link rel="stylesheet" media="screen" href="@routes.Assets.versioned("stylesheets/admin.css")">
</head>
<body id="edit-url">
<div id="content">
<div id="edit-url-form">
<h1>URL Shortener</h1>
@* Flash shows updates to a page *@
@request.flash.data.map{ case (name, value) =>
<div>@name: @value</div>
}
@* Global errors are not tied to any particular form field *@
@if(form.hasGlobalErrors) {
@form.globalErrors.map { error: FormError =>
<div>
Error: @error.key: @error.message
</div>
}
}
@helper.form(postUrl, 'id -> "blog-edit-form") {
@helper.CSRF.formField
@* id is 0 for 'add', and is set by the 'edit' process *@
<input type="hidden" name="id" value='@urlId'>
@helper.inputText(
form("long_url"),
'_label -> "Long URL",
'placeholder -> "the original, long url",
'id -> "long_url",
'size -> 68
)
@helper.inputText(
form("short_uri"),
'_label -> "Short URI",
'placeholder -> "the short uri you want",
'id -> "short_uri",
'size -> 68
)
@helper.textarea(
form("notes"),
'_label -> "Notes",
'id -> "notes",
'rows -> 5,
'cols -> 60
)
<button>Save</button>
}
</div>
</div>
</body>
</html>
I’m not going to bother to explain that code at all, other than to say that the short_uri field in the template is where my custom error message will show up.
As a final note, here’s what those custom form error messages look like in the template (a data-entry form):
In summary, if you wanted to see how to handle Play Framework things like how to handle a SQL exception related to a unique constraint violation; how to create a new form after an exception like that; and how to add custom error messages to a Play form, I hope this example is helpful.
As a quick note to self, here’s how to just printed some HTTP request information in a Play Framework controller action:
As a quick example, if you need to see some code for a Play Framework Anorm method that inserts an object into a relational database table and returns the auto-into (MySQL auto_increment) ID field on success, here you go: