F# 言語仕様ガイド

let x = 42              // 不変バインディング
let mutable count = 0   // ミュータブル
count <- count + 1      // 再代入（<- を使う）
let pi: float = 3.14    // 型注釈

let i: int    = 42
let f: float  = 3.14
let b: bool   = true
let s: string = "F#"
let u: unit   = ()    // void 相当
let c: char   = 'A'
let l: int64  = 100L  // サフィックスで型指定

let add a b = a + b        // a, b: int と推論
let addF (a: float) b = a + b  // float と明示
let len xs = List.length xs    // 'a list -> int

printfn "Hello, %s!" "F#"   // unit を返す
let greet name: unit = printfn "Hi, %s" name
ignore (1 + 1)  // 値を捨てて unit にする

let max a b = if a > b then a else b

let label =
    if score >= 90 then "A"
    elif score >= 70 then "B"
    else "C"

let describe x =
    match x with
    | 0            -> "zero"
    | n when n < 0 -> sprintf "negative %d" n
    | n            -> sprintf "positive %d" n

for i in 1..10 do
    printfn "%d" i

for i in 10 .. -1 .. 1 do   // downto
    printfn "%d" i

let mutable i = 0
while i < 5 do
    printfn "%d" i
    i <- i + 1

let processFile path =
    let content = System.IO.File.ReadAllText(path)
    printfn "Read %d chars" content.Length
    content.ToUpper()

let add a b = a + b       // int -> int -> int
let add5 = add 5          // 部分適用 → int -> int
add5 3                    // 8

// 無名関数
let double = fun x -> x * 2
let triple = (*) 3        // 演算子も部分適用可

"hello world"
|> String.split ' '
|> List.map (fun s -> s.[0..0].ToUpper() + s.[1..])
|> String.concat " "
// "Hello World"

let processText = String.trim >> String.toLower >> String.length

let rec factorial n =
    if n <= 1 then 1 else n * factorial (n - 1)

// 末尾再帰版
let factorial' n =
    let rec loop acc = function
        | 0 | 1 -> acc
        | n     -> loop (acc * n) (n - 1)
    loop 1 n

[1..5] |> List.map (fun x -> x * x)   // [1;4;9;16;25]
[1..10] |> List.filter (fun x -> x % 2 = 0)  // [2;4;6;8;10]
[1..5] |> List.fold (+) 0               // 15

let xs = [1; 2; 3]         // セミコロン区切り
let ys = 0 :: xs           // [0;1;2;3]（先頭追加）
let zs = xs @ [4; 5]       // [1;2;3;4;5]（結合）
let h, t = List.head xs, List.tail xs

let arr = [| 1; 2; 3 |]
arr.[0]                    // 1
arr.[1] <- 99              // 変更可能
Array.map ((*) 2) arr      // [|2;198;6|]

let nats = Seq.initInfinite id   // 0,1,2,...
nats |> Seq.take 5 |> Seq.toList  // [0;1;2;3;4]

let evens = seq { for i in 0..2..100 -> i }

let squares = [ for i in 1..10 -> i * i ]
// [1;4;9;16;25;36;49;64;81;100]

let evens = [ for i in 1..20 do if i % 2 = 0 then yield i ]

let s = "Hello, F#!"
s.Length                         // 10
s.ToUpper()                      // "HELLO, F#!"
String.concat ", " ["a";"b";"c"] // "a, b, c"
sprintf "Pi is %.4f" System.Math.PI  // "Pi is 3.1416"

let name = "World"
let greeting = $"Hello, {name}!"     // "Hello, World!"
let info = $"Pi = {System.Math.PI:.4f}"  // "Pi = 3.1416"

printf "%s is %d years old
" "Alice" 30
printfn "%A" [1; 2; 3]   // [1; 2; 3]（デバッグ表示）
let msg = sprintf "score: %d" 95

try
    let n = int "abc"
    n
with
| :? System.FormatException as e -> printfn "Format error: %s" e.Message; 0
| ex -> printfn "Unknown: %s" ex.Message; -1

let divide a b =
    if b = 0 then Error "Division by zero"
    else Ok (a / b)

