Example:

scala> val list = List("a"->1,"b"->2,"c"->3)
list: List[(java.lang.String, Int)] = List((a,1), (b,2), (c,3))

scala> val map = list.toMap
map: scala.collection.immutable.Map[java.lang.String,Int] = Map((a,1), (b,2), (c,3))

scala> val m: Map[Int,String] = (for{ (k,v) <- list; t=(v,k) } yield t)(breakOut)
m: Map[Int,String] = Map((1,a), (2,b), (3,c))

Example

scala> def divide(dividend: Double, divisor: Double) = dividend/divisor
divide: (dividend: Double,divisor: Double)Double

scala> divide(divisor=2,dividend=10)
res7: Double = 5.0

In Scala 2.8.0 we can use default arguments as well.

Example

scala> def divide(dividend: Double, divisor: Double = 2) = dividend/divisor
divide: (dividend: Double,divisor: Double)Double

scala> divide(10)
res7: Double = 5.0

Named and default arguments are used in the compiler-generated “copy” methods in case classes, which takes same parameter types as
primary constructor and its arguments are treated as a default values.

Example

scala> case class C (s: String, i: Int)
defined class C
scala> val c1 = C("some",1)
c1: C = C(some,1)
scala> val c2 = c1.copy(i=2)
c2: C = C(some,2)

For futher information please visit http://www.scala-lang.org/node/2075

For comprehension is evaluating all bindings for each bindings generated by enumerators. For comprehension with yield evaluates each bindings and collect result. What is the enumerator? It could be a generator, which produces values like an iterator: ‘a <- list’. Then it could be a guard (filter) ‘a>1′ and finally could be a value definition ‘val’ pattern ‘=’ expression: val x=a+1.
For comprehension always starts with generator and could be followed by other generators, value definition and then guards.
Generators and guards are translated to map,withFilter,flatmap and foreach.
Here is a quote from Scala 2.8.0 Spec (page 89/90 – For Comprehensions and For Loops) about translation rules:

The translation scheme is as follows. In a first step, every generator p <-e, where p is not irrefutable (§8.1) for the type of e is replaced by
p <- e.withFilter { case p => true; case _ => false }

Then, the following rules are applied repeatedly until all comprehensions have been
eliminated.

Example:

private def loadDescriptors(bundle: Bundle): Array[URL] = {
	val descriptorLocations = bundle.getHeaders().get( "Service-Component" ).asInstanceOf[String]
	val entries = for(descriptor <-descriptorLocations.split(","); val entry = descriptor.split("/") ) yield (entry(0),entry(1))
	for((path, filen) <- entries; url <- bundle.findEntries(path,filen,false).toTraversable) yield url.asInstanceOf[URL]
}

In the example I am reading the header “Service-Component” and I have to find service descriptor URL.
In the first for comprehension first enum is an Array[String] generator then for each element in the array value definition enum is evaluated and finally yield collects values from each evaluation and every result I am collecting as a tuple of file path and file name.
Second for comprehension is pretty same, two generators and collecting values as URL objects.

Example with a guard:

private def readFromURL(url: URL): Iterator[String] = {
    for (line <- Source.fromURL(url).getLines() if ((line.length > 0) && (line.charAt(0) != '#')))
    yield line
  }
 

The for comprehension is translated to:

Source.fromURL(url).getLines.
  		withFilter { line => ((line.length > 0) && (line.charAt(0) != '#'))}.map { case line => line }

For more information please have a look at Scala 2.8.0 Specification. It’s included in Scala distribution.

First I will describe usage of Guice without any extensions.
Google Juice dependency is mainly provided by using annotations, xml is not used for any configuration.
The only dependencies for using Google Guice without any extensions in OSGi bundles:

1    ACTIVE      com.google.inject_2.0.0
3    ACTIVE      com.springsource.org.aopalliance_1.0.0

In compare to spring it is big difference only 2 extra bundles to have automatically managed dependency injection in our bundle!
In order to use Guice first we have to define a module which will describe our bindings.
Our module must extend AbstractModule class and implement configure method.
In my example I’m using binding of interfaces to concrete implementation classes and interceptor which will intercept all methods with Intercept annotation. Binding to instance could be used as well.

package guice_test.module;

import com.google.inject.AbstractModule;
import com.google.inject.matcher.Matchers;
import com.labs.interceptor.Intercept;
import com.labs.interceptor.ParserInterceptor;
import com.labs.parser.IParser;
import com.labs.parser.Parser;
import com.labs.provider.IProvider;
import com.labs.provider.Provider;

public class TestModule extends AbstractModule {

@Override
protected void configure() {
bind(IParser.class).to(Parser.class);
bind(IProvider.class).to(Provider.class);
bindInterceptor(Matchers.any(), Matchers.annotatedWith(Intercept.class),
new ParserInterceptor());

}

}

In the example we have Parser which is used by Provider and should be injected using its constructor.To use automatic injection we have to annotate method with com.google.inject.Inject annotation. Parser method will be intercepted by ParserInterceptor. With one line in the module we can define and use advantages of AOP language.

package com.labs.provider;

import com.google.inject.Inject;
import com.labs.parser.IParser;

public class Provider implements IProvider {

private IParser parser;

@Inject
public Provider(IParser parser){
this.parser = parser;
}

public String process(String name){
return this.parser.parse(name);
}

}

package com.labs.parser;

import com.labs.interceptor.Intercept;

public class Parser implements IParser {

@Intercept
public String parse(String input){

return "output" + input;

}
}

package com.labs.interceptor;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class ParserInterceptor implements MethodInterceptor{

public Object invoke(MethodInvocation invocation) throws Throwable {

System.out.println("Invocation intercepted : " + invocation.getMethod().getName());

return invocation.proceed();
}

}

