小编men*_*ics的帖子

我正在尝试在运行时(我必须这样做)连接函数,这可能涉及函数的输入和输出中的类型类约束.

在像Java这样的语言中,这将是微不足道的.f1 :: Int -> Num,f2 :: Num -> Num我们现在可以打电话了f2 . f1.如果Num是一个Java风格的界面,那将没有问题.但类型类的行为不像接口.

类型类允许您做的一件事是避免在数据类型之间进行转换.我们可以来回转换并摆脱类型类.但令人担忧的是,我们无缘无故地创造了所有物品.我们试着避免这种情况.

我开始尝试创建一个(a,Api a)的元组,其中Api是一个将在a上运行的函数的记录.我的猜测可能与类型类的工作方式非常相似？但是你遇到了混凝土类型问题,我认为存在.但后来我意识到(a,Api a)应该能够完全隐藏a,因为没有人关心,然后Api变成了数据类型的简单记录,而不是函数.

所以我想知道......是否解决了这种懒惰？

module Main where

--data Api a = Api { f1 :: a -> Int, f2 :: a -> String }
data Api = Api { f1 :: Int, f2 :: String }

data MyData = MyData Int String

myf1 (MyData x y) = x
myf2 (MyData x y) = y
myApi x = Api (myf1 x) (myf2 …

我知道我可以删除集合中的最后一个元素:

s.Remove(s.MaximumElement)

但是如果我想删除n个最大元素......我只执行上述n次,还是有更快的方法呢？

需要说明的是,这是一个明显的解决方案:

let rec removeLastN (s : Set<'a>, num : int) : Set<'a> = 
    match num with
    | 0 -> s
    | _ -> removeLast(s.Remove(s.MinimumElement), num-1)

但它涉及创建一个新的n次.有没有办法做到这一点,只创建一个新的一次？

希尔伯特 - 黄变换,经验模式分解......

我发现它在R和Matlab中实现.我想在C#/ F#/ .NET中找到它的开源实现.

我正在寻找一个具有以下标准的持久性解决方案（可能是 NoSQL 数据库？或其他东西......）：

1) 有 Haskell API

2）磁盘空间是否高效——数据库可以轻松获取许多千兆字节的数据，但我需要它在典型的桌面上运行良好。我需要尽可能有效地存储数据的东西。因此，例如，将字段名称存储在记录中是很糟糕的。

3) 读取连续记录的高性能。典型的用例是从某处开始，然后直接向前读取数据——尽快读取可能数百万条记录。

4）数据基本上不会改变（只有在发现数据不正确时才会改变），只是记录

5）它应该直接作用于可以轻松移动/复制的文件。它不应该调用单独运行的服务器。

示例代码如下.我有点好奇为什么MyActor比MyActor2更快.MyActor以递归方式调用process/react并在函数参数中保持状态,而MyActor2将状态保持在vars中.MyActor甚至有额外的开销状态,但仍然运行得更快.我想知道是否有一个很好的解释,或者我是否做了"错误"的事情.

我意识到性能差异并不显着,但它存在且一致的事实让我很好奇这里发生了什么.

忽略前两次运行作为预热,我得到:

MyActor:559 511 544 529

与

MyActor2:647 613 654 610

import scala.actors._

object Const {
  val NUM = 100000
  val NM1 = NUM - 1
}

trait Send[MessageType] {
  def send(msg: MessageType)
}

// Test 1 using recursive calls to maintain state

abstract class StatefulTypedActor[MessageType, StateType](val initialState: StateType) extends Actor with Send[MessageType] {
  def process(state: StateType, message: MessageType): StateType

  def act = proc(initialState)

  def send(message: MessageType) = {
    this ! message
  }

  private def proc(state: StateType) {
    react …

我需要根据有孩子的东西来建模一个图形(或者可以看作是一个递归树,因为它通常是一个或少数个根):

a hasChildren (b, c)
b hasChildren (d, e)
c hasChildren (f, g)
d hasChildren (h, a)

现在有隐含路径,a/c/f和递归路径:a/b/d/a/b/d/...

然后我需要通过路径表达式在图表上设置内容,包括它们的属性(这些路径有颜色:蓝色等)以及更改它们的子项 - 可能是删除/隐藏它们,或者添加新的子项.

通过路径表达,我的意思是这样的:

a/b/** -> color = "blue"

意味着所有以a/b /开头的路径都具有属性color ="blue".因此,如果我查询a/b/d/a/b/d/a的颜色,它将返回蓝色.但是如果我只询问a的颜色,那么就没有了.

其他表达可能是:

**/d/h
a/b/[color="blue"]
a/**/h

所以,这将用于发表声明.我需要类似的查询方式.我需要简单的查询,例如:

a/b/d

更复杂的是:

a/**[color="blue"]  -- descendants that have attribute color = "blue". This could be infinite in recursive case so we can put a restriction on this type of query to have it make sense, like does such a path exist, or just return first one …

是否有一个工具可以从源代码中自动创建haskell数据模型的可视化(类图表类型)？向下遍历数据构造函数和记录的东西,显示类型和字段的树,并输出带有框等的漂亮图像.

因此,它会分析源代码,例如:

data Type1 = Type1 Int Type2
data Type2 = Type2 { v1 :: Type3, v2 :: Type4, v3 :: String }
data Type3 = Type3 { v4 :: Double }
data Type4 = Type4 { v4 :: Type3 }

并且它将生成一个图表,其中Type1显示2个属性并链接到Type2,显示3个属性及其名称并链接到Type3和Type4等.

是否有Java的免费凭证存储框架？

我有一个桌面应用程序，需要将用户的凭据存储到外部系统。

我只是想知道是否有人已经有了一个简化这一过程的框架。

I put together a microbenchmark that seemed to show that the following types of calls took roughly the same amount of time across many iterations after warmup.

static.method(arg);
static.finalAnonInnerClassInstance.apply(arg);
static.modifiedNonFinalAnonInnerClassInstance.apply(arg);

Has anyone found evidence that these different types of calls in the aggregate will have different performance characteristics? My findings are they don't, but I found that a little surprising (especially knowing the bytecode is quite different for at least the static call) so I want to find if others …

为什么以下代码抛出UnsupportedOperationException？

import javafx.beans.property.MapProperty;
import javafx.beans.property.SimpleMapProperty;


public class TestMapProperty {
    static MapProperty<String, String> model = new SimpleMapProperty<String, String>();


    public static void main(String[] args) {
        model.put("blue", "green"); // exception thrown here
    }
}

堆栈跟踪:

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.AbstractMap.put(AbstractMap.java:203)
    at javafx.beans.binding.MapExpression.put(MapExpression.java:277)
    at TestMapProperty.main(TestMapProperty.java:10)