extraño comportamiento de la matriz de corte de

Question

> let a = [| 'a'..'d' |];; 
val a : char [] = [|'a'; 'b'; 'c'; 'd'|] 

Haz rebanar trivial:

> a.[1..2], [1..2];; 
val it : char [] * int list = ([|'b'; 'c'|], [1; 2]) 

Ahora intentarlo con la región vacía:

> a.[1..0], [1..0];; 
val it : char [] * int list = ([||], []) 

parece trabajar y razonable - nos dieron dos secuencias vacías.

pero fracasa aquí:

> a.[5..0];; 
System.OverflowException: Arithmetic operation resulted in an overflow. 
    at <StartupCode$FSI_0018>.$FSI_0018.main@() 
Stopped due to error 

Por supuesto, no es una solución [| for i in [5..0] -> a.[i] |]. Pero extraño el punto por el cual a.[5..0] falla? ¿Por qué no solo devuelve una matriz vacía? ¿Alguna razón para tal comportamiento?

Answer 1

Esto es un error.

Aunque la división en matriz y la expresión de rango son conceptos diferentes (no se puede usar a.[1..2..5] por ejemplo), deben comportarse de forma coherente.

en cuenta que la excepción ocurre con a.[start..finish] cuando finish - start <= -2 (a.[3..1] falla) y la matriz de rebanado funciona bien si finish - start = -1 (a.[5..4] = [||]).

rebanar matriz se realiza mediante el uso de GetArraySlice función en prim-types.fs:

let inline GetArraySlice (arr: _[]) start finish = 
    let start = (match start with None -> 0 | Some n -> n) 
    let finish = (match finish with None -> arr.Length - 1 | Some n -> n) 
    GetArraySub arr start (finish - start + 1) 

mientras GetArraySub se implementa en el mismo módulo de la siguiente manera:

let inline GetArraySub arr (start:int) (len:int) = 
    let dst = zeroCreate len 
    for i = 0 to len - 1 do 
     SetArray dst i (GetArray arr (start + i)) 
    dst 

Si finish - start = -1, tenemos len = 0 en GetArraySub y zeroCreate 0 devuelve una matriz vacía. Ya no es el caso con finish - start <= -2 que conduce a len < 0 y zeroCreate len falla.

Esto podría solucionarse siempre devolviendo una matriz vacía siempre que finish - start <= -1.