使用静态类型语言处理异构数据(F#)

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#本质上是快速和脏的异构数据工作的错误工具吗？

F#本质上是快速和脏的异构数据工作的错误工具吗？

对于完全临时的,探索性的数据挖掘,我不建议使用F#,因为类型会妨碍你.

但是,如果您的数据定义得非常好,那么您可以通过将所有类型映射到公共F#联合来将不同的数据类型保存在同一容器中:

> #r "FSharp.PowerPack";;

--> Referenced 'C:\Program Files\FSharp-1.9.6.16\bin\FSharp.PowerPack.dll'

> let rawData =
    "Name: Juliet
     Age: 23
     Sex: F
     Awesome: True"

type csv =
    | Name of string
    | Age of int
    | Sex of char
    | Awesome of bool

let parseData data =
    String.split ['\n'] data
    |> Seq.map (fun s ->
        let parts = String.split [':'] s
        match parts.[0].Trim(), parts.[1].Trim() with
        | "Name", x -> Name(x)
        | "Age", x -> Age(int x)
        | "Sex", x -> Sex(x.[0])
        | "Awesome", x -> Awesome(System.Convert.ToBoolean(x))
        | data, _ -> failwithf "Unknown %s" data)
    |> Seq.to_list;;

val rawData : string =
  "Name: Juliet
     Age: 23
     Sex: F
     Awesome: True"
type csv =
  | Name of string
  | Age of int
  | Sex of char
  | Awesome of bool
val parseData : string -> csv list

> parseData rawData;;
val it : csv list = [Name "Juliet"; Age 23; Sex 'F'; Awesome true]

csv list 是强类型的,你可以模式匹配它,但你必须预先定义所有的联合构造函数.

我个人更喜欢这种方法,因为比使用无类型的ArrayList要好几个数量级.但是,我不确定你的要求是什么,我不知道一个很好的方法来表示特殊变量(除了可能是一个Map{string, obj})所以YMMV.

我认为还有其他一些选择.

(?) 操作者

正如Brian所说,你可以使用(?)运算符:

type dict<'a,'b> = System.Collections.Generic.Dictionary<'a,'b>

let (?) (d:dict<_,_>) key = unbox d.[key]
let (?<-) (d:dict<_,_>) key value = d.[key] <- box value

let df = new dict()
df?weight <- 50.
df?logWeight <- log(df?weight)

这确实在每次访问时使用装箱/取消装箱,有时您可能需要添加类型注释:

(* need annotation here, since we could try to unbox at any type *)
let fltVal = (df?logWeight : float)

顶级标识符

另一种可能性是,您可以只使用顶级标识符,而不是动态定义现有对象的属性(F#不支持特别好).

let dfLogWeight = log(dfWeight)

这样做的好处是,您几乎不需要指定类型,但它可能会混乱您的顶级命名空间.

属性对象

需要更多键入和更粗略语法的最终选项是创建强类型"属性对象":

type 'a property = System.Collections.Generic.Dictionary

let createProp() : property<'a> = new property<'a>()
let getProp o (prop:property<'a>) : 'a = prop.[o]
let setProp o (prop:property<'a>) (value:'a) = prop.[o] <- value

let df = new obj()
let (weight : property) = createProp()
let (logWeight : property) = createProp()

setProp df weight 50.
setProp df logWeight (getProp df weight)
let fltVal = getProp df logWeight

这需要显式创建每个属性(并且在该点需要类型注释),但之后不需要类型注释.我发现它比其他选项更不易读,尽管定义一个替换运算符getProp可能会有所缓解.