在两个表之间进行外连接很简单:
tblA.leftJoin(tblB).on(_.aId === _.bId)
但是当在5个表之间进行连接时,它很快变得笨拙:
tblA.leftJoin(tblB).on(_.aId === _.bId).
leftJoin(tblC).on(_._1.aId === _.cId).
leftJoin(tblD).on(_._1._1.aId === _.dId).
leftJoin(tblE).on(_._1._1._1.aId === _.eId)
元组访问器变得有点混乱,特别是如果它们不能访问第一个表.
有没有更好的办法？
内部联接在语义上等效于带有过滤器的flatMap这一事实解决了内部联接的这个问题:
for {
a <- tblA
b <- tblB if a.aId === b.bId
c <- tblC if a.aId === c.cId
d <- tblD if a.aId === d.dId
e <- tblE if a.aId === e.eId
} yield ???
外连接是否有类似的优雅语法？
假设我有一个更高阶的函数,它使用它从函数参数中检索的值执行一些计算.
f :: a -> (b -> c) -> d
其中a,b,c,d是一些具体类型.
然后我有这种类型的功能
g :: b -> m c
其中m是一些monad.
现在有一种方法可以使用g和f.那就是把f变成一个产生m d代替的函数,d并且可以使用g作为它的第二个参数？
一个具体的例子是m是IO monad,f是计算从其功能参数检索的n个数字的总和的函数,g从标准输入读取数字.
f n g = sum $ map g (1..n)
g :: Int -> IO Int
g _ = readLn
我知道有一些函数可以将标准输入转换为惰性列表,这可以解决这个问题,但我的实际情况并不那么简单.
假设我有一个在图上做某事的算法.该算法使用功能参数来确定节点的邻居.这样我就可以有多个图形实现.
现在我想将此算法与非确定性图形(List monad)或未完全已知的图形(可能是monad)一起使用.我知道我可以重写算法使用monads然后使用身份monad作为基本情况,但这是唯一的方法吗？我认为编写没有monad的算法会更容易.
这种行为可能吗？我找不到它不应该的原因,但我无法找到一种方法.
我有一个包含实时数据的流，以及一个基本上分隔属于一起的实时数据部分的流。现在，当有人订阅实时数据流时，我想重播他们的实时数据。但是，我不想记住所有实时数据，只记住自上次其他流发出值以来的部分。
有一个问题可以解决我的问题，因为有一个重播操作符完全符合我的要求（或者至少我认为）。
目前有什么方法可以轻松做到这一点？有没有比以下更好的方法？
private class ReplayWithLimitObservable<TItem, TDelimiter> : IConnectableObservable<TItem>
{
private readonly List<TItem> cached = new List<TItem>();
private readonly IObservable<TDelimiter> delimitersObservable;
private readonly IObservable<TItem> itemsObservable;
public ReplayWithLimitObservable(IObservable<TItem> itemsObservable, IObservable<TDelimiter> delimitersObservable)
{
this.itemsObservable = itemsObservable;
this.delimitersObservable = delimitersObservable;
}
public IDisposable Subscribe(IObserver<TItem> observer)
{
lock (cached)
{
cached.ForEach(observer.OnNext);
}
return itemsObservable.Subscribe(observer);
}
public IDisposable Connect()
{
var delimiters = delimitersObservable.Subscribe(
p =>
{
lock (cached)
{
cached.Clear();
}
});
var items = itemsObservable.Subscribe(
p =>
{
lock (cached)
{
cached.Add(p); …我有一个Universe类型和一个worker类型.工人可以改变宇宙.我想要实现的是确保宇宙只能由来自该宇宙的工人(未来或过去的工人)修改.
我能做到的最好的是:
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE KindSignatures #-}
module Module(initialUniverse, doSomething, doStep) where
data Nat = Z | S Nat
data Universe (t :: Nat) = Universe {
_allWorkers :: [Worker t]
}
data Worker (t :: Nat) = Worker
initialUniverse :: Universe Z
initialUniverse = Universe [Worker]
doSomething :: Worker t -> Universe t -> Universe (S t)
doSomething = undefined
doStep :: Universe t -> Universe (S (S t))
doStep u = let w = head …假设我有一个宏实现
def testImpl[T](c:Context)(implicit wtt:c.WeakTypeTag[T]):c.Tree = {
import c.universe._
def info(msg: Any) = c.info(c.enclosingPosition, msg.toString, true)
val parameter = wtt.tpe.member(TermName("f")).paramLists(0)(0)
info(parameter.typeSignature)
q"{}"
}
和宏定义
def test[T]:Unit = macro DerivingImpl.testImpl[T]
此宏f在其类型参数中查找函数,并打印有关其第一个参数类型的信息.
现在如果我像这样使用这个宏
trait Trait[A] {
def f(x:A): Int
}
test[Trait[Int]]
我被A打印了.我想得到Int.我理解调用member返回的方法符号没有关于具体应用类型的信息.那么,找到参数的实际类型的正确方法是什么？
谢谢.
假设我有一个函数,它使用外部值中的其他内部值来提取一些内部值
func :: outer -> inner1 -> inner2
然后我有一个函数,使用这个inner2值在外部值和其他值之间创建一个镜头
existingLensFunc :: inner2 -> Lens' outer result
有没有办法创建另一个函数,使用inner1值在外部值和结果值之间创建一个镜头？
finalLens :: inner1 -> Lens' outer result
换句话说,有更好的方法来写这个吗？
finalLens inner1 = lens getter setter
where setter outer result = let inner2 = func outer inner1 in set (existingLens inner2) result outer
getter outer = let inner2 = func outer inner1 in view (existingLens inner2) outer