[OCaml] Alternate,

by

(OCaml) Alternate, Fib, Count changes, Map, Filter, Drop while, Fold left, Fold right

이것은 3일차의 OCaml 요약입니다.

무슨 요일인지는 중요하지 않지만, 습관을 들여야 하기 때문에 여전히 날짜를 세고 있습니다.

가능하면 이론을 빠르게 정리하고, 이를 바탕으로 프로그래밍을 더 실습하는 과정이 필연적으로 따라야 한다.

이론을 정리하는 데 너무 많은 시간을 소비하지 말고 최대한 속도를 높이자. 이해가 되지 않는 부분이 있으면 반복해서 읽을 수밖에 없습니다.

교환

let rec alternate1 l =
match l with
| () -> ()
| (x) -> (x)
| x1::x2::xs -> x1 :: alternate1 xs
  1. 목록 l을 매개변수로 사용하는 재귀 함수 alternate1을 정의합니다.

  1. 이 목록의 구조 분석 l.
    1. l의 구조가 빈 목록이면 → 빈 목록을 반환합니다.

    1. l의 구조가 단일 요소 목록인 경우 → 단일 요소 목록을 반환합니다.

    1. l의 구조가 단일 요소 x1::x2와 목록의 나머지로 구성된 경우 → 목록의 맨 위에 x1을 놓고 alternate1을 다시 호출합니다.

      매개변수는 xs로 수신됩니다.

      1. x2를 건너뛰고 그 이후에만 연결합니다.

      1. 즉, 홀수 요소만 추가하는 역할을 합니다.

    1. 목록의 항목 수가 홀수이면 마지막 항목이 포함되지 않습니다.

      예를 들어 항목 수가 홀수인 목록이 있는 경우 (1, 2, 3)은 alternate1 함수 (1, 3)을 적용한 결과입니다.

let rec alternate2 =
function
| x1::x2::xs -> x1 :: alternate2 xs
| l -> l
  1. 함수(익명 함수)로 정의된 재귀 함수의 대안2를 정의합니다.

    1. 즉, 이 익명 함수에는 매개변수 선언 부분과 일치 부분이 포함되어 있습니다.

  1. 이 alternative2 함수에 전달된 매개변수의 구조는 다음 규칙에 따라 구문 분석되어 반환됩니다.

    1. 어떤 것의 구조는 매개변수로 주어진다
      1. x1::x2::x2인 경우 → x1을 추가하고 또는 2 xs를 추가합니다.

        즉, 홀수 번호 요소만 연결됩니다.

      1. 단일 목록인 경우 → 목록을 그대로 반환합니다.

    1. 목록의 요소 수가 홀수이면 마지막 요소가 변경되지 않고 반환됩니다.

      따라서 (1, 2, 3)과 같이 요소 수가 홀수인 목록이 있는 경우 “alternate2” 함수를 적용한 결과는 (1, 3)입니다.

let rec alternate3 l =
match l with
| () | (_) -> l
| x1::x2::xs -> x1 :: alternate3 xs
  1. 목록 l을 매개변수로 사용하는 재귀 함수의 alternative3을 정의합니다.

  1. l 매개 변수의 구조를 구문 분석하고 해당 값을 반환합니다.

    1. l이 빈 목록이거나 단일 요소 목록인 경우 값에 관계없이 l이 있는 그대로 반환됩니다.

    1. l에 x1::x2::xs 구조가 있으면 x1과 xs가 연결됩니다.

    1. 입력 목록의 항목 개수가 0 또는 1이면 그대로 반환됩니다.

      그렇지 않으면 목록의 처음 두 요소를 가져와 새 목록의 시작 부분에 놓고 재귀적으로 “alternate3″을 호출합니다.

      목록의 나머지 부분에 대해 기능을 수행하여 새 목록을 만듭니다.

      의 나머지 요소를 추가합니다.

      따라서 alternate3 함수는 요소 수가 홀수여도 마지막 요소를 제외하지 않고 입력 목록의 요소 수가 0 또는 1인 경우에도 적절하게 처리합니다.

악의 없는 거짓말

