我如何编写类型安全的递归内联函数来扁平化元组

我想创建一个类型安全的递归函数来扁平化元组。但是我不能让下面的第一个递归级别的类型安全我如何编写类型安全的递归内联函数来扁平化元组

type Flatten = Flatten 
with 
    static member inline ($) (Flatten, (a: 'a, b: 'b)) : 'x list = 
     List.concat [ Flatten.Flat a; Flatten.Flat b] 
    static member inline($) (Flatten, (a: 'a, b: 'b, c: 'c)) : 'x list = 
     List.concat [Flatten.Flat a; Flatten.Flat b; Flatten.Flat c] 
    static member inline Flat(x: obj) : 'x list = 
     match x with 
     | :? Tuple<'a, 'b> as t -> Flatten $ (t.Item1, t.Item2) 
     | :? Tuple<'a, 'b, 'c> as t ->Flatten $ (t.Item1, t.Item2, t.Item3) 
     | _ -> [x] 
let inline flatten x = Flatten $ x 
let a1 = flatten (1, (2, 2, 3), (3,3)) 
//this compiles 
let a2 = flatten (1, (2, 2, 3, 4), (3,3)) 
//       ^but this too

方面我尝试另一种方法

type Flatten = Flatten 
with 
    static member inline ($) (Flatten, (a: 'a, b: 'b)) = List.concat [ Flat $ a; Flat $ b] 
    static member inline ($) (Flatten, (a: 'a, b: 'b, c: 'c)) = List.concat [Flat $ a; Flat $ b; Flat $ c] 

and Flat = Flat 
with 
    static member inline ($) (Flat, a: 'a) = [a] 
    static member inline ($) (Flat, x: ('a *'b)) = 
     let (a, b) = x 
     List.concat [ Flatten $ a; Flatten $ b] 
    static member inline($) (Flat, x : ('a * 'b * 'c)) = 
     let (a, b, c) = x 
     List.concat [Flatten $ a; Flatten $ b; Flatten $ c] 

let inline flatten x = Flatten $ x 
let a = flatten (1, 1) 
let a1 = flatten (1, 1, 3) 
let a2 = flatten (1, 1, (3, 3))

，但我不能让一个键入检查。

有没有人有线索？

一个额外的要求

我做这一切的原因，部分是因为我想

let a1 = flatten (1, (2, 2, 3), (3,3))

产生

val a1 : int list

这是因为，当我在喂int的元组的元组，那么唯一明智的结果应该是int list。此刻我得到一个obj list int第一个例子在第二个编译错误。

此致

来源

2017-05-12 robkuz

当然，你不能所有的元组大小。在某些时候，你必须指定尽可能多的重载元素。 – Gustavo

我只是放弃静态键入保证并使用反射。 – scrwtp

@Gustavo - 由于F＃只有元组大小1-8，并且“具有嵌套元组的更大元组大小”，所以我认为实际上可以为所有元组大小写这个。不过，我从来没有觉得有必要这样做，因为通常有更好的（恕我直言）解决方案来解决无论什么问题都会导致你想要压扁未知元组的元组。 – rmunn

在.NET Tuple类有arities from 1 to 8在其号码的类型的参数。我相信在F＃中，如果有8个或更多元素的元组，它将被视为7个元素的元组加上8个槽中的嵌套元组。 (a,b,c,d,e,f,g,h,i,j)实际上是(a,b,c,d,e,f,g,(h,i,j))，这是一个System.Tuple<'T1,'T2,'T3,'T4,'T5,'T6,'T7,System.Tuple<'T8,'T9,'T10>>类型的元组。

但是，您的第一种方法只能处理2号和3号区域，但当您执行flatten (1, (2, 2, 3, 4), (3,3))时，您正在用arity-4元组进行测试。如果你重写你的第一个Flat函数如下？

static member inline Flat(x: obj) : 'x list = 
    match x with 
    | :? Tuple<'a> as t -> Flatten $ (t.Item1) 
    | :? Tuple<'a, 'b> as t -> Flatten $ (t.Item1, t.Item2) 
    | :? Tuple<'a, 'b, 'c> as t ->Flatten $ (t.Item1, t.Item2, t.Item3) 
    | :? Tuple<'a, 'b, 'c, 'd> as t -> Flatten $ (t.Item1, t.Item2, t.Item3, t.Item4) 
    | :? Tuple<'a, 'b, 'c, 'd, 'e, 'f> as t -> Flatten $ (t.Item1, t.Item2, t.Item3, t.Item4, t.Item5, t.Item6) 
    | :? Tuple<'a, 'b, 'c, 'd, 'e, 'f, 'g> as t -> Flatten $ (t.Item1, t.Item2, t.Item3, t.Item4, t.Item5, t.Item6, t.Item7) 
    | :? Tuple<'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h> as t -> Flatten $ (t.Item1, t.Item2, t.Item3, t.Item4, t.Item5, t.Item6, t.Item7, t.Item8) 
    | _ -> [x]

，当然，你需要相应static member inline ($)实现对每个arities从1到8这是否解决您的问题吗？

P.S.请注意，我只是将此代码键入Stack Overflow中的答案窗口;我还没有真正测试过它。

来源

2017-05-12 09:42:43 rmunn

thx的答案 - 可惜它不是我想要的。请看看我上面的评论。反正无论如何 – robkuz

我想打赌，如果没有运行时类型测试，不能以类型安全的方式进行这种猜测。

module Tuple = 
    open Microsoft.FSharp.Reflection 
    let rec collect<'T> (x : obj) = [| 
     if FSharpType.IsTuple <| x.GetType() then 
      for y in FSharpValue.GetTupleFields x do 
       yield! collect y 
     elif x :? 'T then yield x :?> 'T |] 

Tuple.collect<int> (((100,101,102),"X"),1,2,3,(4,5)) 
// val it : int [] = [|100; 101; 102; 1; 2; 3; 4; 5|]

内嵌重载方案不起作用，因为F＃的类型系统是不够的表达类型'T并通过构件的约束方式的元组'T*'T之间进行辨别;该元组必须被视为原子单元'T。因此，编译时方案将始终解析为原子大小写，而不是元组。

来源

2017-05-12 21:15:05 kaefer

我如何编写类型安全的递归内联函数来扁平化元组

回答

相关问题