F 샤프

1. 개요

F#은 강력한 형식의 함수형 프로그래밍 언어로, 마이크로소프트에서 개발되었다. 다양한 버전으로 출시되었으며, 2005년에 처음 등장하여 .NET 프레임워크를 지원해왔다. F#은 함수형, 명령형, 객체 지향 프로그래밍을 지원하며, 람다 함수, 클로저, 패턴 매칭, 대수적 데이터 형식, 튜플, 리스트 컴프리헨션, 모나드 패턴 등 다양한 기능을 제공한다. 또한, 단위 측정, 메타프로그래밍, 에이전트 프로그래밍을 지원하며, 웹, 크로스 플랫폼 앱, 분석 프로그래밍, 스크립팅 등 다양한 분야에서 활용된다. F#은 OCaml과 호환되며, 오픈 소스 커뮤니티를 통해 지속적으로 발전하고 있다.

2. 역사

마이크로소프트 리서치(Microsoft Research)의 Don Syme^영어 등이 2002년부터 OCaml을 기반으로 F# 개발을 시작했다. F#의 F는 함수형 프로그래밍 언어(Functional programming language) 및 System F에서 유래했다. 앤드류 케네디(Andrew Kennedy)는 단위 측정 설계에 기여했다.

F#은 OCaml에서 많은 요소를 물려받은 함수형 및 객체 지향의 멀티 패러다임이다. 형 안전하며 형 추론 기능을 가진다. 하지만 오버로딩을 지원하기 때문에 OCaml이 가진 형 추론의 완전성을 잃었다. C# 및 Visual Basic .NET 등 .NET 언어와 상호 운용성이 있으며, .NET 클래스 라이브러리의 이용 및 개발이 가능하다. Mono 및 Xamarin을 이용한 Android 애플리케이션 개발도 지원된다. 이전에는 실버라이트를 이용한 Windows Phone 7 애플리케이션 개발도 지원되었다.

F#의 개발 환경은 Visual Studio의 유료 버전 제품 (또는 무료 Community 에디션)에 Visual F#으로 포함되어 있으며, Express 에디션에서 사용할 수 있는 무료 도구 배포도 이루어지고 있다. Visual F# Tools 4.1에서 Roslyn (compiler)^영어를 지원하게 되었다. 또한, Mono 및 .NET Core 환경용으로 F# 컴파일러가 이식되었기 때문에, macOS나 리눅스 등에서도 F# 프로그램의 개발 및 실행이 가능하다.

OCaml 호환 표준 라이브러리를 갖추고 있으며, F#과 OCaml 모두에서 컴파일할 수 있는 코드를 작성하는 것도 가능하다. 그러나 클래스 구문 등은 F#과 OCaml에서 다르다.

2.1. 버전

2.2. 언어 발전

F#는 개방형 개발 및 엔지니어링 프로세스를 사용한다. 언어 진화 과정은 F# 소프트웨어 재단과 함께 언어 설계를 위한 생각하는 독재자(BDFL)인 돈 심(Don Syme)이 마이크로소프트 리서치(Microsoft Research)에서 관리한다. 과거 F# 언어 버전은 마이크로소프트(Microsoft)와 마이크로소프트 리서치(Microsoft Research)에서 폐쇄형 개발 프로세스를 사용하여 설계했다.

F#는 2010 에디션에 Visual Basic (.NET) 및 C#과 동일한 수준(옵션)으로 처음 포함되었으며, 이후 모든 에디션에 남아 있어 언어의 광범위한 사용과 지원이 이루어지고 있다.

F#는 영국 케임브리지에 있는 마이크로소프트 리서치에서 시작되었다. 이 언어는 원래 돈 심에 의해 설계 및 구현되었으며, F# 팀에서는 F가 "Fun"(재미)을 의미한다고 한다. 앤드류 케네디(Andrew Kennedy)는 단위 측정 설계에 기여했다. Visual Studio용 Visual F# 도구는 마이크로소프트에서 개발했다. F# 소프트웨어 재단은 마이크로소프트 Visual F# 도구 팀에서 제공하는 오픈 소스 컴파일러 구현을 통합하여 F# 오픈 소스 컴파일러 및 도구를 개발했다.