let rec fib n =
if n = 0 then 0
else if n = 1 then 1
else
fib (n - 1) + fib (n - 2)
  1. n을 매개변수로 사용하는 재귀 함수를 정의합니다.

  1. n = 0이면 0 반환
    1. n ≠ 0이면 fib(n – 1)의 결과와 fib(n – 2)의 결과가 더해집니다.

    1. 즉, fib는 재귀적으로 계산됩니다.

  1. 그러나 이 함수는 계산을 재귀적으로 수행하기 때문에 “n”이 클 때 많은 계산 시간과 메모리를 차지할 수 있습니다.

    이를 개선하기 위해 메모이제이션과 같은 기술을 사용할 수 있습니다.

let fib2 n =
	let rec fib' i a b =
		if i = n then a
		else
		fib' (i + 1) b (a + b)
	in
fib' 0 0 1
  1. n을 매개변수로 취하는 함수 fib2를 정의합니다.

  1. 이 fib2 함수 내에서만 사용할 수 있는 새 함수 fib’를 정의합니다.

    1. 이 fib’ 함수는 i, a, b를 매개변수로 받습니다.

      1. i = n이면 a를 반환합니다.

      1. 그렇지 않으면 fib (i +1) b (a + b)의 결과가 반환됩니다.

  1. 함수를 정의한 후 첫 번째 fib’ 0 0 1, in 이후의 호출 코드가 호출됩니다.

    1. i=0, a=0, b=1이 들어오고,
      1. 여기서 i와 n의 값을 비교하십시오.
      1. n이 5이면 i ≠ n이므로 fib’ (0 + 1) 1 1이라고 합니다.

      1. n과 i가 다르기 때문에 fib’ 2 1 2 → fib’ 3 1 3 → fib’ 4 1 4 → fib’ 5 1 5라고 합니다.

      1. 이제 i = n이므로 a의 값인 1을 반환합니다.

변경 횟수

