exercism/fsharp

This system is the F\# track for Exercism, a platform for learning programming through guided practice. It provides a curated collection of concept and practice exercises that teach F\# language features such as pattern matching, discriminated unions, and functional data structures. The repository includes the exercise stubs, test suites, reference solutions, and documentation necessary for learners to complete coding challenges.

74 changes.

This period focused on establishing and expanding the Exercism F\# track by adding numerous practice and concept exercises covering core language features. It also involved building essential maintenance infrastructure, including test generators, validation scripts, and documentation tools, while upgrading the underlying .NET and xUnit dependencies.

12 changes.

This period focused on significantly expanding the F\# track by adding numerous new concept and practice exercises, including introductions to Option, Result, and Flags types. It also involved adding exercises to other tracks like C\# and .NET, while simultaneously introducing performance benchmarking and deep-dive articles to help users optimize their solutions.

The Anagram practice exercise is now available in F\#. This change introduces the starter file (Anagram.fs) with a placeholder implementation, a reference example solution (.meta/Example.fs) that demonstrates case-insensitive anagram detection, and the associated test suite (AnagramTests.fs) along with its configuration (config.json) and test mapping (tests.toml).

exercises/practice/anagram/.meta · high confidence

Introduced two new F\# concept exercises: 'Annalyn's Infiltration', which guides users through implementing boolean logic functions (canFastAttack, canSpy, canSignalPrisoner, canFreePrisoner) based on character states, and 'Valentines Day', which introduces discriminated unions (Approval, Cuisine, Genre, Activity) and pattern matching via the rateActivity function.

exercises/concept/annalyns-infiltration · high confidence

Introduced a new 'Bandwagoner' concept exercise in the F\# track that guides learners through defining and using record types (Coach, Stats, Team) and implementing functions to create, update, and compare these records.

exercises/concept/bandwagoner · high confidence

A new concept exercise named 'Bandwagoner' has been added to the F\# track, designed to teach users how to define and use records, including structural equality, immutability, pattern matching, and type inference. The entry includes the exercise configuration (config.json), a design document outlining learning objectives, and an exemplar solution (Exemplar.fs) that demonstrates creating and manipulating record types for basketball team statistics.

exercises/concept/bandwagoner/.meta · high confidence

A new practice exercise for the Camicia card game has been added. Users can now simulate a two-player card game where they must determine if the match ends or enters an infinite loop, calculating the total cards played and tricks won. The exercise includes instructions, an example solution in F\#, and a comprehensive test suite covering various game scenarios including simple tricks, penalty interactions, and loop detection.

exercises/practice/camicia · high confidence

The Cars Assemble exercise for the F\# track has been introduced, providing a new learning scenario for students. The exercise requires implementing three functions: \successRate\, which calculates the success rate of a production line based on speed with an explicit float tolerance; \productionRatePerHour\, which computes the hourly production output; and \workingItemsPerMinute\, which determines the number of successfully assembled items per minute. The test suite includes specific test cases for each function, covering various speed inputs and verifying results against expected values.

exercises/concept/cars-assemble · high confidence

The Darts practice exercise now includes its configuration metadata, test definitions, and an example solution. The config.json file defines the exercise files (solution, test, example, and invalidator) and provides a blurb describing the task as calculating points scored in a single toss of a Darts game. The tests.toml file lists 13 specific test cases covering various target positions, including missed targets, positions on the inner, middle, and outer circles, and edge cases near circle boundaries. The Example.fs file provides a reference implementation that calculates the score based on the distance from the center, awarding 10 points for the inner circle (distance \<= 1.0), 5 for the middle (\<= 5.0), 1 for the outer (\<= 10.0), and 0 otherwise.

(repo-wide) · high confidence

A new practice exercise has been added for the F\# track, requiring users to count the number of set bits (1s) in the binary representation of a given integer. The package includes the problem instructions, a stub implementation in EliudsEggs.fs, a test suite in EliudsEggsTests.fs, and an example solution in .meta/Example.fs.

exercises/practice/eliuds-eggs · high confidence

The 'Change' exercise is now available in F\#, providing a stub implementation in Change.fs for users to complete. The .meta directory includes an Example.fs file demonstrating a correct solution using dynamic programming to find the fewest coins for a given target, along with config.json and tests.toml files that define the exercise metadata and map 14 specific test cases (such as handling single coins, multiple coins, and error conditions) to the F\# test suite.

exercises/practice/change/.meta · high confidence

Users can now practice the Diffie-Hellman key exchange algorithm in F\#. This change introduces the initial exercise files, including a stub implementation in DiffieHellman.fs with placeholder functions for generating private keys, calculating public keys, and deriving shared secrets, along with a corresponding test suite in DiffieHellmanTests.fs that validates key generation constraints and cryptographic correctness.

exercises/practice/diffie-hellman · high confidence

Introduced the Isogram practice exercise for F\#, providing a starter implementation in Isogram.fs and a comprehensive test suite in IsogramTests.fs. The tests cover various scenarios including empty strings, case-insensitive checks, hyphenated words, and mixed-case inputs, allowing users to implement the isIsogram function to determine if a string contains no duplicate letters.

exercises/practice/isogram · high confidence

Introduced the SimpleLinkedList practice exercise for the F\# track, providing a stub file with placeholder implementations for the linked list API (nil, create, isNil, next, datum, toList, fromList, reverse) and a corresponding test suite using xUnit. The test file includes cases for empty lists, single and multi-item lists, conversion between lists and linked lists, reversal, and roundtrip integrity, with most tests initially skipped to guide learners through the implementation steps.

exercises/practice/simple-linked-list · high confidence

Introduced a new F\# concept exercise that guides users through defining basic functions and bindings, including expected minutes in oven, remaining minutes in oven, preparation time, and elapsed time.

exercises/concept/lucians-luscious-lasagna · high confidence

Introduced the 'Booking Up for Beauty' concept exercise in the F\# track, providing stubs and tests for five functions: parsing appointment strings into DateTime objects, checking if an appointment has passed, determining if it is an afternoon appointment, formatting a description string, and retrieving the anniversary date.

exercises/concept/booking-up-for-beauty · high confidence

Introduced the 'interest-is-interesting' concept exercise to teach F\# users about floating-point types (decimal, float, double) and their usage in financial calculations. The package includes the exercise configuration, design documentation outlining learning objectives, and an exemplar solution demonstrating functions for calculating interest rates, updating balances, and determining donation amounts based on tax-free percentages.

exercises/concept/interest-is-interesting/.meta · high confidence

New F\# concept exercises have been added for 'Annalyn's Infiltration' (covering boolean types and operators) and 'Tracks on Tracks on Tracks' (covering list creation, manipulation, and pattern matching). Each exercise includes a solution exemplar, design documentation outlining learning objectives, and configuration files defining the file structure and prerequisites.

exercises/concept/annalyns-infiltration/.meta, exercises/concept/tracks-on-tracks-on-tracks/.meta · high confidence

Added the F\# implementation stub (CustomSet.fs) and the corresponding test suite (CustomSetTests.fs) for the custom-set exercise. The stub provides the module structure with placeholder functions for set operations (empty, singleton, isEmpty, size, fromList, toList, contains, insert, union, intersection, difference, isSubsetOf, isDisjointFrom), while the test file includes the full set of unit tests to guide implementation.

(repo-wide) · high confidence

The Nucleotide Count exercise now includes an F\# example implementation (.meta/Example.fs) that demonstrates how to count nucleotides in a DNA strand, including validation for invalid inputs. The exercise metadata (config.json) has been updated to reference this example file and list the authors and contributors, while the test configuration (tests.toml) defines the specific test cases for empty strands, single characters, repeated nucleotides, multiple nucleotides, and invalid inputs.

exercises/practice/alphametics/.meta, exercises/practice/nucleotide-count/.meta · high confidence

The Protein Translation exercise now includes an official F\# example solution (Example.fs) in the .meta directory, providing a reference implementation that translates RNA sequences into proteins by mapping codons to amino acids and handling STOP conditions. This addition is accompanied by the creation of the exercise's configuration file (config.json) defining authors, contributors, and file paths, as well as a tests.toml file that synchronizes the test suite with the problem-specifications, ensuring the F\# track's test cases align with the canonical exercise data.

(repo-wide) · high confidence

New example implementations and configuration files have been added for the Affine Cipher, OCR Numbers, and Saddle Points exercises. The \Example.fs\ files provide reference solutions for users to study, while \config.json\ files define the exercise metadata (including authors, blurb, and file paths) and \tests.toml\ files map the specific test cases to their descriptions, ensuring the exercises are fully configured for the track.

exercises/practice/affine-cipher/.meta, exercises/practice/ocr-numbers/.meta, exercises/practice/saddle-points/.meta · high confidence

New practice exercises have been added for the F\# track, including stubs and test suites for Allergies, Armstrong Numbers, Book Store, Bowling, Complex Numbers, Dominoes, Luhn, Matching Brackets, Meetup, Pangram, and Queen Attack. These files provide the initial implementation placeholders and test cases for users to solve these specific coding challenges.

(repo-wide) · high confidence

A new concept exercise has been added to the F\# track that teaches students how to work with the \Option\ type. The exercise uses a role-playing game scenario where students implement mechanics for introducing a player (handling optional names), reviving a character (managing optional health and mana states), and casting spells (checking for sufficient mana). It includes instructions, hints, an introduction to Option usage, and a test suite covering pattern matching and default value handling.

exercises/concept/role-playing-game · high confidence

New F\# exercise stubs and corresponding test suites have been added for the Affine Cipher, Clock, OCR Numbers, Pythagorean Triplet, and Saddle Points tracks. These files provide the initial implementation placeholders and test cases for users to complete within the practice directory.

(repo-wide) · high confidence

A new practice exercise called 'Flower Field' has been added to the .NET track. This exercise, which serves as a reimagining of the classic Minesweeper game, requires users to implement an \annotate\ function that calculates adjacent flower counts for a garden grid. The addition includes the starter F\# code (\FlowerField.fs\), a comprehensive test suite (\FlowerFieldTests.fs\), an example solution, and associated metadata and documentation files.

exercises/practice/flower-field, exercises/practice/resistor-color-trio · high confidence

A new practice exercise has been added to the F\# track, requiring users to implement a helper function that calculates valid digit combinations for Killer Sudoku cages. The solution must respect standard Sudoku constraints (no repeated digits within a cage, exclusion of digits already present in the relevant row/column) and return sorted combinations that sum to a specified target. The entry includes the problem instructions, test cases, and a reference implementation.

(repo-wide) · high confidence

A new F\# exercise has been added to teach the use of the \Result\ type for handling success and failure states. Students implement a password validator that checks for length, character types, and symbols, returning a \Result\<string, PasswordError\>\ to indicate whether the password is valid or which specific rule was violated. The exercise also requires implementing a helper function to generate human-readable error messages for each failure case.

exercises/concept/password-checker · high confidence

This change introduces the new 'Satellite' exercise, which challenges users to reconstruct a binary tree from its pre-order and in-order traversals. The addition includes the F\# solution stub (\Satellite.fs\), a comprehensive test suite (\SatelliteTests.fs\) covering cases like empty trees, degenerate structures, and validation of invalid inputs (mismatched lengths, inconsistent elements, or duplicate items), along with the example solution, instructions, and configuration files required to run the exercise.

exercises/practice/satellite · high confidence

A new practice exercise, Save the Cow, has been added to the C\# track. This word-guessing game challenges users to implement logic for guessing letters in a secret word, with a limit of ten incorrect guesses before losing. The entry includes the necessary test scaffolding, instructions, and an example solution to guide learners.

exercises/practice/save-the-cow · high confidence

A new concept exercise, Tisbury Treasure Hunt, has been added to the F\# track to teach users about tuples. The exercise includes configuration files, a design document outlining learning objectives (such as tuple definition, structural equality, and pattern matching), and an exemplar solution that demonstrates combining data from two sources using tuple operations.

exercises/concept/tisbury-treasure-hunt/.meta · high confidence

The Trinary practice exercise is now available, including an example solution (Example.fs) that converts trinary strings to decimal values and a test configuration (tests.toml) defining the expected test cases for validation.

exercises/practice/trinary/.meta · high confidence

The Two Bucket practice exercise is now available, providing a starter file for users to implement a solution that measures a specific volume using two buckets of given capacities. The release includes a complete example solution in .meta/Example.fs, a corresponding test suite in TwoBucketTests.fs, and metadata configuration in .meta/config.json and .meta/tests.toml to define the exercise scope and test cases.

exercises/practice/forth/.meta, exercises/practice/two-bucket/.meta · high confidence

Added the instructional materials for the new 'Valentine's Day' concept exercise, including introduction, instructions, and hints files. The exercise guides users through defining and using discriminated unions in F\# to model activities, approvals, cuisines, and genres, and to implement pattern matching logic for rating those activities.

exercises/concept/valentines-day/.docs · high confidence

The Zebra Puzzle exercise now includes an official example solution (Example.fs) that demonstrates how to solve the logic puzzle using F\# permutations and constraint matching. The exercise metadata (config.json) has been updated to reference this new example file, list the authors and contributors, and provide a blurb and source attribution. Additionally, the test configuration (tests.toml) has been synchronized to map the specific test cases for identifying the water-drinking resident and the zebra-owning resident.

(repo-wide) · high confidence

A new F\# practice exercise has been added to help users practice formatting ordinal numerals. The task requires implementing a function that takes a customer's name and a number (1–999) and returns a formatted sentence (e.g., "Mary, you are the 1st customer..."). The solution must correctly handle English ordinal suffixes (st, nd, rd, th), including exceptions for numbers ending in 11, 12, and 13.

exercises/practice/line-up · high confidence

Added the 'bottle-song' exercise, which challenges users to recite the lyrics to the children's song 'Ten Green Bottles'. The implementation requires generating verses that count down from a starting number of bottles, handling singular/plural grammar (e.g., 'bottle' vs 'bottles') and capitalization correctly, and joining multiple verses with blank lines.

exercises/concept/tisbury-treasure-hunt, exercises/practice/bottle-song, exercises/practice/game-of-life · high confidence

A new tool, CodeFenceChecker, has been added to the tools directory to validate F\# code snippets within Markdown files. The tool scans Markdown files for F\# code fences, parses them using the F\# Interactive (FSI) engine, and reports any compilation errors, helping to ensure that code examples in documentation are valid.

tools · high confidence

Added new documentation files (instructions, hints, and introduction) for the Annalyn's Infiltration concept exercise, providing learners with the narrative context, task definitions, and F\# boolean operator guidance required to complete the exercise.

exercises/concept/annalyns-infiltration/.docs · high confidence

Added the introduction, instructions, and hints documentation files for the Bird Watcher concept exercise, providing users with the necessary context, task descriptions, and guidance for implementing array operations in F\#.

exercises/concept/bird-watcher/.docs · high confidence

Added the introduction, instructions, and hints documentation files for the 'tracks-on-tracks-on-tracks' concept exercise. These files provide users with the necessary context, task descriptions, and guidance for learning F\# list operations such as creation, modification, counting, reversing, and pattern matching.

exercises/concept/tracks-on-tracks-on-tracks/.docs · high confidence

This change introduces the official example solution files (Example.fs) and associated metadata (config.json, tests.toml) for the Atbash Cipher, Grains, and RNA Transcription practice exercises. For users, this means the track now provides reference implementations to study after completing these exercises, along with updated configuration details including author/contributor credits, specific file mappings for solutions and tests, and explicit test case descriptions defined in tests.toml to clarify expected behavior.

exercises/practice/atbash-cipher/.meta, exercises/practice/grains/.meta, exercises/practice/rna-transcription/.meta · high confidence

The Robot Simulator exercise now includes an official example solution (Example.fs) that demonstrates the required types (Direction, Position, Robot) and functions (create, move) for handling robot instructions. Additionally, the exercise metadata has been updated with a config.json file listing authors and contributors, and a tests.toml file mapping test cases to their descriptions, ensuring the exercise is fully configured for learners.

exercises/practice/robot-simulator/.meta · high confidence

The Variable Length Quantity exercise now includes an official F\# example solution (Example.fs) that demonstrates how to encode integers into variable-length bytes and decode them back, along with the necessary metadata configuration (config.json) and test synchronization file (tests.toml) to support the exercise in the track.

exercises/practice/variable-length-quantity/.meta · high confidence

Added .meta/Example.fs reference implementations and .meta/config.json metadata files for the Grade School and High Scores exercises. The Grade School example provides functions to manage a school roster (adding students, retrieving the full roster sorted by grade and name, and retrieving students by grade), while the High Scores example implements functions to retrieve the list of scores, the latest score, the personal best, and the top three scores. These files serve as reference solutions for learners and define the exercise structure, including authors, contributors, and test mappings via tests.toml.

(repo-wide) · high confidence

This change introduces official example implementations (\.meta/Example.fs\) and associated metadata files (\config.json\, \tests.toml\) for several practice exercises, including all-your-base, go-counting, react, and rest-api. The \config.json\ files define the exercise structure, listing solution, test, and example file paths, while \tests.toml\ maps test cases to their descriptions. These additions provide users with reference solutions to study and clarify the expected behavior for these specific tracks.

(repo-wide) · high confidence

Added reference implementation files (Example.fs) and updated metadata (config.json, tests.toml) for the Food Chain and Twelve Days exercises, providing users with official solution examples to guide their practice.

exercises/practice/food-chain/.meta, exercises/practice/twelve-days/.meta · high confidence

The guessing-game, pizza-pricing, and valentines-day concept exercises now include official exemplar solutions (Exemplar.fs) and updated config.json files that register these exemplars. This provides learners with reference implementations for pattern matching, recursive functions/types, and discriminated unions respectively, alongside design documentation outlining the specific learning objectives and scope for each exercise.

exercises/concept/guessing-game/.meta, exercises/concept/pizza-pricing/.meta, exercises/concept/valentines-day/.meta · high confidence

The F\# track now includes the Poker practice exercise, providing a starter module (Poker.fs) with a placeholder implementation and a comprehensive test suite (PokerTests.fs). The tests cover the full hierarchy of poker hands, including single hands, high cards, pairs, two pairs, three of a kind, straights (with special ace rules), flushes, full houses, and four of a kind, along with tie-breaking logic. Most tests are initially skipped, requiring users to remove the skip attribute to run them as they implement the solution.

exercises/practice/poker · high confidence

Three new concept exercises have been added to the F\# track, providing starter code and test suites for learners. The Guessing Game exercise requires implementing a function that returns hints based on a guessed number relative to a target. The Log Levels exercise focuses on string manipulation, asking users to extract messages, identify log levels, and reformat log entries. The Pizza Pricing exercise introduces discriminated unions and recursion, requiring the calculation of prices for individual pizzas with optional toppings and for entire orders.

exercises/concept/guessing-game, exercises/concept/log-levels, exercises/concept/pizza-pricing · high confidence

A new 'Performance deep dive' article has been added to the Protein Translation exercise, introducing a fourth solution approach that uses \Span\<T\>\ for efficient string handling. The article includes F\# implementation code for recursion, \Seq\ module, \Seq.unfold\, and the new \Span\ approaches, along with benchmark results generated using BenchmarkDotNet to compare their execution time and memory allocation across different input sizes.

exercises/practice/protein-translation/.articles · high confidence

New F\# practice exercises have been added for Acronym, All Your Base, Alphametics, Atbash Cipher, Beer Song, Binary Search, Binary Search Tree, Circular Buffer, Collatz Conjecture, Difference of Squares, D&D Character, ETL, and Food Chain. Each exercise includes a stub implementation file with placeholder functions and a corresponding test suite where most tests are skipped by default, allowing users to begin working on the problems.

(repo-wide) · high confidence

New practice exercises for Connect and Perfect Numbers have been added to the F\# track. The Connect exercise provides a test suite for determining the winner of a board game, while the Perfect Numbers exercise introduces a Classification type (Perfect, Abundant, Deficient) and a classify function for categorizing integers.

exercises/practice/connect, exercises/practice/perfect-numbers · high confidence

New F\# exercise stubs and corresponding test suites have been added for the Darts and Grains tracks. The Darts exercise provides a \score\ function to calculate points based on coordinate distance, while the Grains exercise provides \square\ and \total\ functions that return \Result\<uint64, string\>\ to handle valid square calculations and error cases for invalid inputs.

exercises/practice/darts, exercises/practice/grains · high confidence

The F\# track now includes the Diamond practice exercise, providing a starter file (Diamond.fs) with a stub implementation and a comprehensive test suite (DiamondTests.fs) using FsCheck for property-based testing. Users can now complete the exercise by implementing the make function to generate a diamond shape of letters.

exercises/practice/diamond · high confidence

The F\# track now includes an official example solution for the D&D Character exercise, providing a reference implementation for calculating ability modifiers and generating random character stats. This change also introduces the necessary metadata files (config.json and tests.toml) to define the exercise structure, link the example file, and specify the test cases for the track.

exercises/practice/dnd-character/.meta · high confidence

The REST API exercise is now available for F\# learners. The implementation stub defines a \RestApi\ class with \Get\ and \Post\ methods that throw \NotImplementedException\ (via \failwith\), and the test suite includes cases for retrieving users, adding users, and handling IOU transactions, with most tests initially skipped to guide implementation.

exercises/practice/rest-api · high confidence

The Zipper practice exercise is now available for F\# learners. The change introduces the \Zipper.fs\ stub file, which defines the module structure for the solution, and the \ZipperTests.fs\ file containing the initial test suite. The tests cover core zipper operations such as traversing left and right, moving up the tree, retrieving values, and modifying the tree structure (setting values, left children, and right children). Most tests are currently skipped, requiring users to remove the skip attributes to run them as they implement the solution.

exercises/practice/bob, exercises/practice/wordy, exercises/practice/zipper · high confidence

New documentation files (hints.md, instructions.md, introduction.md) and a template file (introduction.md.tpl) have been added to the booking-up-for-beauty concept exercise. These files provide learners with guidance on using the F\# DateTime class, including parsing dates, checking if appointments have passed, determining if they are in the afternoon, describing dates, and calculating anniversary dates, while noting that the test culture is set to en-US.

exercises/concept/booking-up-for-beauty/.docs · high confidence

New documentation files (instructions, hints, and introductions) have been added for the F\# concept exercises 'guessing-game' and 'pizza-pricing'. The guessing-game exercise introduces pattern matching, including constant, variable, and wildcard patterns, as well as guards. The pizza-pricing exercise introduces recursion, covering recursive functions and recursive discriminated union types.

exercises/concept/guessing-game/.docs, exercises/concept/pizza-pricing/.docs · high confidence

New documentation files have been added for the bandwagoner exercise, including instructions, hints, and an introduction to F\# records. The instructions guide users through defining records (Coach, Stats, Team) and implementing functions to create, update, and compare them, while the introduction explains record syntax, structural equality, and pattern matching.

exercises/concept/bandwagoner/.docs, exercises/concept/tisbury-treasure-hunt/.docs · high confidence

The Transpose exercise now includes an official example solution (Example.fs) that demonstrates how to transpose input text, along with a config.json file defining the exercise metadata (authors, source, and file paths) and a tests.toml file mapping specific test cases to their descriptions. This allows users to view a reference implementation and ensures the exercise's test suite is properly configured within the track.

(repo-wide) · high confidence

Example solution files (e.g., Example.fs) and corresponding .meta/config.json metadata files have been added for the bank-account, hangman, lens-person, and parallel-letter-frequency practice exercises. These additions provide reference implementations for users and configure exercise metadata such as authors, contributors, file paths, and blurbs.

(repo-wide) · high confidence

A new benchmark suite has been added to the Tree Building exercise to measure and compare the performance of the solution implementation against a baseline. The benchmarks use BenchmarkDotNet to run scenarios including single nodes, ordered and reverse-ordered inputs, trees with multiple children, binary trees, and unbalanced trees, providing users with insight into the efficiency of their tree-building logic.

exercises/practice/tree-building/benchmark · high confidence

The Bird Watcher concept exercise now includes the initial F\# source file (BirdWatcher.fs) and its corresponding test suite (BirdWatcherTests.fs). The source file provides stub implementations for six functions: lastWeek, yesterday, total, dayWithoutBirds, incrementTodaysCount, and unusualWeek. The test suite defines six tasks, with Task 6 (unusualWeek) featuring extensive pattern-matching scenarios to validate odd/even day zero or ten counts, ensuring learners practice array manipulation and conditional logic.

exercises/concept/bird-watcher · high confidence

Added the Log Levels exercise for the F\# track, including the configuration file, design documentation, and an exemplar solution. This exercise teaches string manipulation concepts such as finding character indices, slicing strings, and concatenation by parsing application log lines.

exercises/concept/log-levels/.meta · high confidence

This change introduces the complete F\# track for Exercism, including the track configuration (config.json), a suite of practice and concept exercises, and the necessary tooling for local development and CI. Users can now complete F\# exercises, with support for the online editor and local test generation via PowerShell scripts and .NET Core local tools.

(repo-wide) · high confidence

The \generators\ directory now contains a complete F\# toolchain (including \Generators.fs\, \Exercise.fs\, and Liquid templates) that reads canonical test data from the \problem-specifications\ repository and generates corresponding F\# test files for practice exercises. This allows users to automatically keep their exercise test suites in sync with upstream canonical data, supporting features like skipping specific tests via \tests.toml\ and rendering complex assertions.

generators · high confidence

Added the initial stub implementation and test suite for the Robot Simulator exercise. The stub defines the \Direction\ and \Position\ types and provides \create\ and \move\ functions that currently throw exceptions, while the test file includes cases for initializing robot state, turning left/right, and moving forward, with most tests skipped by default to guide implementation.

exercises/practice/robot-simulator · high confidence

A new concept exercise for the F\# track has been added to teach users about the \DateTime\ type, including creating instances, accessing current date/time, comparing dates, and converting between strings and \DateTime\ objects. The package includes the exercise configuration, a design document outlining learning objectives and scope, and an exemplar solution demonstrating the required functionality.

exercises/concept/booking-up-for-beauty/.meta · high confidence

The Lucians Luscious Lasagna concept exercise now provides a reference implementation (Exemplar.fs) that demonstrates the expected solution in F\#. This exemplar defines the core functions—expectedMinutesInOven, remainingMinutesInOven, preparationTimeInMinutes, and elapsedTimeInMinutes—allowing users to compare their work against a standard solution. The exercise configuration has been updated to include this file alongside the existing solution and test files, and the design documentation clarifies the learning objectives around F\# basics such as values, bindings, functions, and type inference.

exercises/concept/lucians-luscious-lasagna/.meta · high confidence

Added the 'Improved Password Checker' concept exercise, which teaches users how to apply the \\[\<Flags\>\]\ attribute to F\# discriminated unions. The exercise requires implementing a password validation function that returns a combined error state for multiple rule violations using bitwise operations, and a helper function to convert those flags into human-readable status phrases.

exercises/concept/improved-password-checker · high confidence

Added PowerShell and Bash scripts to the bin directory to streamline track maintenance: fetch-configlet downloads the latest configlet binary for the current OS and architecture; add-practice-exercise scaffolds new exercises using .NET 10 and xUnit v3; test.ps1 validates solution correctness by running example implementations against test suites; update-exercises.ps1 syncs metadata and regenerators; check-code-snippets.ps1 validates F\# syntax in documentation; and update-exercise-tools.ps1 refreshes local tool manifests.

bin · high confidence

Added Exercises.slnx and Refactoring.slnx to organize the F\# exercise collection. Exercises.slnx lists all concept and practice exercises, including new additions like camicia, save-the-cow, and line-up, while Refactoring.slnx groups specific practice exercises (ledger, markdown, tree-building) for refactoring workflows.

exercises · high confidence

The exercise documentation has been updated to reflect the F\# track implementation. New files (hints.md, instructions.md, introduction.md) and a template (introduction.md.tpl) were added, providing F\#-specific guidance on bindings, functions, type inference, and modules, replacing previous generic or C\#-aligned content.

exercises/concept/lucians-luscious-lasagna/.docs · high confidence

New documentation files have been added for the F\# interest-is-interesting concept exercise, including an introduction to floating-point types (single, float, decimal), detailed instructions for four tasks (calculating interest rate, interest, annual balance update, and donation amount), and a hints file with formulas and F\# operator references.

exercises/concept/interest-is-interesting/.docs · high confidence

The Bird Watcher concept exercise has been updated to include a new exemplar solution file (Exemplar.fs) that demonstrates the expected implementation for array operations, including pattern matching and mutation. The exercise configuration (config.json) has been updated to reference this new exemplar file and includes a blurb describing the learning objectives. Additionally, the design documentation has been added to clarify the learning objectives, prerequisites, and out-of-scope topics for the exercise.

exercises/concept/bird-watcher/.meta · high confidence

The exercise configuration now includes an official example solution (Example.fs) that implements the steps calculation, along with updated metadata (config.json) listing authors and contributors. The test suite metadata (tests.toml) has been synchronized to the latest problem specifications, explicitly marking the previous 'zero is an error' and 'negative value is an error' test cases as reimplemented to align with the current spec.

exercises/practice/collatz-conjecture/.meta · high confidence

The F\# Ledger exercise implementation has been updated to correctly handle line endings and cultural formatting. The code now uses \System.Environment.NewLine\ for row separation instead of hardcoded strings, ensuring compatibility across different operating systems. Additionally, the date formatting and currency symbol placement for both \en-US\ and \nl-NL\ locales have been refined to match the expected test outputs, specifically addressing how negative numbers and long descriptions are rendered.

exercises/practice/ledger · high confidence

