| package lambda; | |
| public interface JFunction1<T1, R> { | |
| R apply(T1 t); | |
| } |
| package jsonquery | |
| object `package` { | |
| import dispatch.json._ | |
| implicit def jsonToSearchable(json: JsValue) = new { | |
| def \ (selector: String): Either[String, JsValue] = json match { | |
| case JsObject(map) => { | |
| (for { |
| {* Example of template processing an article *} | |
| {article: Article} | |
| li class="article {article.featured ? 'featured'}" /view.root | |
| a href="/details" | |
| | {article.name} /data.name | |
| span.actions | |
| button type=button /view.editBtn | Edit | |
| button type=button /view.deleteBtn | Delete |
| object MyApp extends Controller { | |
| // Home page | |
| val index = Action { | |
| Ok(views.html.index()) | |
| } | |
| // Login action: here I just bind a (non empty) username from the query and put it in the session | |
| val login = Action { implicit request => | |
| Form(mapping("username" -> nonEmptyText)(identity)(Some(_))).bindFromRequest.fold( | |
| noUser => redirectToIndex, |
| object Happy { | |
| def sumSquare(ds: List[Int]): Int = ds map (d => d * d) sum | |
| def digits(n: Int): List[Int] = if (n < 10) List(n) else (n % 10) :: digits(n / 10) | |
| def happy(n: Int, visited: List[Int] = Nil): Boolean = sumSquare(digits(n)) match { | |
| case 1 => true | |
| case n => if (visited contains n) false else happy(n, n :: visited) | |
| } |
| *{ Liste éditable d’éléments }* | |
| *{ @param _arg: Iterable[A] Liste des éléments constitutifs de la liste }* | |
| *{ @param as: String Name of the iterator }* | |
| *{ @param (optional) addAction: ActionDefinition URL permettant d’ajouter un élément }* | |
| *{ @param (optional) pager: Pager }* | |
| #{ui.list users, as: 'user', addAction: @Users.add(), pager: pager} | |
| #{useritem user /} | |
| #{/ui.list} | |
| *{ Formulaire }* |
Find a way to easily allow industrial web applications developers to write consistent user interfaces without having to repeat themselves, and to efficiently handle variability.
The user interface is displayed by the web browser from the HTML of the page. Developers write the HTML markup using a template engine. This template engine allows to include parametrized fragments, giving the ability to define some UI traits (capturing one UI concept) and to reuse them across the application.
| /** Say we have a `max` function, computing the maximum of two numbers */ | |
| def max(a: Int, b: Int): Int = { | |
| if (a < b) b | |
| else a | |
| } | |
| /** It can be used like that: */ | |
| max(3, 4) |
| import tyco.compiler._ | |
| object MyWebsite extends tyco.Site { | |
| for (page <- Content.allPages) | |
| page.uri ==> Template.show(page) | |
| for (file <- Path("stylesheets/*.scss")) | |
| "/css/"+file.name ==> new TextFile(file) with Sass with CssMinifier | |
| } |