├── .travis.yml
├── README.md
├── LICENSE
├── src
    ├── main
    │   └── scala
    │   │   └── sext
    │   │       ├── OrderedMap.scala
    │   │       ├── Cli.scala
    │   │       ├── Benchmarking.scala
    │   │       └── package.scala
    └── test
    │   └── scala
    │       └── sext
    │           ├── OrderedMapTest.scala
    │           ├── Demo.scala
    │           └── Test.scala
└── pom.xml


/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: scala
 2 | 
 3 | jdk:
 4 |   - oraclejdk8
 5 | 
 6 | scala:
 7 |   - 2.12.0
 8 | 
 9 | install: 
10 |   mvn install -DskipTests=true -Dgpg.skip=true
11 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | #SExt
 2 | A small library that adds the missing useful functions to the standard Scala library. These include
 3 | 
 4 | * `unfold`, `unfold1`, `foldTo`, `foldFrom`
 5 | * `mapKeys`
 6 | * `zipBy`, `unzip4`
 7 | * `treeString`,`valueTreeString`
 8 | * `prependLines`, `splitBy`
 9 | 
10 | ... and some others you'll have to check in the [source `src/main/scala/sext/package.scala`](src/main/scala/sext/package.scala)
11 | 
12 | #Using
13 | Add the following Maven dependency
14 | 
15 |     <dependency>
16 |       <groupId>com.github.nikita-volkov</groupId>
17 |       <artifactId>sext</artifactId>
18 |       <version>0.2.3</version>
19 |     </dependency>
20 | 
21 | or SBT dependency
22 |     
23 |     libraryDependencies += "com.github.nikita-volkov" % "sext" % "0.2.4"
24 | 
25 | (or the appropriate Gradle one)
26 | 
27 | Add the following import statement to your files:
28 | 
29 |     import sext._
30 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Copyright (c) 2012, Nikita Volkov
2 | 
3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
4 | 
5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
6 | 
7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/src/main/scala/sext/OrderedMap.scala:
--------------------------------------------------------------------------------
 1 | package sext
 2 | 
 3 | import collection.immutable.Queue
 4 | 
 5 | object OrderedMap {
 6 |   def apply[A, B](elems: (A, B)*) =
 7 |     new OrderedMap(Map(elems: _*), Queue(elems.map(_._1): _*))
 8 | }
 9 | /**
10 |  * An ordered map implementation that should perform effectively on all operations except
11 |  * removal, where it performs linearly.
12 |  */
13 | class OrderedMap[A, B](
14 |   map: Map[A, B],
15 |   protected val order: Queue[A]
16 | ) extends Map[A, B] {
17 |   def get(key: A) =
18 |     map.get(key)
19 |   def iterator =
20 |     order.iterator.map(x => x -> map(x))
21 |   def +[B1 >: B](kv: (A, B1)) =
22 |     new OrderedMap(
23 |       map + kv,
24 |       if( map.contains(kv._1) ) order else order enqueue kv._1
25 |     )
26 |   def -(key: A) =
27 |     new OrderedMap(
28 |       map - key,
29 |       order diff Queue(key)
30 |     )
31 |   override def hashCode() =
32 |     order.hashCode
33 |   override def equals(that: Any) =
34 |     that match {
35 |       case that: OrderedMap[A, B] =>
36 |         order.equals(that.order)
37 |       case _ =>
38 |         super.equals(that)
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/main/scala/sext/Cli.scala:
--------------------------------------------------------------------------------
 1 | package sext
 2 | 
 3 | /**
 4 |  * Utilities for command-line applications
 5 |  */
 6 | object Cli {
 7 |   /**
 8 |    * Process the input args string-array while providing default values for unspecified args.
 9 |    *
10 |    * Sample usage:
11 |    *
12 |    * @example {{{
13 |    *   val (intArg, longArg, stringArg) = Cli.parseArgs(args, Seq("1", "100", "someString")){ 
14 |    *       case Array(a, b, c) => (a.toInt, b.toLong, c)
15 |    *     }
16 |    * }}}
17 |    * @param args The value of `args` field provided by [[scala.App]]
18 |    * @param defaults Default values for unspecified args
19 |    * @param process A function which will process a complete list of args with defaults provided for skipped args
20 |    * @tparam Z Result of `process` function
21 |    * @return Result of `process` function
22 |    */
23 |   def parseArgs
24 |     [ Z ]
25 |     ( args     : Array[String], 
26 |       defaults : Seq[String] )
27 |     ( process  : Array[String] => Z )
28 |     : Z
29 |     = if( args.length <= defaults.length )
30 |         process(args ++ defaults.drop(args.length))
31 |       else 
32 |         throw new Exception("Too many args")
33 | 
34 | 
35 | }


--------------------------------------------------------------------------------
/src/test/scala/sext/OrderedMapTest.scala:
--------------------------------------------------------------------------------
 1 | package sext
 2 | 
 3 | import org.scalatest._
 4 | import org.junit.runner.RunWith
 5 | import org.scalatest.junit.JUnitRunner
 6 | import collection.immutable.Queue
 7 | 
 8 | @RunWith(classOf[JUnitRunner])
 9 | class OrderedMapTest extends FunSuite with Matchers {
10 |   test("preserves order of creation") {
11 |     val elems = (1 to 100) zip (1 to 100)
12 |     OrderedMap(elems: _*).toSeq should equal (elems)
13 |   }
14 |   test("preserves order of addition") {
15 |     val elems1 = (1 to 100) zip (1 to 100)
16 |     val elems2 = (101 to 200) zip (101 to 200)
17 |     (OrderedMap(elems1: _*) ++ OrderedMap(elems2: _*) toSeq) should equal(elems1 ++ elems2)
18 |   }
19 |   test("equals equal and have same hashCode") {
20 |     val elems = (1 to 100) zip (1 to 100)
21 | 
22 |     OrderedMap(elems: _*) should equal (OrderedMap(elems: _*))
23 |     OrderedMap(elems: _*).hashCode should equal (OrderedMap(elems: _*).hashCode)
24 |   }
25 |   test("differently ordered don't equal and have different hashcodes") {
26 |     val elems1 = (1 to 100) zip (1 to 100)
27 |     val elems2 = elems1.reverse
28 | 
29 |     OrderedMap(elems1: _*) should not equal (OrderedMap(elems2: _*))
30 |     OrderedMap(elems1: _*).hashCode should not equal (OrderedMap(elems2: _*).hashCode)
31 |   }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/test/scala/sext/Demo.scala:
--------------------------------------------------------------------------------
 1 | package sext
 2 | 
 3 | object Demo extends App {
 4 | 
 5 |   case class A(a: Int, b: String, c: Seq[A])
 6 |   val a = A(1, "adsf", A(5, "oiweur\nsadf", Nil) :: A(4, "", A(6, "dsf", Nil) :: Nil) :: A(9, "sdlfkjw", Nil) :: Nil)
 7 |   a.valueTreeString.trace()
 8 | 
 9 |   Map(
10 |     "repo/" -> Map(
11 |       "org/" -> Map(
12 |         "eclipse/" -> Map(
13 |           "e4/" -> Map(
14 |             "xwt/" -> Seq(
15 |               "0.9.1-SNAPSHOT/" -> Seq(
16 |                 "maven-metadata-local.xml",
17 |                 "maven-metadata-local.xml.md5",
18 |                 "maven-metadata-local.xml.sha1",
19 |                 "xwt-0.9.1-SNAPSHOT-sources.jar",
20 |                 "xwt-0.9.1-SNAPSHOT-sources.jar.md5",
21 |                 "xwt-0.9.1-SNAPSHOT-sources.jar.sha1",
22 |                 "xwt-0.9.1-SNAPSHOT.jar",
23 |                 "xwt-0.9.1-SNAPSHOT.jar.md5",
24 |                 "xwt-0.9.1-SNAPSHOT.jar.sha1",
25 |                 "xwt-0.9.1-SNAPSHOT.pom",
26 |                 "xwt-0.9.1-SNAPSHOT.pom.md5",
27 |                 "xwt-0.9.1-SNAPSHOT.pom.sha1"
28 |               ),
29 |               "maven-metadata-local.xml",
30 |               "maven-metadata-local.xml.md5",
31 |               "maven-metadata-local.xml.sha1"
32 |             )
33 |           )
34 |         )
35 |       )
36 |     )
37 |   ).valueTreeString.trace()
38 | 
39 | 
40 |   ("lsdkfj\nsdljfdkslf\n   ldkf", 0, 3).valueTreeString.trace()
41 | 
42 | }
43 | 


--------------------------------------------------------------------------------
/src/main/scala/sext/Benchmarking.scala:
--------------------------------------------------------------------------------
 1 | package sext
 2 | 
 3 | object Benchmarking {
 4 | 
 5 |   /**
 6 |    * Execute a function and return its result paired with execution time
 7 |    * @param f The function to execute
 8 |    * @tparam Z Function execution result
 9 |    * @return A pair of function result and running time in nanoseconds
10 |    */
11 |   def benchmark [Z] ( f : => Z ) : (Z, Long)
12 |     = {
13 |       val start = System.nanoTime()
14 |       val result = f
15 |       val period = System.nanoTime() - start
16 |       (result, period)
17 |     }
18 |   /**
19 |    * Execute and get result of a function while printing the time it took to execute it
20 |    * @param label A label to prepend the outputted time with
21 |    * @param f A function to execute
22 |    * @tparam Z Result of the executed function
23 |    * @return Result of the executed function
24 |    */
25 |   def benchmarkAndPrint [Z] ( label : String ) ( f : => Z ) : Z
26 |     = benchmark(f) match {case (r, p) => println(label + ": " + p); r}
27 |   /**
28 |    * Execute and get result of function `f` while executing a function `g` on nanoseconds it took to execute function `f`
29 |    * @param g Function on nanoseconds
30 |    * @param f Function to measure execution time of
31 |    * @tparam Z Result of function `f`
32 |    * @return Result of function `f`
33 |    */
34 |   def benchmarkDoing [Z] ( g : Long => Unit ) ( f : => Z ) : Z
35 |     = benchmark(f) match {case (r, p) => g(p); r}
36 | 
37 | }
38 | 


--------------------------------------------------------------------------------
/src/test/scala/sext/Test.scala:
--------------------------------------------------------------------------------
 1 | package sext
 2 | 
 3 | import org.scalatest._
 4 | import org.junit.runner.RunWith
 5 | import org.scalatest.junit.JUnitRunner
 6 | 
 7 | @RunWith(classOf[JUnitRunner])
 8 | class Test extends FunSuite with Matchers {
 9 |   import Test._
10 |   test("Tuple4 zipped and unzip4"){
11 |     val as = List("a1", "a2", "a3")
12 |     val bs = List("b1", "b2", "b3")
13 |     val cs = List("c1", "c2", "c3")
14 |     val ds = List("d1", "d2", "d3")
15 | 
16 |     
17 |     (as, bs, cs, ds).zipped.filterNot(_._1 == "a2").unzip4 should equal ( (List("a1", "a3"), List("b1", "b3"), List("c1", "c3"), List("d1", "d3")) )
18 | 
19 |   }
20 |   test("zipBy preserves root type"){
21 |     Seq(1,2,3).zipBy(_ + 3) should beInstanceOf[Seq[_]]
22 |     Seq(1,2,3).zipBy(_ + 3) should not (beInstanceOf[Set[_]])
23 |   }
24 |   test("mapKeys") {
25 |     Map("b" -> 1, "c" -> 4, "a" -> 9).mapKeys(_ + "1") should
26 |     equal(Map("b1" -> 1, "c1" -> 4, "a1" -> 9))
27 |   }
28 |   test("toInstanceOf returns None for unmatching type"){
29 |     8.toInstanceOf[String] should equal(None)
30 |   }
31 |   test("toInstanceOf returns Some for a matching type"){
32 |     8.toInstanceOf[Int] should equal(Some(8))
33 |   }
34 |   test("toInstanceOf returns Some for an inheriting type"){
35 |     List(1).toInstanceOf[Seq[Int]] should be ('defined)
36 |   }
37 |   test("toInstanceOf on mixins"){
38 |     (new A with B).toInstanceOf[B] should be ('defined)
39 |   }
40 |   test("toInstanceOf on general types as input"){
41 |     (Seq(new A with B, new A{}, new B {}))
42 |       .flatMap{_.toInstanceOf[B]}
43 |       .should( have size (2) )
44 |   }
45 | }
46 | object Test {
47 |   trait A
48 |   trait B
49 | 
50 |   import org.scalatest.matchers._
51 |   import reflect._
52 |   def beInstanceOf [A : ClassTag]
53 |     = Matcher { x : Any =>
54 |         MatchResult(
55 |           classTag[A].runtimeClass.isAssignableFrom(x.getClass),
56 |           x.getClass + " is not an instance of " + classTag[A].runtimeClass,
57 |           x.getClass + " is an instance of " + classTag[A].runtimeClass
58 |         )
59 |       }
60 | 
61 | }
62 | 


--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <project xmlns="http://maven.apache.org/POM/4.0.0"
  3 |          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4 |          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5 |   <modelVersion>4.0.0</modelVersion>
  6 | 
  7 |   <groupId>com.github.nikita-volkov</groupId>
  8 |   <artifactId>sext</artifactId>
  9 |   <version>0.2.6</version>
 10 |   <packaging>jar</packaging>
 11 | 
 12 |   <name>SExt</name>
 13 |   <description>A small extensions library for Scala</description>
 14 |   <url>http://www.github.com/nikita-volkov/sext</url>
 15 | 
 16 |   <licenses>
 17 |     <license>
 18 |       <name>MIT/X11</name>
 19 |       <url>http://www.github.com/nikita-volkov/sext/LICENSE</url>
 20 |     </license>
 21 |   </licenses>
 22 | 
 23 |   <developers>
 24 |     <developer>
 25 |       <id>nikita-volkov</id>
 26 |       <name>Nikita Volkov</name>
 27 |       <email>nikita.y.volkov@mail.ru</email>
 28 |     </developer>
 29 |   </developers>
 30 | 
 31 |   <scm>
 32 |     <connection>scm:git:git@github.com:nikita-volkov/sext.git</connection>
 33 |     <url>scm:git:git@github.com:nikita-volkov/sext.git</url>
 34 |     <developerConnection>scm:git:git@github.com:nikita-volkov/sext.git</developerConnection>
 35 |   </scm>
 36 | 
 37 |   <parent>
 38 |     <groupId>org.sonatype.oss</groupId>
 39 |     <artifactId>oss-parent</artifactId>
 40 |     <version>7</version>
 41 |   </parent>
 42 | 
 43 |   <dependencies>
 44 |     <dependency>
 45 |       <groupId>org.scalatest</groupId>
 46 |       <artifactId>scalatest_2.12</artifactId>
 47 |       <version>3.0.1</version>
 48 |       <scope>test</scope>
 49 |     </dependency>
 50 |     <dependency>
 51 |       <groupId>junit</groupId>
 52 |       <artifactId>junit</artifactId>
 53 |       <version>4.7</version>
 54 |       <scope>test</scope>
 55 |     </dependency>
 56 |     <dependency>
 57 |       <groupId>org.scala-lang</groupId>
 58 |       <artifactId>scala-reflect</artifactId>
 59 |       <version>[2.10,2.12.999)</version>
 60 |     </dependency>
 61 |     <dependency>
 62 |       <groupId>org.scala-lang</groupId>
 63 |       <artifactId>scala-library</artifactId>
 64 |       <version>[2.10,2.12.999)</version>
 65 |     </dependency>
 66 |   </dependencies>
 67 | 
 68 |   <build>
 69 |     <plugins>
 70 |       <plugin>
 71 |         <groupId>net.alchim31.maven</groupId>
 72 |         <artifactId>scala-maven-plugin</artifactId>
 73 |         <version>3.2.2</version>
 74 |         <configuration>
 75 |           <recompileMode>incremental</recompileMode>
 76 |           <useZincServer>true</useZincServer>
 77 |         </configuration>
 78 |         <executions>
 79 |           <execution>
 80 |             <id>compile</id>
 81 |             <goals>
 82 |               <goal>compile</goal>
 83 |               <goal>testCompile</goal>
 84 |             </goals>
 85 |           </execution>
 86 |           <execution>
 87 |             <id>attach-javadocs</id>
 88 |             <goals>
 89 |               <goal>doc</goal>
 90 |               <goal>doc-jar</goal>
 91 |             </goals>
 92 |           </execution>
 93 |           <execution>
 94 |             <goals>
 95 |               <goal>doc</goal>
 96 |             </goals>
 97 |             <phase>site</phase>
 98 |           </execution>
 99 |         </executions>
100 |       </plugin>
101 |       <plugin>
102 |         <groupId>org.apache.maven.plugins</groupId>
103 |         <artifactId>maven-surefire-plugin</artifactId>
104 |         <version>2.12</version>
105 |         <configuration>
106 |           <includes>
107 |             <include>**/*Suite.class</include>
108 |             <include>**/*Test.class</include>
109 |             <include>**/*Tests.class</include>
110 |             <include>**/*Spec.class</include>
111 |             <include>**/*Specs.class</include>
112 |           </includes>
113 |         </configuration>
114 |       </plugin>
115 |       <plugin>
116 |         <groupId>org.apache.maven.plugins</groupId>
117 |         <artifactId>maven-source-plugin</artifactId>
118 |         <version>2.1.2</version>
119 |         <executions>
120 |           <execution>
121 |             <id>attach-sources</id>
122 |             <phase>package</phase>
123 |             <goals>
124 |               <goal>jar-no-fork</goal>
125 |             </goals>
126 |           </execution>
127 |         </executions>
128 |       </plugin>
129 |       <plugin>
130 |         <groupId>org.apache.maven.plugins</groupId>
131 |         <artifactId>maven-gpg-plugin</artifactId>
132 |         <version>1.4</version>
133 |         <executions>
134 |           <execution>
135 |             <id>sign-artifacts</id>
136 |             <goals>
137 |               <goal>sign</goal>
138 |             </goals>
139 |           </execution>
140 |         </executions>
141 |         <configuration>
142 |           <useAgent>true</useAgent>
143 |         </configuration>
144 |       </plugin>
145 |       <!--RELEASING-->
146 |       <plugin>
147 |         <groupId>org.sonatype.plugins</groupId>
148 |         <artifactId>nexus-staging-maven-plugin</artifactId>
149 |         <version>1.6.7</version>
150 |         <extensions>true</extensions>
151 |         <configuration>
152 |           <serverId>ossrh</serverId>
153 |           <nexusUrl>https://oss.sonatype.org/</nexusUrl>
154 |           <autoReleaseAfterClose>true</autoReleaseAfterClose>
155 |         </configuration>
156 |       </plugin>
157 |       <plugin>
158 |         <artifactId>maven-release-plugin</artifactId>
159 |         <version>2.2.2</version>
160 |         <configuration>
161 |           <goals>clean deploy site-deploy</goals>
162 |         </configuration>
163 |       </plugin>
164 |     </plugins>
165 |   </build>
166 | 
167 | </project>
168 | 


--------------------------------------------------------------------------------
/src/main/scala/sext/package.scala:
--------------------------------------------------------------------------------
  1 | package sext
  2 | 
  3 | import util.Try
  4 | import reflect.runtime.universe._
  5 | import reflect.runtime.currentMirror
  6 | import collection.GenTraversableOnce
  7 | 
  8 | object `package` {
  9 | 
 10 |   implicit class SextMap [ A, B ] ( val a : Map[ A, B ] ) extends AnyVal {
 11 |     def filterValues(predicate: B => Boolean)
 12 |       = a.filter(pair => predicate(pair._2))
 13 |     def withValuesFilter(predicate: B => Boolean)
 14 |       = a.withFilter(pair => predicate(pair._2))
 15 |     def mapKeys[Z](f: A => Z)
 16 |       = a.map(pair => f(pair._1) -> pair._2)
 17 |   }
 18 | 
 19 |   implicit class SextTraversable
 20 |     [ A, B[A] <: Traversable[A] ]
 21 |     ( val a : B[A] )
 22 |     extends AnyVal
 23 |     {
 24 |       def zipBy [ Z ] ( f : A => Z ) : B[(A, Z)]
 25 |         = a.map(x => x -> f(x)).asInstanceOf[B[(A, Z)]]
 26 |     }
 27 | 
 28 |   implicit class SextAny [ A ] ( val a : A ) extends AnyVal {
 29 |     def tap [ Z ] ( f : A => Z ) = { f(a); a }
 30 | 
 31 |     /**
 32 |      * Is the value empty. Equivalent to monoid zero.
 33 |      */
 34 |     def isEmpty : Boolean
 35 |       = a match {
 36 |         case null => true
 37 |         case x: Boolean => !x
 38 |         case x: Byte => x == 0.toByte
 39 |         case x: Short => x == 0.toShort
 40 |         case x: Char => x == 0.toChar
 41 |         case x: Int => x == 0
 42 |         case x: Long => x == 0l
 43 |         case x: Float => x == 0f
 44 |         case x: Double => x == 0d
 45 |         case x: Product => x.productIterator.forall(_.isEmpty)
 46 |         case x: GenTraversableOnce[_] => x.isEmpty
 47 |         case _ => false
 48 |       }
 49 | 
 50 |     def notNull = Option(a)
 51 | 
 52 |     def notEmpty = if (a.isEmpty) None else Some(a)
 53 | 
 54 |     def satisfying(p: A => Boolean) : Option[A]
 55 |       = if (p(a)) Some(a) else None
 56 | 
 57 |     def trace [ Z ] ( f : A => Z = (x : A) => x.treeString )
 58 |       = { Console.println(f(a)); a }
 59 | 
 60 |     def trying [ Z ] ( f : A => Z ) = Try(f(a)).toOption
 61 | 
 62 |     def unfold
 63 |       [ Z ]
 64 |       ( f : A => Option[(Z, A)] )
 65 |       : Stream[Z]
 66 |       = f(a) map {case (b, a) => b #:: (a unfold f)} getOrElse Stream()
 67 | 
 68 |     def unfold1
 69 |       ( f : A => Option[A] )
 70 |       : Stream[A]
 71 |       = f(a) map (a => a #:: (a unfold1 f)) getOrElse Stream()
 72 | 
 73 |     def iterate
 74 |       ( f : A => A )
 75 |       : Stream[A]
 76 |       = a #:: (f(a) iterate f)
 77 | 
 78 |     def foldTo
 79 |       [ Z ]
 80 |       ( b : Traversable[Z] )
 81 |       ( f : (Z, A) => A)
 82 |       = (b foldRight a)(f)
 83 | 
 84 |     def foldFrom
 85 |       [ Z ]
 86 |       ( b : Traversable[Z] )
 87 |       ( f : (A, Z) => A)
 88 |       = (b foldLeft a)(f)
 89 | 
 90 |   }
 91 | 
 92 |   implicit class SextAnyToInstanceOf[ A : TypeTag ]( x : A ) {
 93 |     /**
 94 |      * Get an option of this value as of instance of type `T`
 95 |      * @tparam T A type to see this value as
 96 |      * @return `Some(a)` if `a` is an instance of `T` and `None` otherwise
 97 |      */
 98 |     def toInstanceOf[ T : TypeTag ] : Option[T]
 99 |       = {
100 |         def test
101 |           = currentMirror.runtimeClass(typeOf[T]) match {
102 |               case c if c.isPrimitive => typeOf[A] <:< typeOf[T]
103 |               case c => c.isAssignableFrom(x.getClass) || typeOf[A] <:< typeOf[T]
104 |             }
105 |         if( test ) Some( x.asInstanceOf[T] )
106 |         else None
107 |       }
108 |   }
109 |   implicit class SextAnyTreeString [ A ] ( a : A ) {
110 | 
111 |     private def indent ( s : String )
112 |       = s.lines.toStream match {
113 |           case h +: t =>
114 |             ( ("- " + h) +: t.map{"| " + _} ) mkString "\n"
115 |           case _ => "- "
116 |         }
117 | 
118 |     /**
119 |      * @return A readable string representation of this value
120 |      */
121 |     def treeString
122 |       : String
123 |       = a match {
124 |           case x : Traversable[_] =>
125 |             x.stringPrefix + ":\n" +
126 |             x.view
127 |               .map{ _.treeString }
128 |               .map{ indent }
129 |               .mkString("\n")
130 |           case x : Product if x.productArity == 0 =>
131 |             x.productPrefix
132 |           case x : Product =>
133 |             x.productPrefix + ":\n" +
134 |             x.productIterator
135 |               .map{ _.treeString }
136 |               .map{ indent }
137 |               .mkString("\n")
138 |           case null =>
139 |             "null"
140 |           case _ =>
141 |             a.toString
142 |         }
143 | 
144 |     /**
145 |      * @return A readable string representation of this value of a different format to `treeString`
146 |      */
147 |     def valueTreeString
148 |       : String
149 |       = a match {
150 |           case (k, v) =>
151 |             k.valueTreeString + ":\n" +
152 |             v.valueTreeString
153 |           case a : TraversableOnce[_] =>
154 |             a.toStream
155 |               .map(_.valueTreeString)
156 |               .map(indent)
157 |               .mkString("\n")
158 |           case a : Product =>
159 |             val b
160 |               = currentMirror.reflect(a).symbol.typeSignature.members.toStream
161 |                   .collect{ case a : TermSymbol => a }
162 |                   .filterNot(_.isMethod)
163 |                   .filterNot(_.isModule)
164 |                   .filterNot(_.isClass)
165 |                   .map( currentMirror.reflect(a).reflectField )
166 |                   .map( f => f.symbol.name.toString.trim -> f.get )
167 |                   .reverse
168 |             collection.immutable.ListMap(b: _*).valueTreeString
169 |           case null =>
170 |             "null"
171 |           case _ =>
172 |             a.toString
173 |         }
174 | 
175 |   }
176 | 
177 |   implicit class SextString
178 |     ( val s : String )
179 |     extends AnyVal
180 |     {
181 |       def notEmpty
182 |         = if( s.isEmpty ) None else Some(s)
183 |       def indent
184 |         ( i : Int )
185 |         = prependLines(" " * i)
186 |       def prependLines
187 |         ( p : String )
188 |         = s.lines
189 |             .reduceOption{ _ + "\n" + p + _ }
190 |             .map{ p + _ }
191 |             .getOrElse( p )
192 |       def splitBy
193 |         ( splitter : String )
194 |         : (String, String)
195 |         = s.indexOf(splitter) match {
196 |             case -1 => (s, "")
197 |             case i => s.splitAt(i) match { case (a, b) => (a, b.drop(splitter.size)) }
198 |           }
199 |     }
200 | 
201 |   implicit class SextBoolean ( val a : Boolean ) extends AnyVal {
202 |     def option [ Z ] ( b : Z ) : Option[Z] = if( a ) Some(b) else None
203 |   }
204 | 
205 |   implicit class SextTuple4
206 |     [ A, B, C, D ]
207 |     ( val t : (Iterable[A], Iterable[B], Iterable[C], Iterable[D]) )
208 |     extends AnyVal
209 |     {
210 |       def zipped
211 |         = t._1.toStream
212 |             .zip(t._2).zip(t._3).zip(t._4)
213 |             .map{ case (((a, b), c), d) => (a, b, c, d) }
214 |     }
215 | 
216 |   implicit class SextIterable
217 |     [ A, B, C, D ]
218 |     ( val ts : Iterable[(A, B, C, D)] )
219 |     extends AnyVal
220 |     {
221 |       def unzip4
222 |         = ts.foldRight((List[A](), List[B](), List[C](), List[D]()))(
223 |             (a, z) => (a._1 +: z._1, a._2 +: z._2, a._3 +: z._3, a._4 +: z._4)
224 |           )
225 |     }
226 | 
227 |   implicit class SextInt ( val a : Int ) {
228 |     def times ( f : => Unit ) = (0 to a).foreach(_ => f)
229 |   }
230 | 
231 |   /**
232 |    * Useful for wrapping a function and passing as lambda when partially applied
233 |    */
234 |   def trying [ A, Z ] ( f : A => Z ) ( a : A ) = a trying f
235 | 
236 |   def memo [ A, Z ] ( f : A => Z ) = {
237 |      // a WeakHashMap will release cache members if memory tightens
238 |      val cache = new collection.mutable.WeakHashMap[A, Z]
239 |      x : A => synchronized { cache.getOrElseUpdate( x, f(x) ) }
240 |   }
241 | 
242 | }
243 | 


--------------------------------------------------------------------------------