(* count_changes 100 (25; 10; 5) *)
let rec count_changes amt denoms =
	if amt < 0 then 0
	else if amt = 0 then 1
	else (
		match denoms with
			| () -> 0
			| d::ds ->
			count_changes (amt - d) denoms +  ( use d )
			count_changes amt ds              ( don't use d )
	)

위의 함수는 주어진 동전(denoms)을 사용하여 주어진 금액(amt)을 만드는 방법의 수를 계산합니다.

이 함수는 재귀적으로 정의되며 주어진 금액과 동전 목록을 매개변수로 사용합니다.

함수 내에서 금액이 음수이면 먼저 0을 반환하고 금액이 0이면 1을 반환합니다.

이는 코인 합계를 계산할 때 0이 당첨되는 경우가 많다는 것을 의미합니다.

'추천 관련글,

그리고 나머지 경우는 다음과 같이 처리한다.

우선 코인 목록이 비어 있으면 0을 반환합니다.

이 경우 코인이 없기 때문에 금액을 생성할 수 없습니다.

그리고 코인 목록이 비어 있지 않으면 목록의 첫 번째 코인이 별도로 사용되고 처리됩니다.

이를 위해 match 문이 사용되며 목록의 첫 번째 동전을 “d”라고 합니다.

코인 “d”가 사용되면 count_changes 함수를 재귀적으로 호출하여 “amt” 금액에서 “d”를 뺀 나머지 금액을 생성합니다.

이 시점에서 코인 목록이 유지되고 사용된 코인 “d”가 결과에 추가됩니다.

코인 “d”가 사용되지 않는 경우 “amt” 금액은 그대로 유지하고 코인 목록에서 “d”를 제외한 나머지 목록을 재귀적으로 처리합니다.

이를 통해 특정 금액을 벌기 위해 동전을 사용할 수 있는 모든 방법을 계산할 수 있습니다.

함수 실행 순서는 다음과 같습니다.

  1. count_changes 함수에 매개변수로 주어진 금액과 코인 목록 액면가를 전달합니다.

  1. amt 금액이 0보다 작으면 0을 반환합니다.

  1. 금액 amt가 0이면 1이 반환됩니다.

  1. 코인 목록 액면가가 비어 있으면 0을 반환합니다.

  1. 코인 목록 액면가가 비어 있지 않으면 목록 상단의 코인을 별도로 사용하여 처리합니다.

  1. 코인 “d”가 사용되면 count_changes 함수를 재귀적으로 호출하여 “amt” 금액에서 “d”를 뺀 나머지 금액을 생성합니다.

    이 시점에서 코인 목록이 유지되고 사용된 코인 “d”가 결과에 추가됩니다.

  1. 코인 “d”가 사용되지 않는 경우 “amt” 금액은 그대로 유지하고 코인 목록에서 “d”를 제외한 나머지 목록을 재귀적으로 처리합니다.

  1. 이를 통해 특정 금액을 벌기 위해 동전을 사용할 수 있는 모든 방법을 계산할 수 있습니다.

“(d를 사용)”은 코인 “d”를 사용하는 경우의 계산식을 의미하는 것이 아니라 이 코인으로 벌 수 있는 돈 경우의 수를 세는 함수를 호출해야 한다는 의미입니다.

이 함수는 count_changes 함수와 동일하며 금액은 “amt – d”로 계산됩니다.

즉, “(use d)”는 실제로 함수 호출 표현식 “count_changes (amt – d) denoms”와 동일합니다.

이 함수는 재귀적으로 호출되며 동전 “d”가 지정된 금액을 “amt”하는 데 사용될 수 있는 횟수를 반환합니다.

“use”는 OCaml 언어에서 사용되지 않는 예약어입니다.

따라서 위의 “use” 키워드를 사용하는 것은 실제로 함수 이름을 의미한다고 가정합니다.

따라서 “(use d)”가 실제로 함수 이름 “count_changes(amt – d)denoms”를 호출한다고 생각할 수 있습니다.

이 함수는 주어진 금액 “amt – d”와 동전 목록 “denoms”를 매개변수로 사용하고 해당 금액을 생성할 수 있는 가능한 방법의 수를 계산합니다.

이 함수가 반환하는 값은 count_changes 함수에서 동전 “d”로 만들 수 있는 현금 상자의 수입니다.

지도

(* some higher order functions
-- most of these are already in the List module
*)
let rec map f l =
match l with
| () -> ()
| x::xs -> f x :: map f xs

  1. 함수 f와 목록 l을 매개 변수로 사용하는 map이라는 재귀 함수를 정의합니다.

  1. 여기에서 목록 1의 구조가 분석되고 각 경우에 대한 값이 반환됩니다.

    1. 목록이 빈 목록이면 → 빈 목록을 그대로 반환합니다.

    1. 목록이 x::xs인 경우 → 첫 번째 요소인 x를 함수 f의 매개변수로 설정합니다.

      1. 그리고 나머지 xs는 함수 f의 매개변수로 하나씩 설정되어 추가됩니다.

아래와 같이 목록과 함수가 주어졌다고 가정합니다.

let lst = (1; 2; 3)
let f x = x * 2

그런 다음 함수 “map f lst”는 다음과 같이 계산됩니다.

  1. 일치 (1; 2; 3)
    • x = 1, xs = (2; 3)
    • f1 = 1 * 2 = 2
  1. f 1 :: 매핑 f(2; 3)
  1. 2 :: ((2; 3)과 일치 – x = 2, xs = (3) – f 2 = 2 * 2 = 4 :: 맵 f(3))
  1. 2 :: (4 :: ((3) 일치 – x = 3, xs = () – f 3 = 3 * 2 = 6 :: 맵 f()))
  1. 2::(4::(6::()))
  1. (2; 4; 6)

따라서 위의 예에서 map f lst는 (2; 4; 6)을 반환합니다.

고차 함수

함수형 프로그래밍에서 “고차 함수”는 다른 함수를 인수로 사용하거나 함수를 반환하는 함수입니다.

함수를 값으로 취급하고 결합하는 것이 함수형 프로그래밍의 핵심 아이디어 중 하나이기 때문에 고차 함수는 함수형 프로그래밍에서 중요한 개념 중 하나입니다.

예를 들어 “map” 함수는 다른 함수를 인수로 받아 목록의 각 요소에 적용하는 고차 함수입니다.

또한 “compose” 함수는 두 개의 함수를 인수로 받아 이 두 함수로 구성된 새로운 함수를 반환하는 고차 함수입니다.

다른 예로는 “Filter”, “Reduce” 및 “Fold”와 같은 기능이 있습니다.

이러한 고차 기능은 코드 재사용성과 가독성을 높이고 코드 일반성을 높입니다.

“지도” 함수는 목록의 각 요소에 “f” 함수를 적용하여 새 목록을 반환합니다.

이때 “map” 함수는 “f” 함수를 매개변수로 하여 각 요소에 “f” 함수를 적용하는 고차 함수이다.

이를 통해 아래와 같이 목록의 각 요소에 다른 기능을 할당할 수도 있습니다.

let add1 x = x + 1
let lst = (1; 2; 3)
let lst' = map add1 lst   (* lst'는 (2; 3; 4)가 됨 *)

