Quick Start

mkdir TaskPipeline
cd TaskPipeline
dotnet new console -lang F#

mkdir TaskPipeline
cd TaskPipeline
code TaskPipeline.fsx  # Opens in VS Code

// TaskPipeline.fsx

// Immutable record type
type Task = {
    Id: int                    // => int field
    Title: string              // => string field
    Description: string        // => string field
    Priority: int              // => 1 (high) to 3 (low)
}                              // => Record is immutable by default

// Create a task
let task1 = {
    Id = 1                     // => Field assignment
    Title = "Learn F#"         // => Immutable value
    Description = "Master functional programming"
    Priority = 1               // => High priority
}                              // => task1 is Task type (inferred)

// Records are immutable - create modified copy
let task2 = {
    task1 with                 // => Copy task1
    Title = "Master F#"        // => Override Title field
}                              // => task2 is new instance, task1 unchanged

printfn "%A" task1             // => Output: { Id = 1; Title = "Learn F#"; ... }
printfn "%A" task2             // => Output: { Id = 1; Title = "Master F#"; ... }

// Task status as discriminated union
type TaskStatus =
    | NotStarted                          // => Case with no data
    | InProgress of startedOn: System.DateTime   // => Case with DateTime data
    | Completed of completedOn: System.DateTime  // => Case with DateTime data
    | Blocked of reason: string           // => Case with string data
                                          // => Compiler ensures exhaustive matching

// Enhanced task with status
type TaskItem = {
    Id: int
    Title: string
    Status: TaskStatus                    // => Status is TaskStatus union
    Priority: int
}

// Create tasks with different statuses
let task1 = {
    Id = 1
    Title = "Learn F#"
    Status = InProgress (System.DateTime.Now)  // => InProgress case with data
    Priority = 1
}

let task2 = {
    Id = 2
    Title = "Build project"
    Status = NotStarted                   // => NotStarted case (no data)
    Priority = 2
}

let task3 = {
    Id = 3
    Title = "Deploy app"
    Status = Blocked "Waiting for API key"     // => Blocked case with reason
    Priority = 3
}

// Get status description using pattern matching
let getStatusDescription status =
    match status with                     // => Pattern match on status
    | NotStarted -> "Not started yet"     // => Match NotStarted case
    | InProgress date ->                  // => Match InProgress, extract date
        sprintf "Started on %s" (date.ToShortDateString())
    | Completed date ->                   // => Match Completed, extract date
        sprintf "Completed on %s" (date.ToShortDateString())
    | Blocked reason ->                   // => Match Blocked, extract reason
        sprintf "Blocked: %s" reason      // => sprintf formats string
                                          // => Compiler verifies all cases covered

// Use pattern matching
let status1 = getStatusDescription task1.Status
// => status1 is "Started on 2/2/2026"

let status2 = getStatusDescription task3.Status
// => status2 is "Blocked: Waiting for API key"

printfn "%s" status1                      // => Output: Started on 2/2/2026
printfn "%s" status2                      // => Output: Blocked: Waiting for API key

// Function to check if task is high priority
let isHighPriority task =
    task.Priority = 1                     // => Returns bool (type inferred)
                                          // => Last expression is return value

// Function to get task title
let getTitle task =
    task.Title                            // => Returns string (inferred)

// Piping - pass result of one function to next
let highPriorityTitle =
    task1                                 // => Start with task1
    |> isHighPriority                     // => Pipe to isHighPriority: true
    |> (fun isHigh ->                     // => Lambda function
        if isHigh then getTitle task1     // => Get title if high priority
        else "Not high priority")         // => Else message
// => highPriorityTitle is "Learn F#"

// Pipe multiple operations
let tasks = [task1; task2; task3]         // => List of tasks

let highPriorityTitles =
    tasks                                 // => Start with list
    |> List.filter isHighPriority         // => Filter high priority tasks
    |> List.map getTitle                  // => Map to titles
    |> List.sort                          // => Sort alphabetically
// => highPriorityTitles is ["Learn F#"] (sorted list)

printfn "High priority tasks: %A" highPriorityTitles
// => Output: High priority tasks: ["Learn F#"]

// Find task by ID (may not exist)
let findTaskById id taskList =
    taskList                              // => Start with task list
    |> List.tryFind (fun t -> t.Id = id)  // => Returns Option<TaskItem>
                                          // => Some task or None

// Use option
let foundTask = findTaskById 1 tasks      // => Some task1
let notFound = findTaskById 99 tasks      // => None

// Pattern match on option
let displayTask taskOption =
    match taskOption with                 // => Match on Option<TaskItem>
    | Some task ->                        // => Some case (task exists)
        printfn "Found: %s" task.Title
    | None ->                             // => None case (not found)
        printfn "Task not found"

displayTask foundTask                     // => Output: Found: Learn F#
displayTask notFound                      // => Output: Task not found

// Option.map - transform if Some, preserve None
let titleOption =
    foundTask                             // => Some task1
    |> Option.map (fun t -> t.Title)      // => Some "Learn F#"

let notFoundTitle =
    notFound                              // => None
    |> Option.map (fun t -> t.Title)      // => None (map not executed)

// Result type for success/failure
type ValidationError = string

// Validate task
let validateTask task =
    if System.String.IsNullOrWhiteSpace task.Title then
        Error "Title cannot be empty"    // => Error case with message
    elif task.Priority < 1 || task.Priority > 3 then
        Error "Priority must be 1-3"     // => Error case
    else
        Ok task                           // => Ok case with task
                                          // => Returns Result<TaskItem, string>

