조각

아티클
03/02/2024

이 문서에서는 기존 F# 형식에서 조각을 가져오는 방법과 고유한 조각을 정의하는 방법을 설명합니다.

F#에서 조각은 모든 데이터 형식의 하위 집합입니다. 조각은 인덱서와 비슷하지만 기본 데이터 구조에서 단일 값을 생성하는 대신 여러 값을 생성합니다. 조각은 연산자 구문을 사용하여 .. 데이터 형식에서 지정된 인덱스의 범위를 선택합니다. 자세한 내용은 루프 식 참조 문서를 참조 하세요.

F#은 현재 문자열, 목록, 배열 및 다차원(2D, 3D, 4D) 배열을 조각화하기 위한 기본 지원을 제공합니다. 조각화는 F# 배열 및 목록에서 가장 일반적으로 사용됩니다. 형식 정의 또는 범위 내 형식 확장에서 메서드를 GetSlice 사용하여 사용자 지정 데이터 형식에 조각화 기능을 추가할 수 있습니다.

F# 목록 및 배열 조각화

조각화되는 가장 일반적인 데이터 형식은 F# 목록 및 배열입니다. 다음 예제에서는 목록을 조각화하는 방법을 보여 줍니다.

// Generate a list of 100 integers
let fullList = [ 1 .. 100 ]

// Create a slice from indices 1-5 (inclusive)
let smallSlice = fullList[1..5]
printfn $"Small slice: {smallSlice}"

// Create a slice from the beginning to index 5 (inclusive)
let unboundedBeginning = fullList[..5]
printfn $"Unbounded beginning slice: {unboundedBeginning}"

// Create a slice from an index to the end of the list
let unboundedEnd = fullList[94..]
printfn $"Unbounded end slice: {unboundedEnd}"

배열을 조각화하면 목록 조각화와 같습니다.

// Generate an array of 100 integers
let fullArray = [| 1 .. 100 |]

// Create a slice from indices 1-5 (inclusive)
let smallSlice = fullArray[1..5]
printfn $"Small slice: {smallSlice}"

// Create a slice from the beginning to index 5 (inclusive)
let unboundedBeginning = fullArray[..5]
printfn $"Unbounded beginning slice: {unboundedBeginning}"

// Create a slice from an index to the end of the list
let unboundedEnd = fullArray[94..]
printfn $"Unbounded end slice: {unboundedEnd}"

F# 6 이전에는 조각화에서 추가 .구문을 expr.[start..finish] 사용했습니다. 선택하는 경우 이 구문을 계속 사용할 수 있습니다. 자세한 내용은 RFC FS-1110을 참조 하세요.

다차원 배열 조각화

F#은 F# 코어 라이브러리에서 다차원 배열을 지원합니다. 1차원 배열과 마찬가지로 다차원 배열의 조각도 유용할 수 있습니다. 그러나 추가 차원을 도입하면 특정 행과 열 조각을 사용할 수 있도록 약간 다른 구문이 사용됩니다.

다음 예제에서는 2D 배열을 분할하는 방법을 보여 줍니다.

// Generate a 3x3 2D matrix
let A = array2D [[1;2;3];[4;5;6];[7;8;9]]
printfn $"Full matrix:\n {A}"

// Take the first row
let row0 = A[0,*]
printfn $"{row0}"

// Take the first column
let col0 = A[*,0]
printfn $"{col0}"

// Take all rows but only two columns
let subA = A[*,0..1]
printfn $"{subA}"

// Take two rows and all columns
let subA' = A[0..1,*]
printfn $"{subA}"

// Slice a 2x2 matrix out of the full 3x3 matrix
let twoByTwo = A[0..1,0..1]
printfn $"{twoByTwo}"

다른 데이터 구조에 대한 조각 정의

F# 코어 라이브러리는 제한된 형식 집합에 대한 조각을 정의합니다. 더 많은 데이터 형식에 대한 조각을 정의하려는 경우 형식 정의 자체 또는 형식 확장에서 이 작업을 수행할 수 있습니다.