위의 예에서 add1 함수는 정수를 매개변수로 받아 1을 더한 값을 반환하는 함수입니다.

map 함수로 list의 각 요소에 add1 함수를 적용하면 list “lst”의 각 요소에 1을 더한 list “lst'”를 반환한다.

이러한 고차 함수를 사용하면 서로 다른 함수를 결합하여 더 복잡한 동작을 구현할 수 있습니다.

필터

let rec filter f l =
match l with
| () -> ()
| x::xs when f x -> x :: filter f xs
| _::xs -> filter f xs
  1. 함수 f와 목록 l을 취하는 재귀 함수 필터를 정의합니다.

  1. 목록 1의 구조를 분석하고 일치하는 항목이 있으면 해당 값을 반환합니다.

    1. 목록이 빈 목록이면 빈 목록이 반환됩니다.

    1. 목록에 x::xs 구조가 있는 경우
      1. when fx 문에서 매개 변수 x를 함수 f에 삽입한 후 해당 값이 참인지 확인합니다.

        1. 필터 기능에서 참 또는 거짓을 결정하는 부분 when f x 부분. 여기서 fx는 인자로 받은 함수 f를 x에 적용하여 결과가 참인지 거짓인지 판단하는 부분이다.

          이때 fx가 참이면 참을 반환하므로 x in (x) @ filter f x의 부분이 결과 목록에 추가되고, fx가 거짓이면 거짓을 반환하고 x in (x) @ filter f가 반환된다.

          결과 목록에 추가된 x의 부분이 됩니다.

          결과 목록에 추가되지 않습니다.

      1. 목록 l의 첫 번째 요소 x를 나머지 부분 xs에서 분리한 후 조건 함수 f를 적용하고 fx의 결과가 참이면 x를 결과 목록에 추가하고 함수 f를 xs에 다시 적용하여 추가합니다.

    1. 그렇지 않으면 처리를 위해 필터 함수에 xs를 반환하는 재귀 구조를 갖습니다.

다음 filter 함수를 사용하여 목록에서 짝수만 추출하는 샘플 코드입니다.

let numbers = (1; 2; 3; 4; 5; 6; 7; 8; 9; 10)
let even_numbers = filter (fun x -> x mod 2 = 0) numbers

위의 코드에서 filter 함수의 첫 번째 인수로 fun x -> x mod 2 = 0이 함수는 입력이 짝수인지 여부를 확인하는 익명 함수가 있습니다.

true 또는 false 값을 반환하는 함수입니다.

filter 함수는 리스트 numbers의 각 요소에 첫 번째 인수로 전달된 함수를 적용하여 true 값을 반환하는 요소만 추출하는 새 목록입니다.

even_numbers따라서 생성 even_numbers의 값이다 (2; 4; 6; 8; 10)된다

if 명령

when은 match 문에서 패턴과 조건을 동시에 지정하는 데 사용되는 키워드입니다.

match 구문은 패턴 일치를 통해 값을 분리하고 분리된 값과 일치하는 패턴에 대해 분기할 수 있습니다.

이때 when 키워드를 사용하여 일치하는 값에 대한 추가 조건을 확인하여 해당 분기를 사용할지 여부를 결정할 수 있습니다.

예를 들어 다음과 같이 목록에서 짝수만 걸러내는 함수를 작성할 수 있습니다.

let filter_even l =
match l with
| () -> ()
| x::xs when x mod 2 = 0 -> x :: filter_even xs
| _::xs -> filter_even xs

여기 when 일치하는 키워드 목록의 첫 번째 요소 x2로 나누어지는 짝수이다.

x결과 목록에. 그렇지 않으면 _ 패턴과 일치하는 다음 요소를 검사하기 위해 재귀 호출을 수행합니다.

when 키워드는 패턴과 표현식 사이에 배치됩니다.

:: 연산자가 뒤에 오는 패턴과 함께 사용할 수 있습니다.

