小编Mik*_*sov的帖子

我正在尝试使用获取当前使用的Kubernetes上下文的名称空间kubectl。

我知道有一个命令，kubectl config get-contexts但我看到它无法在json / yaml中输出。我随附的唯一脚本是这样的：

kubectl config get-contexts --no-headers | grep '*' | grep -Eo '\S+$'

我想知道是否有一种优雅的方式来实现这样的目标:

val l = Stream.from(1)

val parts = l.some_function(3)  //any number

parts.foreach( println(_) )

> 1,4,7,10... 
> 2,5,8,11...
> 3,6,9,12...

实际上我需要在Streams上进行并行化这样的操作 - 在多个actor之间拆分数据而不将整个内容加载到内存中.

有没有一种简单的方法来使用scala并行集合而无需将完整集合加载到内存中？

例如,我有一个大型集合,我想在一个小块上并行执行特定操作(折叠),这个块适合内存,而不是另一个块等等,最后重新组合所有块的结果.

我知道,可以使用actor,但是使用par-collections会非常好.

我写了一个解决方案,但它并不好:

  def split[A](list: Iterable[A], chunkSize: Int): Iterable[Iterable[A]] = {
    new Iterator[Iterable[A]] {
      var rest = list
      def hasNext = !rest.isEmpty
      def next = {
        val chunk = rest.take(chunkSize)
        rest = rest.drop(chunkSize)
        chunk
      }
    }.toIterable
  }                                               

  def foldPar[A](acc: A)(list: Iterable[A], chunkSize: Int, combine: ((A, A) => A)): A = {
    val chunks: Iterable[Iterable[A]] = split(list, chunkSize)
    def combineChunk: ((A,Iterable[A]) => A) = { case (res, entries) => entries.par.fold(res)(combine) }
    chunks.foldLeft(acc)(combineChunk)
  }                                               

  val chunkSize = 10000000                        
    val x = …

我想使用类似于take(n: Int)时间维度的函数： consume(period: Duration。因此，如果发生超时，我希望流终止。我知道我可以将流编译为类似内容IO[List[T]]并取消它，但是那样我会丢失结果。实际上，我想将无尽的流转换成有限的流，并保留结果。

更多关于问题的更广泛范围。我有来自消息传递代理的无尽事件流，但是我也有轮换凭证来连接到代理。因此，我想要的是消耗事件流一段时间，然后停止，获取新的凭据，再次连接到代理，以创建新的流并将两个流连接为一个。

我对 Slick 文档中的声明感到困惑：

在对事务内的非数据库操作进行排序时，Slick 将使用比池中线程更多的连接。

这是否意味着 Slick 打开一个事务，然后使用不同的数据库连接（在不同的线程中）在该事务中执行操作？我做对了吗？我从没想过可以在多个连接之间保持事务打开。

我正在尝试编译流，但不知何故Compiler不在范围内，将其置于范围内需要什么上下文限制？

import cats.Monad

def compilingStream[F[_]: Monad]: F[List[Int]] = {
  val stream: fs2.Stream[F, Int] = fs2.Stream.emit(1).covary[F]
  stream.head.compile.toList
}


error: could not find implicit value for parameter compiler: fs2.Stream.Compiler[[x]F[x],G]
         stream.head.compile.toList
                     ^

Java有一个接口Comparator<T>,它有一个方法int compare(T o1, T o2).

编辑:

我错了:

返回的整数必须是-1第一个对象小于第二个,1如果第二个小于第一个,0如果它们相等.

文件说:

第一个参数的负整数,零或正整数小于,等于或大于第二个参数.

所以我重新提出我的问题:是否有更优雅的方式来比较对象,而不是记住comparator.compare(o1, o2) < 0实际意味着第一个对象小于第二个对象？

假设在 PostgreSQL 中，特定用户有打开的会话，当密码更改时，它们会发生什么？

我认为有以下几点：

1. 不允许发出密码更改命令
2. 所有会话在完成最后一个查询后终止
3. 打开的会话将继续工作，直到明确关闭或超时。