标签: lazy-evaluation

我在使用 JPA(Hibernate) 和 LazyFetching 时遇到了一些麻烦

我有一些实体：任务、奖励、合同

关系（都是懒人）：

• Quest One2Many 奖励；任务多对多合约；
• 合约One2Many奖励；合同多对多任务；
• 奖励 Many2One 查询；奖励多对一合约；

DB 包含这样的数据：Quest1 有 Reward1、Reward2 和 Contract1、Contract2；

在某些情况下，我需要 Quest 及其奖励和合同，所以我在 JPArepository 中这样做：

@Query("select Q from Quest Q left join fetch Q.rewards left join fetch Q.contracts")
List<Quest> getAllQuestsWithRewardsAndContracts();

问题是我收到了
一个有 4 个（但只有 2 个）奖励（Reward1、Reward2、Reward1、Reward2）和两个合同的任务。
我得到重复的奖励！
我不明白为什么！
如果我这样做：

@Query("select distinct Q from Quest Q left join fetch Q.rewards")
List<Quest> getAllQuestsWithRewardsRew();

我收到一个任务有两个奖励（Reward1，Reward2）

为什么 ？为什么我有重复？

对于数据流场景,我需要以递归方式相互引用的值.以下不起作用:

class Foo(val that: Foo)

class Bar {
  lazy val a: Foo = new Foo(b)
  lazy val b: Foo = new Foo(a)
  println(s"a = $a, b = $b")
}

new Bar  // boom!

如何在不弄脏我的情况下解决这个问题var？

我知道scala by-name参数是如何工作的:https://tpolecat.github.io/2014/06/26/call-by-name.html

我在一段非常敏感的代码中使用它,它可以运行很多.我的问题是:是否存在任何性能或内存缺陷？例如,我知道使用lazy val有它的缺点:Scala的懒惰val的(隐藏)成本是多少？

有关类名参数的类似内容吗？它们是如何在下面实现的？

请注意我不会在懒惰的情况下使用它进行缓存.所以我不会有上述问题.我只需要知道它不是懒惰本身.

谢谢

对于延迟评估的属性，以下两种方法（具有支持字段的属性和具有默认值的属性）之间是否有任何差异，或者它们是否等效？

// (1)
public static class Foo
{
    private static readonly Lazy<Foo> instance = new Lazy<Foo>();
    public static Foo Instance { get; } = instance.Value;
}

// (2)
public static class Foo
{
    public static Foo Instance { get; } = new Lazy<Foo>().Value;
}

我想要实现的是，Foo仅在访问 时创建 的实例Foo.Instance，而不是之前创建 - 更重要的是，当Foo.Instance从未访问过时，不应创建任何实例。

根据我的理解，Haskell 使用惰性求值，它允许在有限的时间内对例如无限列表的操作进行求值。

作为测试，我定义了以下函数

X Boolean
Y Int

f(X,Y) = (Y == 3) OR X

因此， fold left 应用于[1..]具有False初始值的无限整数列表和上面定义的函数，应该返回True，因为当它达到n=3评估时f(n==3,False)将返回True，因此这True将通过函数传播。

我在 Haskell 代码中实现了这个功能

myfunc :: Bool -> Int -> Bool
myfunc True _ = True
myfunc _ n
  | (n == 3)  = True
  | otherwise = False

并在 cli 中试用

foldl myfunc False [1..]

该命令变得无响应，表明它正在执行无限计算。为什么 Haskell 没有从这里的惰性求值中受益？

正在看clojure第 9 章底部的练习，寻找勇敢和真实的人 （特别是搜索多个引擎并返回每个引擎的第一次命中的最后一个）

我用 slurp 部分嘲笑实际搜索是这样的：

(defn search-for
  [query engine]
  (Thread/sleep 2000)
  (format "https://www.%s.com/search?q%%3D%s", engine query))

并实现了这样的行为：

(defn get-first-hit-from-each
  [query engines]
  (let [futs (map (fn [engine]
                    (future (search-for query engine))) engines)]
    (doall futs)
    (map deref futs)))

（我知道这里的返回是一个列表，练习要求一个向量，但可以into为此做一个......）

但是当我在 REPL 中运行它时

