Skip to content
CAI
Software that uses CAICheck a score

exercism/fsharp

64.2

Adequate · 15 November 2026

2.3k

lines of production code

F#

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Anagram exercise stub, example solution, and test metadata for F\#

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

Add Annalyn's Infiltration and Valentines Day concept exercises

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

Add Bandwagoner concept exercise for F\# records

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

Add Bandwagoner concept exercise for learning F\# records

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

Add Camicia card game simulation exercise

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

Add Cars Assemble exercise with success rate, production rate, and working items calculations

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

Add Darts exercise metadata and example solution

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

Add Eliud's Eggs exercise for F\#

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

Add F\# 'Change' exercise with solution and tests

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

Add F\# 'Squeaky Clean' concept exercise

Introduced a new F\# concept exercise focused on the \char\ type, teaching learners how to manipulate individual characters within strings. The exercise requires implementing \transform\ and \clean\ functions to handle specific identifier-cleaning rules: replacing hyphens with underscores, removing whitespace and digits, converting camelCase to kebab-case, and replacing Greek lowercase letters with question marks.

(repo-wide) · high confidence

Add F\# Diffie-Hellman exercise stubs and tests

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

Add F\# Isogram exercise with test suite

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

Add F\# Robot Simulator exercise stub and tests

Introduced the F\# implementation for the Robot Simulator exercise, providing a starter file with the \RobotSimulator\ module, \Direction\ and \Position\ types, and stubs for the \create\ and \move\ functions. The accompanying test suite includes cases for initial positioning, turning left and right, advancing in cardinal directions, and complex movement sequences, with most tests initially skipped to guide the learner through the implementation.

(repo-wide) · high confidence

Add F\# SimpleLinkedList exercise stub and tests

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

Add F\# concept exercise for Lucian's Luscious Lasagna

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

Add F\# concept exercise for appointment scheduling

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

Add F\# concept exercise for floating-point numbers

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

Add F\# concept exercise for interest calculations

The F\# track now includes the 'Interest Is Interesting' concept exercise, providing students with stubs and tests for four functions: \interestRate\, \interest\, \annualBalanceUpdate\, and \amountToDonate\. This exercise guides learners through implementing logic for calculating tiered interest rates, applying interest to balances, updating annual balances, and calculating donation amounts based on tax-free percentages.

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

Add F\# concept exercises for booleans and lists

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

Add F\# custom-set exercise stub and tests

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.

exercises/practice/largest-series-product · high confidence

Add F\# example solution and metadata for Protein Translation exercise

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

Add F\# example solution and metadata for the 'Say' exercise

The 'Say' exercise now includes an official F\# example solution (Example.fs) that converts integers from 0 to 999,999,999,999 into their English word representation, handling ranges, hundreds, thousands, millions, and billions. This addition is accompanied by the creation of the exercise's metadata configuration (config.json) and test mapping (tests.toml), enabling users to view a reference implementation and ensuring the test suite is correctly aligned with the problem specifications.

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

Add F\# example solutions and metadata for Affine Cipher, OCR Numbers, and Saddle Points

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

Add F\# practice exercises

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

Add F\# role-playing game exercise for Option types

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

Add F\# stubs and tests for practice exercises

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

Add Flower Field exercise for .NET

A new practice exercise called 'Flower Field' has been added to the .NET track, serving as a reimagined version of the classic Minesweeper game. Users are tasked with implementing an \annotate\ function that takes a grid of flowers and spaces and returns the grid with numbers indicating the count of adjacent flowers for each empty square. The entry includes the stub implementation, test suite, example solution, and configuration files.

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

Add Forth exercise with example solution and test metadata

The Forth practice exercise is now available, including an example solution (\Example.fs\) that implements an evaluator for a simple subset of Forth. This implementation supports stack-based arithmetic (addition, subtraction, multiplication, division), stack manipulation (dup, drop, swap, over), and user-defined words. The entry also adds the necessary metadata files (\config.json\ and \tests.toml\) to define the exercise structure and map the test cases.

exercises/practice/forth/.meta · high confidence

Add Killer Sudoku Helper exercise for F\#

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.

exercises/practice/resistor-color · high confidence

Add PasswordChecker exercise for the Result concept

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

Add Point of View exercise example solution and metadata