예를 들어 다음과 같이 패턴을 일치시킬 때 when 키워드로 :: 연산자를 함께 사용하여 일치하는 목록에서 특정 조건을 충족하는 요소만 추출할 수 있습니다.

let lst = (1;2;3;4;5)

let even_elems =
match lst with
| () -> ()
| hd :: tl when hd mod 2 = 0 -> hd :: even_elems tl
| _ :: tl -> even_elems tl

(* even_elems: int list = (2; 4) *)

위의 코드에서 even_elems 기능은 lst 목록에서 짝수 요소만 추출하여 반환합니다.

패턴 매칭의 첫 번째 분기는 빈 목록을 처리하고 두 번째 분기는 hd :: tl 패턴에 대한 추가 제약 검사를 수행합니다.

hd mod 2 = 0 조건식 true로 평가하는 경우 hd 재귀적으로 결과 목록에 항목 추가 tl 목록에 대해 동일한 프로세스를 반복합니다.

그렇지 않으면 다음 패턴 일치 분기로 이동합니다.

그러므로, when 패턴이 있는 키워드 :: 이는 연산자를 사용하여 목록을 처리하는 패턴 일치에 유용할 수 있습니다.

동안 가을

(* drop_while is not in the List module *)

let rec drop_while f l =
match l with
| () -> ()
| x::xs when f x -> drop_while f xs
| _ -> l

함수 f의 조건식을 만족하는 리스트를 최종 리스트에서 삭제하는 함수입니다.

  1. 함수 f와 목록 l을 매개변수로 사용하는 drop_while이라는 재귀 함수를 정의합니다.

  1. 목록 1의 구조를 구문 분석하고 일치하는 결과를 반환합니다.

    1. 빈 목록 → 빈 목록
    1. 구조체가 x::xs이면 f 함수에 x 매개변수를 넣고, 참이면 f 함수와 xs를 매개변수로 drop_while 함수에 넣습니다.

      1. 즉, 나머지 요소 xs도 참인지 확인하기 위해 함수 f로 대체됩니다.

      1. 이와 같이 함수 f가 참이면 이에 대응하는 모든 원소를 생략한다.

    1. 위의 구조가 해당되지 않는 경우 목록을 그대로 반환합니다.

아래에 예가 나와 있습니다.

let l = (1; 2; 3; 4; 5)
let l' = drop_while (fun x -> x < 3) l (* (3; 4; 5) *)

왼쪽으로 접기

(* think of this as processing a list from left to right *)
let rec fold_left f a l =
match l with
| () -> a
| x::xs -> fold_left f (f a x) xs

이 함수는 왼쪽부터 주어진 리스트를 순회하여 이전 누적 값과 현재 요소를 입력으로 받아 누적 값을 누적하고 마지막 요소까지 순회하여 최종 결과를 반환합니다.

여기 f두 개의 인수를 받아 값을 반환하는 함수입니다.

a누적되는 값을 의미합니다.

처음에 a함수에는 목록의 첫 번째 요소부터 순차적으로 초기 값이 할당됩니다.

f누적 적용됩니다.

예를 들어 다음과 같은 목록이 있는 경우:

let l = (1; 2; 3; 4; 5)

이 목록에 모든 항목을 추가하는 기능 sum두번째 fold_left로 쓸 수 있습니다

여기 fun acc x -> acc + x두 개의 인수를 받아 합계를 반환하는 익명 함수입니다.

0목록의 첫 번째 요소인 초기 값입니다.

1추가됩니다.

그리고 그 결과 1두 번째 항목입니다 2 이 방법으로 목록의 모든 요소를 ​​추가한 후의 최종 결과입니다.

15돌아왔다.

1. 목록의 합계를 계산하는 예:

let sum l = fold_left (+) 0 l

# sum (1; 2; 3; 4; 5);;
- : int = 15

위의 코드에서 +더하기 연산자입니다.

0초기 값입니다.

fold_left 함수를 사용하여 목록의 합계를 계산할 수 있습니다.

  1. 목록의 모든 문자열을 하나의 문자열로 연결하는 예:
let concat l = fold_left (^) "" l

# concat ("hello"; "world"; "!
");;
- : string = "helloworld!
"

위의 코드에서 ^문자열을 연결하는 연산자입니다.

""초기 값으로 빈 문자열을 의미합니다.

fold_left