(time (get-first-hit-from-each "gray+cat" '("google" "bing")))

添加后似乎需要 2 秒doall（因为 map 返回一个惰性 seq，我认为除非我使用 seq，否则任何期货都不会启动，(last futs)似乎也有效）但是当我time在 REPL 中使用宏时，它会报告即使需要 2 秒，也几乎不消耗时间：

(time (get-first-hit-from-each "gray+cat" '("google" "bing")))
"Elapsed time: 0.189609 msecs"
("https://www.google.com/search?q%3Dgray+cat" "https://www.bing.com/search?q%3Dgray+cat") …

目前，我正在尝试通过宾夕法尼亚大学的 FP in Haskell 课程来学习 Haskell。在其中一项作业中，我必须定义以下类型类来实现表达式求值计算器：

class Expr a where
  mul :: a -> a -> a
  add :: a -> a -> a
  lit :: Integer -> a

class HasVars a where
  var :: String -> a

一种模仿数学表达式的数据类型，可以包含整数、加法、乘法，还可以在表达式中保存变量。

data VarExprT = VarLit Integer
              | VarAdd VarExprT VarExprT
              | VarMul VarExprT VarExprT
              | Var String
              deriving (Show, Eq)

instance HasVars VarExprT where
  var = Var

instance Expr VarExprT where
  lit = VarLit
  add = VarAdd
  mul = VarMul

现在，为了模拟表达式中变量的加法、乘法操作，我必须创建上述类型类的实例，如下所示：

instance …

我正在寻找一段代码,其行为有点像单身但不是(因为单身人士很糟糕:)我正在寻找的必须达到以下目标:

1. 线程安全
2. 简单(理解和使用,即几行代码.库调用正常)
3. 快速
4. 不是单身人士; 对于测试,必须可以覆盖该值(并在测试后重置它).
5. 本地(所有必要的信息必须在一个地方)
6. 懒惰(仅在实际需要值时运行).
7. 运行一次(RHS上的代码必须执行一次且仅执行一次)

示例代码:

private int i = runOnce(5); // Set i to 5
// Create the connection once and cache the result
private Connection db = runOnce(createDBConnection("DB_NAME"));

public void m() {
    String greet = runOnce("World");
    System.out.println("Hello, "+greet+"!");
}

请注意,这些字段不是静态的; 只有表达式的RHS(右侧)在某种程度上......"静态".测试应该能够为注入新的价值观i和greet暂时的.

另请注意,这段代码概述了我打算如何使用这个新代码.随意用任何东西替换runOnce()或将其移动到其他地方(构造函数,可能,或init()方法或getter).但LOC越少越好.

一些背景资料:

我不是在寻找Spring,我正在寻找一段可用于最常见情况的代码:你需要实现一个接口,除了你想要的测试之外,不会有第二个实现传递模拟对象.另外,Spring失败了#2,#3和#5:你需要学习配置语言,你必须在某处设置应用程序上下文,它需要一个XML解析器而且它不是本地的(信息遍布各处).

由于#5,全局配置对象或工厂不符合要求.

static final因为#4而出局(最终无法改变).static因为类加载器问题而闻起来,但你可能需要它runOnce().我只是希望能够在表达式的LHS中避免它.

一种可能的解决方案可能是使用具有默认设置的ehcache,该设置将返回相同的对象.由于我可以将内容放入缓存中,因此也可以随时覆盖该值.但也许有一个比ehcache更简洁/简单的解决方案(它还需要一个XML配置文件等).

[编辑]我想知道为什么这么多人投票.这是一个有效的问题,用例很常见(至少在我的代码中).所以,如果你不理解这个问题(或背后的原因),或者你没有答案或者你不关心,为什么还要投票呢？:/

[编辑2]如果你看看Spring的应用程序上下文,你会发现超过99%的bean只有一个实现.你可以拥有更多,但在实践中,你根本就没有.因此,我不是分离接口,实现和配置,而是查看只有一个实现(在最简单的情况下),current()方法和一行或两行聪明的代码来初始化current()的结果的东西.一次(当它第一次被调用时)但同时允许覆盖结果(线程安全,如果可能的话).可以把它想象成一个原子"if(o == null)o = new O(); return o"你可以覆盖o.也许AtomicRunOnceReference类是解决方案.

现在,我只是觉得我们每天都拥有和使用的东西并不是最佳的,有一个令人困惑的解决方案会让我们大家都低头说"就是这样".就像我们几年前Spring出现时所感受到的那样,我们意识到我们所有单身人士问题的来源以及如何解决这些问题.

我正在查看该range功能,在线搜索显示(编辑:在2.x),它是热切评估

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

但是当我在我的本地Python3.3解释器中尝试下面的代码时

a = range(10)
print(a)

我得到一个输出

range(0, 10)

这是我对懒惰评估函数的期望,是什么情况？

注意:在Python2.7中,它始终表现为热切评估.

我发现很难理解Haskell如何评估这个primes函数.是的primes功能得到评估一遍又一遍,或primes在primeFactors功能将指向回到第一primes？

primes = 2 : filter ((==1) . length . primeFactors) [3,5..]

primeFactors n = factor n primes
  where
    factor n (p:ps)
        | p * p > n        = [n]
        | n `mod` p == 0   = p : factor (n `div` p) (p:ps)
        | otherwise        = factor n ps

main :: IO ()
main = print $ length . take 100000 $ primes