The Point of View exercise now includes an example solution (Example.fs) that demonstrates how to reparent a graph on a selected node and trace paths between nodes using a zipper-based approach. The exercise metadata (config.json) has been created to define the file structure, authors, and blurb, while tests.toml maps the specific test cases for rerooting trees and finding paths.

exercises/practice/pov/.meta · high confidence

Add Satellite exercise for rebuilding binary trees from traversals

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

Add Save the Cow exercise for the C\# track

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

Add Tisbury Treasure Hunt concept exercise for tuples

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

Add Trinary exercise with example solution and test configuration

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

Add Two Bucket exercise with example solution and test suite

The Two Bucket practice exercise is now available, including the stub file for implementation, a comprehensive test suite covering various bucket sizes and goal conditions, and an example solution that demonstrates the correct algorithm for measuring exact amounts using two buckets.

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

Add Valentine's Day exercise documentation

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

Add Zebra Puzzle example solution and metadata

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

Add \`line-up\` exercise for generating ordinal customer sentences

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

Add bottle-song exercise

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/game-of-life · high confidence

Add code fence validation tool for Markdown documentation

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

Add concept exercise documentation for Annalyn's Infiltration

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

Add documentation for the Bird Watcher exercise

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

Add documentation for the F\# lists concept exercise

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

Add example implementations and metadata for Atbash Cipher, Grains, and RNA Transcription exercises

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

Add example solution and configuration for Robot Simulator

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

Add example solution and configuration for Variable Length Quantity exercise

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

Add example solution and metadata for Binary Search Tree

An example implementation for the Binary Search Tree exercise has been added, providing a reference solution that constructs a tree from a list of integers, supports insertion, and retrieves sorted data. The exercise metadata has been updated to include author and contributor information, a blurb describing the exercise, and a test configuration file mapping specific test cases to their descriptions.

exercises/practice/crypto-square/.meta, exercises/practice/largest-series-product/.meta, exercises/practice/simple-linked-list/.meta · high confidence

Add example solutions and metadata for Grade School and High Scores exercises

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.

exercises/practice/etl/.meta, exercises/practice/matrix/.meta, exercises/practice/grade-school/.meta, exercises/practice/high-scores/.meta, exercises/practice/queen-attack/.meta, exercises/practice/series/.meta · high confidence

Add example solutions and metadata for practice exercises

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

Add example solutions for Food Chain and Twelve Days exercises

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

Add exemplar solutions and configuration for three F\# concept exercises

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

Add initial Poker exercise stub and test suite for F\#

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/bob, exercises/practice/poker · high confidence

Add new F\# concept exercises: Guessing Game, Log Levels, and Pizza Pricing

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

Add performance deep-dive article with Span-based approach

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

Add stub exercises to the practice track

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

Added Connect and Perfect Numbers exercises for F\#

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

Added Darts and Grains exercise stubs and tests

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

Added F\# Diamond exercise stub and property-based tests

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

Added F\# custom-set exercise stub and tests

The F\# track now includes the 'custom-set' practice exercise. Students are provided with a stub file defining the CustomSet module and a comprehensive test suite covering set operations such as creation, insertion, union, intersection, difference, subset checks, and equality. Most tests are initially skipped, requiring the student to implement the logic to pass them.

exercises/practice/custom-set · high confidence

Added F\# example solution and metadata for the Transpose exercise

The Transpose exercise now includes an official F\# example solution (Example.fs) that demonstrates how to transpose input text by mapping characters to coordinates and reconstructing rows. This is accompanied by the necessary metadata files (config.json and tests.toml) which define the exercise configuration, list the authors and contributors, and specify the test cases to be validated against the solution.

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

Added F\# track for the REST API exercise

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

Added ISBN Verifier exercise for F\#

A new practice exercise for the ISBN Verifier problem has been added to the F\# track. It includes a stub implementation in IsbnVerifier.fs and a comprehensive test suite in IsbnVerifierTests.fs that validates ISBN-10 check digit logic, including handling of dashes, the 'X' check digit, and various invalid input formats.

exercises/practice/isbn-verifier · high confidence

Added Zipper exercise stub and test suite for F\#

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/wordy · high confidence

Added documentation files for the booking-up-for-beauty exercise

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

Added documentation for F\# guessing-game and pizza-pricing concept exercises

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

Added documentation for the F\# Cars Assemble exercise

New documentation files have been added for the F\# Cars Assemble concept exercise, including instructions, hints, and an introduction to the relevant concepts (Numbers and Conditionals). The instructions define three tasks: calculating the success rate based on production speed, calculating the production rate per hour, and calculating the number of working items produced per minute. The hints provide guidance on using conditional expressions and type conversion operators in F\#.

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

Added documentation for the bandwagoner concept exercise

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

Added example solution and metadata configuration for the Accumulate exercise

The Accumulate exercise now includes a canonical example solution (Example.fs) that demonstrates a recursive implementation of the accumulate function, along with a new config.json file defining the exercise metadata, file paths, and contributor information. A tests.toml file has also been added to map test cases to their descriptions, including a note that one recursive test case is reimplemented from a previous version.

exercises/practice/accumulate/.meta · high confidence

Added example solution and metadata for the Transpose exercise

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.

exercises/practice/binary/.meta, exercises/practice/leap/.meta · high confidence

Added example solutions and metadata for Acronym and Two Fer exercises

The Acronym and Two Fer practice exercises now include official example implementations (Example.fs) and updated metadata files (config.json, tests.toml). The Acronym example demonstrates converting phrases to acronyms using regex, while the Two Fer example handles optional input names with a default value. These additions provide users with reference solutions and clarify the expected test cases for these exercises.

exercises/practice/acronym/.meta, exercises/practice/two-fer/.meta · high confidence

Added example solutions and metadata for practice exercises

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

Added performance benchmarks for the Tree Building exercise

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

Bird Watcher exercise scaffold and tests added

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

Bob exercise adds example solution and metadata

The Bob exercise now includes an example solution file (Example.fs) that demonstrates the expected logic for handling a lackadaisical teenager's responses, along with a new config.json file defining authors, contributors, and file paths, and a tests.toml file mapping test cases to their descriptions.

exercises/practice/bob/.meta · high confidence

Initial creation of the Log Levels concept exercise

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

Initial release of the Exercism F\# track

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

Introduce F\# test case generators for Exercism exercises

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

Introduce Robot Simulator exercise stub and tests

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

Introduction of the booking-up-for-beauty concept exercise

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

Lasagna exercise now includes an official F\# exemplar solution

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

New F\# concept exercise on using the Flags attribute

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

New bin scripts for exercise management and validation

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

New solution files for exercise management

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

Behavioural changes

Add F\#-specific documentation for the Lucian's Luscious Lasagna exercise

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

Added documentation for the interest-is-interesting exercise

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

Bird Watcher exercise now includes an exemplar solution and updated configuration

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

Collatz Conjecture exercise metadata and example solution added

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

Fix Ledger exercise newline and culture formatting issues

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

Introduce success rate calculation and exemplar solution for Cars Assemble

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

Pig Latin exercise scaffold updated with comprehensive test suite

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

Simplified stub for the F\# Hello World exercise

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

Updated F\# concept exercise with stricter excitement criteria

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

Updated Linked List exercise stubs and tests for F\#

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

Updated Markdown exercise with corrected default implementation

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

Updated documentation for the Log Levels concept exercise

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

Variable Length Quantity exercise scaffold updated with comprehensive test cases

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

Dependencies

Exercises upgraded to .NET 10 and xUnit v3

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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 63 → 64 (+1.1)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 85 → 85 (+0.1)
  • Architecture 100 → 100 (+0.0)
  • Maturity 54 → 54 (+0.0)
  • Readiness 61 → 61 (+0.0)
  • Security 84 → 78 (-5.4)
  • Performance 73 → 90 (+17.1)

Resolved (2)

  • No ADRs found
  • Program.main (cognitive 21) (tools/CodeFenceChecker/Program.fs)

New (4)

  • Edited copies of one member (3 members, 11+ corresponding lines) (exercises/practice/bank-account/BankAccount.fs)
  • Edited copies of one member (4 members, 17+ corresponding lines) (exercises/practice/complex-numbers/ComplexNumbers.fs)
  • Edited copy of a member (9 corresponding lines) (exercises/practice/circular-buffer/CircularBuffer.fs)
  • No ADRs found (generators/Generators.fsproj)

Changes since last survey

  • 2 commits — 2 feature/other, 0 fixes

By area

  • .github/CODEOWNERS — 2 commits

Notable commits

  • change: Add a sign-up snippet (#1400)
  • change: List the checks that must pass before a PR can merge (#1401)

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 15 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit bbb10e74f245938748695e7e4a1633ee0c984fb8 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-3c33c1882dc1.