// Result computation expression
let processTask task =
    result {                              // => Result computation expression
        let! validated = validateTask task    // => Unwrap Ok, short-circuit on Error
        let updated = {                   // => let! succeeds, continue
            validated with
            Status = InProgress System.DateTime.Now
        }
        return updated                    // => Wrap in Ok
    }                                     // => Returns Result<TaskItem, string>

// Valid task
let validResult = processTask task1      // => Ok (updated task)

// Invalid task
let invalidTask = { task1 with Title = "" }
let invalidResult = processTask invalidTask  // => Error "Title cannot be empty"

// Pattern match results
match validResult with
| Ok task -> printfn "Processed: %s" task.Title
| Error msg -> printfn "Error: %s" msg

match invalidResult with
| Ok task -> printfn "Processed: %s" task.Title
| Error msg -> printfn "Error: %s" msg
// => Output: Error: Title cannot be empty

// List comprehension
let numbers = [1..10]                     // => [1; 2; 3; ... 10]
let evens = [for i in 1..10 do
                if i % 2 = 0 then i]      // => [2; 4; 6; 8; 10]

// Generate sample tasks
let sampleTasks = [
    for i in 1..5 do                      // => Loop from 1 to 5
        {
            Id = i
            Title = sprintf "Task %d" i
            Status = NotStarted
            Priority = (i % 3) + 1        // => Rotate priorities 1-3
        }
]                                         // => List of 5 tasks

// Sequence (lazy evaluation)
let taskSequence = seq {                  // => Sequence expression
    for i in 1..1000000 do                // => Not evaluated until iterated
        yield {                           // => yield produces element
            Id = i
            Title = sprintf "Task %d" i
            Status = NotStarted
            Priority = 1
        }
}                                         // => Seq<TaskItem> (lazy)

// Take first 3 (only evaluates those 3)
let first3 =
    taskSequence
    |> Seq.take 3                         // => Take first 3 elements
    |> Seq.toList                         // => Force evaluation to list

printfn "First 3 tasks: %A" first3

open System.Threading.Tasks

// Simulate async operation
let fetchTaskDetailsAsync taskId = async {
    do! Async.Sleep 1000                  // => Non-blocking delay (1 second)
                                          // => do! awaits async operation
    return {                              // => return wraps in Async
        Id = taskId
        Title = sprintf "Fetched task %d" taskId
        Status = NotStarted
        Priority = 1
    }
}                                         // => Returns Async<TaskItem>

// Run async operation
let runAsync() =
    async {
        printfn "Fetching task..."
        let! task = fetchTaskDetailsAsync 42  // => let! awaits and unwraps
        printfn "Fetched: %s" task.Title
        return task
    }
    |> Async.RunSynchronously             // => Execute async workflow

// Parallel async operations
let fetchMultipleTasks() =
    async {
        let tasks = [1; 2; 3]             // => Task IDs
        let! results =
            tasks                         // => Start with list
            |> List.map fetchTaskDetailsAsync     // => Map to async operations
            |> Async.Parallel             // => Run in parallel
                                          // => Returns Async<TaskItem[]>
        return results |> Array.toList    // => Convert array to list
    }
    |> Async.RunSynchronously             // => Execute and wait

printfn "Fetching multiple tasks in parallel..."
let parallelResults = fetchMultipleTasks()
printfn "Fetched %d tasks" parallelResults.Length

// Complete task processing pipeline
let processTasks tasks =
    tasks
    |> List.filter (fun t ->              // => Filter high priority
        t.Priority = 1)
    |> List.map (fun t ->                 // => Validate each
        validateTask t)
    |> List.choose (fun result ->         // => Choose only Ok results
        match result with                 // => Pattern match Result
        | Ok task -> Some task            // => Keep successful validations
        | Error _ -> None)                // => Discard errors
    |> List.map (fun t ->                 // => Update status
        { t with Status = InProgress System.DateTime.Now })
    |> List.sortBy (fun t -> t.Id)        // => Sort by ID

// Run pipeline
let processedTasks = processTasks sampleTasks
printfn "Processed %d high-priority tasks" processedTasks.Length

// Display results
processedTasks
|> List.iter (fun t ->                    // => List.iter for side effects
    printfn "  [%d] %s - %s"
        t.Id
        t.Title
        (getStatusDescription t.Status))

dotnet fsi TaskPipeline.fsx

// Immutable record
type Task = { Id: int; Title: string }

// Discriminated union
type Status = NotStarted | InProgress of System.DateTime

// Pattern matching
match status with
| NotStarted -> "not started"
| InProgress date -> sprintf "started %O" date

// Piping
tasks
|> List.filter (fun t -> t.Priority = 1)
|> List.map (fun t -> t.Title)

// Option type
let found = List.tryFind (fun t -> t.Id = 1) tasks

// Result type
let validated = result {
    let! task = validateTask input
    return task
}

// Async workflow
let fetch = async {
    do! Async.Sleep 1000
    return "data"
}

// Values
let x = 42                          // Immutable binding
let mutable y = 10                  // Mutable (rare)
y <- 15                             // Mutation

// Functions
let add x y = x + y                 // Function with 2 parameters
let result = add 3 5                // result is 8

// Records
type Person = { Name: string; Age: int }
let person = { Name = "Alice"; Age = 30 }

// Discriminated unions
type Shape =
    | Circle of radius: float
    | Rectangle of width: float * height: float

// Pattern matching
match shape with
| Circle r -> 3.14 * r * r
| Rectangle (w, h) -> w * h

// Lists
let numbers = [1; 2; 3]
let doubled = numbers |> List.map (fun x -> x * 2)

// Option
let maybeValue = Some 42
let nothing = None

// Result
let success = Ok "data"
let failure = Error "error message"