예를 들어 편리한 데이터 조작을 허용하도록 클래스에 ArraySegment<T> 대한 조각을 정의하는 방법은 다음과 같습니다.

open System

type ArraySegment<'TItem> with
    member segment.GetSlice(start, finish) =
        let start = defaultArg start 0
        let finish = defaultArg finish segment.Count
        ArraySegment(segment.Array, segment.Offset + start, finish - start)

let arr = ArraySegment [| 1 .. 10 |]
let slice = arr[2..5] //[ 3; 4; 5]

및 ReadOnlySpan<T> 형식을 Span<T> 사용하는 또 다른 예는 다음과 같습니다.

open System

type ReadOnlySpan<'T> with
    member sp.GetSlice(startIdx, endIdx) =
        let s = defaultArg startIdx 0
        let e = defaultArg endIdx sp.Length
        sp.Slice(s, e - s)

type Span<'T> with
    member sp.GetSlice(startIdx, endIdx) =
        let s = defaultArg startIdx 0
        let e = defaultArg endIdx sp.Length
        sp.Slice(s, e - s)

let printSpan (sp: Span<int>) =
    let arr = sp.ToArray()
    printfn $"{arr}"

let sp = [| 1; 2; 3; 4; 5 |].AsSpan()
printSpan sp[0..] // [|1; 2; 3; 4; 5|]
printSpan sp[..5] // [|1; 2; 3; 4; 5|]
printSpan sp[0..3] // [|1; 2; 3|]
printSpan sp[1..3] // |2; 3|]

기본 제공 F# 조각은 최종 포함

F#의 모든 내장 조각은 엔드투시브입니다. 즉, 상한이 조각에 포함됩니다. 시작 인덱스와 끝 인덱 xy스가 있는 지정된 조각의 경우 결과 조각에는 yth 값이 포함됩니다.

// Define a new list
let xs = [1 .. 10]

printfn $"{xs[2..5]}" // Includes the 5th index

기본 제공 F# 빈 조각

F# 목록, 배열, 시퀀스, 문자열, 다차원(2D, 3D, 4D) 배열은 구문이 존재하지 않는 조각을 생성할 수 있는 경우 모두 빈 조각을 생성합니다.

다음 예제를 참조하세요.

let l = [ 1..10 ]
let a = [| 1..10 |]
let s = "hello!"

let emptyList = l[-2..(-1)]
let emptyArray = a[-2..(-1)]
let emptyString = s[-2..(-1)]

Important

C# 개발자는 빈 조각을 생성하지 않고 예외를 throw할 것으로 예상할 수 있습니다. 빈 컬렉션이 F#으로 작성된다는 사실에 뿌리를 둔 디자인 결정입니다. 빈 F# 목록은 다른 F# 목록으로 작성할 수 있으며, 기존 문자열에 빈 문자열을 추가할 수 있습니다. 매개 변수로 전달된 값에 따라 조각을 사용하는 것이 일반적일 수 있으며, F# 코드의 컴퍼지션 특성에 맞는 빈 컬렉션을 생성하여 범위를 > 벗어나는 것에 관대할 수 있습니다.

3D 및 4D 배열에 대한 고정 인덱스 조각

F# 3D 및 4D 배열의 경우 특정 인덱스를 "수정"하고 해당 인덱스가 고정된 다른 차원을 조각화할 수 있습니다.

이를 설명하기 위해 다음 3D 배열을 고려합니다.

z = 0

x\y	0	1
0	0	1
1	2	3

z = 1

x\y	0	1
0	4	5
1	6	7

배열에서 조각을 [| 4; 5 |] 추출하려면 고정 인덱스 조각을 사용합니다.

let dim = 2
let m = Array3D.zeroCreate<int> dim dim dim

let mutable count = 0

for z in 0..dim-1 do
    for y in 0..dim-1 do
        for x in 0..dim-1 do
            m[x,y,z] <- count
            count <- count + 1

// Now let's get the [4;5] slice!
m[*, 0, 1]

마지막 줄은 3D 배열의 인덱스와 z 인덱스를 수정 y 하고 행렬에 x 해당하는 나머지 값을 사용합니다.

참고 항목

인덱싱된 속성

조각