F #-시퀀스

목록과 같은 시퀀스는 순서가 지정된 값 모음을 나타냅니다. 그러나 시퀀스 또는 시퀀스 식의 요소는 필요할 때 계산됩니다. 한 번에 계산되지 않으며 이러한 이유로 무한 데이터 구조를 나타내는 데 사용됩니다.

시퀀스 정의

시퀀스는 다음 구문을 사용하여 정의됩니다-

seq { expr }

예를 들면

let seq1 = seq { 1 .. 10 }

시퀀스 및 시퀀스 식 만들기

목록과 유사하게 범위와 이해를 사용하여 시퀀스를 만들 수 있습니다.

시퀀스 표현식은 시퀀스 생성을 위해 작성할 수있는 표현식입니다. 이것들은 할 수 있습니다-

범위를 지정하여.
증가 또는 감소로 범위를 지정합니다.
사용하여 yield 시퀀스의 일부가되는 값을 생성하는 키워드입니다.
→ 연산자를 사용합니다.

다음 예제는 개념을 보여줍니다-

예 1

(* Sequences *)
let seq1 = seq { 1 .. 10 }

(* ascending order and increment*)
printfn "The Sequence: %A" seq1
let seq2 = seq { 1 .. 5 .. 50 }

(* descending order and decrement*)
printfn "The Sequence: %A" seq2

let seq3 = seq {50 .. -5 .. 0}
printfn "The Sequence: %A" seq3

(* using yield *)
let seq4 = seq { for a in 1 .. 10 do yield a, a*a, a*a*a }
printfn "The Sequence: %A" seq4

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

The Sequence: seq [1; 2; 3; 4; ...]
The Sequence: seq [1; 6; 11; 16; ...]
The Sequence: seq [50; 45; 40; 35; ...]
The Sequence: seq [(1, 1, 1); (2, 4, 8); (3, 9, 27); (4, 16, 64); ...]

예 2

다음 프로그램은 1에서 50까지 소수를 인쇄합니다-

(* Recursive isprime function. *)
let isprime n =
   let rec check i =
      i > n/2 || (n % i <> 0 && check (i + 1))
   check 2

let primeIn50 = seq { for n in 1..50 do if isprime n then yield n }
for x in primeIn50 do
   printfn "%d" x

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

시퀀스에 대한 기본 작업

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