3. 문법

F#은 OCaml을 계승한 언어로, OCaml과 호환되는 장황 구문 (verbose syntax^영어)과 파이썬과 같은 오프사이드 규칙을 사용한 경량 구문 (lightweight syntax^영어)의 두 종류 구문을 사용할 수 있다. 표준 설정에서는 경량 구문이 활성화되어 있다. F#은 타입을 자동으로 유추하는 강력한 형식 지정 언어이다.

3.1. F# 함수의 형태

함수형 프로그래밍의 "Hello World"라고 할 만한 것은 팩토리얼을 계산하는 코드이다. F#으로는 다음과 같이 표현할 수 있다.


let rec fact n =
match n with
| 0 -> 1
| _ -> n * fact (n-1);;


이 코드는 팩토리얼을 재귀 함수로 정의한 것이다. 일반적으로 함수를 정의할 때는 `let`을 쓰고, 재귀함수를 정의할 때는 `let rec`와 같이 명시한다. 함수의 마지막에는 두 개의 세미콜론으로 끝마침을 해 준다.

위 함수 정의는 수학 교과서에서 볼 수 있는 팩토리얼의 정의와 비슷하다. F# 코드는 문법과 계산 방식의 측면에서 수학적 언어와 닮았다.

F#은 자동으로 타입을 유추한다. 위의 `fact` 함수는 `(int -> int)` 타입, 즉 정수를 인자로 받아 또 다른 정수를 반환하는 함수이다.

두 번째 줄에서 F#의 또 다른 중요한 특성인 패턴 매칭을 볼 수 있다. 패턴 매칭은 `match ... with ...`와 같이 표현한다. 함수 `fact`는 인자가 0이면 1을 반환하고, 아니면 두 번째 케이스를 실행하여 0에 도달할 때까지 `fact`을 재귀적으로 계속 호출한다. 패턴 매칭에서 `_`는 디폴트 케이스를 의미한다.

3.2. 개선된 팩토리얼 함수

fsharp
#light

