我正试图用Yampa-Framework模拟一个弹跳球:给定一个初始的x位置,高度和速度,球应该根据重力规则弹跳.信号功能以"提示 - 事件"作为输入,这个想法是"当球被倾斜时,它的速度应该加倍".
球反弹很好,但每次有小费事件时,该功能都会进入无限循环.我想我可能需要添加一个延迟(dSwitch,pre,notYet？),但我不知道如何.任何帮助,将不胜感激!
{-# LANGUAGE Arrows #-}
module Ball where
import FRP.Yampa
type Position = Double
type Velocity = Double
type Height = Double
data Ball = Ball {
height :: Height,
width :: Position,
vel :: Velocity
} deriving (Show)
type Tip = Event ()
fly :: Position -> (Height, Velocity) -> SF Tip (Ball, Event (Height,Velocity))
fly w0 (h0, v0) = proc tipEvent -> do
let tip = (tipEvent == Event ())
v <- (v0+) ^<< integral …我一直在使用Rx一段时间用于我的项目上的事件,并专门用于Socket编程,其中很好的部分是它做得很好.管理我的代码,性能优势,更好地执行和解释.
最近我必须修改我的项目的流程,我需要将所有传入的数据(从套接字操作)转储到队列中(使用MSMQ实现作为排队决定).
由于MSMQ提供异步调用以从队列中取消消息(但是以一种奇怪的模式).我现在一直在努力将Rx用于此目的,但是能够这样做.
问题:有人可以给我一个干净的代码示例来实现Rx,以便使用异步模式从队列接收消息.
我需要MSMQ的异步运算符实现类似于这样的东西
var data = Observable.FromAsyncPattern<byte[]>(
this.receiverSocket.BeginReceive,
this.receiverSocket.EndReceive(some parameters);
提前致谢.*欢呼*到Rx和.NET
随着Scala.React的兴起,我想知道当使用Qt作为Scala程序的GUI框架时,Qt的Signals&Slots机制是否会过时.两种方法中的一种如何在以下每个类别中表现出色？
假设Scala.React已经处于完成状态并且有很好的文档记录:您何时更喜欢一种方法而不是另一种方法？
我试图在具有10000多条记录的数据库表上实现即时搜索.
搜索文本框内的文本发生更改时搜索开始,当搜索框变空时,我想调用另一种加载所有数据的方法.
此外,如果用户更改搜索字符串,而正在加载另一个搜索的结果,则应停止加载这些结果以支持新搜索.
我像下面的代码一样实现它,但我想知道是否有更好或更清晰的方法来使用Rx(Reactive Extension)运算符,我觉得在第一个observable的subscribe方法中创建第二个observable比声明性的,对于if语句也是如此.
var searchStream = Observable.FromEventPattern(s => txtSearch.TextChanged += s, s => txtSearch.TextChanged -= s)
.Throttle(TimeSpan.FromMilliseconds(300))
.Select(evt =>
{
var txtbox = evt.Sender as TextBox;
return txtbox.Text;
}
);
searchStream
.DistinctUntilChanged()
.ObserveOn(SynchronizationContext.Current)
.Subscribe(searchTerm =>
{
this.parties.Clear();
this.partyBindingSource.ResetBindings(false);
long partyCount;
var foundParties = string.IsNullOrEmpty(searchTerm) ? partyRepository.GetAll(out partyCount) : partyRepository.SearchByNameAndNotes(searchTerm);
foundParties
.ToObservable(Scheduler.Default)
.TakeUntil(searchStream)
.Buffer(500)
.ObserveOn(SynchronizationContext.Current)
.Subscribe(searchResults =>
{
this.parties.AddRange(searchResults);
this.partyBindingSource.ResetBindings(false);
}
, innerEx =>
{
}
, () => { }
);
}
, ex =>
{
}
, …处理允许流不终止的RxJS(或任何其他RX实现)中的错误的惯用方法是什么？
相关代码是
function convert(unit, value) {
var request = {};
request[unit] = value;
var conversion = $.ajax({
method: 'POST',
url: './convert.php',
data: request,
dataType: 'json'
}).promise();
return Rx.Observable.fromPromise(conversion).takeUntil(inInput.merge(cmInput));
}
var cmElement = document.getElementById('cm'),
inElement = document.getElementById('in');
var cmInput = Rx.Observable.fromEvent(cmElement, 'input').map(targetValue),
inInput = Rx.Observable.fromEvent(inElement, 'input').map(targetValue);
var inches = cmInput
.flatMap(convert.bind(null, 'cm'))
.startWith(0);
var centimeters = inInput
.flatMap(convert.bind(null, 'in'))
.startWith(0);
因此,您可以看到我们使用输入字段更改流convert并将其传递给将其转换为另一个单元的函数,并进一步传递结果.
如果在$.ajax()调用期间发生错误,则它会向上传播,整个inches或cetimeters流停止(实际上是预期的).
但是如何实现它呢？
这样我就可以优雅地处理错误,比如显示错误消息,并在新数据到达时再试一次？
我目前的想法是引入像Haskell这样的复合类型Data.Either …
我正试图反应性地在我闪亮的应用程序中显示图像.我已经在server.R脚本中成功完成了以下操作:
output$display.image <- renderImage({
image_file <- paste("www/",input$image.type,".jpeg",sep="")
return(list(
src = image_file,
filetype = "image/jpeg",
height = 520,
width = 696
))
}, deleteFile = FALSE)
但它很慢.
但是,将其中一个图像嵌入到ui.R脚本中是非常快的,如下所示:
tabPanel("Live Images", img(src = "img_type1.jpeg"))
为什么会有这样的差异？有没有办法让反应图像看起来更快？
我在这里使用RxJS,我似乎无法克服这个看似简单的问题.
rx.Observable
.from([1,2,3,54,3,22,323,23,11,2])
.distinct()
.subscribe(function next (x) {
console.log('Next');
console.log(x);
}, function error (x) {
console.log('Error');
console.log(x);
}, function completed () {
console.log('Completed');
});
上面的代码按预期顺序吐出每个数组项.
rx.Observable
.fromPromise(getNumbers([1,2,3,54,3,22,323,23,11,2]))
.distinct()
.subscribe(function next (x) {
console.log('Next');
console.log(x);
}, function error (x) {
console.log('Error');
console.log(x);
}, function completed () {
console.log('Completed');
});
function getNumbers (nums) {
return new Promise(function (resolve, reject) {
resolve(nums);
});
}
虽然我只得到完整的数组(即[ 1, 2, 3, 54, 3, 22, 323, 23, 11, 2 ]).RxJS不应该破坏结果吗？我希望它至少对此有一些逻辑.
谢谢
我有三个Observables,我和combineLastest合并:
Observable<String> o1 = Observable.just("1");
Observable<String> o2 = Observable.just("2");
Observable<String> o3 = Observable.just("3");
Observable.combineLatest(o1, o2, o3, new Func3<String, String, String, Object>() {
@Override
public Object call(String s, String s2, String s3) {
return null;
}
});
我想通知其中一个Observable的第一次发射而不忽略后面的发射,我想第一个操作员会这样做.是否有一个方便的操作员(例如):
o1.doOnFirst(new Func1<String, Void>() {
@Override
public Void call(String s) {
return null;
}
})
我试图理解Reactive和ReactiveStream之间的区别,特别是在RxJava的上下文中？
我能想到的最多的是Reactive Streams在规范中有一些背压概念,但RxJava/Reactive中已存在request(n)接口.
不介意ELI5的答案.
最近,我决定尝试使用projectreactor.io的春天5 (io.projectreactor:reactor-test:jar:3.1.1).
有谁知道使用这个功能的最佳情况是什么？使用它们以及应该在哪里使用它们有什么缺点和优点？
好的例子会有所帮助.