값	기술
추가 : seq < 'T> → seq <'T> → seq < 'T>	주어진 두 열거를 하나의 연결된 열거로 래핑합니다.
평균 : seq <^ T> → ^ T	시퀀스에있는 요소의 평균을 반환합니다.
averageBy : ( 'T → ^ U) → seq <'T> → ^ U	시퀀스의 각 요소에 함수를 적용하여 생성 된 결과의 평균을 반환합니다.
캐시 : seq < 'T> → seq <'T>	입력 시퀀스의 캐시 된 버전에 해당하는 시퀀스를 반환합니다.
캐스트 : IEnumerable → seq < 'T>	느슨한 유형의 시스템을 감 쌉니다. 입력 된 시퀀스로 컬렉션 시퀀스입니다.
선택 : ( 'T →'U 옵션) → seq < 'T> → seq <'U>	목록의 각 요소에 주어진 함수를 적용합니다. 함수가 반환하는 각 요소에 대한 결과로 구성된 목록을 반환합니다.Some.
collect : ( 'T →'Collection) → seq < 'T> → seq <'U>	주어진 함수를 시퀀스의 각 요소에 적용하고 모든 결과를 연결합니다.
compareWith : ( 'T →'T → int) → seq < 'T> → seq <'T> → int	주어진 비교 함수를 사용하여 요소별로 두 시퀀스를 비교합니다.
concat : seq < '컬렉션> → seq <'T>	주어진 열거 형을 하나의 연결된 열거 형으로 결합합니다.
countBy : ( 'T →'Key) → seq < 'T> → seq <'Key * int>	시퀀스의 각 요소에 키 생성 함수를 적용하고 원래 시퀀스에서 고유 키와 해당 발생 횟수를 생성하는 시퀀스를 반환합니다.
지연 : (단위 → seq < 'T>) → seq <'T>	시퀀스의 지정된 지연된 사양에서 빌드 된 시퀀스를 반환합니다.
구별 : seq < 'T> → seq <'T>	항목에 대한 일반 해시 및 같음 비교에 따라 중복 항목이없는 시퀀스를 반환합니다. 요소가 시퀀스에서 여러 번 발생하면 이후 발생은 버려집니다.
distinctBy : ( 'T →'키) → seq < 'T> → seq <'T>	주어진 키 생성 함수에 의해 반환 된 키에 대한 일반 해시 및 동일성 비교에 따라 중복 항목이없는 시퀀스를 반환합니다. 요소가 시퀀스에서 여러 번 발생하면 이후 발생은 버려집니다.
비어 있음 : seq < 'T>	빈 시퀀스를 만듭니다.
exactOne : seq < 'T> →'T	시퀀스의 유일한 요소를 반환합니다.
존재 : ( 'T → bool) → seq <'T> → bool	시퀀스의 요소가 주어진 술어를 만족하는지 테스트합니다.
exist2 : ( 'T1 →'T2 → bool) → seq < 'T1> → seq <'T2> → bool	입력 시퀀스의 해당 요소 쌍이 주어진 조건자를 충족하는지 테스트합니다.
필터 : ( 'T → bool) → seq <'T> → seq < 'T>	주어진 술어가 리턴하는 콜렉션의 요소 만 포함하는 새 콜렉션을 리턴합니다. true.
찾기 : ( 'T → bool) → seq <'T> → 'T	주어진 함수가 반환하는 첫 번째 요소를 반환합니다. true.
findIndex : ( 'T → bool) → seq <'T> → int	주어진 함수가 반환하는 첫 번째 요소의 인덱스를 반환합니다. true.
fold : ( 'State →'T → 'State) →'State → seq < 'T> →'State	컬렉션의 각 요소에 함수를 적용하여 계산을 통해 누산기 인수를 스레딩합니다. 입력 함수가 f이고 요소가 i0 ... iN이면이 함수는 f (... (fs i0) ...) iN을 계산합니다.
forall : ( 'T → bool) → seq <'T> → bool	시퀀스의 모든 요소가 주어진 조건자를 충족하는지 테스트합니다.
forall2 : ( 'T1 →'T2 → bool) → seq < 'T1> → seq <'T2> → bool	두 시퀀스에서 가져온 모든 요소 쌍이 주어진 술어를 충족하는지 테스트합니다. 한 시퀀스가 다른 시퀀스보다 짧으면 더 긴 시퀀스의 나머지 요소는 무시됩니다.
groupBy : ( 'T →'키) → seq < 'T> → seq <'Key * seq < 'T >>	시퀀스의 각 요소에 키 생성 기능을 적용하고 고유 한 키 시퀀스를 생성합니다. 각 고유 키에는이 키와 일치하는 모든 요소의 시퀀스도 포함됩니다.
헤드 : seq < 'T> →'T	시퀀스의 첫 번째 요소를 반환합니다.
init : int → (int → 'T) → seq <'T>	반복 될 때 주어진 개수까지 주어진 함수를 호출하여 연속 요소를 반환하는 새 시퀀스를 생성합니다. 함수 호출 결과는 저장되지 않습니다. 즉, 요소를 재생성하기 위해 필요에 따라 함수가 다시 적용됩니다. 함수는 생성중인 항목의 색인을 전달합니다.
initInfinite : (int → 'T) → seq <'T>	반복 될 때 주어진 함수를 호출하여 연속 요소를 반환하는 새 시퀀스를 생성합니다. 함수 호출의 결과는 저장되지 않습니다. 즉, 요소를 재생성하는 데 필요한 함수가 다시 적용됩니다. 함수는 생성중인 항목의 색인을 전달합니다.
isEmpty : seq < 'T> → bool	시퀀스에 요소가 있는지 여부를 테스트합니다.
iter : ( 'T → 단위) → seq <'T> → 단위	컬렉션의 각 요소에 주어진 함수를 적용합니다.
iter2 : ( 'T1 →'T2 → 단위) → seq < 'T1> → seq <'T2> → 단위	주어진 함수를 두 개의 컬렉션에 동시에 적용합니다. 한 시퀀스가 다른 시퀀스보다 짧으면 더 긴 시퀀스의 나머지 요소는 무시됩니다.
iteri : (int → 'T → unit) → seq <'T> → unit	컬렉션의 각 요소에 주어진 함수를 적용합니다. 함수에 전달 된 정수는 요소의 인덱스를 나타냅니다.
마지막 : seq < 'T> →'T	시퀀스의 마지막 요소를 반환합니다.
길이 : seq < 'T> → int	시퀀스의 길이를 반환합니다.
맵 : ( 'T →'U) → seq < 'T> → seq <'U>	컬렉션의 각 요소에 지정된 함수를 적용한 결과 인 요소가있는 새 컬렉션을 만듭니다. 지정된 함수는 개체에서 검색된 열거 자에 대해 MoveNext 메서드를 사용하여 요소가 요구 될 때 적용됩니다.
map2 : ( 'T1 →'T2 → 'U) → seq <'T1> → seq < 'T2> → seq <'U>	두 시퀀스의 해당 요소 쌍에 지정된 함수를 적용한 결과 요소가있는 새 컬렉션을 만듭니다. 한 입력 시퀀스가 다른 시퀀스보다 짧으면 더 긴 시퀀스의 나머지 요소는 무시됩니다.
mapi : (int → 'T →'U) → seq < 'T> → seq <'U>	컬렉션의 각 요소에 지정된 함수를 적용한 결과 인 요소가있는 새 컬렉션을 만듭니다. 함수에 전달 된 정수 인덱스는 변환되는 요소의 인덱스 (0부터)를 나타냅니다.
최대 : seq < 'T> →'T	Operators.max를 사용하여 비교 한 시퀀스의 모든 요소 중 가장 큰 요소를 반환합니다.
maxBy : ( 'T →'U) → seq < 'T> →'T	함수 결과에 Operators.max를 사용하여 비교하여 시퀀스의 모든 요소 중 가장 큰 요소를 반환합니다.
min : seq < 'T> →'T	Operators.min을 사용하여 비교하여 시퀀스의 모든 요소 중 가장 낮은 값을 반환합니다.
minBy : ( 'T →'U) → seq < 'T> →'T	함수 결과에 대해 Operators.min을 사용하여 비교하여 시퀀스의 모든 요소 중 가장 낮은 값을 반환합니다.
nth : int → seq < 'T> →'T	컬렉션 의 n 번째 요소를 계산합니다 .
ofArray : 'T 배열 → seq <'T>	주어진 배열을 시퀀스로 봅니다.
ofList : 'T리스트 → seq <'T>	주어진 목록을 시퀀스로 봅니다.
쌍으로 : seq < 'T> → seq <'T * 'T>	두 번째 요소의 선행 요소로만 반환되는 첫 번째 요소를 제외하고 입력 시퀀스 및 해당 선행 요소의 각 요소 시퀀스를 반환합니다.
선택 : ( 'T →'U 옵션) → seq < 'T> →'U	주어진 함수를 연속 요소에 적용하여 함수가 a를 반환하는 첫 번째 값을 반환합니다. Some 값.
읽기 전용 : seq < 'T> → seq <'T>	지정된 시퀀스 개체에 위임하는 새 시퀀스 개체를 만듭니다. 이렇게하면 원본 시퀀스가 유형 캐스트에 의해 재발견 및 변형 될 수 없습니다. 예를 들어, 배열이 주어지면 반환 된 시퀀스는 배열의 요소를 반환하지만 반환 된 시퀀스 객체를 배열로 캐스팅 할 수 없습니다.
감소 : ( 'T →'T → 'T) → seq <'T> → 'T	시퀀스의 각 요소에 함수를 적용하여 계산을 통해 누산기 인수를 스레딩합니다. 처음 두 요소에 함수를 적용하여 시작하십시오. 그런 다음이 결과를 세 번째 요소와 함께 함수에 입력합니다. 최종 결과를 반환합니다.
스캔 : ( 'State →'T → 'State) →'State → seq < 'T> → seq <'State>	Seq.fold와 비슷하지만 요청시 계산하고 중간 및 최종 결과의 순서를 반환합니다.
싱글 톤 : 'T → seq <'T>	하나의 항목 만 생성하는 시퀀스를 반환합니다.
스킵 : int → seq < 'T> → seq <'T>	기본 시퀀스의 지정된 요소 수를 건너 뛰고 시퀀스의 나머지 요소를 생성하는 시퀀스를 반환합니다.
skipWhile : ( 'T → bool) → seq <'T> → seq < 'T>	반복 될 때 주어진 술어가 리턴하는 동안 기본 시퀀스의 요소를 건너 뛰는 시퀀스를 리턴합니다. true, 그런 다음 시퀀스의 나머지 요소를 생성합니다.
정렬 : seq < 'T> → seq <'T>	키로 정렬 된 시퀀스를 생성합니다.
sortBy : ( 'T →'키) → seq < 'T> → seq <'T>	시퀀스의 각 요소에 키 생성 기능을 적용하고 키로 정렬 된 시퀀스를 생성합니다. Operators.compare에서 구현 한 일반 비교를 사용하여 키를 비교합니다.
합계 : seq <^ T> → ^ T	시퀀스에있는 요소의 합계를 반환합니다.
sumBy	시퀀스의 각 요소에 함수를 적용하여 생성 된 결과의 합계를 반환합니다.
take : int → seq < 'T> → seq <'T>	시퀀스의 첫 번째 요소를 지정된 개수까지 반환합니다.
takeWhile : ( 'T → bool) → seq <'T> → seq < 'T>	반복 될 때 주어진 술어가 리턴하는 동안 기본 시퀀스의 요소를 생성하는 시퀀스를 리턴합니다. true, 그런 다음 더 이상 요소를 반환하지 않습니다.
toArray : seq < 'T> →'T []	지정된 컬렉션에서 배열을 만듭니다.
toList : seq < 'T> →'T리스트	주어진 컬렉션에서 목록을 만듭니다.
자르기 : int → seq < 'T> → seq <'T>	열거 될 때 지정된 수의 요소 만 반환하는 시퀀스를 반환합니다.
tryFind : ( 'T → bool) → seq <'T> → 'T 옵션	주어진 함수가 반환하는 첫 번째 요소를 반환합니다. true, 또는 None 그러한 요소가 존재하지 않는 경우.
tryFindIndex : ( 'T → bool) → seq <'T> → int 옵션	시퀀스에서 주어진 술어를 만족하는 첫 번째 요소의 인덱스를 반환합니다. None 그러한 요소가 존재하지 않는 경우.
tryPick : ( 'T →'U 옵션) → seq < 'T> →'U 옵션	주어진 함수를 연속 요소에 적용하여 함수가 a를 반환하는 첫 번째 값을 반환합니다. Some 값.
펼치기 : ( 'State →'T * 'State 옵션) →'State → seq < 'T>	주어진 계산에 의해 생성 된 요소를 포함하는 시퀀스를 반환합니다.
여기서 : ( 'T → bool) → seq <'T> → seq < 'T>	주어진 술어가 리턴하는 콜렉션의 요소 만 포함하는 새 콜렉션을 리턴합니다. true. Seq.filter의 동의어입니다.
창 : int → seq < 'T> → seq <'T []>	입력 시퀀스에서 가져온 요소를 포함하는 슬라이딩 윈도우를 생성하는 시퀀스를 반환합니다. 각 창은 새로운 배열로 반환됩니다.
zip : seq < 'T1> → seq <'T2> → seq < 'T1 *'T2>	두 시퀀스를 쌍 목록으로 결합합니다. 두 시퀀스의 길이가 같을 필요는 없습니다. 하나의 시퀀스가 소진되면 다른 시퀀스의 나머지 요소는 무시됩니다.
zip3 : seq < 'T1> → seq <'T2> → seq < 'T3> → seq <'T1 * 'T2 *'T3>	세 시퀀스를 트리플 목록으로 결합합니다. 시퀀스의 길이가 같을 필요는 없습니다. 하나의 시퀀스가 소진되면 다른 시퀀스의 나머지 요소는 무시됩니다.

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

예 1

이 프로그램은 빈 시퀀스를 생성하고 나중에 채 웁니다.

(* Creating sequences *)
let emptySeq = Seq.empty
let seq1 = Seq.singleton 20

printfn"The singleton sequence:"
printfn "%A " seq1
printfn"The init sequence:"

let seq2 = Seq.init 5 (fun n -> n * 3)
Seq.iter (fun i -> printf "%d " i) seq2
printfn""

(* converting an array to sequence by using cast *)
printfn"The array sequence 1:"
let seq3 = [| 1 .. 10 |] :> seq<int>
Seq.iter (fun i -> printf "%d " i) seq3
printfn""

(* converting an array to sequence by using Seq.ofArray *)
printfn"The array sequence 2:"
let seq4 = [| 2..2.. 20 |] |> Seq.ofArray
Seq.iter (fun i -> printf "%d " i) seq4
printfn""

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

The singleton sequence:
seq [20]
The init sequence:
0 3 6 9 12
The array sequence 1:
1 2 3 4 5 6 7 8 9 10
The array sequence 2:
2 4 6 8 10 12 14 16 18 20

유의하십시오-

Seq.empty 메서드는 빈 시퀀스를 만듭니다.
Seq.singleton 메서드는 지정된 요소 하나의 시퀀스를 만듭니다.
Seq.init 메서드는 주어진 함수를 사용하여 요소가 생성되는 시퀀스를 생성합니다.
Seq.ofArray 및 Seq.ofList < 'T> 메서드는 배열과 목록에서 시퀀스를 만듭니다.
Seq.iter 메서드를 사용하면 시퀀스를 반복 할 수 있습니다.

예 2

Seq.unfold 메서드는 상태를 가져 와서 시퀀스의 각 후속 요소를 생성하도록 변환하는 계산 함수에서 시퀀스를 생성합니다.

다음 함수는 처음 20 개의 자연수를 생성합니다.

let seq1 = Seq.unfold (fun state -> if (state > 20) then None else Some(state, state + 1)) 0
printfn "The sequence seq1 contains numbers from 0 to 20."
for x in seq1 do printf "%d " x
printfn" "

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

The sequence seq1 contains numbers from 0 to 20.
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

예제 3

Seq.truncate 메서드는 다른 시퀀스에서 시퀀스를 생성하지만 시퀀스를 지정된 요소 수로 제한합니다.

Seq.take 메서드는 시퀀스 시작부터 지정된 수의 요소를 포함하는 새 시퀀스를 만듭니다.

let mySeq = seq { for i in 1 .. 10 -> 3*i }
let truncatedSeq = Seq.truncate 5 mySeq
let takeSeq = Seq.take 5 mySeq

printfn"The original sequence"
Seq.iter (fun i -> printf "%d " i) mySeq
printfn""

printfn"The truncated sequence"
Seq.iter (fun i -> printf "%d " i) truncatedSeq
printfn""

printfn"The take sequence"
Seq.iter (fun i -> printf "%d " i) takeSeq
printfn""

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

The original sequence
3 6 9 12 15 18 21 24 27 30
The truncated sequence
3 6 9 12 15
The take sequence
3 6 9 12 15