[nongnu] elpa/scala-mode 6f1b748 001/217: Example.scala to show how we intend to indent

[ELPA Syncer]

branch: elpa/scala-mode
commit 6f1b748d7240deb30e5921a61646237f025f18f1
Author: Heikki Vesalainen <heikkivesalainen@yahoo.com>
Commit: Heikki Vesalainen <heikkivesalainen@yahoo.com>

    Example.scala to show how we intend to indent
---
 Example.scala | 233 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 README        |  14 ++++
 2 files changed, 247 insertions(+)

diff --git a/Example.scala b/Example.scala
new file mode 100644
index 0000000..19b4859
--- /dev/null
+++ b/Example.scala
@@ -0,0 +1,233 @@
+/*
+1. Indenting
+
+The rules how this mode indents code, are as follows
+*/
+
+/*
+1.1 Indent anchors
+
+Indenting happens relative to an indent anchor. Usually the indent anchor is 
the first character on the starting line of a declaration or expression, 
however if
+the declaration or expression is inside a parameter list, then the anchor is 
inside the list.
+*/
+
+def f(s: String,
+      i: Int) = 
+  s.take(i) // indented relative to 'def'
+
+/* */ val x = foo(
+  zot, // indented relative to '/* */'
+  someThing
+     map (x => x.length) // indented relative to 'someThing'
+)
+
+val x =
+  foo( // indented relative to 'val'
+    zot // indented relative to 'foo'
+  )
+
+class OmgLol[Option[x] forSome {
+               val x: String // indented relative to 'Option'
+             }] {
+  // body
+}
+
+/*
+1.2. Run-on lines
+
+Any line not beginning with a declaration or expression start reserved word 
(i.e. class, trait, object, package, type, val, var, def, for, yield, if, else 
if, else, do, while) will be interpreted as a run-on of the previous line, and 
will be indented two step from the indent anchor. 
+
+This rule does not apply in the following cases:
+- if the previous lines was empty
+- previous line was an annotation
+- previous statement ended with ';'
+- the current line starts a body (of declaration or anonymous function)
+- block or simple expression starts with an anonymous function (lambda) 
declaration
+*/
+
+val f = List("foo", "bar")
+    map ( s => // run-on, anchor is 'val', also start of lambda
+      s.length // not a run-on line, is body
+    )
+    sum // still a run-on
+
+val f = 
+  List("foo", "bar") // not a run-on line, is body
+      map (s => s.length) // run-on line, anchor is 'List'
+
+zot() // previous line was empty
+
+val f = List("foo", "bar");
+zot() // previous statement ended with ';'
+
+val f: Bar = new Zot
+    with Bar // run-on line, achor is 'val'
+
+class Foo(
+  foo: String,
+  bar: Bar
+      with Zot // run-on line, anchor is 'bar'
+) extends Bar
+    with Zot { // run-on line, anchor is 'class'
+  // body here
+}
+
+trait Leijona( x: Int,
+               y: Int )
+    extends Kissa // run-one line, acnhor is 'trait'
+    with Harja // ditto
+
+def someThingReallyLong(having: String, aLot: Int, ofParameters: Boolean): 
+    SomeAbsurdlyLongTypeThatBarelyFitsOnALine[Z, F] // run-on line, anchor is 
'def'
+    with SomeOtherType = { // ditto
+  // body here
+}
+
+List("foo", "bar") 
+    map ( s => // 'map' indented as run-on, 's =>' start lambda
+      s.length
+    )
+
+/*
+1.3 Parameter lists
+
+Both value ('()') and type ('[]') parameter lists will be indented acording to 
the following rule:
+
+- If the first parameter is on its own line, it will be indented one step from 
the
+indent anchor.
+- All following parameters will be indented to the same column with the first 
parameter
+- Af the opening parentheses of a second or subsequent parameter group is at 
the start 
+of a line, it will be indented to the same column as the first paremeter 
groups opening
+parentheses.
+- A closing parantheses that is on its own line, will be indented to the same 
column
+  with the indent anchor.
+*/
+
+class Foo(
+  i: String, // one step from indent anchor column
+  k: String
+) // at indent anchor column
+
+def f(   i: String, j: String,
+         k: String) // indented acording to previous
+
+val f = foo(kissa,
+            kala)
+
+val g = bar(
+  kissa
+  kala
+)
+
+val h = 
+  zot(
+    kissa,
+    kala
+  )
+
+type ->[FirstElementOfAPair,
+        SecondElementOfAPair] =
+  (FirstElementOfAPair,
+   SecondElementOfAPair)
+
+/*
+1.4
+*/
+
+/*
+1.5 Case blocks
+
+Any block whose first word is 'case', but not 'case class' is a case block. 
The lines of a case block are 
+indented with two steps, except for lines beginning with the word 'case'
+*/
+
+val x = 
+  f match {
+    case xs: Seq[String] =>
+      xs map ( x => x.length)
+          sum
+    case x: String =>
+      println(x);
+      x.length // not the ';' on previous line. Without it, this line would be 
interpreted as run-on
+  }
+
+/*
+1.6 For comprehension
+
+There are two special rules for for statements:
+
+- even if the bindings of a for statement are in curly brackets, they will be 
indented acording to the 
+parentheses indenting rules.
+- yield is aligned with for
+*/
+
+val y = for { i <- 1 to 10,
+              j <- 2 to 20 }
+        yield i +j
+
+val z =
+  for {
+    i <- 1 to 10,
+    j <- 2 to 20
+  } yield {
+    i + j
+  }
+
+val z = for { i <- 1 to 10,
+              j <- 2 to 20 }
+        yield {
+          i + j
+        }
+
+/*
+1.7 If statements
+
+If statements will be indented acording to the following rules:
+
+- The the body of the 'if' or 'else if' statement is a simple expression (i.e. 
not a block), then the next 'else if' or 'else' is aligned with the previous 
'if' or 'else if',
+- otherwise 'else if' and 'else' is aligned with previous block close.
+*/
+
+val x = if (kissa)
+          foo
+        else if (kala)
+          bar
+        else
+          zot
+
+val y = if (kissa) {
+  foo
+} else if (kala) {
+  bar
+} else {
+  zot
+}
+
+/*
+1.8 Block opening curly brackets on new line
+
+While not couraged, should the opening curly bracket of a block be on a new 
line, it is indented acording to the following rules:
+
+- If the block is the body of a package object, object, class or trait, then 
the opening is aligned acording to the anchor.
+- If the block is the body or value of a val, var, type, then the opening is 
aligned one step from the anchor
+- If the block is the body of a def, then the opening is aligned acording to 
the anchor for Unit functions without explicitly
+  specified return value and one step from anchor otherwise.
+*/
+
+class Foo 
+{
+  def foo
+  {
+    println(zot)
+  }
+
+  def bar =
+    {
+      zot
+    }
+
+  val zot =
+    {
+      "hello"
+    }
+}
diff --git a/README b/README
new file mode 100644
index 0000000..00930f7
--- /dev/null
+++ b/README
@@ -0,0 +1,14 @@
+A new scala-mode for emacs.
+
+The current scala-mode with for emacs that comes scala-dist is beyond
+repair. It is overly complex and hard to maintain.
+
+This new major mode intends to be simple, yet provide the following:
+- indenting
+- highlighting
+- motion commands
+
+The mode will target scala code written in a functinal style.
+
+Check out Example.scala to see how it indents.
+