let factorial n =
let rec fac a x =
match x with
| k when k < 1 -> 1I
| k when k = 1 -> a
| v -> fac (a * (bigint x)) (x - 1)
fac 1I n
```

팩토리얼 함수는 지수 함수보다 훨씬 빠르게 커지므로 큰 정수 계산이 가능해야 하고, 재귀 호출 함수의 성능도 고려해야 한다. 큰 정수의 곱셈 계산을 위해 팩토리얼 값은 `bigint` 타입을 사용하고, 함수의 인자는 `int` 타입을 사용한다. `bigint` 타입 리터럴은 `int` 타입 리터럴 끝에 `I`를 붙여 표현한다. (예: `4`는 `int` 타입, `4I`는 `bigint` 타입). `int` 타입을 `bigint` 타입으로 변환하려면 `bigint x`와 같이 표현식 왼쪽에 `bigint`를 붙인다.

위의 `factorial` 함수는 `(int -> bigint)` 타입의 함수이다. 함수 안에서 재귀 호출 함수 `fac`을 정의하는 중첩 구조로 되어 있다. `fac` 함수의 첫 번째 인자 `a`는 재귀 호출 과정에서 계산된 이전 단계의 팩토리얼 값을 저장하는 상태 역할을 한다.

예를 들어 4! 계산 과정은 다음과 같다.

* fac 1I 4
* => fac (4I) 3
* => fac (12I) 2
* => fac (24I) 1
* => 24I

이 코드는 5000!을 계산할 때도 스택 오버플로우를 걱정할 필요가 없다. F# 언어는 패턴 매칭(match)에 의한 재귀 호출이 상태에 의한 호출이기 때문이다. 이러한 재귀 호출을 꼬리 재귀 호출이라고 한다.

4. 언어 개요

F#은 함수형 프로그래밍과 객체 지향 프로그래밍을 모두 지원하는 함수 우선 언어이다. C#에서 사용할 수 있는 객체 지향 기능을 지원하면서, 함수형 프로그래밍 언어에서 일반적으로 발견되는 많은 기능을 갖춘 강력한 형식 지정 언어이다. 이러한 기능을 통해 F# 프로그램은 완전한 함수형 스타일로 작성될 수 있으며, 함수형 스타일과 객체 지향 스타일을 혼합하여 사용할 수도 있다.

2002년부터 마이크로소프트 리서치(Microsoft Research)의 Don Syme<sup>영어</sup> 등이 OCaml을 기반으로 개발을 시작했다. OCaml에서 많은 요소를 물려받은 함수형 및 객체 지향의 멀티 패러다임 프로그래밍 언어이다. 형 안전성을 가지며, 형 추론 기능을 갖추고 있다. 하지만 오버로딩을 지원하기 때문에 OCaml이 가진 형 추론의 완전성은 잃었다.

C# 및 Visual Basic .NET 등 .NET 언어와 상호 운용성이 있으며, .NET 클래스 라이브러리의 이용 및 개발이 가능하다. Mono 및 Xamarin을 이용한 Android 애플리케이션 개발도 지원된다. F#의 F는 Functional programming language(함수형 프로그래밍 언어) 및 System F에서 유래했다.

4.1. 함수형 프로그래밍

F#은 객체 지향 프로그래밍 기능을 지원하는 동시에, 함수형 프로그래밍에서 주로 사용되는 여러 기능을 갖춘 강력한 형식 지정 언어이다. F# 프로그램을 완전한 함수형 스타일로 작성하거나, 함수형 스타일과 객체 지향 스타일을 혼합하여 사용할 수 있다.

F#에서 지원하는 함수형 기능은 다음과 같다.

* 모든 것은 표현식이다.
* 형식 추론(힌들리-밀너 형식 추론 사용)
* 일급 함수
* 포획 의미론(클로저 등)을 가진 익명 함수
* 불변 변수 및 객체
* 지연 평가 지원
* 고차 함수
* 중첩 함수
* 커링
* 패턴 매칭
* 대수적 데이터 형식
* 튜플
* 리스트 컴프리헨션
* 모나드 패턴 지원 (컴퓨테이션 표현식이라고 함)
* 꼬리 재귀 최적화

F#은 즉시 평가를 사용하며, 경우에 따라 지연 평가를 사용하는 표현식 기반 언어이다. `if` 표현식, `try` 표현식 및 루프를 포함한 F#의 모든 문은 정적 형식을 가진 구성 가능한 표현식이다. 값을 반환하지 않는 함수와 표현식은 `unit` 반환 형식을 갖는다. F#은 `let` 키워드를 사용하여 값을 이름에 바인딩한다. 예를 들어,
```fsharp
let x = 3 + 4
```
는 값 `7`을 이름 `x`에 바인딩한다.

새로운 형식은 `type` 키워드를 사용하여 정의된다. 함수형 프로그래밍을 위해 F#은 튜플, 레코드, 구별된 유니온, 리스트, 옵션 및 결과 형식을 제공한다. 튜플은 n개의 값 집합을 나타내며, 여기서 n ≥ 0이다. 값 n은 튜플의 항수라고 한다. 3-튜플은 `(A, B, C)`로 표시되며, 여기서 A, B, C는 서로 다른 형식의 값일 수 있다. 튜플은 실행 시에 값의 수가 설계 시점에 알려지고 일정하게 유지될 때만 값을 저장하는 데 사용할 수 있다.

레코드는 데이터 멤버의 이름이 지정된 형식이다. 레코드 정의의 예는 다음과 같다.
```fsharp
type R =
{ Name : string
Age : int }
```
레코드는 `let r = { Name="AB"; Age=42}`와 같이 생성할 수 있다. `with` 키워드는 `{ r with Name="CD"}`와 같이 레코드의 복사본을 만드는 데 사용되며, `r`을 복사하고 `Name` 필드의 값을 변경하여 새 레코드를 생성한다(마지막 예제에서 생성된 레코드가 `r`로 명명되었다고 가정).

구별된 유니온 형식은 형식 안전 버전의 C 유니온이다. 예를 들어,
```fsharp
type A =
| UnionCaseX of string
| UnionCaseY of int
```
유니온 형식의 값은 각 유니온 케이스에 해당할 수 있다. 각 유니온 케이스가 전달하는 값의 형식은 각 케이스의 정의에 포함된다.

리스트 형식은 `head::tail` 표기법(`::`는 cons 연산자) 또는 `[item1; item2; item3]`과 같은 약식을 사용하여 표현되는 불변의 연결 리스트이다. 빈 리스트는 `[]`로 작성된다. 옵션 형식은 `Some(x)` 또는 `None` 선택 항목이 있는 구별된 유니온 형식이다. F# 형식은 제네릭일 수 있으며, 제네릭 .NET 형식으로 구현된다.

F#은 람다 함수와 클로저를 지원한다. F#의 모든 함수는 일급 값이며 불변이다. 함수는 커리 될 수 있다. 일급 값이므로 함수는 다른 함수의 인수로 전달될 수 있다. 다른 함수형 프로그래밍 언어와 마찬가지로 F#은 `>>` 및 `<<` 연산자를 사용하여 함수 합성을 허용한다.

F#은 값을 생성하는 코드를 통해 시퀀스 `seq { ... }`, 리스트 `[ ... ]` 또는 배열 `[| ... |]`을 정의하는 시퀀스 표현식을 제공한다. 예를 들어,
```fsharp
seq { for b in 0 .. 25 do
if b < 15 then
yield b*b }
```
는 0에서 25까지의 숫자 범위에서 숫자를 필터링하여 0에서 14까지의 숫자의 제곱 시퀀스를 형성한다. 시퀀스는 생성기이다. 즉, 값은 필요에 따라 생성된다(즉, 지연 평가됨). 반면 리스트와 배열은 즉시 평가된다.

F#은 패턴 매칭을 사용하여 값을 이름에 바인딩한다. 패턴 매칭은 구별된 유니온에 액세스할 때도 사용된다. 유니온은 패턴 규칙에 대해 값 일치되며, 일치가 성공하면 규칙이 선택된다. F#은 또한 확장 가능한 패턴 매칭 형태인 액티브 패턴을 지원한다. 예를 들어, 형식에 대한 일치하는 여러 방법이 존재할 때 사용된다.

F#은 컴퓨테이션 표현식이라고 하는 구성 가능한 계산을 정의하기 위한 일반적인 구문을 지원한다. 시퀀스 표현식, 비동기 계산 및 쿼리는 특정 종류의 컴퓨테이션 표현식이다. 컴퓨테이션 표현식은 모나드 패턴의 구현이다.

4.2. 명령형 프로그래밍

F#은 다음과 같은 명령형 프로그래밍 기능을 지원한다.

* `let` 키워드를 사용한 값 바인딩.
* `unit` 반환 형식을 가진 함수 및 표현식.
* 튜플, 레코드, 구별된 유니온, 리스트, 옵션, 결과 형식.
* `::` (cons 연산자) 또는 `[item1; item2; item3]` 표기법을 사용한 불변 연결 리스트.
* `seq { ... }`, `[ ... ]`, `[| ... |]`를 사용한 시퀀스 표현식 (생성기는 지연 평가되고, 리스트와 배열은 즉시 평가됨).
* 패턴 매칭을 통한 값 바인딩 및 구별된 유니온 접근.
* 컴퓨테이션 표현식 (모나드 패턴 구현)을 통한 구성 가능한 계산 정의.
* `async{ ... }`를 사용한 비동기 프로그래밍 지원 (비동기 워크플로우).
* .NET 작업 직접 생성, 사용 및 반환 지원 (버전 6.0부터).

4.3. 객체 지향 프로그래밍

F#은 다른 공용 언어 기반 (CLI) 언어와 마찬가지로 객체 지향 프로그래밍을 통해 CLI 형식을 사용할 수 있다. F#은 C#에서 사용할 수 있는 객체 지향 기능을 지원한다.

2002년부터 마이크로소프트 리서치(Microsoft Research)의 Don Syme^영어 등이 OCaml을 기반으로 개발을 시작했다.

4.4. 비동기 프로그래밍

F#은 비동기 워크플로우를 통해 비동기 프로그래밍을 지원한다. 비동기 워크플로우는 `async{ ... }` 내의 일련의 명령으로 정의된다. 다음은 그 예이다.

```fsharp
let asynctask =
async { let req = WebRequest.Create(url)
let! response = req.GetResponseAsync()
use stream = response.GetResponseStream()
use streamreader = new System.IO.StreamReader(stream)
return streamreader.ReadToEnd() }
```

`let!`은 오른쪽에 있는 표현식(응답 가져오기)이 비동기적으로 수행되어야 하지만 결과가 사용 가능할 때만 흐름이 계속되어야 함을 나타낸다. 즉, 코드 블록의 관점에서 볼 때 응답을 가져오는 것은 차단 호출과 같지만, 시스템의 관점에서 볼 때 스레드는 차단되지 않으며 이 스레드에 필요한 결과가 나올 때까지 다른 흐름을 처리하는 데 사용될 수 있다.

async 블록은 `Async.RunSynchronously` 함수를 사용하여 호출할 수 있다. 여러 async 블록은 `async` 객체 목록을 사용하는 `Async.Parallel` 함수를 사용하여 병렬로 실행할 수 있다. (예제에서 `asynctask`는 async 객체이다.) 이 함수는 목록의 작업을 병렬로 실행하기 위해 다른 async 객체를 생성한다. 결과 객체는 `Async.RunSynchronously`를 사용하여 호출된다.

F#의 제어 역전은 이 패턴을 따른다.

버전 6.0부터 F#은 .NET 작업을 직접 생성, 사용 및 반환하는 것을 지원한다.

```fsharp
open System.Net.Http
let fetchUrlAsync (url:string) = // string -> Task
task {
use client = new HttpClient()
let! response = client.GetAsync(url)
let! content = response.Content.ReadAsStringAsync()
do! Task.Delay 500
return content
}