함수를 사용하여 목록의 모든 문자열을 단일 문자열로 연결할 수 있습니다.

fold_left (fun a x -> x::a) () (3;2;7;6;8);; (* 리스트를 뒤집는다.

 *)
fold_left (fun a x -> x^a) "" ("hello"; "world")
fold_left (^) "" ("Hello";"world")
let flip f x y = f y x
fold_left (flip(^)) "" ("Hello";"world")

let ( -- ) = flip ( - ) 이렇게 선언하면  1 -- 2;; => int = 1 오른쪽에서 왼쪽을 뺀다.

오른쪽으로 접기

(* think of this as processing a list from right to left *)
let rec fold_right f l a =
match l with
| () -> a
| x::xs -> f x (fold_right f xs a)

fold_left그리고 fold_right 함수는 목록의 모든 요소에 연산을 적용하고 단일 값으로 결합하는 기능을 제공하는 함수입니다.

이 두 함수의 공통점은 목록을 반복하고 작업을 수행하여 단일 결과를 얻는다는 것입니다.

그러나 두 기능은 작업을 수행하는 방식이 다릅니다.

fold_left 이 함수는 목록의 왼쪽 끝에서 시작하여 순차적으로 요소를 통해 작동합니다.

작업 순서는 다음과 같습니다.

fold_left f a (b1; b2; b3; ...; bn) = f (... (f (f (f a b1) b2) b3) ...) bn

즉, 초기값 a목록의 첫 번째 요소 b1작업 결과 다음 요소 b2, b3… , bn까지 연산을 순차적으로 적용하는 방식입니다.

예를 들어, fold_left (+) 0 (1; 2; 3)은 ((0 + 1) + 2) + 3다음과 같이 계산됩니다.

반면에 fold_right 이 함수는 목록의 오른쪽 끝에서 시작하여 순차적으로 요소를 통해 작동합니다.

작업 순서는 다음과 같습니다.

fold_right f (b1; b2; b3; ...; bn) a = f b1 (f b2 (f b3 (... (f bn a) ...)))

즉, 초기값 a그리고 목록의 마지막 요소 bn연산 결과 후, 그 앞의 요소 bn-1, bn-2… , b1까지 연산을 순차적으로 적용하는 방식입니다.

예를 들어, fold_right (+) (1; 2; 3) 0은 1 + (2 + (3 + 0))다음과 같이 계산됩니다.

이 두 작업이 수행되는 순서가 역순이므로 결과가 다르게 계산됩니다.

또한 fold_left 함수는 일반적으로 성능상의 이점이 있는 스택 오버플로 오류를 피하기 위해 꼬리 재귀적으로 구현됩니다.

아래는 두 기능의 차이점을 보여주는 예입니다.

(* fold_left 예시 *)
let lst = (1; 2; 3; 4; 5)
let result_left = fold_left (fun acc x -> x - acc) 0 lst
(* 결과: -15 *)

(* fold_right 예시 *)
let lst = (1; 2; 3; 4; 5)
let result_right = fold_right (fun x acc -> x - acc) lst 0
(* 결과: 3 *)

위의 예에서 fold_left는 (((((0 – 1) – 2) – 3) – 4) – 5) = -15가 되고 fold_right는 (1 – (2 – (3 – (4 – (5 – 5)가 됩니다.

– 0)) .))))) = 3.

명령으로

as 키워드는 특정 모듈, 네임스페이스 또는 유형에 대한 별칭을 만드는 데 사용됩니다.

별칭은 긴 모듈 또는 유형 이름을 짧은 이름으로 대체하여 코드를 더 읽기 쉽게 만듭니다.

as 키워드 구문은 다음과 같습니다.

open SomeModule as M
type someType = SomeModule.someType as t

위의 샘플 코드에서 첫 번째 줄은 M을 SomeModule 모듈의 별칭으로 사용합니다.

이제 M을 사용하여 SomeModule의 내용에 액세스할 수 있습니다.

두 번째 줄은 SomeModule 모듈의 someType 유형을 별칭 t로 사용합니다.

이제 t를 사용하여 SomeModule.someType 유형을 참조할 수 있습니다.

as 키워드는 모듈을 가져오는 open 문과 모듈 내에서 유형을 선언하는 type 문 모두에서 사용할 수 있습니다.

x::xs as l -> l (* x::xs의 이름을 l로 정한다.

 as *)

