F #-목록

F #에서 목록은 동일한 형식의 순서가 지정되고 변경할 수없는 일련의 요소입니다. 링크드리스트 데이터 구조와 어느 정도 동일합니다.

F # 모듈, Microsoft.FSharp.Collections.List,목록에 대한 일반적인 작업이 있습니다. 그러나 F #은이 모듈을 자동으로 가져와 모든 F # 응용 프로그램에서 액세스 할 수 있도록합니다.

목록 생성 및 초기화

다음은 목록을 만드는 다양한 방법입니다-

• 목록 사용 literals.

• 사용 cons (::) 운영자.

• 사용 List.init List 모듈의 방법.

• 일부 사용 syntactic constructs 전화 List Comprehensions.

리터럴 나열

이 방법에서는 세미콜론으로 구분 된 값 시퀀스를 대괄호로 지정하기 만하면됩니다. 예를 들면-

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]

단점 (: :) 연산자

이 방법을 사용하면 앞에 또는 cons-ing:: 연산자를 사용하여 기존 목록에 추가합니다. 예를 들면-

let list2 = 1::2::3::4::5::6::7::8::9::10::[];;

[]는 빈 목록을 나타냅니다.

초기화 방법 나열

List 모듈의 List.init 메서드는 종종 목록을 만드는 데 사용됩니다. 이 방법은 유형이 있습니다-

val init : int -> (int -> 'T) -> 'T list

첫 번째 인수는 새 목록의 원하는 길이이고 두 번째 인수는 목록에 항목을 생성하는 이니셜 라이저 함수입니다.

예를 들면

let list5 = List.init 5 (fun index -> (index, index * index, index * index * index))

여기서 index 함수는 목록을 생성합니다.

목록 이해

목록 이해는 목록을 생성하는 데 사용되는 특수 구문 구조입니다.

F # 목록 이해 구문은 범위와 생성기의 두 가지 형태로 제공됩니다.

범위에는 [시작 .. 끝] 및 [시작 .. 단계 .. 끝] 구조가 있습니다.

예를 들면

let list3 = [1 .. 10]

생성기는 다음과 같은 구조를 가지고 있습니다.-[for x in collection do ... yield expr]

예를 들면

let list6 = [ for a in 1 .. 10 do yield (a * a) ]

로 yield 키워드는 단일 값을 목록, 키워드, yield!, 값 모음을 목록으로 푸시합니다.

다음 함수는 위의 방법을 보여줍니다-

예

(* using list literals *)
let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1

(*using cons operator *)
let list2 = 1 :: 2 :: 3 :: []
printfn "The list: %A" list2

(* using range constructs*)
let list3 = [1 .. 10]
printfn "The list: %A" list3

(* using range constructs *)
let list4 = ['a' .. 'm']
printfn "The list: %A" list4

(* using init method *)
let list5 = List.init 5 (fun index -> (index, index * index, index * index * index))
printfn "The list: %A" list5

(* using yield operator *)
let list6 = [ for a in 1 .. 10 do yield (a * a) ]
printfn "The list: %A" list6

(* using yield operator *)
let list7 = [ for a in 1 .. 100 do if a % 3 = 0 && a % 5 = 0 then yield a]
printfn "The list: %A" list7

(* using yield! operator *)
let list8 = [for a in 1 .. 3 do yield! [ a .. a + 3 ] ]
printfn "The list: %A" list8

프로그램을 컴파일하고 실행하면 다음과 같은 출력이 생성됩니다.

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The list: [1; 2; 3]
The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The list: ['a'; 'b'; 'c'; 'd'; 'e'; 'f'; 'g'; 'h'; 'i'; 'j'; 'k'; 'l'; 'm']
The list: [(0, 0, 0); (1, 1, 1); (2, 4, 8); (3, 9, 27); (4, 16, 64)]
The list: [1; 4; 9; 16; 25; 36; 49; 64; 81; 100]
The list: [15; 30; 45; 60; 75; 90]
The list: [1; 2; 3; 4; 2; 3; 4; 5; 3; 4; 5; 6]

목록 데이터 유형의 속성

다음 표는 목록 데이터 유형의 다양한 속성을 보여줍니다-

특성	유형	기술
머리	'티	첫 번째 요소.
빈	'T 목록	적절한 유형의 빈 목록을 반환하는 정적 속성입니다.
비었다	부울	true 목록에 요소가없는 경우.
안건	'티	지정된 인덱스 (0부터 시작)의 요소입니다.
길이	int	요소 수입니다.
꼬리	'T 목록	첫 번째 요소가없는 목록입니다.

다음 예제는 이러한 속성의 사용을 보여줍니다-

예

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]

