| object scala { | |
| val version = "SCALA_VERSION$" | |
| } | |
| val xml = <dependencies> | |
| <dependency> | |
| <groupId>org.scalanlp</groupId> | |
| <artifactId>scalala_${scala.version}</artifactId> | |
| <version>0.3.1</version> | |
| </dependency> |
| class A | |
| class A2 extends A | |
| class B | |
| trait M[X] | |
| // | |
| // Upper Type Bound | |
| // | |
| def upperTypeBound[AA <: A](x: AA): A = x |
| // scala 2.7 simple type constraint. This can only constrain a type parameter of this function. | |
| // Below, in ListW.sumint28, we can't use this approach because we want to constrain T, | |
| // a type param of the enclosing trait. | |
| def sumint27A[T <: Int](l: List[T]) : Int = l.reduceLeft((a: Int, b: Int) => a + b) | |
| trait IntLike[X] extends (X => Int) | |
| object IntLike { | |
| implicit val intIntLike: IntLike[Int] = new IntLike[Int] { def apply(x: Int) = identity(x) } | |
| } |
If possible, target commits at the 2.10.x branch rather than master. This can be done if the change is:
If such changes were targeted against master and now must be applied to 2.10.x, here's how to do it.
| tail local.sbt project/local.sbt | |
| ==> local.sbt <== | |
| TaskKey[Unit]("printBillOfMaterials") := (Def.taskDyn { | |
| val proj = thisProject.value | |
| val filter = ScopeFilter(inProjects(proj.aggregate: _*)) | |
| Def.task { | |
| (updateSbtClassifiers.value :: update.all(filter).value.toList).flatMap(_.configurations).flatMap(_.modules).flatMap(_.artifacts).flatMap(_._1.url).distinct.foreach(println) | |
| () | |
| } | |
| }).value |
| package mapmap | |
| trait ECtx | |
| trait KCtx | |
| trait Var[C, T] { | |
| def get(c: C): T | |
| } |
| BSStrategy = { | |
| version: 1, | |
| displayName: "Kayo", | |
| accepts: { | |
| method: "predicateOnTab", | |
| format: "%K LIKE[c] '*kayosports.com.au/*/*'", | |
| args: ["URL"] | |
| }, | |
| toggle: function () { console.log("toggle"); document.querySelector('[aria-label="Toggle play/pause"]').click(); }, | |
| pause: function () { console.log("pause") }, |
| class covariant extends scala.annotation.StaticAnnotation with scala.annotation.TypeConstraint | |
| object SetFactory { | |
| def empty[K]: Set[K @covariant] = Set.empty[K @covariant] | |
| } | |
| class Client { | |
| val x = if (true) Set("") else SetFactory.empty | |
| } |
| scala> :power | |
| ** Power User mode enabled - BEEP BOOP ** | |
| ** scala.tools.nsc._ has been imported ** | |
| ** New vals! Try repl, global, power ** | |
| ** New cmds! :help to discover them ** | |
| ** New defs! Type power.<tab> to reveal ** | |
| scala> val s = repl.stringToCompilerType("scala.Some") | |
| s: repl.compiler.Type = object Some |
Java 8 introduced lambdas to the Java language. While the design choices differ in many regards from Scala's functions, the underlying mechanics used to represent Java lambdas is flexible enough to be used as a target for the Scala compiler.
Java does not have canonical heirarchy of generic function types (ala scala.FunctionN), but instead allows a lambda to be used as a shorthand for an anonymous implementation of an Functional Interface
Here's an example of creating a predicate that closes over one value: