Merge pull request #49683 from v-thpra/azure-triage-fix-1037374

JamesJBarnett · web-flow · commit b78c173524d7 · 2025-04-02T09:56:15.000-07:00
Technical Review 1037374: Write your first F# code
diff --git a/learn-pr/language/fsharp-first-steps/1-introduction.yml b/learn-pr/language/fsharp-first-steps/1-introduction.yml
@@ -5,7 +5,7 @@ metadata:
   unitType: introduction
   title: "Introduction"
   description: "What is F# and what can you build with it?"
-  ms.date: 02/22/2023
+  ms.date: 03/26/2025
   author: baronfel
   ms.author: chethusk 
   ms.topic: unit
diff --git a/learn-pr/language/fsharp-first-steps/2-what-is-fsharp.yml b/learn-pr/language/fsharp-first-steps/2-what-is-fsharp.yml
@@ -5,7 +5,7 @@ metadata:
   unitType: learning-content
   title: "What is F#?"
   description: "F# is an open-source, cross-platform programming language that makes it easy to write succinct, performant, robust, and practical code"
-  ms.date: 02/22/2023
+  ms.date: 03/26/2025
   author: baronfel
   ms.author: chethusk 
   ms.topic: unit
diff --git a/learn-pr/language/fsharp-first-steps/3-fsharp-development-environment.yml b/learn-pr/language/fsharp-first-steps/3-fsharp-development-environment.yml
@@ -5,7 +5,7 @@ metadata:
   unitType: learning-content
   title: "F# development environment"
   description: "Overview of tools to help you build F# applications"
-  ms.date: 02/22/2023
+  ms.date: 03/26/2025
   author: baronfel
   ms.author: chethusk 
   ms.topic: unit
diff --git a/learn-pr/language/fsharp-first-steps/4-set-up-development-environment-exercise.yml b/learn-pr/language/fsharp-first-steps/4-set-up-development-environment-exercise.yml
@@ -4,8 +4,8 @@ title: Exercise - Set up your F# development environment
 metadata:
   unitType: exercise
   title: "Exercise - Set up your F# development environment"
-  description: "Install the .NET SDK, Visual Studio Code, and Ionide F# extension to develop your F# applications"
-  ms.date: 02/22/2023
+  description: "Install the .NET SDK, Visual Studio Code, and Ionide F# extension for developing your F# application."
+  ms.date: 03/26/2025
   author: baronfel
   ms.author: chethusk 
   ms.topic: unit
diff --git a/learn-pr/language/fsharp-first-steps/5-fsharp-interactive.yml b/learn-pr/language/fsharp-first-steps/5-fsharp-interactive.yml
@@ -5,7 +5,7 @@ metadata:
   unitType: learning-content
   title: "What is F# Interactive?"
   description: "Learn what F# Interactive is and how you can use it to evaluate code and scripts in real-time"
-  ms.date: 02/22/2023
+  ms.date: 03/26/2025
   author: baronfel
   ms.author: chethusk 
   ms.topic: unit
diff --git a/learn-pr/language/fsharp-first-steps/6-write-your-first.yml b/learn-pr/language/fsharp-first-steps/6-write-your-first.yml
@@ -4,8 +4,8 @@ title: Exercise - Write your first line of F# code
 metadata:
   unitType: exercise
   title: "Exercise - Write your first line of F# code"
-  description: "Use F# Interactive to print Hello World to the console"
-  ms.date: 02/22/2023
+  description: "Use F# Interactive to print Hello World to the console."
+  ms.date: 03/26/2025
   author: baronfel
   ms.author: chethusk 
   ms.topic: unit
diff --git a/learn-pr/language/fsharp-first-steps/7-fsharp-build-application.yml b/learn-pr/language/fsharp-first-steps/7-fsharp-build-application.yml
@@ -4,8 +4,8 @@ title: Create F# applications
 metadata:
   unitType: learning-content
   title: "Create F# applications"
-  description: "Overview of .NET templates and how they can help you build your first F# application"
-  ms.date: 02/22/2023
+  description: "Overview of .NET templates and how they can help you build your first F# application."
+  ms.date: 03/26/2025
   author: baronfel
   ms.author: chethusk 
   ms.topic: unit
diff --git a/learn-pr/language/fsharp-first-steps/8-build-your-first.yml b/learn-pr/language/fsharp-first-steps/8-build-your-first.yml
@@ -4,8 +4,8 @@ title: Exercise - Create your first F# application
 metadata:
   unitType: exercise
   title: "Exercise - Create your first F# application"
-  description: "Create an F# application to print out a message to a text console"
-  ms.date: 02/22/2023
+  description: "Create an F# application to print a message to a text console."
+  ms.date: 03/26/2025
   author: baronfel
   ms.author: chethusk 
   ms.topic: unit
diff --git a/learn-pr/language/fsharp-first-steps/9-summary.yml b/learn-pr/language/fsharp-first-steps/9-summary.yml
@@ -4,8 +4,8 @@ title: Summary
 metadata:
   unitType: summary
   title: "Summary"
-  description: "In this module you set up your F# development environment, wrote your first line of F# code, and built your first F# application"
-  ms.date: 02/22/2023
+  description: "In this module you set up your F# development environment, wrote your first line of F# code, and built your first F# application."
+  ms.date: 03/26/2025
   author: baronfel
   ms.author: chethusk 
   ms.topic: unit
diff --git a/learn-pr/language/fsharp-first-steps/includes/1-introduction.md b/learn-pr/language/fsharp-first-steps/includes/1-introduction.md
@@ -1,4 +1,4 @@
-F# is an open-source, cross-platform programming language that makes it easy to write succinct, performant, robust, and practical code
+F# is an open-source, cross-platform programming language that makes it easy to write succinct, performant, robust, and practical code.
 
 With F#, you can build applications like:
 
@@ -16,10 +16,10 @@ With F#, you can build applications like:
 
 In this module, you'll:
 
-- Understand what makes F# a good language for building applications
+- Understand what makes F# a good language for building applications.
 - Write your first line of F# code.
 - Build your first F# console application.
 
 ## What is the main goal?
 
-By the end of this module, you'll be able to write F# code to print a message to a text console, like the Windows command prompt or Linux bash shell. These lines of code provide you with your first look at the F# syntax, and immediately provide invaluable insights into what makes F# a great programming language.
+By the end of this module, you're able to write F# code to print a message to a text console, like the Windows command prompt or Linux bash shell. These lines of code provide you with your first look at the F# syntax, and immediately provide invaluable insights into what makes F# a great programming language.
diff --git a/learn-pr/language/fsharp-first-steps/includes/2-what-is-fsharp.md b/learn-pr/language/fsharp-first-steps/includes/2-what-is-fsharp.md
@@ -6,19 +6,19 @@ F# has numerous features that include:
 
 - **Lightweight syntax:** Write low-ceremony code and focus on the core logic of your application.
 - **Type inference and automatic generalization:** Use the compiler to get the benefits of a statically typed language without explicitly defining your types.
-- **Immutable by default:** Apply predictable & repeatable transformations to your data without worrying about side-effects.
-- **Powerful data types:** Represent complex data & model domains using tuples, records, and discriminated unions.
+- **Immutable by default:** Apply predictable and repeatable transformations to your data without worrying about side-effects.
+- **Powerful data types:** Represent complex data and model domains using tuples, records, and discriminated unions.
 - **Pattern matching:** Enforce correctness in your application's behavior using the compiler.
 - **Asynchronous programming:** Support for asynchronous workflows out of the box.
 
 ## Why F#?
 
-There are many language features and aspects of the F# language that make it easy to be productive when writing code:
+There are many language features and aspects of the F# language that makes it easy to be productive when writing code:
 
-- **Succinct:** You write less code with F#, and it's also expressed in a clear manner.
+- **Succinct:** You write less code with F#, and the code is expressed in a clear manner.
 - **Performant:** F# comes with built-in parallelism and concurrency. It also uses the fact that it's part of the .NET runtime to speed up things.
-- **Robust:**  There are language constructs that make the code fault tolerant and robust like immutable by default, null value management and more.
-- **Supports multiple programming paradigms:** F# lets you choose the patterns and practices most effective for solving problems by providing strong support for functional and object programming paradigms.
+- **Robust:** There are language constructs that make the code fault tolerant and robust, like immutable by default, null value management, and more.
+- **Support for multiple programming paradigms:** F# lets you choose the patterns and practices most effective for solving problems by providing strong support for functional and object programming paradigms.
 
 ### Succinct
 
@@ -36,16 +36,16 @@ As the demands on your application grow, writing scalable code to meet those dem
 
 ### Robust
 
-Writing code that's unreliable can be costly. When you develop applications, you want to make sure that they stand the test of time. F# helps you write robust code by making the expected outcomes predictable and reproducible. Using world-class tooling and libraries you can catch and handle those edge-cases before your users do.
+Writing code that's unreliable can be costly. When you develop applications, you want to make sure that they stand the test of time. F# helps you write robust code by making the expected outcomes predictable and reproducible. Using world-class tooling and libraries, you can catch and handle those edge-cases before your users do.
 
 - **Immutable by default**: Having immutability by default means you can process your data without changing the original data throughout the execution of your program. Therefore when applying changes to your data you have a high degree of certainty of the expected outcome making code simpler to reason about and test.
-- **Null value handling**: Errors in an application due to null values can be costly. As a result, code bases can often be riddled with code to check for and handle null values. In F#, you can use the `Option` type to safely handle scenarios where `null` values may arise.
+- **Null value handling**: Errors in an application due to null values can be costly. As a result, code bases can often be riddled with code to check for and handle null values. In F#, you can use the `Option` type to safely handle scenarios where `null` values might arise.
 - **Professional-grade tooling**: Use lightweight text editors such as Visual Studio Code or an IDE like Visual Studio.
 - **Works with .NET libraries**: The .NET ecosystem has a rich ecosystem of libraries. As a .NET language, F# can take advantage of those libraries and use them inside your applications.
 
 ### Supports multiple programming paradigms
 
-F# is about getting things done. With strong functional & object programming support, F# lets you choose which patterns and practices best solve your problem. Using its interactive programming & scripting environments, you can begin validating your ideas instantly.
+F# is about getting things done. With strong functional and object programming support, F# lets you choose which patterns and practices best solve your problem. Using its interactive programming and scripting environments, you can begin validating your ideas instantly.
 
-- **Strong functional & object programming support**: Regardless of the patterns you implement in your applications, with F# you don't have to choose because it provides strong support for both functional and object programming. 
+- **Strong functional & object programming support**: Regardless of the patterns you implement in your applications, with F# you don't have to choose because it provides strong support for both functional and object programming.
 - **Interactive programming**: F# via F# Interactive provides scripting capabilities. Instead of compiling your code inside an F# project, you can get started writing and evaluating your code logic interactively via the console or through script files. For more visual environments such as when building visualizations, you can use tools like .NET notebooks via .NET Interactive.
diff --git a/learn-pr/language/fsharp-first-steps/includes/3-fsharp-development-environment.md b/learn-pr/language/fsharp-first-steps/includes/3-fsharp-development-environment.md
@@ -1,4 +1,4 @@
-F# has access to world-class tooling. Whether it's a lightweight text editor or an IDE, you have choices when it comes to choosing your tools. However, at a minimum, you need the .NET SDK to start writing F# code. 
+F# has access to world-class tooling. Whether it's a lightweight text editor or an IDE, you have choices when it comes to choosing your tools. However, at a minimum, you need the .NET SDK to start writing F# code.
 
 ## .NET SDK
 
@@ -14,8 +14,8 @@ The .NET SDK is free and cross-platform, which means you can install it on Windo
 
 You can use any text editor to write F# code. However, Visual Studio Code is a free, open-source, and cross-platform text editor that is lightweight but also offers the following features to take your development workflow to the next level:
 
-- **Debugging:** Visual Studio Code's built-in debugger helps accelerate your edit, compile and debug loop.
-- **Version control:** Visual Studio Code has integrated source control management (SCM) and includes Git support built-in to help you keep track of your code as it changes.
+- **Debugging:** Visual Studio Code's built-in debugger helps accelerate your edit, compile, and debug loop.
+- **Version control:** Visual Studio Code integrates source control management (SCM) and includes Git support built-in to help you keep track of your code as it changes.
 - **Integrated terminal:** Visual Studio Code includes a fully featured integrated terminal, which makes it easy to work with the .NET CLI from inside the editor.
 - **Extensions:** Extend the functionality of Visual Studio Code using extensions.
 