The Cars Assemble exercise now includes a success rate mechanic that adjusts production output based on vehicle speed, alongside a new official exemplar solution. Users will see updated test requirements to calculate success rates (with specific multipliers for different speed ranges) and production metrics, while the provided reference implementation demonstrates the correct logic for handling these conditional calculations.

exercises/concept/cars-assemble/.meta · high confidence

The Pig Latin practice exercise now includes a complete set of unit tests covering various linguistic rules, such as handling vowels, consonant clusters (ch, th, sch, qu), and the special behavior of 'y'. The stub file remains unchanged, requiring users to implement the \translate\ function to pass these new assertions.

exercises/practice/pig-latin · high confidence

The F\# Hello World exercise stub has been updated to provide a simpler starting point for students. The new stub defines the module and a \hello\ function returning "Goodbye, Mars!", reducing initial syntax complexity while the test suite verifies the correct output of "Hello, World!".

exercises/practice/hello-world · high confidence

The Tracks on Tracks on Tracks exercise now enforces a stricter definition of an 'exciting' list: F\# is only considered exciting if it appears in a list of three or fewer items. Previously, the logic may have allowed F\# to be exciting in longer lists, but the updated tests (specifically for four-item lists) now expect false when F\# is present in lists of four or more items, regardless of position.

exercises/concept/tracks-on-tracks-on-tracks · high confidence

The F\# Linked List exercise has been updated to align with the v3 track structure. The stub file (LinkedList.fs) now exposes the core API functions: mkLinkedList, push, pop, shift, and unshift, all initially throwing NotImplementedException. The test suite (LinkedListTests.fs) has been refreshed to verify these operations, including tests for FIFO/Last-In-First-Out behavior via shift/unshift and LIFO/First-In-First-Out behavior via pop/push, with most tests marked as skipped by default to guide the learner.

exercises/practice/linked-list · high confidence

The Markdown practice exercise now includes a corrected default implementation (Markdown.fs) that properly handles parsing of headers, unordered lists, bold text, and italic text, along with updated tests (MarkdownTests.fs) to verify these behaviors.

exercises/practice/markdown · high confidence

The documentation files for the F\# Log Levels exercise have been replaced with new concept-specific content. The introduction now explains string immutability, concatenation, and formatting. The instructions define three tasks: extracting the message, retrieving the log level in lowercase, and reformating the log line. A new hints file provides guidance on using string methods like IndexOf, Trim, and ToLower.

exercises/concept/log-levels/.docs · high confidence

The Variable Length Quantity exercise now provides a complete set of test cases for both encoding and decoding operations, covering single through quintuple byte sequences and edge cases like incomplete sequences. The stub implementation file remains empty, requiring users to implement the \encode\ and \decode\ functions to pass the newly added tests.

exercises/practice/variable-length-quantity · high confidence

The F\# exercise project files have been updated to target .NET 10.0 and migrated to xUnit v3 (version 3.2.2), replacing the previous xUnit 2.x versions. This change also updates the Microsoft.NET.Test.Sdk to 18.3.0, FsUnit.xUnit to 7.1.1, and the Exercism.Tests.xunit.v3 package to 0.1.0-beta1, ensuring the exercises are compatible with the latest .NET runtime and testing framework.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 61 → 58 (-3.1)
• Rubric changed (rubric-2026.09.13 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 85 → 85 (+0.0)
• Architecture 100 → 100 (+0.0)
• Maturity 40 → 40 (+0.0)
• Readiness 74 → 61 (-12.6)
• Security 86 → 83 (-3.3)
• Performance 90 (new)

• Documentation: no installation or build instructions (README.md)

• Banned license: Exercism.Tests.xunit.v3
• Deprecated: LibGit2Sharp
• Documentation: no project overview (README.md)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Outdated: BenchmarkDotNet
• Outdated: DotLiquid
• Outdated: FSharp.Core
• Outdated: FakeItEasy
• Outdated: FsCheck.Xunit.v3
• Outdated: Humanizer
• Outdated: LibGit2Sharp
• Outdated: Microsoft.NET.Test.Sdk
• Outdated: Newtonsoft.Json
• Outdated: Serilog
• Outdated: Serilog.Sinks.Console
• Outdated: Tomlyn
• Outdated: xunit.runner.visualstudio
• …and 3 more

• 1 commits — 1 feature/other, 0 fixes

• .github/workflows — 1 commit

• change: 🤖 Sync org-wide files to upstream repo (#1395)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

exercism/fsharp was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.