Scala application structure

Question

I am learning Scala now and I want to write some silly little app like a console Twitter client, or whatever. The question is, how to structure application on disk and logically. I know python, and there I would just create some files with classes and then import them in the main module like import util.ssh or from tweets import Retweet (strongly hoping you wouldn't mind that names, they are just for reference). But how should I do this stuff using Scala? Also, I have not much experience with JVM and Java, so I am a complete newbie here.

Answer 1

I'm going to disagree with Jens, here, though not all that much.

Project Layout

My own suggestion is that you model your efforts on Maven's standard directory layout.

Previous versions of SBT (before SBT 0.9.x) would create it automatically for you:

dcs@ayanami:~$ mkdir myproject dcs@ayanami:~$ cd myproject dcs@ayanami:~/myproject$ sbt Project does not exist, create new project? (y/N/s) y Name: myproject Organization: org.dcsobral Version [1.0]:  Scala version [2.7.7]: 2.8.1 sbt version [0.7.4]:  Getting Scala 2.7.7 ... :: retrieving :: org.scala-tools.sbt#boot-scala     confs: [default]     2 artifacts copied, 0 already retrieved (9911kB/134ms) Getting org.scala-tools.sbt sbt_2.7.7 0.7.4 ... :: retrieving :: org.scala-tools.sbt#boot-app     confs: [default]     15 artifacts copied, 0 already retrieved (4096kB/91ms) [success] Successfully initialized directory structure. Getting Scala 2.8.1 ... :: retrieving :: org.scala-tools.sbt#boot-scala     confs: [default]     2 artifacts copied, 0 already retrieved (15118kB/160ms) [info] Building project myproject 1.0 against Scala 2.8.1 [info]    using sbt.DefaultProject with sbt 0.7.4 and Scala 2.7.7 > quit [info]  [info] Total session time: 8 s, completed May 6, 2011 12:31:43 PM [success] Build completed successfully. dcs@ayanami:~/myproject$ find . -type d -print . ./project ./project/boot ./project/boot/scala-2.7.7 ./project/boot/scala-2.7.7/lib ./project/boot/scala-2.7.7/org.scala-tools.sbt ./project/boot/scala-2.7.7/org.scala-tools.sbt/sbt ./project/boot/scala-2.7.7/org.scala-tools.sbt/sbt/0.7.4 ./project/boot/scala-2.7.7/org.scala-tools.sbt/sbt/0.7.4/compiler-interface-bin_2.7.7.final ./project/boot/scala-2.7.7/org.scala-tools.sbt/sbt/0.7.4/compiler-interface-src ./project/boot/scala-2.7.7/org.scala-tools.sbt/sbt/0.7.4/compiler-interface-bin_2.8.0.RC2 ./project/boot/scala-2.7.7/org.scala-tools.sbt/sbt/0.7.4/xsbti ./project/boot/scala-2.8.1 ./project/boot/scala-2.8.1/lib ./target ./lib ./src ./src/main ./src/main/resources ./src/main/scala ./src/test ./src/test/resources ./src/test/scala 

So you'll put your source files inside myproject/src/main/scala, for the main program, or myproject/src/test/scala, for the tests.

Since that doesn't work anymore, there are some alternatives:

giter8 and sbt.g8

Install giter8, clone ymasory's sbt.g8 template and adapt it to your necessities, and use that. See below, for example, this use of unmodified ymasory's sbt.g8 template. I think this is one of the best alternatives to starting new projects when you have a good notion of what you want in all your projects.

$ g8 ymasory/sbt project_license_url [http://www.gnu.org/licenses/gpl-3.0.txt]: name [myproj]: project_group_id [com.example]: developer_email [[email protected]]: developer_full_name [John Doe]: project_license_name [GPLv3]: github_username [johndoe]:  Template applied in ./myproj  $ tree myproj myproj ├── build.sbt ├── LICENSE ├── project │   ├── build.properties │   ├── build.scala │   └── plugins.sbt ├── README.md ├── sbt └── src     └── main         └── scala             └── Main.scala  4 directories, 8 files 

np plugin

Use softprops's np plugin for sbt. In the example below, the plugin is configured on ~/.sbt/plugins/build.sbt, and its settings on ~/.sbt/np.sbt, with standard sbt script. If you use paulp's sbt-extras, you'd need to install these things under the right Scala version subdirectory in ~/.sbt, as it uses separate configurations for each Scala version. In practice, this is the one I use most often.

$ mkdir myproj; cd myproj $ sbt 'np name:myproj org:com.example' [info] Loading global plugins from /home/dcsobral/.sbt/plugins [warn] Multiple resolvers having different access mechanism configured with same name 'sbt-plugin-releases'. To avoid conflict, Remove duplicate project resolvers (`resolvers`) or rename publishing resolver (`publishTo`). [info] Set current project to default-c642a2 (in build file:/home/dcsobral/myproj/) [info] Generated build file [info] Generated source directories [success] Total time: 0 s, completed Apr 12, 2013 12:08:31 PM $ tree . ├── build.sbt ├── src │   ├── main │   │   ├── resources │   │   └── scala │   └── test │       ├── resources │       └── scala └── target     └── streams         └── compile             └── np                 └── $global                     └── out  12 directories, 2 files 

mkdir

You could simply create it with mkdir:

$ mkdir -p myproj/src/{main,test}/{resource,scala,java} $ tree myproj myproj └── src     ├── main     │   ├── java     │   ├── resource     │   └── scala     └── test         ├── java         ├── resource         └── scala  9 directories, 0 files 

Source Layout

Now, about the source layout. Jens recommends following Java style. Well, the Java directory layout is a requirement -- in Java. Scala does not have the same requirement, so you have the option of following it or not.

If you do follow it, assuming the base package is org.dcsobral.myproject, then source code for that package would be put inside myproject/src/main/scala/org/dcsobral/myproject/, and so on for sub-packages.

Two common ways of diverging from that standard are:

• Omitting the base package directory, and only creating subdirectories for the sub-packages.

  For instance, let's say I have the packages org.dcsobral.myproject.model, org.dcsobral.myproject.view and org.dcsobral.myproject.controller, then the directories would be myproject/src/main/scala/model, myproject/src/main/scala/view and myproject/src/main/scala/controller.

• Putting everything together. In this case, all source files would be inside myproject/src/main/scala. This is good enough for small projects. In fact, if you have no sub-projects, it is the same as above.

And this deals with directory layout.

File Names

Next, let's talk about files. In Java, the practice is separating each class in its own file, whose name will follow the name of the class. This is good enough in Scala too, but you have to pay attention to some exceptions.

First, Scala has object, which Java does not have. A class and object of the same name are considered companions, which has some practical implications, but only if they are in the same file. So, place companion classes and objects in the same file.

Second, Scala has a concept known as sealed class (or trait), which limits subclasses (or implementing objects) to those declared in the same file. This is mostly done to create algebraic data types with pattern matching with exhaustiveness check. For example:

sealed abstract class Tree case class Node(left: Tree, right: Tree) extends Tree case class Leaf(n: Int) extends Tree  scala> def isLeaf(t: Tree) = t match {      |     case Leaf(n: Int) => println("Leaf "+n)      | } <console>:11: warning: match is not exhaustive! missing combination           Node         def isLeaf(t: Tree) = t match {                              ^ isLeaf: (t: Tree)Unit 

If Tree was not sealed, then anyone could extend it, making it impossible for the compiler to know whether the match was exhaustive or not. Anyway, sealed classes go together in the same file.

Another naming convention is to name the files containing a package object (for that package) package.scala.

Importing Stuff

The most basic rule is that stuff in the same package see each other. So, put everything in the same package, and you don't need to concern yourself with what sees what.

But Scala also have relative references and imports. This requires a bit of an explanation. Say I have the following declarations at the top of my file:

package org.dcsobral.myproject package model 

Everything following will be put in the package org.dcsobral.myproject.model. Also, not only everything inside that package will be visible, but everything inside org.dcsobral.myproject will be visible as well. If I just declared package org.dcsobral.myproject.model instead, then org.dcsobral.myproject would not be visible.

The rule is pretty simple, but it can confuse people a bit at first. The reason for this rule is relative imports. Consider now the following statement in that file:

import view._ 

This import may be relative -- all imports can be relative unless you prefix it with _root_.. It can refer to the following packages: org.dcsobral.myproject.model.view, org.dcsobral.myproject.view, scala.view and java.lang.view. It could also refer to an object named view inside scala.Predef. Or it could be an absolute import refering to a package named view.

If more than one such package exists, it will pick one according to some precedence rules. If you needed to import something else, you can turn the import into an absolute one.

This import makes everything inside the view package (wherever it is) visible in its scope. If it happens inside a class, and object or a def, then the visibility will be restricted to that. It imports everything because of the ._, which is a wildcard.

An alternative might look like this:

package org.dcsobral.myproject.model import org.dcsobral.myproject.view import org.dcsobral.myproject.controller 

In that case, the packages view and controller would be visible, but you'd have to name them explicitly when using them:

def post(view: view.User): Node = 

Or you could use further relative imports:

import view.User 

The import statement also enable you to rename stuff, or import everything but something. Refer to relevant documentation about it for more details.

So, I hope this answer all your questions.