다음은 as 키워드를 사용하는 예제 코드입니다.

open System
open System.IO as IO
let file = IO.File.OpenRead("filename.txt")

위의 코드에서 System.IO.File 대신 IO.File을 사용하여 파일을 열 수 있습니다.

as 키워드를 사용하지 않으면 System.IO.File을 매번 작성해야 하므로 코드가 길어지고 가독성이 떨어질 수 있습니다.

$ : 이진 연산자

이항 연산자 $는 함수 적용 연산자입니다.

이 연산자는 함수를 왼쪽 피연산자로, 인수를 오른쪽 피연산자로 받아 함수를 적용합니다.

함수 적용 연산자 $는 다음과 같이 정의됩니다.

let ($) f x = f x

$ 연산자는 함수 적용의 우선 순위를 낮추는 데 사용됩니다.

함수 적용은 일반적으로 가장 높은 우선순위를 가지므로 복잡한 표현식을 읽기 어렵게 만들 수 있습니다.

$ 연산자를 사용하면 괄호를 사용하지 않고 함수 적용 순서를 명시적으로 지정할 수 있으므로 코드를 더 읽기 쉽게 만들 수 있습니다.

다음은 $ 연산자를 사용하는 예입니다.

let f x = x + 1
let g x = x * 2
let h x = x |> f |> g   (* equivalent to: g (f x) *)
let h' x = x |> f $ g   (* equivalent to: g (f x) *)

위의 코드에서 |> 연산자는 왼쪽 피연산자의 값을 오른쪽 피연산자의 인수인 함수로 전달하는 파이프라인 연산자입니다.

$ 연산자는 |> 연산자와 같은 역할을 합니다.

그래서 위의 예에서 h그리고 h' 모든 기능 f그리고 g 함수를 순서대로 적용한 결과를 반환합니다.

하지만 h' 기능은 $ 함수 적용의 우선순위를 낮추는 연산자, h 결과적으로 함수보다 더 읽기 쉬운 코드가 됩니다.

두 연산자는 유사하지만 다르게 작동합니다.

|> 연산자는 함수를 첫 번째 인수로 사용하고 두 번째 인수로 전달된 값을 해당 함수에 적용합니다.

대조적으로 $ 연산자는 함수와 인수를 모두 취하여 인수를 함수에 적용하기 전에 괄호로 묶인 부분을 평가한 다음 그 결과를 함수에 적용합니다.

다시 말해서, |>함수 체인을 생성하여 읽을 수 있는 코드를 작성하는 데 유용합니다.

$계산 순서를 명확하게 표시해야 할 때 유용합니다.

fold_left ($) a (b; c; d)

=> ((a $ b) $ c) $d)

(3;2;7;6;8) |>
List.filter (fun x -> x mod 2 =0) |>
List.map (fun x -> x * x) |>
List.fold_left (+) 0

기기 종류

모든 함수에는 반환 값이 있어야 합니다.

반환 값이 없으면 ()는 “unit”이라는 값을 반환합니다.

unitOCaml 프로그래밍 언어의 유형 중 하나이며, ()로 표시 unit 유형이 고유합니다.

()만 가질 수 있습니다 unit 값을 반환하는 함수를 “부작용” 함수라고 합니다.

일반적으로 부작용 함수는 값을 계산하고 반환하는 것이 아니라 외부 효과를 내기 위한 것입니다.

예를 들어 화면에 메시지를 출력하는 함수는 값 자체를 반환하는 것이 아니라 프로그램의 상태를 변경하여 콘솔에 출력합니다.

그런 기능 unit부작용을 일으키는 것으로 생각됨.

또한 unit 유형은 다른 유형과 조합하여 값을 나타내는 데에도 사용됩니다.

예를 들어, int -> unit 유형의 함수 int 유형의 입력 값을 허용합니다.

unit 값을 반환합니다.

이와 같은 함수는 대부분 부작용 함수로 사용되며 무언가를 수행하는 데 사용될 수 있습니다.

즉, 반환 값이 없는 특정 작업만 실행된다는 의미입니다.

  1. 교환
  1. 악의 없는 거짓말
  1. 변경 횟수
  1. 지도
  1. 필터
  1. 동안 가을
  1. 왼쪽으로 접기
  1. 오른쪽으로 접기