Today I encountered pattern matching for the first time.

C# has it too, but I felt this is a feature characteristic of F#.

F# Pattern Matching

This is amazing. I thought C#’s switch expression pattern matching was similar, but this feature probably went from F# to C#.

match Expression

I think the match expression will be used often, so I need to remember it well.

Also, it seems there are different kinds of patterns like or patterns and as patterns, so I need to memorize these properly too.

let testFunc param =
    match param with
        | 'a' -> 0
        | 'b' -> 1
        | _ -> -1
       
let ret = testFunc 'b'
printfn "%A" ret

function Expression

Simply put, it seems to be a combination of the fun expression and the match expression.

I thought it could be created with if statements even without function, but how is it really??

let testFunc = function 
    | value when value > 0 -> 1
    | value when value < 0 -> -1
    | _ -> 0

let ret = testFunc 2
printfn "%A" ret

Records

Is this equivalent to class in C#?

It doesn’t seem to have functions though.

But to avoid side effects, is it better to create it by passing a record type as an argument?

Like C# extension methods.

// Define the record type first
type Favorite = { color: string; number: int; music: string }

let favorite = { color = "red"; number = 7; music = "Jazz" } 
let { color = favoriteColor; number = favoriteNumber; music = favoriteMusic} = favorite 
printfn "%s, %d, %s" favoriteColor favoriteNumber favoriteMusic

Discriminated Unions

My understanding of this is really low right now.

It’s said to be close to enum, but since it can have associated values, it seems difficult to master.

But it feels like it would be satisfying if used well.

type Fruits = 
    | Apple
    | Orange
    | Grape

let favoriteFruits = Apple

printfn "%A" favoriteFruits

I’m taking it slow, so that’s all for today. I haven’t even read half of the book yet, when will I finish—.

Honestly, I still don’t understand it well.
When should I choose it?
What are its advantages? To be honest, I don’t know.
Searching the web brings up things like “can write logic without side effects,” “code is easier to understand,” “testing is easier,” but I feel like I haven’t grasped the essence yet.
My image was that it’s a “language with a completely different way of thinking and usage from procedural languages,” and even if I memorized the meaning of arbitrary corresponding programming grammar, it wouldn’t mean I could actually use it.
That’s the strong impression I had – something in a realm I couldn’t touch.

F#

Despite using C# for a long time, embarrassingly, I only learned about its existence recently.
I first learned about it at the Center CLR .Net600 study group I attended last year.
At that time, I was impressed that “you can use a functional language with .Net” and prepared my VS environment to use it, but I haven’t touched it since then.

I think the main reason I didn’t touch it was probably because I thought I needed to understand the underlying philosophy to use a functional language.

Reference Book

Wanting to study F# properly, I was looking for books. Although it was published a little while ago, I found and purchased a book written by Mr. Arai, who also spoke at the aforementioned .Net600 event.
(I really wanted to buy it new, but couldn’t find it, so I reluctantly bought it used.)

I haven’t finished reading it all yet, but as the book title suggests, it’s written for beginners, so for now, it feels like the information is sinking in properly!

I wonder if it will get more difficult in the latter half, but I intend to read it through without giving up. Lately, most information can be found online, but personally, I prefer having a book because I can concentrate better and absorb the information.

Just Try It

Because the fixed idea that “functional languages are quite difficult” occupied my mind, I was hesitant to start. However, I realized that if I stay like this, I’ll never be able to use it, so I decided to just try touching it.
Fortunately, I’ve been using C# for a long time, so I think F#, which uses the same .Net, will be easier to approach. And I won’t know what it’s like unless I try.

If I hit a wall after trying, I’ll think about what to do then!