scala implicit identity - scala

Question

Take a database transaction:
def create(model: Model, orderNum: String) = {
db.handle withSession { implicit ss: Session=>
ss.withTransaction { // auto commit now set to false
val result = for {
uid <- repo.user.create(model)
mid <- repo.membership.create(uid)
oid <- repo.orders.create(model, uid, orderNum)
} yield uid
result fold(
e=> { ss.rollback; Left(e) },
s=> { Cache.remove("member.directory"); Right(s) }
)
}
}
}
If the repository user create implementation takes an implicit Session, is it the same Session as the withTransaction enabled Session above, or is implicit value "is a" rather than "is the" identity?
def create[T <: User](t: T)(implicit ss: Session) = // what Session is this?
for {
uid <- either( Users.insert( Users(t) ), i18n("user not created") )
ur <- either( UserRoles.insert( UserRole(uid, t.role) ), i18n("user role not created") )
} yield uid
I could pass in the Session explicitly repo.user.create(model)(ss) and have create take an explicit Session, but am curious to know if more concise/convenient implicit approach provides the same outcome, the transaction enabled session.

Answer 1

If I correctly understood you, you are using ScalaQuery and you want to have your method working also when the user provide the session from outside.
def withSession
[T] (f: ⇒ T): T Run the supplied thunk with a new session and
automatically close the session at the end.
def withSession [T] (f:
(Session) ⇒ T): T Run the supplied function with a new session and
automatically close the session at the end.
Both of these are creating a new transaction, so the way I would go is to use an Optional[Session] as implicit and default it to None
def onProvidedOrCreatedSession[K](f: Session => K)(session:Option[Session]) = {
session match {
case Some(s) => f(s)
case None => db.withSession { f }
}
}
def create(model: Model, orderNum: String)(implicit session:Option[Session]=None){
onProvidedOrCreatedSession(
implicit s => s.withTransaction { val x = 10 }
)(session)
}

Answer 2

Not sure if the following is a faithful abstraction of what you are trying to do, but I hope it helps:
class Store(var x: Int) {
def flip() { x = -x }
}
object M1 {
implicit val store2 = new Store(2)
def create(s: String) = {
implicit val store3 = new Store(3)
{ implicit store: Store =>
println("[M1.create] store.x = " + store.x)
store.flip()
M2.create("tummy")
println("[M1.create] store.x = " + store.x)
}
}
}
object M2 {
implicit val store4 = new Store(4)
def create(s: String)(implicit store: Store) = {
println("[M2.create] store.x = " + store.x)
store.flip()
}
}
M1.create("dummy")(new Store(1))
The output is:
[M1.create] store.x = 1
[M2.create] store.x = -1
[M1.create] store.x = 1
The new Store(1) that is explicitly passed to M1.create is forwarded to M2.create
The additional implicit stores store2, store3, store4 are apparently ignored by the compiler.