The last thing is our Activator which will be used to start our code managed by Guice. In the start method Injector is created and from injector we can get an instance of provider which will have injected Parser by Guice framework.

import guice_test.module.TestModule;

import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;

import com.google.inject.Guice;
import com.google.inject.Injector;
import com.labs.provider.Provider;

public class Activator implements BundleActivator {

public void start(BundleContext context) throws Exception {
Injector injector = Guice.createInjector(new TestModule());
Provider provider = injector.getInstance(Provider.class);
String res = provider.process("hello");
System.out.println("Result =" + res);

}

public void stop(BundleContext context) throws Exception {

}

}

Mainfest of our guice_test bundle looks:

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Guice_test
Bundle-SymbolicName: guice_test
Bundle-Version: 1.0.0.qualifier
Bundle-Activator: guice_test.Activator
Import-Package: com.google.inject;version="1.2.0",
com.google.inject.binder;version="1.2.0",
com.google.inject.matcher;version="1.2.0",
org.aopalliance.intercept;version="1.0.0",
org.osgi.framework;version="1.3.0"
Bundle-RequiredExecutionEnvironment: J2SE-1.5

In the first example we didn’t register or use any service. We can still do this using OSGI API like context.registerService(…). Output of starting the bundle should be as follow:

osgi> Invocation intercepted : parse
Result =outputhello

In the second example we will concentrate on usage of Peaberry project to expose IProvider as a OSGI service.
Peaberry allows us to inject dynamic service to our code or to expose our component as a service.
We will change the previous example to use the Peaberry extension.

First we need to add to the manifest three packages:

org.ops4j.peaberry;version="1.0.0",
org.ops4j.peaberry.builders;version="1.0.0",
org.ops4j.peaberry.util;version="1.0.0"

When we start our container and list bundles with command ss we should have five following bundles:

id    State       Bundle
0    ACTIVE      org.eclipse.osgi_3.5.0.v20090520
1    ACTIVE      com.google.inject_2.0.0
3    ACTIVE      com.springsource.org.aopalliance_1.0.0
5    ACTIVE      guice_test_1.0.0.qualifier
6    ACTIVE      org.ops4j.peaberry_1.0.0

We want to expose IProvider implementation as a service. To do that we need to bind IProvider interface to service instance represent by Provider class.

We can use following API to export the service:

bind(TypeLiterals.export(A.class)).
toProvider(Peaberry.service(new A()).export());

At the same time we also import single instance of IProvider service using API:

bind(A.class).toProvider(Peaberry.service(A.class).single());

Here is a code snippet of TestModule..

@Override
protected void configure() {
bind(IParser.class).to(Parser.class);
//exporting service
bind(TypeLiterals.export(IProvider.class)).
toProvider(Peaberry.service(new Provider()).export());

bindInterceptor(Matchers.any(),
Matchers.annotatedWith(Intercept.class), new ParserInterceptor());

//importing service
bind(IProvider.class).
toProvider(Peaberry.service(IProvider.class).single());

bind(IServiceUser.class).to(ServiceUser.class);

}

Provider instance will be registered as a service and new class ServiceUser will
use Provider service.

public class ServiceUser implements IServiceUser {

private IProvider provider;

@Inject
public ServiceUser(IProvider provider){
this.provider = provider;
}

public String processRequest(String name){
return provider.process(name);
}

}

Then we need to add org.ops4j.peaberry.Peaberry.osgiModule to createInjector method.
We are also injecting IProvider service using a handle for export of a service org.ops4j.peaberry.Export. Using a handle we can unregister the service when the bundle is stopped. The Peaberry is providing handle for import as well which can be used to unget the service.

Here is how Activator looks now.

package guice_test;

import guice_test.module.TestModule;

import org.ops4j.peaberry.Export;
import org.ops4j.peaberry.Peaberry;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;

import com.google.inject.Guice;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.labs.provider.IProvider;
import com.labs.user.IServiceUser;

public class Activator implements BundleActivator {

//injecting a handle to IProvider service can be used to unregister
// service when bundle is stopped
@Inject
private Export<IProvider> providerProxy;

public void start(BundleContext context) throws Exception {
Injector injector = Guice.createInjector(Peaberry.osgiModule(context),
new TestModule());
injector.injectMembers(this);

IServiceUser user = injector.getInstance(IServiceUser.class);
String res = user.processRequest("hello");
System.out.println("Result =" + res);

}

public void stop(BundleContext context) throws Exception {
this.providerProxy.unput();
}

}

When the bundle is started ServiceUser will use Provider service and execute process method. Output of the execution should be:

osgi> Invocation intercepted : parse
Result =outputhello

API for import multiple services:

Import org.ops4j.peaberry.Peaberry.service;
Import org.ops4j.peaberry.util.TypeLiterals.iterable;

@Inject
Iterable<A> services;
bind(iterable(A.class)).toProvider(service(A.class).multiple());

API for service binding:

service(A.class).filter(/* apply a filter */)...
service(A.class).in(/* query a specific registry */)...
service(A.class).out(/* watch for service changes - act like ServiceTracker*/)...
service(A.class).decoratedWith(/* apply decoration */)...

Exporting service with service properties:

service(AImpl).attributes(names("serviceName=A")).export();

Instead of using dynamic proxy you can use direct binding

service(A.class).single().direct();

Conclusion:
The Peaberry project looks quite good I don’t see any big tricks (hacks) done to support OSGi capabilities on Guice. It’s very lightweight only couple bundles which you have to include in your runtime. No xml to configure dependency and very nice API to handle dynamic nature of OSGi services.
Both examples were tested on Eclipse 3.5.