match divide 10 2 with
| Ok result -> printfn "Result: %d" result
| Error msg -> printfn "Error: %s" msg

let head = function
    | []    -> failwith "Empty list"
    | x :: _ -> x

let checkAge age =
    if age < 0 then invalidArg "age" "Must be non-negative"
    age

type Person = {
    Name: string
    Age:  int
}

let alice = { Name = "Alice"; Age = 30 }
let older = { alice with Age = 31 }    // コピー
alice = { Name = "Alice"; Age = 30 }   // true（構造的等値）

type Shape =
    | Circle    of radius: float
    | Rectangle of width: float * height: float
    | Triangle  of base: float * height: float

let area = function
    | Circle r        -> System.Math.PI * r * r
    | Rectangle(w, h) -> w * h
    | Triangle(b, h)  -> b * h / 2.0

let safeDiv a b =
    if b = 0 then None else Some (a / b)

safeDiv 10 2  |> Option.map ((*) 3)   // Some 15
safeDiv 10 0  |> Option.defaultValue -1 // -1

type UserId  = UserId  of int
type OrderId = OrderId of int

let uid = UserId 42
let (UserId rawId) = uid   // アンラップ

// let wrong: OrderId = uid  // コンパイルエラー

type Counter(initial: int) =
    let mutable count = initial

    member _.Value = count
    member _.Increment() = count <- count + 1
    member _.Reset()    = count <- 0

let c = Counter(10)
c.Increment()
printfn "%d" c.Value   // 11

type IShape =
    abstract Area: float

type Circle(r) =
    interface IShape with
        member _.Area = System.Math.PI * r * r

let s: IShape = Circle(5.0)
printfn "%.2f" s.Area

[<Struct>]
type Vector2D = { X: float; Y: float }

let v1 = { X = 1.0; Y = 2.0 }
let v2 = { X = 3.0; Y = 4.0 }
let sum = { X = v1.X + v2.X; Y = v1.Y + v2.Y }