// Usage
let fetchPrint() =
let task = task {
let! data = fetchUrlAsync "https://example.com"
printfn $"{data}"
}
task.Wait()

4.5. 병렬 프로그래밍

F#은 `Async.Parallel`, `Async.Start` 등의 함수를 통해 병렬 프로그래밍을 지원한다. F# 표준 라이브러리의 `Array.Parallel` 함수형 프로그래밍 연산자, `System.Threading.Tasks` 작업 프로그래밍 모델, .NET 스레드 풀 등을 사용할 수 있다. F# 코드를 GPU 코드와 같은 대체 병렬 실행 엔진으로 동적 변환하는 기능도 지원한다.

4.6. 단위 측정

F# 타입 시스템은 숫자 값에 대한 단위 검사를 지원한다.

F#에서는 미터나 킬로그램과 같은 단위(측정)를 부동 소수점, 부호 없는 정수 및 부호 있는 정수 값에 할당할 수 있다. 이를 통해 컴파일러는 이러한 값을 포함하는 산술 연산이 차원적으로 일치하는지 확인할 수 있으며, 예를 들어 길이를 시간에 실수로 더하는 것과 같은 일반적인 프로그래밍 실수를 방지할 수 있다.

단위(측정) 기능은 F# 타입 추론과 통합되어 사용자 코드에서 최소한의 타입 주석만 필요로 한다.

```fsharp
[] type m // 미터
[] type s // 초

let distance = 100.0 // float
let time = 5.0 // float
let speed = distance/time // float

[] type kg // 킬로그램
[] type N = (kg * m)/(s^2) // 뉴턴
[] type Pa = N/(m^2) // 파스칼

[] type days
let better_age = 3u // uint
```

F# 정적 타입 검사기는 컴파일 시간에 이 기능을 제공하지만, 단위는 컴파일된 코드에서 지워진다. 결과적으로 런타임에 값의 단위를 결정하는 것은 불가능하다.