小编Nir*_*lya的帖子

我正在使用Scalacheck来查找缺陷,作为任务的一部分.令人难以置信的是,我被卡住了,因为它产生了一对非零整数.

从我的IntelliJ工作表,逐字广告:

import org.scalacheck._
    import Arbitrary._
    import Gen._
    import Prop._

    implicit lazy val genUnequalIntPairs = for {
      i <- Gen.choose(1,1000)
      j <- Gen.choose(i+1,1000)
      if (i < j)
    } yield (i,j)

    val kk = forAll (genUnequalIntPairs)  {
      case (x,y) => println("x =" + x + ", y =" + y)
        x == y
    }

kk.check

因为,我明确提到所选值的最小值为非零,我不应该在属性中看到任何零,对吧？至少,这是我的理解.但这就是我所看到的:

x =134, y =547
x =0, y =547
x =0, y =0
x =0, y =274
x =0, y =0
x …

我正在使用vavr和jOOQ,最近出现了两个出色的库,允许我们在常规Java服务器应用程序中使用功能方言.

我试图使用jOOQ,相当于SQL的选择计数(*).

查询以这种方式形成:

 ResultQuery query = dsl.selectCount()
                .from(Tables.SH_PLAYER_REPORT)
                .join(Tables.SH_PLAYERS)
                .on(Tables.SH_PLAYERS.PLAYER_ID.eq(Tables.SH_PLAYER_REPORT.PLAYER_ID))
                .join(Tables.SH_LOCATION)
                .on(Tables.SH_LOCATION.LOCATION_ID.eq(Tables.SH_PLAYERS.LOCATION))
                .and(Tables.SH_PLAYER_REPORT.START_ON.ge(Timestamp.from(fromWhenInUTCInstant)))
                .and(Tables.SH_PLAYER_REPORT.START_ON.le(Timestamp.from(toWhenInUTCInstant)))
                .and(Tables.SH_LOCATION.LOCATION_ID.eq(criteriaAllFieldsTeam.getLocation_id()));

jOOQ的生成器工作得很好,这里没有任何类型不匹配.所以,我想,查询是正确形成的.

然后,我使用vavr的尝试,因此:

Optional<Integer> mayBeCount = Optional.empty();

try (final Connection cn = this.ds.getConnection()) {

    DSLContext dsl = DSL.using(cn, this.dialect);

    Try<Integer> countFromDBAttempted =
               Try
               .of(() -> prepareCountOfGamesPlayedQuery(dsl,criteriaAllFieldsTeam))
               .map(e -> e.fetchOne(0, Integer.class)) // Here's the problem!
               .onFailure(e -> logger.warning(String.format("Count Of Games Played, status=Failed, reason={%s}",e.getMessage())));

           mayBeCount = (countFromDBAttempted.isFailure() ? Optional.empty() : Optional.of(countFromDBAttempted.getOrElse(0)));

  } catch (SQLException ex) {

    logger.warning(
         String.format("DB(jOOQ): Failed, counting games played, using criteria {%s},reason={%s}",criteriaAllFieldsTeam.toString(),ex.getMessage()));
  } …

在重新阅读scala.lan.org的页面,详细说明未来在这里,我无意中发现了以下句子:

如果某些回调从未完成(例如回调包含无限循环),则可能根本不执行其他回调.在这些情况下,潜在的阻塞回调必须使用阻塞构造(见下文).

为什么其他回调根本不会被执行？我可以为给定的Future安装一些回调.完成Future的线程可能会也可能不会执行回调.但是,因为一个回调不是在玩脚趾,其余的不应该受到惩罚,我想.

我能想到的一种可能性是ExecutionContext的配置方式.如果它配置了一个线程,那么这可能会发生,但这是一个特定的行为和一般不期望的行为.

我错过了一些明显的东西吗？

我是 Flink 的新手，试图了解如何最有效地使用它。

我正在尝试使用 Window API，从 CSV 文件中读取。读取的行被转换为案例类，因此

case class IncomingDataUnit (
sensorUUID: String, radiationLevel: Int,photoSensor: Float,
humidity: Float,timeStamp: Long, ambientTemperature: Float)
  extends Serializable {

}

而且，这就是我阅读行的方式：

env.readTextFile(inputPath).map(datum => {
      val fields = datum.split(",")
      IncomingDataUnit(
        fields(0),              // sensorUUID
        fields(1).toInt,        // radiationLevel
        fields(2).toFloat,      // photoSensor
        fields(3).toFloat,      // humidity
        fields(4).toLong,       // timeStamp
        fields(5).toFloat       // ambientTemperature
      )
    })

后来，使用一个简单的窗口，我尝试打印最大环境温度，因此：

env.setStreamTimeCharacteristic(TimeCharacteristic.ProcessingTime)

val readings =
      readIncomingReadings(env,"./sampleIOTTiny.csv")
      .map(e => (e.sensorUUID,e.ambientTemperature))
      .timeWindowAll(Time.of(5,TimeUnit.MILLISECONDS))
      .trigger(CountTrigger.of(5))
      .evictor(CountEvictor.of(4))
      .max(1)

readings.print

输出包含这些（来自一堆 DEBUG 日志语句）：

1> (probe-987f2cb6,29.43)
1> (probe-987f2cb6,29.43)
3> (probe-dccefede,30.02) …

我试图使用小片段来理解 Rust 互斥体的行为。我对 RAII 及其所扮演的角色有一个合理的想法，并且我知道阻塞呼叫的MutexGuard事实。lock()

以下代码（代码片段1）有效：

use std::sync::Mutex;

fn main() {
    let a_mutex = Mutex::new(5);
    let v = a_mutex.lock().unwrap().to_string();

    // An attempt to acquire the lock again.
    let w = a_mutex.try_lock().unwrap();
}

但这段代码（代码片段2）不起作用！

use std::sync::Mutex;

fn main() {
    let a_mutex = Mutex::new(5);
    let v = a_mutex.lock().unwrap();

    // An attempt to acquire the lock again.
    let w = a_mutex.try_lock().unwrap();
}

不出所料，输出告诉我，再次获取锁的尝试不会成功（WouldBlock；从我的 Unix/C 编程时代起，我就很清楚 an 的含义EWOULDBLOCK）。

Finished dev [unoptimized + debuginfo] …

我有一个 [Int, Option[/* of some type that I am using */] 形式的 Map，因此：

scala> val t1: Map[Int,Option[(String,List[Int])]] = Map(500->Some("A",List(1,2,3)))
t1: Map[Int,Option[(String, List[Int])]] = Map(500 -> Some((A,List(1, 2, 3))))

scala> t1 + (400 -> Some("B",List(9,8,7))) + (300 -> None) + (200 -> None)
res6: scala.collection.immutable.Map[Int,Option[(String, List[Int])]] = Map(500 -> Some((A,List(1, 2, 3))), 400 -> Some((B,List(9, 8, 7))), 300 -> None, 200 -> None)

现在，我试图分成两张地图，一张包含来自同名键/值的所有空值，另一张则没有，因此：

res6.span(e => e._2.isEmpty)
res7: (scala.collection.immutable.Map[Int,Option[(String, List[Int])]], scala.collection.immutable.Map[Int,Option[(String, List[Int])]]) = (Map(),Map(500 -> Some((A,List(1, 2, 3))), 400 …