let identity (x: 'a): 'a = x
let swap (a, b) = (b, a)   // 'a * 'b -> 'b * 'a

type Tree<'a> =
    | Leaf
    | Node of 'a * Tree<'a> * Tree<'a>

let maximum (xs: 'a list when 'a : comparison) =
    List.reduce max xs

let inline addAny (a: ^T) (b: ^T) : ^T =
    a + b   // + 演算子を持つ型ならすべて OK

let inline sumList (lst: ^T list) : ^T =
    List.fold (+) LanguagePrimitives.GenericZero lst

sumList [1; 2; 3]       // 6（int）
sumList [1.0; 2.0; 3.0] // 6.0（float）

// seq CE
let evens = seq {
    for i in 0..100 do
        if i % 2 = 0 then yield i
}

// option CE（カスタム例）
let result = option {
    let! x = Some 10
    let! y = Some 20
    return x + y
}

let fetchAsync url = async {
    use client = new System.Net.Http.HttpClient()
    let! response = client.GetStringAsync(url) |> Async.AwaitTask
    return response.Length
}

fetchAsync "https://example.com"
|> Async.RunSynchronously
|> printfn "Length: %d"

open System.Threading.Tasks

let fetchTask url : Task<int> = task {
    use client = new System.Net.Http.HttpClient()
    let! content = client.GetStringAsync(url)
    return content.Length
}

fetchTask "https://example.com" |> _.Result |> printfn "%d"

// FSharp.Data の JSON 型プロバイダー
#r "nuget: FSharp.Data"
open FSharp.Data

type Weather = JsonProvider<"https://api.example.com/weather">
let data = Weather.Load("https://api.example.com/weather")
printfn "Temp: %.1f" data.Temperature  // 型安全にアクセス

type Stocks = CsvProvider<"stocks.csv">
let stocks = Stocks.Load("stocks.csv")
for row in stocks.Rows do
    printfn "%s: %.2f" row.Symbol row.Price
// Symbol, Price は CSV ヘッダーから自動生成された型

// SQLProvider 例（概念）
type Sql = SqlDataProvider<"Data Source=mydb.sqlite">
let ctx = Sql.GetDataContext()
query {
    for user in ctx.Users do
    where (user.Age > 18)
    select user.Name
}

open System
open System.IO

let files = Directory.GetFiles(".", "*.fs")
let content = File.ReadAllText(files[0])
printfn "%s" (DateTime.Now.ToString("yyyy-MM-dd"))

let numbers = [1..20]
let result =
    query {
        for n in numbers do
        where (n % 2 = 0)
        select (n * n)
        take 5
    }
// [4; 16; 36; 64; 100]

# CLI でパッケージ追加
dotnet add package Newtonsoft.Json
dotnet add package FSharp.Data

# .fsproj に追記される
# <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />

open Xunit

[<Fact>]
let ``add returns correct sum`` () =
    let result = 1 + 1
    Assert.Equal(2, result)

[<Theory>]
[<InlineData(1, 2, 3)>]
[<InlineData(0, 0, 0)>]
let ``add is commutative`` a b expected =
    Assert.Equal(expected, a + b)

open Expecto

let tests = testList "Math" [
    test "addition" {
        Expect.equal (1 + 1) 2 "should be 2"
    }
    test "float" {
        Expect.floatClose Accuracy.high 3.14 3.14 "should be equal"
    }
]

[<EntryPoint>]
let main args = runTestsWithCLIArgs [] args tests

open FsCheck

let revRevIsOriginal (xs: int list) =
    List.rev (List.rev xs) = xs

Check.Quick revRevIsOriginal
// Ok, passed 100 tests.

dotnet new console -lang F# -o MyApp
dotnet build
dotnet run
dotnet test
dotnet publish -c Release

<!-- .fsproj の例 -->
<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="Types.fs" />
    <Compile Include="Logic.fs" />
    <Compile Include="Program.fs" />
  </ItemGroup>
</Project>

# FSI 起動
dotnet fsi

# スクリプト実行（.fsx ファイル）
dotnet fsi my_script.fsx

# nuget パッケージを FSI で使う
#r "nuget: FSharp.Data"
open FSharp.Data

let (>>=) result f =
    match result with
    | Ok v    -> f v
    | Error e -> Error e

let validateAge age =
    if age >= 0 then Ok age else Error "Negative age"

let validateName name =
    if name <> "" then Ok name else Error "Empty name"

let result =
    Ok { Name = ""; Age = -1 }
    >>= (fun p -> validateName p.Name |> Result.map (fun n -> { p with Name = n }))
    >>= (fun p -> validateAge p.Age  |> Result.map (fun a -> { p with Age = a }))

// 不正状態を型で排除
type Email = private Email of string
module Email =
    let create s =
        if s.Contains("@") then Ok (Email s)
        else Error "Invalid email"
    let value (Email s) = s

// OrderStatus が型で保証される
type Order =
    | Pending  of items: string list
    | Shipped  of trackingNo: string
    | Delivered

let (|Even|Odd|) n = if n % 2 = 0 then Even else Odd
let (|Positive|Negative|Zero|) n =
    if n > 0 then Positive
    elif n < 0 then Negative
    else Zero

match 42 with
| Even & Positive -> "even positive"
| Odd             -> "odd"
| _               -> "other"

open System

let countChars (s: ReadOnlySpan<char>) (target: char) =
    let mutable count = 0
    for c in s do
        if c = target then count <- count + 1
    count

let text: ReadOnlySpan<char> = "hello world".AsSpan()
countChars text 'l'   // 3

<!-- .fsproj -->
<PublishAot>true</PublishAot>

# ビルド
dotnet publish -r linux-x64 -c Release
# 自己完結シングルバイナリが生成される

open BenchmarkDotNet.Attributes
open BenchmarkDotNet.Running

[<MemoryDiagnoser>]
type MyBench() =
    [<Benchmark>]
    member _.ListMap() = [1..1000] |> List.map ((*) 2)
    [<Benchmark>]
    member _.ArrayMap() = [|1..1000|] |> Array.map ((*) 2)

BenchmarkRunner.Run<MyBench>() |> ignore