[nongnu] elpa/scala-mode 0c5ed9e 022/217: deleted example files

[ELPA Syncer]

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

    deleted example files
---
 Example.scala | 413 ----------------------------------------------------------
 Test.scala    | 175 -------------------------
 2 files changed, 588 deletions(-)

diff --git a/Example.scala b/Example.scala
deleted file mode 100644
index 9f893ef..0000000
--- a/Example.scala
+++ /dev/null
@@ -1,413 +0,0 @@
-
-/*
-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.
-*/
-
-/* private */ def f(s: String,
-                    i: Int) =
-  s.take(i) // indented relative to 'def'
-
-/* private */ val y = 1; val x = foo(
-    zot, // indented relative to '/* */'
-    someThing 
-      map ((s: String, i: Int) =>
-        x.length) // indented relative to 'someThing'
-  )
-
-var foo = 
-  foo( // indented relative to 'val'
-    zot // indented relative to 'foo'
-      Zot
-      Nil
-  )
-
-class OmgLol[Option[x] forSome {
-               val a, z: String // indented relative to 'Option'
-             }] {
-  
-  val x = y match {
-      /* where do comments go */
-      case x => _
-    }
-  // body
-}
-
-
-/**
-  * Run-on lines
-  *
-  * ==Foo==
-  *
-  * 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.
-  * 
-  * Ordered lists:
-  * 1. foo bar zot zot zot foo baa ölajdsfölkajdsf aödslf aöldskfj asödlf 
jasdf asdfjasd kfjas djfa skjdf asdf asdlfkjasd lfajs dfasd  flaksdjf sad f
-  * 1. fo bar zot zot zot foo baa ölajdsfölkajdsf aödslf aöldskfj asödlf jasdf 
asdfjasd kfjas djfa skjdf asdf asdlfkjasd lfajs dfasd flaksdjf sad f
-  * 
-  * 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
-  *
-  * @author Heikki Vesalainen
-  * @version 1.2
-  */
-
-val f, g = List("foo", "bar").
-  filter (_ > 0) map ( s => // run-on, anchor is 'val', also start of lambda 
-    s.length
-      zot // run-on line, because in newlines-disabled region
-  )
-  sum // still a run-on
-
-val f = {
-  List("foo", "bar").
-    filter (_ > 0) map ( s => // run-on, anchor is 'val', also start of lambda 
-      s.length
-        zot // run-on line, because in newlines-disabled region
-    )
-    sum
-}
-
-val f = List("foo", "bar"). // not a run-on line, is body
-  filter(_ > 0).
-  map ( s =>
-    s.length
-  ) // run-on line, anchor is 'List'
-  filter ( s =>
-    s.length
-)
-
-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'
-    def a
-        :String = {
-      asd
-    }
-  }
-
-/* private */ 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 with Int,
-               y: Int )
-    extends cam.test.Kissa // run-one line, acnhor is 'trait'
-    with com.foo.super[Zot].Koira.this.type#Bar // ditto
-
-def someThingReallyLong(having: String, aLot: Int, ofParameters: Boolean):// 
foo zot
-    SomeAbsurdlyLongTypeThatBarelyFitsOnALine[Z, F] // run-on line, anchor is 
'def'
-    with SomeOtherType = { // ditto
-  // body here
-}
-
-List("foo", "bar") 
-map { s/* */
-         : /* */  Any =>
-  s.length // 'map' indented as run-on, 's =>' start lambda
-  toString
-}
-filter (foo =>
-  bar
-)
-
-List("foo") map ( 
-  s => // start lambda
-  s.length // run-on rule does not apply
-)
-
-
-/*
-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.
-- Rule does not apply, if the first parameter was a lambda expression
-*/
-
-class Foo( /* */
-  i: String, // one step from indent anchor column
-  k: String
-) // at indent anchor column
-
-def f( /* */ i: String, j: String with Bar,
-       k: String or
-         Int) // indented acording to previous
-
-val f = 
-{
-  foo(kissa,
-      kala
-        filter (odd))
-}
-
-{
-  val g = 
-    bar.
-      zot.
-      babarbar(
-        kissa,
-        kala
-      )
-}
-
-val h = "foo"
-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] 
-        if xs.size > 7 => 
-      xs map ( x => x.length)
-        sum
-
-    case a: Int if a < 0 =>
-      println(x);
-      x.length // note 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
-    val zot = jaada
-    if asdasd
-  } 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 and try statements
-
-If statements will be indented acording to the following rules:
-
-- If 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.
-
-Try statements will be indented acording to the following rules:
-- If the body of the 'try' is a simple expression (i.e. not a block), then the 
next 'catch' is aligned with the previous try
-- otherwise 'catch' is aligned with previous block close.
-- Finally is aligned similarly
-*/
-
-val x = if (kissa)
-          foo
-            map(s => s.toInt)
-            filter(_ > 0)
-        else if (kala)
-          bar
-        else
-          zot
-
-val y = if (kissa) {
-    foo
-    bar
-    zot
-  } else if (kala) {
-    bar
-  } else {
-    zot
-  }
-
-val a = try {
-    foo()
-  }
-  catch {
-    case e => bar()
-  }
-
-val b = try {
-    foo()
-  } catch {
-    case e => bar()
-  } finally {
-    zot()
-  }
-
-val c = try
-          zot()
-        catch {
-          case x =>
-            foo
-        }
-        finally
-          log("zotted")
-
-do {
-  zot
-} while (bar)
-
-while (zot)
-bar
-
-    
-
-/*
-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
-    {
-      zot
-        foo
-    }
-    
-    def bar =
-    {
-      zot
-    }
-    
-    def bar = 
-      (zot,
-       bar)
-    
-    val zot =
-    {
-      "hello"
-    }
-  }
-}
-
-/* 
-2. font-lock support
-*/
-
-/*
-2.1 Types
-*/
-
-val strings = Seq("""
-                 | multi line"
-                 | quote strings
-                 | zot
-                 """, "normal strings", 'c')
-
-val `yield` = 1
-
-val symbol = 'Symbol
-
-var List(foo, bar)
-
-var foo, bar :: bar::Nil, foo @ (foo, bar), List(foo: Int, bar: String) = foo
-
-x match {
-  case zot => zot
-  case (foo, zot) => foo + zot
-  case List(a, b) => a + b
-  case a :: Nil => a + b
-  case Zot | Bar => println("foo")
-}
-
-val x: Zot with Apropos[Zot forSome { val x: String }, Zot -> Bar <% Dif]
-
-type ->[A,B] = (A,B)
-val x: List[Bar] -> List[Zot] => List[Bar -> Zot] = _.toZot
-
-class Mail extends Communication with { def x = 2 } with OldStyle[A <% String]
-
-{
-  case a: String if zot > bar =>
-}
diff --git a/Test.scala b/Test.scala
deleted file mode 100644
index 7a55162..0000000
--- a/Test.scala
+++ /dev/null
@@ -1,175 +0,0 @@
-val x = if (foo) {
-    zot
-  } else {
-    bar
-  }
-
-val x = 
-  if (foo)
-    zot
-  else
-    bar 
-
-val x = 
-  if (foo)
-  { 
-    zot 
-  }
-  else
-  { 
-    bar 
-  }
-
-
-
-
-
-
-val x = for { 
-    a <- 1 to 10
-    b <- 1 to 20
-    if a > b
-    var x = 10  
-  } 
-  yield
-    ( a+b )
-    
-def x
-  (a, 
-   b)
-  (c,
-   d) =
-{
-  zot
-}
-
-@foo val x,
-         y = foo 
-| bar 
-| zot
-
-
-val y /* */ = bazoot {
-    foofoo
-  }
-
-def x = else
-          (x, y)
-
-def x = if (foo)
-        {
-          then
-        } 
-        else if (zot) 
-        {
-          fi
-        } 
-        else 
-        {
-          zot
-        }
-
-val y = 
-  if (foo)
-    bar
-  else if (bar)
-    zot
-  else
-    zot
-}
-
-
-val x = try {
-    foo
-  } catch {
-    asd
-  } finally {
-    bar
-  }
-
-while (bar) {
-  zot
-}
-
-do
-  zot
-while (bar)
-
-
-var x = if (foo)
-          if (bar) {
-            bar
-          } else {
-            zot
-          }
-          else
-            bar
-        
-
-
-
-{
-
-  class A
-      extends B {
-    asd
-  }
-  
-  someReallyAbsurdyLongLine.
-    thatMadeMeWantToCutIt.
-    yeahMoreOfThatLongStuff map {
-      foo =>
-      asdasd
-    }
-
-  /*
-   * asd asd 
-   */
-  
-  val a,
-      b,
-      c = "foo"
-  
-  def myVeryLongMethodName(x: String,
-                           y: String)
-                          (x: String):
-      Foo[Alko + Zugurov + Bagurov] = {
-    asdasdf
-  }
-  
-  def myVeryLongMethodName( x: String, y: String )
-                          ( z: String, b: String ) = {
-    asd
-  }
-  
-  /* fooo bar */
-
-  """foo""".r """bar""".r
-
-  """
-qasduote_asdasd a+_
-'f'
-""", val zot "fo\ro"
-
-  __
-
-  asdasd_dfasdf_>> _<<
-
-  val x:[Type <% Foo] => '\u123c'
-  val y = "foo a\"sdasd"
-  " ", " ", "as\"dasd"
-  `asdasd`> asdasdasd 
-  "asdasd
-
-  """asdasdasd
-asdasda
-asdasdasd
-asdasdasd"asda"
-asdasdasdasdasd asd""
-asdasd
-asdasdasdasdasd"""asdasdasd
-
-  """asdasd"""asasdasd
-
-  """asdasdasdasdasdlkjhasd
-asdasdkj"""