diff --git a/learn-pr/language/fsharp-first-steps/includes/4-set-up-development-environment.md b/learn-pr/language/fsharp-first-steps/includes/4-set-up-development-environment.md
@@ -5,8 +5,8 @@ In this exercise, set up your F# development environment by installing the .NET
 To get started writing code with F#, install the .NET SDK.
 
 1. [Download and install .NET SDK](https://dotnet.microsoft.com/download/dotnet) for your operating system.
-1. Verify that the .NET SDK has installed successfully
-    1. Open the terminal
+1. Verify that the .NET SDK is installed successfully.
+    1. Open the terminal.
     1. Enter the following .NET CLI command
 
         ```dotnetcli
@@ -16,7 +16,7 @@ To get started writing code with F#, install the .NET SDK.
     1. The following output is similar to what displays in the console. Your version might be different, but as long as the version information is output to the console, it means everything is installed correctly.
 
         ```console
-        5.0.302
+        9.0.201
         ```
 
 ## Install Visual Studio Code & Ionide F# extension
diff --git a/learn-pr/language/fsharp-first-steps/includes/5-fsharp-interactive.md b/learn-pr/language/fsharp-first-steps/includes/5-fsharp-interactive.md
@@ -13,7 +13,7 @@ dotnet fsi
 Starting F# Interactive launches you into a read-evaluate-print-loop (REPL) session where you can write your F# code and immediately evaluate its output in the console.
 
 ```fsharp
-Microsoft (R) F# Interactive version 11.4.2.0 for F# 5.0 
+Microsoft (R) F# Interactive version 13.9.201.0 for F# 9.0 
 Copyright (c) Microsoft Corporation. All Rights Reserved.
 
 For help type #help;;
@@ -40,16 +40,18 @@ F# Interactive directives:
     #load "file.fs" ...;;                         // Load the given file(s) as if compiled and referenced
     #time ["on"|"off"];;                          // Toggle timing on/off
     #help;;                                       // Display help
+    #help "idn";;                                 // Display documentation for an identifier, e.g. #help "List.map";;
     #r "nuget:FSharp.Data, 3.1.2";;               // Load Nuget Package 'FSharp.Data' version '3.1.2'
     #r "nuget:FSharp.Data";;                      // Load Nuget Package 'FSharp.Data' with the highest version
+    #clear;;                                      // Clear screen
     #quit;;                                       // Exit
     
 F# Interactive command line options:
 
     See 'dotnet fsi --help' for options
 ```
 
-The end of an expression is delimited by the `;;` characters. No code is evaluated until you input the `;;` characters. This structure is useful when writing multi-line expressions since your code isn't delimited by new line characters.
+The `;;` characters delimit the end of an expression. No code is evaluated until you input the `;;` characters. This structure is useful when writing multi-line expressions since your code isn't delimited with new line characters.
 
 Evaluating F# code works the same way. The following code prints a message to the console.
 
@@ -61,10 +63,10 @@ The evaluated output is:
 
 ```console
 Hello World!
-val it : unit = ()
+val it: unit = ()
 ```
 
-The first line displays the output from the evaluated code while the second line displays output's type information. In this case, the value output to the console is of type `unit`, which is represented by the `()` token and bound to the `it` name. You can access the `it` value later on in your program if you want to perform more operations.
+The first line displays the output from the evaluated code while the second line displays the type information of the output. In this case, the value (`val`) output to the console is of type `unit`, which is represented by the `()` token and bound to the `it` name. You can access the `it` value later on in your program if you want to perform more operations.
 
 ## Exiting the REPL
 
@@ -74,7 +76,7 @@ After you use the F# Interactive REPL, use the `#q` or `#quit` commands to exit.
 > #q;;
 ```
 
-## fsx script files
+## F# script files
 
 As you write more code, you can save your code in a script with the *fsx* file extension.
 
diff --git a/learn-pr/language/fsharp-first-steps/includes/6-write-your-first.md b/learn-pr/language/fsharp-first-steps/includes/6-write-your-first.md
@@ -1,9 +1,9 @@
-In this exercise, we write our first line of F# code, which prints the message **Hello World** to the console.
+In this exercise, we write our first F# code, which prints the message **Hello World** to the console.
 
 ## Start F# Interactive
 
-1. Open a command prompt
-1. Enter the following .NET CLI command into the command prompt
+1. Open a command prompt.
+1. Enter the following .NET CLI command into the command prompt:
 
     ```dotnetcli
     dotnet fsi
@@ -12,17 +12,17 @@ In this exercise, we write our first line of F# code, which prints the message *
     When the F# Interactive terminal opens, you should see something similar to the following output:
 
     ```dotnetcli
-    Microsoft (R) F# Interactive version 11.0.0.0 for F# 5.0
+    Microsoft (R) F# Interactive version 13.9.201.0 for F# 9.0
     Copyright (c) Microsoft Corporation. All Rights Reserved.
     
     For help type #help;;
     
     >
     ```
 
-## Write your first line of code
+## Write your first F# code
 
-Add the following line of code next to the `>` character in the F# Interactive terminal
+Add the following line of code next to the `>` character in the F# Interactive terminal:
 
 ```fsharp
 printfn "Hello World!";;
@@ -32,10 +32,10 @@ The code is evaluated and similar output displays on the console:
 
 ```fsharp
 Hello World!
-val it : unit = ()
+val it: unit = ()
 ```
 
-Congratulations! You've written your first line of F# code!
+Congratulations! You wrote your first line of F# code!
 
 ## (Optional) Write a script
 
diff --git a/learn-pr/language/fsharp-first-steps/includes/7-fsharp-build-application.md b/learn-pr/language/fsharp-first-steps/includes/7-fsharp-build-application.md
diff --git a/learn-pr/language/fsharp-first-steps/includes/9-summary.md b/learn-pr/language/fsharp-first-steps/includes/9-summary.md
diff --git a/learn-pr/language/fsharp-first-steps/index.yml b/learn-pr/language/fsharp-first-steps/index.yml
diff --git a/learn-pr/language/fsharp-first-steps/knowledge-check.yml b/learn-pr/language/fsharp-first-steps/knowledge-check.yml
