階隱式標識

Question

以一個數據庫事務：

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) } 
    ) 
    } 
    } 
} 

如果庫用戶創建的實現需要一個隱含的會議，是相同會議的withTransaction啓用會議上面，或者是隱含價值「是一個「而不是」身份？「

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 

我能通過在會議明確repo.user.create(model)(ss)和具有創造採取明確的會議，但我想知道是否更簡潔/便利隱含的方式提供了相同的結果，的交易啓用會話。

Answer 1

不知道下面是什麼你正在嘗試做一個忠實的抽象，但我希望它能幫助：

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)) 

輸出是：

[M1.create] store.x = 1 
[M2.create] store.x = -1 
[M1.create] store.x = 1 

• 的new Store(1)明確轉交給M1.create轉發給M2.create

• 編譯器明顯忽略了其他隱式存儲庫store2, store3, store4。

Answer 2

如果我正確地理解了你，你正在使用ScalaQuery，並且你想讓你的方法也在用戶從外部提供會話時工作。

DEF withSession [T]（F：⇒T）：T運行所提供的thunk用一個新的會話和 在結束時自動關閉會話。

def withSession [T]（f： （Session）⇒T）：T用新會話運行提供的功能，並在最後自動關閉會話。

這些都正在創造一個新的事務，所以我會去的方式是使用一個可選[會議]作爲隱含的而且默認爲無

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) 

    }