小编Hug*_*ira的帖子

我正在寻找一个无脑应用程序,它允许我通过蓝牙连接发送预定义的命令列表,或者在OSX(64位)中正常工作的等效Java/Scala库.

简而言之,我想用我的电脑"模拟"蓝牙配件,所以我必须能够控制配对,交换的代码等等......

思考？

有没有人知道C++的BDD框架允许执行(Gherkin)场景,例如:

Feature: Table support in nbehave
Scenario: a table
  Given a list of people:
    |Name   |Country|
    |Morgan |Sweden |
    |Jimmy  |Sweden |
    |Jimmy  |USA    |
  When I search for people from Sweden
  Then I should find:
    |Name  |Country|
    |Morgan|Sweden |
    |Jimmy |Sweden |

所以,我正在使用d3和d3-hexbin作为全局库:

<script src="https://d3js.org/d3.v4.min.js"></script>
<script src="https://d3js.org/d3-hexbin.v0.2.min.js"></script>

......并将它们引用.ts为:

/// <reference types="d3" />
/// <reference types="d3-hexbin" />

...使用DefinitelyTyped定义.但是,虽然这有效:

const svg = d3.select('#hitmap').append('svg')

... 这个:

const hexbin = d3.hexbin().radius(binsize + 1)

...失败了:

Property 'hexbin' does not exist on type 
  'typeof "/Users/bytter/node_modules/@types/d3/index"'

思考？

我正在研究我的bc论文项目,该项目应该是用scala和Akka编写的Minecraft服务器.服务器应该可以轻松地部署在云中或集群上(不确定我是否使用正确的术语......它应该在多个节点上运行).然而,我是akka的新手,我一直想知道如何实现这样的事情.我现在想弄清楚的问题是如何在不同节点上的演员之间共享状态.我的第一个想法是有一个骆驼演员会从我的世界客户端读取TCP流,然后将其发送到负载平衡器这将选择将处理请求,然后发送通过TCP给客户一些响应的节点.假设我有一个AuthenticationService实现actor,它检查用户提供的凭据是否有效.每个节点都有这样的actor(或者可能更多),并且所有actor都应该始终拥有完全相同的用户数据库(或状态).我的问题是,保持这种状态的最佳方法是什么？我想出了一些我能想到的解决方案,但我没有做过这样的事情,所以请指出错误:

解决方案#1:将状态保存在数据库中.这可能会很好地工作,其中状态仅由类似的用户名和密码列表来表示该认证的例子,但它可能在那里状态包含对象不容易被分解成整数和字符串不会在情况下工作.

解决方案2:每次会有一定男主角会改变它的状态,要求演员会,处理请求有关的变化相同类型的所有其他行动人将改变根据自己的状态,广播信息后原始演员发送的信息.这看起来非常低效而且相当笨拙.

解决方案#3:让某个节点充当一个状态节点,其中会有代表整个服务器状态的actor.除了这样的节点中的actor之外的任何其他actor都没有状态,并且每次他们需要一些数据时都会询问"状态节点"中的actor.这似乎也是低效的,有点不容错误.

所以你有它.只有我真正喜欢的解决方案才是第一个,但就像我说的那样,它可能仅适用于非常有限的问题子集(当状态可以分解为redis结构时).来自更有经验的大师的任何回应都会非常受欢迎.此致,托马斯赫尔曼

为什么我不能这样做:

def compare[A <% { def toInt: Int }, 
            B <% { def toInt: Int }]
           (bs: Seq[A], is: Seq[B]): Boolean = { 
  bs.toArray.zip(is) forall { p => p._1.toInt == p._2.toInt } 
}

为了比较任何可转换的类型序列Int？我怎样才能实现类似的模式？

更新:这应该运行 Message.compare(List(1.0, 2.0, 3.0), List(0, 0, 0))

想象一下,我有以下代码:

let a = Rx.Observable.of(1, 2, 3)
let b = Observable.zip(a, a, (a, b) => a + b)
b.forEach(t => console.log(t))

这会立即输出结果.现在,我如何在每个消息之间设置一个定时延迟作为一种反压方式(注意我不想要一个缓冲区;相反,我想要a并b成为Cold Observables),如:

b.takeEvery(1000).forEach(t => console.log(t))

并得到完全相同的答案:

<wait 1s>
2
<wait 1s>
4
<wait 1s>
6

替代方案:如果RxJS不支持背压(某些可观测量的pull拉机制),那么如何在不耗尽资源的情况下创建无限生成器呢？

备选方案2:支持拉动和推动机制的其他JS框架？

考虑以下正方形：

您将获得三个约束：

1. 所有矩形（A、B、C、D 和 E）具有相同的面积；
2. 它们的几何布局构成一个正方形；和
3. A 的高度为 2。

现在，我知道手动解决这个问题非常简单，但我认为这将是一个很好的例子来展示 CLP(Q/R) 与 Prolog 的功能：

剧透警告：如果您想先自己解决难题，请不要继续阅读本文，因为存在一些限制条件会泄露解决方案。

无论如何，这是我尝试用 CLP(Q/R)定义（我认为包括冗余约束）这个难题：

:- use_module(library(clpr)).

solve(Eh) :-
  A = B, B = C, C = D, D = E,

  { A  >= 1, B  >= 1, C  >= 1, D  >= 1, E  >= 1,
    Aw >= 1, Bw >= 1, Cw >= 1, Dw >= 1, Ew >= 1 },
  
  { Ah = 2 },
  
  { A = Ah * Aw,
    B …

我正在寻找一个好的黄瓜教程,不会强迫我使用rails.有什么好的建议吗？

我正在编写用于处理案例类实例列表的通用代码,在每个字段中收集值,组合然后将其传递给库.

使用无形LabelledGeneric和多态函数,它看起来像这样:

object toNamedSingletonListOfValues extends Poly1 {
  implicit def caseField[K,T] = 
    at[FieldType[K, T]](field => { field.key -> List[T](field) })
}

val generic = LabelledGeneric[MyClass]
val records = listOfMyClassInstances.map(generic.to)
val values = records.map(_.map(toNamedSingletonListOfValues)) // Then combining and passing

但是,我需要一种获取方式,field.key因为库需要参数名称.

你介意建议解决方案吗？

考虑以下代码：

interface Wrap<Value> {
  pick(): Value
}

class WrapConstant<Value> implements Wrap<Value> {
  constructor(public readonly a: Value) { }
  pick(): Value { return this.a }
}

type Unwrap<Wrapped> = { [P in keyof Wrapped]: Wrapped[P] extends Wrap<infer Value> ? Value : never }

class WrapTuple<Tuple extends Wrap<unknown>[], Value = Unwrap<Tuple>> implements Wrap<Value> {
  readonly ts: Tuple
  constructor(...t: Tuple) { this.ts = t }

  pick(): Value { return this.ts.map(a => a.pick()) }                // fails to type check
}

type T1 = Unwrap<[WrapConstant<number>, …