小编kvb*_*kvb的帖子

F#的一个主张是它允许交互式脚本和数据操作/探索.我一直在玩F#试图了解它与Matlab和R在数据分析工作中的比较.显然,F#没有这些生态系统的所有实用功能,但我对底层语言的一般优点/缺点更感兴趣.

对我而言,即使在功能风格方面,最大的变化是F#是静态类型的.这有一些吸引力,但也经常感觉像一件紧身衣.例如,我还没有找到一种处理异构矩形数据的便捷方法 - 想想R中的数据帧.假设我正在读取一个带有名称(字符串)和权重(浮点数)的CSV文件.通常我会加载数据,执行一些转换,添加变量等,然后运行分析.在R中,第一部分可能看起来像:

df <- read.csv('weights.csv')
df$logweight <- log(df$weight)

在F#中,我不清楚应该使用什么结构来做到这一点.据我所知,我有两个选择:1)我可以先定义一个强类型的类(专家F#9.10)或2)我可以使用异构容器,如ArrayList.静态类型的类似乎不可行,因为我需要在加载数据后以ad-hoc方式(logweight)添加变量.异构容器也不方便,因为每次访问变量时我都需要将其解包.在F#中:

let df = readCsv("weights.csv")
df.["logweight"] = log(double df.["weight"])

如果这是一次或两次,它可能没问题,但每次使用变量时指定一个类型似乎都不合理.我经常处理调查,其中包含100个添加/删除的变量,分成新的子集并与其他数据帧合并.

我错过了一些明显的第三选择吗？是否有一些有趣和轻松的方式来交互和操纵异构数据？如果我需要在.Net上进行数据分析,我现在的意思是我应该使用IronPython进行所有数据探索/转换/交互工作,并且只对数字密集型部分使用F#/ C#.F#本质上是快速和脏的异构数据工作的错误工具吗？

我有点困惑的是,在C#中只有引用类型被垃圾收集.这意味着GC只选择内存解除分配的引用类型.那么值类型会发生什么呢？因为它们也会占用堆栈上的内存？

使用C#时,典型路径可以包含的最大字符数是多少？

例如C:\test\,长度为7个字符,最大长度是多少？

我只是想知道如何以与F#单位系统正确交互的方式编写用户定义的平方根函数(sqrt).

应该是什么样的:

let sqrt (x : float<'u ^ 2>) =
    let x' = x / 1.0<'u ^ 2> // Delete unit
    (x ** 0.5) * 1.0<'u>     // Reassign unit

但由于非零常量不允许使用通用单位,因此不允许这样做.

有没有办法写这个功能？内置sqrt它工作正常,它有什么神奇的表现？

我有以下课程:

public class Entity<T> where T : Entity<T> {
    public Factory<T> Factory { get; private set; }
    public Entity(Factory<T> factory) {
        Factory = factory;
    }
}
public class Factory<T> { }

public class MyEntity : Entity<MyEntity> {
    public MyEntity(Factory<MyEntity> factory) : base(factory) { }
}

我试图用指定的构造函数动态创建类MyEntity.到目前为止,我有以下代码:

class Program {
    static ModuleBuilder _moduleBuilder;
    public static ModuleBuilder ModuleBuilder {
        get {
            if (_moduleBuilder == null) {
                AssemblyBuilder asmBuilder = System.Threading.Thread.GetDomain().DefineDynamicAssembly(new AssemblyName("Dynamic"), AssemblyBuilderAccess.Run);
                _moduleBuilder = asmBuilder.DefineDynamicModule("MainModule");
            }
            return _moduleBuilder;
        }
    }

    static void …

在搜索了stackoverflow和googling很多之后,为DynamicMethods调试代码提供的调试解决方案似乎已经过时且非常笨拙.

当然,在LCG(轻量级代码生成)发布后的4年或更长时间内,有人必须找到更好的方法.

您发现什么是验证您编写和调试它的动态IL的最简单方法？

你使用peverify或ILDasm还是别的什么？这两个工具需要将程序集写入磁盘,但DynamicMethod不提供任何直接的方法.

显然,WinDbg aso提供了一种查看IL的方法,但处理这个问题非常尴尬.

像VisualStudio 2010这样的插件将是理想的选择.

有任何想法吗？

我试图动态创建一个空构造函数,它接受一个参数,并使用TypeBuilder简单地调用base(参数).

我的代码是这样的:

(...)
// Create a class derived from this class
TypeBuilder typeBuilder = moduleBuilder.DefineType("NewClass", TypeAttributes.Class, this.GetType());    
ConstructorInfo baseCtor = this.GetType().GetConstructor(new[] { typeof(int) });

// Define new ctor taking int
ConstructorBuilder constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public,  CallingConventions.Standard, new[] { typeof(int) });

// Generate code to call base ctor passing int
ILGenerator ctorIL = constructorBuilder.GetILGenerator();
ctorIL.Emit(OpCodes.Ldarg_0);
ctorIL.Emit(OpCodes.Ldarg_1);
ctorIL.Emit(OpCodes.Call, baseCtor);
ctorIL.Emit(OpCodes.Ret);

// Generate derived class
Type type = typeBuilder.CreateType();

// Try to instantiate using new constructor 
ConstructorInfo ctor = type.GetConstructor(new[] { typeof(int) });
object …

您好，我目前正在尝试使用活动的模式和Int.TryParse方法将字符串解析为Int。使用2012年的旧示例，它以前的工作方式如下：

let (|Int|_|) str =
    match System.Int32.TryParse str with
    | true,int -> Some int
    | _ -> None

但是现在我收到一条错误消息，告诉我无法选择TryParse（）的正确重载。将str注释为字符串，错误仍然存​​在。预先感谢，我希望你们中的任何一个可以帮助我解决这个简单的问题。

一些其他信息：我正在尝试使用FSharp.Core 4.5.2和.Net Core 2.1。

错误：

FS0041无法基于此程序点之前的类型信息确定方法“ TryParse”的唯一重载。可能需要类型注释。候选：Int32.TryParse（s：ReadOnlySpan <char>，结果：byref <int>）：bool，Int32.TryParse（s：字符串，结果：byref <int>）：bool

我有一个看起来像这样的泛型类型

public class Entity<T> where T : Entity<T>{ ... }

我需要动态构造类型T.所以它看起来像这样:

public class MyClass : Entity<MyClass>{ ... }

可以这样做吗？

我认为我编写的用于复制对象属性树的代码非常实用 - F#版本是否带来了另一层次的简洁性？

public static class CopyUtility
{
    public static void Copy(object source, object target)
    {
        (
            from s in Properties(source)
            from t in Properties(target)
            where Matches(s, t)
            select Action(t, target, s.GetValue(source, null))
        )
        .ToList().ForEach(c => c());
    }

    static IEnumerable<PropertyInfo> Properties(object source)
    {
        return source.GetType().GetProperties().AsEnumerable();
    }

    static bool Matches(PropertyInfo source, PropertyInfo target)
    {
        return source.Name == target.Name;
    }

    static Action Action(PropertyInfo source, object target, object value)
    {
        if (value.GetType().FullName.StartsWith("System."))
            return () => source.SetValue(target, value, null);
        else
            return () => Copy(value, …