小编nic*_*las的帖子

我正在尝试使用Infer.Net(用于概率编程的F#库)并在VS11 Beta中运行示例导致错误:

无法加载文件或程序集'FSharp.Core,Version = 4.0.0.0,Culture = neutral,PublicKeyToken = b03f5f7f11d50a3a'或其依赖项之一.该系统找不到指定的文件.

如果我打开使用Reflector中的infer.net样本的dll,一个,probcomp.dll,说它无法自动找到"FSharp.Core,Version = 4.0.0.0",我需要手动选择位置.

这两件事是否相关？是否有可能使用"固定路径"引用编译probcomp.dll,现在它在我的机器上是不一样的？

PS:当然fsharp项目从头开始工作正常..

PS2:视觉工作室中参考的dll没有显示任何未找到它们的迹象.我可以在对象浏览器中打开它们.

UPDATE

在程序开始时错误发生,没有时间看到任何东西.然而,它发生在程序内:如果未调用以下行

let coinsD = inferExpr <@ coins @> 

然后错误不会发生.有了它,在另一个例子中引发了以下错误.不出所料,它来自dll,它的行为在反射器中很奇怪.

无法加载文件或程序集'FSharp.Core,Version = 4.0.0.0,Culture = neutral,PublicKeyToken = b03f5f7f11d50a3a'或其依赖项之一.定位的程序集的清单定义与程序集引用不匹配.(HRESULT异常:0x80131040)

在对象浏览器中,所述函数的签名非常奇怪:

public static IDistribution<b>inferExpr<b>(**unknown-type e**)

是的,在我告诉他在打开dll 后在哪里找到Fsharp 4.0.0时,在反射器中,它有签名

public static IDistribution<b> inferExpr<b>(FSharpExpr<b> e);

这个dll必须有某种奇怪的硬链接依赖关系,而且反射器比VS更聪明(或者不是......)来解决它.

为了从坏事中获益,如果你对这个dll中可能发生的事情有所了解,这可能是一个学习的机会.

我有一个嵌套字典Map<'a,Map<'b,'T>>,因此对于组合a*b,条目是唯一的.

为了有效地进行预计算,我需要反转一个中的键 Map<'b,Map<'a,'T>>

我有一些更高阶的方法来完成这项工作(|/>将在嵌套序列|//>中应用相同的操作,但是2级深度,|*>将枚举嵌套序列的笛卡尔积),但我想知道是否有更好的方法来执行此操作,以防万一有漂亮的代码分享这个.

let reversenmap (x:Map<'a,Map<'b,'T>>) :Map<'b,Map<'a,'T>> = 
      let ret  = x |> Map.toSeq |/> Map.toSeq |*> squash12
      let ret2 = ret |> Seq.groupByn2 (fun (a,b,t) -> b) 
                                      (fun (a,b,t) -> a) |//> Seq.head 
                                                         |//> (fun (a,b,c) -> c)
      ret2 |> Seq.toMapn2

我试图从我简化的示例中吸取以下行为的教训:

let groupedEnum  (input: 'a seq) =
   using (input.GetEnumerator()) (fun en ->
   Seq.unfold(fun _ -> 
                  if en.MoveNext() then 
                     Some(en.Current, ())
                  else None) ()
   )


//WORKS    
let c = groupedEnum    ("11111122334569999"   |>  List.ofSeq ) |>  List.ofSeq 

//BOOM !!  System.NullReferenceException
let c = groupedEnum    ("11111122334569999"                  ) |>  List.ofSeq

• 调查员"en"是否被独立处理？(我想这是关于ressources这个msdn doc旁边有什么可以说的/材料来阅读这个行为)

• 如果序列首先转换为列表,为什么它可以工作？

编辑:这只是一个玩具示例来说明行为,而不是被遵循.直接操纵枚举器的理由很少.

我无法使用由一组字符组成的列创建数据框.

是不是可能/我应该坚持列表？

>subsets <- c(list("a","d","e"),list("a","b","c","e"))
customerids <- c(1,1)
transactions <- data.frame(customerid = customerids,subset =subsets)
> str(transactions)
'data.frame':   2 obs. of  8 variables:
 $ customerid  : num  1 1
 $ subset..a.  : Factor w/ 1 level "a": 1 1
 $ subset..d.  : Factor w/ 1 level "d": 1 1
 $ subset..e.  : Factor w/ 1 level "e": 1 1
 $ subset..a..1: Factor w/ 1 level "a": 1 1
 $ subset..b.  : Factor w/ 1 level "b": 1 1
 $ subset..c.  : …

我在分类上有一系列概率

post <- c(0.73,0.69,0.44,0.55,0.67,0.47,0.08,0.15,0.45,0.35)

我想要检索预测的课程.现在我用

predicted <- function(post) { 
               function(threshold) {plyr::aaply(post, 1, 
                   function(x) {if(x >= threshold) '+' else '-'})}}

但这似乎是R会有一个语法.

是否有一些索引表达式会更直接？

通过以下等式定义,我们将refl作为构造函数

data _?_ {a} {A : Set a} (x : A) : A ? Set a where
    refl : x ? x

我们可以证明功能在平等上是一致的

cong : ? { a b} { A : Set a }  { B : Set b }
       (f : A ? B ) {m  n}  ? m ? n ? f m ? f n
cong f  refl  = refl

我不确定我能解析这里到底发生了什么.我认为我们是隐藏参数的模式匹配refl:如果我们用refl替换第一个出现的另一个标识符,我们得到一个类型错误.在模式匹配之后,我想通过refl的定义m和n是相同的.然后魔术发生(应用关系功能的定义？还是内置？)

有关于发生了什么的直观描述？

我正在尝试调试一些编译问题,我想知道是否可以使用非交错构建步骤,如此处所示.

$ stack build
string-conv-0.1: configure
string-conv-0.1: build
dotnet-timespan-0.0.1.0: configure
dotnet-timespan-0.0.1.0: build
servant-0.7: configure
string-conv-0.1: copy/register
dotnet-timespan-0.0.1.0: copy/register
servant-0.7: build
control-monad-omega-0.3.1: configure
control-monad-omega-0.3.1: build
swagger2-2.0.1: configure
control-monad-omega-0.3.1: copy/register
swagger2-2.0.1: build
eventstore-0.12.0.0: configure
eventstore-0.12.0.0: build
servant-0.7: copy/register
servant-client-0.7: configure
servant-client-0.7: build
servant-docs-0.7: configure
servant-docs-0.7: build
servant-client-0.7: copy/register
servant-server-0.7: configure
servant-server-0.7: build
servant-server-0.7: copy/register
servant-docs-0.7: copy/register
swagger2-2.0.1: copy/register
servant-swagger-1.0.3: configure
servant-swagger-1.0.3: build
servant-swagger-1.0.3: copy/register
eventstore-0.12.0.0: copy/register
pl-cqrs-0.1.0.0: configure
pl-cqrs-0.1.0.0: build
pl-cqrs-0.1.0.0: copy/register
pl-server-0.1.0.0: configure
pl-server-0.1.0.0: build
pl-server-0.1.0.0: copy/register
pl-wrapper-0.0.0: configure
pl-wrapper-0.0.0: build …

我不确定为什么ko不进行类型检查.有没有特别启发性的解释？

{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE NoMonomorphismRestriction, FlexibleInstances #-}

module Wrap where

class ExpSYM repr where
    lit :: Int -> repr

newtype Wrapped = Wrapped{unWrap :: forall repr. ExpSYM repr => repr}

a = (lit <$> Just 5) :: ExpSYM expr => Maybe expr

ko :: Maybe Wrapped
ko = do v <- a
        return $ Wrapped $ v

ok :: Maybe Wrapped
ok = do v <- Just 5
        let e = …

对于单个文件可执行文件，如何加载它dune utop？

lib准确地说，在目录中有库和相应文件的项目上dune，我可以启动dune utop lib，open Lib.MyModule这将加载文件MyModule.ml。

对于没有子目录且根目录下有以下文件的项目来说，相当于一个dune文件

(executable
  (name auth)
  (libraries ezjsonm cryptokit))

和一个文件auth.ml

let hi = "value"

我想从该文件中加载值dune utop

我有一个价格向量 ( f64)。我想计算最高价格。

当前计算f64in rust集合的最大值的最简单和最惯用的方法是什么？

已经有一些讨论Ord，f64但我不确定什么是最新的和不那么笨拙的方法。

我依赖以下，但我想有一些内置的操作

let max = prices.iter().fold(None, |r, &n| match r {
    Some(p) => Some(f64::max(p, n)),
    None => Some(e),
});

（这只是一些自由幺半群的折叠）