// Use of Properties
printfn "list1.IsEmpty is %b" (list1.IsEmpty)
printfn "list1.Length is %d" (list1.Length)
printfn "list1.Head is %d" (list1.Head)
printfn "list1.Tail.Head is %d" (list1.Tail.Head)
printfn "list1.Tail.Tail.Head is %d" (list1.Tail.Tail.Head)
printfn "list1.Item(1) is %d" (list1.Item(1))

프로그램을 컴파일하고 실행하면 다음과 같은 출력이 생성됩니다.

list1.IsEmpty is false
list1.Length is 8
list1.Head is 2
list1.Tail.Head is 4
list1.Tail.Tail.Head is 6
list1.Item(1) is 4

목록의 기본 연산자

다음 표는 목록 데이터 유형에 대한 기본 작업을 보여줍니다-

값	기술
추가 : 'T 목록 →'T 목록 → 'T 목록	첫 번째 목록의 요소와 두 번째 요소의 순서를 포함하는 새 목록을 반환합니다.
평균 : 'T리스트 → ^ T	목록에있는 요소의 평균을 반환합니다.
averageBy : ( 'T → ^ U) →'T 목록 → ^ U	목록의 각 요소에 함수를 적용하여 생성 된 요소의 평균을 반환합니다.
선택 : ( 'T →'U 옵션) → 'T 목록 →'U 목록	목록의 각 요소에 주어진 함수를 적용합니다. 함수가 반환하는 각 요소에 대한 결과로 구성된 목록을 반환합니다.Some.
수집 : ( 'T →'U리스트) → 'T리스트 →'U리스트	목록의 각 요소에 대해 주어진 함수를 적용합니다. 모든 결과를 연결하고 결합 된 목록을 반환합니다.
concat : seq < 'T 목록> →'T 목록	각 목록의 요소를 순서대로 포함하는 새 목록을 반환합니다.
비어 있음 : 'T 목록	주어진 유형의 빈 목록을 반환합니다.
존재 : ( 'T → bool) →'T list → bool	목록의 요소가 주어진 술어를 만족하는지 테스트합니다.
exist2 : ( 'T1 →'T2 → bool) → 'T1 목록 →'T2 목록 → bool	목록의 해당 요소 쌍이 주어진 술어를 충족하는지 테스트합니다.
필터 : ( 'T → 부울) →'T리스트 → 'T리스트	주어진 술어가 리턴하는 콜렉션의 요소 만 포함하는 새 콜렉션을 리턴합니다. true.
찾기 : ( 'T → bool) →'T 목록 → 'T	주어진 함수가 반환하는 첫 번째 요소를 반환합니다. true.
findIndex : ( 'T → bool) →'T 목록 → int	목록에서 주어진 술어를 만족하는 첫 번째 요소의 색인을 리턴합니다.
fold : ( 'State →'T → 'State) →'State → 'T list →'State	컬렉션의 각 요소에 함수를 적용하여 계산을 통해 누산기 인수를 스레딩합니다. 이 함수는 두 번째 인수를 가져 와서 그 함수와 목록의 첫 번째 요소를 적용합니다. 그런 다음이 결과를 두 번째 요소와 함께 함수에 전달합니다. 마지막으로 최종 결과를 반환합니다. 입력 함수가 f이고 요소가 i0 ... iN이면이 함수는 f (... (fs i0) i1 ...) iN을 계산합니다.
fold2 : ( 'State →'T1 → 'T2 →'State) → 'State →'T1 목록 → 'T2 목록 →'State	두 컬렉션의 해당 요소에 함수를 적용하여 계산을 통해 누산기 인수를 스레딩합니다. 컬렉션의 크기는 동일해야합니다. 입력 함수가 f이고 요소가 i0 ... iN 및 j0 ... jN이면이 함수는 f (... (fs i0 j0) ...) iN jN을 계산합니다.
foldBack : ( 'T →'상태 → '상태) →'T 목록 → '상태 →'상태	컬렉션의 각 요소에 함수를 적용하여 계산을 통해 누산기 인수를 스레딩합니다. 입력 함수가 f이고 요소가 i0 ... iN이면 f i0 (... (f iN s))를 계산합니다.
foldBack2 : ( 'T1 →'T2 → '상태 →'상태) → 'T1 목록 →'T2 목록 → '상태 →'상태	두 컬렉션의 해당 요소에 함수를 적용하여 계산을 통해 누산기 인수를 스레딩합니다. 컬렉션의 크기는 동일해야합니다. 입력 함수가 f이고 요소가 i0 ... iN 및 j0 ... jN이면이 함수는 f i0 j0 (... (f iN jN s))를 계산합니다.
forall : ( 'T → bool) →'T list → bool	컬렉션의 모든 요소가 주어진 조건자를 만족하는지 테스트합니다.
forall2 : ( 'T1 →'T2 → bool) → 'T1 목록 →'T2 목록 → bool	컬렉션의 모든 해당 요소가 주어진 조건자를 쌍으로 충족하는지 테스트합니다.
head : 'T리스트 →'T	목록의 첫 번째 요소를 반환합니다.
init : int → (int → 'T) →'T 목록	각 인덱스에서 지정된 생성기를 호출하여 목록을 만듭니다.
isEmpty : 'T리스트 → 부울	보고 true 목록에 요소가 없으면 false 그렇지 않으면.
iter : ( 'T → 단위) →'T 목록 → 단위	컬렉션의 각 요소에 주어진 함수를 적용합니다.
iter2 : ( 'T1 →'T2 → 단위) → 'T1 목록 →'T2 목록 → 단위	주어진 함수를 두 개의 컬렉션에 동시에 적용합니다. 컬렉션의 크기는 동일해야합니다.
iteri : (int → 'T → unit) →'T list → unit	컬렉션의 각 요소에 주어진 함수를 적용합니다. 함수에 전달 된 정수는 요소의 인덱스를 나타냅니다.
iteri2 : (int → 'T1 →'T2 → 단위) → 'T1 목록 →'T2 목록 → 단위	주어진 함수를 두 개의 컬렉션에 동시에 적용합니다. 컬렉션의 크기는 동일해야합니다. 함수에 전달 된 정수는 요소의 인덱스를 나타냅니다.
길이 : 'T 목록 → 정수	목록의 길이를 반환합니다.
map : ( 'T →'U) → 'T리스트 →'U리스트	컬렉션의 각 요소에 지정된 함수를 적용한 결과 인 요소가있는 새 컬렉션을 만듭니다.
map2 : ( 'T1 →'T2 → 'U) →'T1 목록 → 'T2 목록 →'U 목록	지정된 함수를 쌍으로 두 컬렉션의 해당 요소에 적용한 결과 인 요소가있는 새 컬렉션을 만듭니다.
map3 : ( 'T1 →'T2 → 'T3 →'U) → 'T1 목록 →'T2 목록 → 'T3 목록 →'U 목록	주어진 함수를 세 컬렉션의 해당 요소에 동시에 적용한 결과 인 요소가있는 새 컬렉션을 만듭니다.
mapi : (int → 'T →'U) → 'T리스트 →'U리스트	컬렉션의 각 요소에 지정된 함수를 적용한 결과 인 요소가있는 새 컬렉션을 만듭니다. 함수에 전달 된 정수 인덱스는 변환되는 요소의 인덱스 (0부터)를 나타냅니다.
mapi2 : (int → 'T1 →'T2 → 'U) →'T1 목록 → 'T2 목록 →'U 목록	List.mapi와 비슷하지만 길이가 같은 두 목록에서 해당 요소를 매핑합니다.
max : 'T리스트 →'T	Operators.max를 사용하여 비교 한 목록의 모든 요소 중 가장 큰 요소를 반환합니다.
maxBy : ( 'T →'U) → 'T 목록 →'T	함수 결과에 Operators.max를 사용하여 비교하여 목록의 모든 요소 중 가장 큰 요소를 반환합니다.
min : 'T리스트 →'T	Operators.min을 사용하여 비교 한 목록의 모든 요소 중 가장 낮은 값을 반환합니다.
minBy : ( 'T →'U) → 'T리스트 →'T	함수 결과에 Operators.min을 사용하여 비교하여 목록의 모든 요소 중 가장 낮은 값을 반환합니다.
nth : 'T리스트 → int →'T	목록에 색인을 생성합니다. 첫 번째 요소에는 인덱스 0이 있습니다.
ofArray : 'T [] →'T리스트	주어진 배열에서 목록을 만듭니다.
ofSeq : seq < 'T> →'T리스트	주어진 열거 가능한 개체에서 새 목록을 만듭니다.
파티션 : ( 'T → bool) →'T 목록 * 'T 목록	주어진 술어가 리턴하는 요소를 포함하는 두 개의 콜렉션으로 콜렉션을 분할합니다. true 과 false 각기.
permute : (int → int) → 'T 목록 →'T 목록	지정된 순열에 따라 순열 된 모든 요소가있는 목록을 반환합니다.
선택 : ( 'T →'U 옵션) → 'T 목록 →'U	주어진 함수를 연속 요소에 적용하여 함수가 반환하는 첫 번째 결과를 반환합니다. Some 어떤 가치를 위해.
축소 : ( 'T →'T → 'T) →'T 목록 → 'T	컬렉션의 각 요소에 함수를 적용하여 계산을 통해 누산기 인수를 스레딩합니다. 이 함수는 지정된 함수를 목록의 처음 두 요소에 적용합니다. 그런 다음이 결과를 세 번째 요소와 함께 함수에 전달합니다. 마지막으로 최종 결과를 반환합니다. 입력 함수가 f이고 요소가 i0 ... iN이면이 함수는 f (... (f i0 i1) i2 ...) iN을 계산합니다.
reduceBack : ( 'T →'T → 'T) →'T 목록 → 'T	컬렉션의 각 요소에 함수를 적용하여 계산을 통해 누산기 인수를 스레딩합니다. 입력 함수가 f이고 요소가 i0 ... iN이면이 함수는 f i0 (... (f iN-1 iN))을 계산합니다.
복제 : (int → 'T →'T 목록)	각 인덱스에서 지정된 생성기를 호출하여 목록을 만듭니다.
rev : 'T리스트 →'T리스트	역순으로 요소가있는 새 목록을 반환합니다.
스캔 : ( '상태 →'T → '상태) →'상태 → 'T 목록 →'상태 목록	컬렉션의 각 요소에 함수를 적용하여 계산을 통해 누산기 인수를 스레딩합니다. 이 함수는 두 번째 인수를 취하고 지정된 함수를이 인수와 목록의 첫 번째 요소에 적용합니다. 그런 다음이 결과를 두 번째 요소와 함께 함수에 전달합니다. 마지막으로 중간 결과 목록과 최종 결과를 반환합니다.
scanBack : ( 'T →'상태 → '상태) →'T 목록 → '상태 →'상태 목록	foldBack과 비슷하지만 중간 및 최종 결과를 모두 반환합니다.
정렬 : 'T리스트 →'T리스트	Operators.compare를 사용하여 주어진 목록을 정렬합니다.
sortBy : ( 'T →'키) → 'T 목록 →'T 목록	주어진 프로젝션에 의해 주어진 키를 사용하여 주어진 목록을 정렬합니다. Operators.compare를 사용하여 키를 비교합니다.
sortWith : ( 'T →'T → int) → 'T 목록 →'T 목록	주어진 비교 함수를 사용하여 주어진 목록을 정렬합니다.
합계 : ^ T 목록 → ^ T	목록에있는 요소의 합계를 반환합니다.
sumBy : ( 'T → ^ U) →'T 목록 → ^ U	목록의 각 요소에 함수를 적용하여 생성 된 결과의 합계를 반환합니다.
tail : 'T 목록 →'T 목록	첫 번째 요소가없는 입력 목록을 반환합니다.
toArray : 'T 목록 →'T []	주어진 목록에서 배열을 만듭니다.
toSeq : 'T 목록 → seq <'T>	주어진 목록을 시퀀스로 봅니다.
tryFind : ( 'T → bool) →'T 목록 → 'T 옵션	주어진 함수가 반환하는 첫 번째 요소를 반환합니다. true. 반환None 그러한 요소가 존재하지 않는 경우.
tryFindIndex : ( 'T → bool) →'T 목록 → int 옵션	목록에서 주어진 술어를 만족하는 첫 번째 요소의 색인을 리턴합니다. 반환None 그러한 요소가 존재하지 않는 경우.
tryPick : ( 'T →'U 옵션) → 'T 목록 →'U 옵션	주어진 함수를 연속 요소에 적용하여 함수가 반환하는 첫 번째 결과를 반환합니다. Some어떤 가치를 위해. 그러한 요소가 없으면 다음을 반환합니다.None.
unzip : ( 'T1 *'T2) 목록 → 'T1 목록 *'T2 목록	쌍 목록을 두 목록으로 분할합니다.
unzip3 : ( 'T1 *'T2 * 'T3) 목록 →'T1 목록 * 'T2 목록 *'T3 목록	트리플 목록을 세 개의 목록으로 분할합니다.
zip : 'T1 목록 →'T2 목록 → ( 'T1 *'T2) 목록	두 목록을 쌍 목록으로 결합합니다. 두 목록은 길이가 같아야합니다.
zip3 : 'T1 목록 →'T2 목록 → 'T3 목록 → ('T1 * 'T2 *'T3) 목록	세 목록을 트리플 목록으로 결합합니다. 목록의 길이는 같아야합니다.

다음 예제는 위의 기능의 사용을 보여줍니다-

예 1

이 프로그램은 목록을 재귀 적으로 뒤집는 것을 보여줍니다-

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]
printfn "The original list: %A" list1

let reverse lt =
   let rec loop acc = function
      | [] -> acc
      | hd :: tl -> loop (hd :: acc) tl
   loop [] lt

printfn "The reversed list: %A" (reverse list1)

프로그램을 컴파일하고 실행하면 다음과 같은 출력이 생성됩니다.

The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]

그러나 rev 동일한 목적을위한 모듈의 기능-

let list1 = [ 2; 4; 6; 8; 10; 12; 14; 16 ]
printfn "The original list: %A" list1
printfn "The reversed list: %A" (List.rev list1)

프로그램을 컴파일하고 실행하면 다음과 같은 출력이 생성됩니다.

The original list: [2; 4; 6; 8; 10; 12; 14; 16]
The reversed list: [16; 14; 12; 10; 8; 6; 4; 2]

예 2

이 프로그램은 List.filter 방법-

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1
let list2 = list1 |> List.filter (fun x -> x % 2 = 0);;
printfn "The Filtered list: %A" list2

프로그램을 컴파일하고 실행하면 다음과 같은 출력이 생성됩니다.

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The Filtered list: [2; 4; 6; 8; 10]

예제 3

그만큼 List.map 메소드는 한 유형에서 다른 유형으로 목록을 매핑합니다-

let list1 = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "The list: %A" list1
let list2 = list1 |> List.map (fun x -> (x * x).ToString());;
printfn "The Mapped list: %A" list2

프로그램을 컴파일하고 실행하면 다음과 같은 출력이 생성됩니다.

The list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The Mapped list: ["1"; "4"; "9"; "16"; "25"; "36"; "49"; "64"; "81"; "100"]

예 4

그만큼 List.append 메소드와 @ 연산자는 한 목록을 다른 목록에 추가합니다.

let list1 = [1; 2; 3; 4; 5 ]
let list2 = [6; 7; 8; 9; 10]
let list3 = List.append list1 list2

printfn "The first list: %A" list1
printfn "The second list: %A" list2
printfn "The appened list: %A" list3

let lt1 = ['a'; 'b';'c' ]
let lt2 = ['e'; 'f';'g' ]
let lt3 = lt1 @ lt2

printfn "The first list: %A" lt1
printfn "The second list: %A" lt2
printfn "The appened list: %A" lt3

프로그램을 컴파일하고 실행하면 다음과 같은 출력이 생성됩니다.

The first list: [1; 2; 3; 4; 5]
The second list: [6; 7; 8; 9; 10]
The appened list: [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
The first list: ['a'; 'b'; 'c']
The second list: ['e'; 'f'; 'g']
The appened list: ['a'; 'b'; 'c'; 'e'; 'f'; 'g']

예 5

그만큼 List.sort메소드는 목록을 정렬합니다. 그만큼List.sum 메소드는 목록의 요소 합계를 제공하고 List.average 방법은 목록에있는 요소의 평균을 제공합니다-

let list1 = [9.0; 0.0; 2.0; -4.5; 11.2; 8.0; -10.0]
printfn "The list: %A" list1

let list2 = List.sort list1
printfn "The sorted list: %A" list2

let s = List.sum list1
let avg = List.average list1
printfn "The sum: %f" s
printfn "The average: %f" avg

프로그램을 컴파일하고 실행하면 다음과 같은 출력이 생성됩니다.

The list: [9.0; 0.0; 2.0; -4.5; 11.2; 8.0; -10.0]
The sorted list: [-10.0; -4.5; 0.0; 2.0; 8.0; 9.0; 11.2]
The sum: 15.700000
The average: 2.242857

"접기"연산은 목록의 각 요소에 함수를 적용하고 누산기 변수의 함수 결과를 집계 한 다음 접기 연산의 결과로 누산기를 반환합니다.

예제 6

그만큼 List.fold 메서드는 왼쪽에서 오른쪽으로 각 요소에 함수를 적용하는 반면 List.foldBack 오른쪽에서 왼쪽으로 각 요소에 함수를 적용합니다.

let sumList list = List.fold (fun acc elem -> acc + elem) 0 list
printfn "Sum of the elements of list %A is %d." [ 1 .. 10 ] (sumList [ 1 .. 10 ])

프로그램을 컴파일하고 실행하면 다음과 같은 출력이 생성됩니다.

Sum of the elements of list [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] is 55.