exercism/elixir

This system is the Elixir track for the Exercism programming platform, providing a structured curriculum for learning the language. It organizes content into concept exercises that teach specific language features—such as recursion, GenServers, and pattern matching—and practice exercises that apply these skills to algorithmic problems. The repository includes comprehensive tooling for validation, formatting, and static analysis to support both student learning and contributor workflows.

123 changes.

This period established the foundational infrastructure for the Elixir track, including repository configuration, standardized tooling, and a v3 exercise structure. It focused on populating the curriculum with a comprehensive set of concept exercises covering core language features and adding numerous practice exercises with full test suites and reference solutions.

9 changes.

This period focused on significantly expanding the Elixir track's curriculum by introducing multiple new concept exercises covering behaviors, GenServers, regular expressions, bitstrings, and MapSets. Additionally, several new practice exercises were added to address specific programming challenges such as ledger refactoring and bit counting.

A new practice exercise titled 'House' has been added to the track. This exercise challenges users to implement the \House.recite/2\ function in Elixir to generate verses of the nursery rhyme 'This is the House that Jack Built'. The entry includes the full exercise scaffold, including the stub implementation in \lib/house.ex\, a comprehensive test suite in \test/house\_test.exs\ covering individual verses through the full rhyme, and supporting metadata and documentation files.

exercises/practice/house · high confidence

A new concept exercise titled 'Mensch ärgere Dich nicht' has been added to the curriculum, focusing on the \streams\ concept. The exercise requires learners to implement a dice-rolling simulation using lazy evaluation via \Stream.repeatedly\ and \Stream.transform\, building on prerequisites such as \enum\, \tuples\, \if\, \ranges\, and \randomness\. The provided solution demonstrates using \Enum.random\ for individual die rolls and composing them into a lazy stream that halts upon rolling a six.

exercises/concept/mensch-aergere-dich-nicht/.meta · high confidence

The Bowling practice exercise is now available, including the stub implementation in lib/bowling.ex, a reference solution in .meta/example.ex, and the test suite metadata in .meta/tests.toml. The solution implements the standard bowling scoring rules, handling strikes, spares, and bonus rolls, while the metadata defines the authorship, file structure, and specific test cases that validate the scoring logic.

exercises/practice/bowling/.meta · high confidence

The Clock practice exercise now includes a starter stub in lib/clock.ex with defined structs and function signatures for new/2 and add/2, alongside a complete reference implementation in .meta/example.ex that handles time rollover logic. The exercise metadata in .meta/config.json and .meta/tests.toml have been added to define the solution file paths, authorship, and the full set of canonical test cases for time manipulation.

exercises/practice/clock/.meta, exercises/practice/etl/.meta · high confidence

The Connect exercise is now available with a starter stub in lib/connect.ex for users to implement the game logic, alongside a reference solution in .meta/example.ex. Configuration files (.meta/config.json, .meta/tests.toml) define the exercise structure, test cases, and contributor metadata, while .formatter.exs and .gitignore set up the local development environment for the Elixir track.

exercises/practice/connect/.meta · high confidence

Introduced the 'dna-encoding' concept exercise, providing users with instructions to encode and decode nucleic acids into binary representations using Elixir's bitstrings and charlists. The package includes an introduction to tail-call recursion with accumulators, detailed instructions for implementing four functions (encoding/decoding single nucleotides and full charlists/bitstrings), and hints guiding users toward using code points, binary integer literals, and tail-recursive strategies.

(repo-wide) · high confidence

A new Elixir practice exercise, Eliud's Eggs, has been added. It challenges users to count the number of set bits (1s) in the binary representation of an integer, framed as counting eggs in a chicken coop. The entry includes the problem instructions, a stub implementation in \lib/eliuds\_eggs.ex\, a test suite in \test/eliuds\_eggs\_test.exs\, and a reference solution in \.meta/example.ex\.

exercises/practice/eliuds-eggs · high confidence

The meetup exercise now includes a .formatter.exs file for consistent code formatting, a .gitignore file to exclude build artifacts and dependencies, and a lib/meetup.ex module defining the Meetup module. The module provides type specifications for weekdays and schedules, and declares a meetup/4 function signature that accepts year, month, weekday, and schedule parameters to calculate meetup dates, though the implementation is currently empty.

exercises/practice/meetup · high confidence

The dot-dsl exercise now includes a \Graph\ module that provides a data structure for managing nodes, edges, and attributes, along with methods to create graphs, add nodes and edges, and compare graph equivalence. A \Dot\ module with a \graph\ macro stub is also added to support the DSL syntax. These files establish the core API for the exercise, allowing students to implement the DSL functionality.

exercises/practice/dot-dsl · high confidence

A new practice exercise has been added to the Elixir track to help users practice combinatorial logic by solving Killer Sudoku cages. The entry point is the \KillerSudokuHelper\ module, which provides a \combinations/1\ function that calculates valid sets of distinct digits (1-9) for a given cage size and sum, while respecting excluded digits. The package includes a stub implementation in \lib/killer\_sudoku\_helper.ex\, a comprehensive test suite in \test/killer\_sudoku\_helper\_test.exs\ covering trivial single-digit cages, full 9-digit cages, and restricted combinations, along with an example solution and standard Exercism metadata files.

(repo-wide) · high confidence

Introduced the new 'pov' practice exercise, which challenges users to reparent a tree structure on a selected node and find paths between nodes. The entry includes the configuration metadata, a reference implementation using a zipper pattern for tree navigation, and a test suite covering scenarios such as rerooting trees with various sibling structures, handling deeply nested nodes, and managing error cases for nonexistent targets or sources.

exercises/practice/pov/.meta · high confidence

A new concept exercise for Elixir has been added to teach boolean logic, including the use of \and/2\, \or/2\, and \not/1\ operators. The package includes a design document outlining learning objectives, an exemplar solution implementing Pac-Man game rules (such as eating ghosts and scoring), and configuration metadata for the exercise.

exercises/concept/pacman-rules/.meta · high confidence

The Pac-Man Rules concept exercise now includes structured documentation files: an introduction explaining Elixir's boolean type and idiomatic naming conventions (ending function names with \?\), detailed instructions for implementing four boolean logic functions (\eat\_ghost?\, \score?\, \lose?\, \win?\), and hints guiding users on using \and/2\, \or/2\, and \not/1\ operators. A template file (\introduction.md.tpl\) is also added to support dynamic content generation.

exercises/concept/pacman-rules/.docs · high confidence

The Protein Translation exercise is now available, providing a starter module with stubbed \of\_rna\ and \of\_codon\ functions for users to implement. An example solution is included in \.meta/example.ex\ to demonstrate the expected behavior, and the test suite defined in \tests.toml\ covers translation of RNA sequences into proteins, handling of STOP codons, and error cases for invalid or incomplete sequences.

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

The RPN Calculator Inspection concept exercise is introduced with a new project structure, including a \.formatter.exs\ for code formatting, a \.gitignore\ for standard Mix artifacts, and a \lib/rpn\_calculator\_inspection.ex\ stub. The stub defines the \RPNCalculatorInspection\ module with four unimplemented functions (\start\_reliability\_check/2\, \await\_reliability\_check\_result/2\, \reliability\_check/2\, and \correctness\_check/2\) that students must implement.

(repo-wide) · high confidence

The Robot Simulator practice exercise is now available, providing students with a starter module (\lib/robot\_simulator.ex\) containing stubbed functions for creating a robot, simulating movement instructions (R, L, A), and retrieving its position and direction. An example solution (\/.meta/example.ex\) is included to demonstrate a valid implementation, alongside configuration files (\config.json\, \tests.toml\) that define the test cases and file structure for the exercise.

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

The Series exercise is now available in the practice directory, including the standard Mix project configuration files (.formatter.exs, .gitignore) and the solution stub (lib/string\_series.ex) which defines the StringSeries.slices/2 function for generating substrings.

exercises/practice/series · high confidence

A new concept exercise titled 'Stack Underflow' has been added to the track, focusing on defining custom exceptions in Elixir. The exercise continues the context of a Reverse Polish Notation calculator, requiring learners to implement a \StackUnderflowError\ that handles context-specific messages, alongside a \DivisionByZeroError\. The provided solution demonstrates the use of the Exception behaviour, including the \exception/1\ callback for dynamic message construction and raising errors during division operations.

(repo-wide) · high confidence

The Strain practice exercise is now available with its configuration, including authors, contributors, and a blurb describing the task to implement \keep\ and \discard\ operations on collections. An example solution file (\example.ex\) is provided, demonstrating implementations of \keep\ and \discard\ using recursion without relying on \Enum.filter\ or \Enum.reject\. Additionally, a test configuration file (\tests.toml\) defines the specific test cases for both keeping and discarding elements from various collection types.

(repo-wide) · high confidence

Introduced a new practice exercise for the Yacht dice game, providing the starter code, test suite, and example solution. Users can now complete the exercise by implementing the \score/2\ function to calculate scores for categories such as ones through sixes, full house, four of a kind, straights, choice, and yacht.

exercises/practice/yacht/.meta · high confidence

The Zipper practice exercise now includes the necessary project structure and stub code for implementing a zipper data structure on binary trees. This adds a \BinTree\ module with a custom \Inspect\ implementation for readable test output, and a \Zipper\ module containing function stubs for navigating and modifying the tree (e.g., \from\_tree\, \to\_tree\, \value\, \left\, \right\, \up\, \set\_value\, \set\_left\, \set\_right\).

exercises/practice/zipper · high confidence

A new practice exercise has been added to the Elixir track, requiring students to implement a basic reactive system using GenServers. The exercise involves creating input cells with settable values and compute cells that automatically propagate changes to dependent values, including support for registering and firing change notification callbacks. The entry includes the stub implementation in \lib/react.ex\, the test suite in \test/react\_test.exs\, and the reference solution in \.meta/example.ex\.

exercises/practice/react · high confidence

A new concept exercise named 'bird-count' has been added to the Elixir track. This exercise teaches users how to write and call recursive functions, process lists, and use pattern matching, guards, and multiple-clause functions. It includes a configuration file defining the solution, test, and exemplar files, a design document outlining learning objectives and prerequisites, and an exemplar solution demonstrating recursive implementations for tasks like counting birds, incrementing day counts, checking for days without birds, calculating totals, and counting busy days.

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

Introduces the new 'book-store' practice exercise, which challenges users to calculate the lowest price for a shopping basket of books based on a tiered discount system. The entry includes the configuration metadata, a canonical example solution implementing the discount algorithm, and the test suite definitions.

exercises/practice/book-store/.meta · high confidence

The Change exercise now includes a \.meta/config.json\ file that defines the authorship, contributors, and a blurb describing the task of determining the least number of coins to give as change. An example solution (\example.ex\) has been added to provide a reference implementation for the \Change.generate/2\ function, which returns either \{:ok, list\_of\_coins}\ or \{:error, "cannot change"}\. Additionally, \tests.toml\ has been created to map specific test cases (such as handling single coin changes, large targets, and error conditions) to the canonical problem specifications.

exercises/practice/change/.meta, exercises/practice/roman-numerals/.meta · high confidence

A new concept exercise named \newsletter\ has been added to the curriculum. This exercise guides users through working with the \File\ module, specifically covering \File.read\, \File.write\, \File.open\, and \File.close\, as well as using the \IO\ module for logging. The implementation involves reading email addresses from a file, sending them via a provided function, and logging successful sends to a separate log file.

exercises/concept/newsletter/.meta · high confidence

The Remote Control Car concept exercise now includes its instructional materials. An introduction explains Elixir structs, including their definition with \defstruct\, field access, pattern matching, and the use of \@enforce\_keys\. The instructions guide users through implementing a struct-based car model with specific behaviors for initialization, distance tracking, battery management, and handling a dead battery state. Additionally, a hints file provides targeted advice on using structs, function clauses, and pattern matching to complete the exercise tasks.

exercises/concept/remote-control-car/.docs · high confidence

Added the \hints.md\, \instructions.md\, and \introduction.md\ files for the \library-fees\ exercise, which teaches users how to work with Elixir's \Date\, \Time\, and \NaiveDateTime\ modules to calculate late fees. The instructions specify a scenario for a library in Ghana (GMT, no DST) and guide the implementation of functions to parse ISO8601 strings, determine return windows based on checkout time, calculate days late, and apply a Monday discount. An \introduction.md.tpl\ template was also added to unify the introduction content with the \dates-and-time\ concept.

(repo-wide) · high confidence

The Rail Fence Cipher exercise now includes a reference implementation (.meta/example.ex) that users can view to understand the expected solution structure, alongside a new .meta/config.json file defining the exercise's metadata (authors, source, blurb) and file paths. The .meta/tests.toml file has also been added to map specific test cases to their descriptions, ensuring the test suite is properly configured for this exercise.

exercises/practice/difference-of-squares/.meta, exercises/practice/rail-fence-cipher/.meta · high confidence

The freelancer-rates concept exercise has been introduced, providing the initial project structure and stub file for learners. The lib/freelancer\_rates.ex module defines the FreelancerRates module with four functions—daily\_rate/1, apply\_discount/2, monthly\_rate/2, and days\_in\_budget/3—each containing a placeholder comment for implementation. Standard Elixir project configuration files (.formatter.exs and .gitignore) have also been added to support the exercise environment.

exercises/concept/freelancer-rates, exercises/concept/pacman-rules, exercises/practice/knapsack · high confidence

The high-score concept exercise now includes a standard Elixir project structure, featuring a \.formatter.exs\ file for code formatting, a \.gitignore\ file to exclude build artifacts and dependencies, and a \lib/high\_score.ex\ stub. The stub defines the \HighScore\ module with empty implementations for functions \new/0\, \add\_player/3\, \remove\_player/2\, \reset\_score/2\, \update\_score/3\, and \get\_players/1\, providing the starting point for learners to implement the exercise logic.

exercises/concept/high-score · high confidence

Introduced a new practice exercise that challenges users to refactor a poorly written ledger printer. The exercise requires rewriting the \format\_entries\ function in \lib/ledger.ex\ to correctly format financial entries based on currency (USD, EUR) and locale (American, Dutch), handling date formatting, number grouping, and description truncation while maintaining specific sorting rules.

exercises/practice/ledger · high confidence

A new concept exercise, log-parser, has been added to the curriculum. It focuses on teaching Elixir-specific regular expression usage, including the Regex module, the =\~ operator, string functions that accept regex, modifiers, captured groups, and sigils. The exercise includes configuration, design documentation outlining learning objectives and prerequisites, and an exemplar solution demonstrating how to validate log lines, split strings, remove artifacts, and tag lines with user names using regex patterns.

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

A new concept exercise titled 'Chessboard' has been added to the Elixir track. This exercise is designed to teach learners about ranges, including how they are structs, how to enumerate them, and how to transform them into lists. The provided solution demonstrates generating rank and file ranges for a chessboard and converting them into appropriate data structures.

exercises/concept/chessboard/.meta, exercises/practice/affine-cipher · high confidence

Introduces a new practice exercise for Elixir that challenges users to implement tree reparenting and path-finding logic. The \Pov\ module provides stub functions \from\_pov/2\ and \path\_between/3\ with specified return types (\{:ok, tree} \| {:error, atom}\ and \{:ok, \[any\]} \| {:error, atom}\), along with necessary project configuration files like \.formatter.exs\ and \.gitignore\ to support the new exercise structure.

exercises/practice/pov · high confidence

A new concept exercise, \lucas-numbers\, has been added to the curriculum to teach the use of streams. The exercise requires learners to implement the \generate/1\ function within the \LucasNumbers\ module to produce the Lucas number sequence. The package includes standard Elixir project scaffolding, such as \.formatter.exs\ and \.gitignore\, to support the learning environment.

exercises/concept/lucas-numbers · high confidence

A new concept exercise, 'lucas-numbers', has been added to help users learn about Elixir streams. The exercise requires students to generate the Lucas number sequence using stream operations, with design documentation outlining prerequisites such as enums, guards, and tuples, and providing an exemplar solution that demonstrates the implementation.

exercises/concept/lucas-numbers/.meta · high confidence

Three new concept exercises have been added to the curriculum: DNA encoding, chessboard, and date parsing. The DNA encoding exercise introduces students to bitstrings with stubs for encoding and decoding nucleotides. The chessboard exercise focuses on ranges, providing stubs for generating rank and file ranges. The date parsing exercise covers pattern matching and capture, offering stubs for parsing day, month, and year components from various date formats. Each exercise includes standard Elixir project configuration files such as .formatter.exs and .gitignore.

exercises/concept/dna-encoding · high confidence

A new practice exercise for the Elixir track has been added, requiring users to simulate the 'Camicia' card game (based on Beggar-My-Neighbour). The \Camicia\ module provides a \simulate/2\ function that takes two player decks and returns the game status (\:finished\ or \:loop\) along with the total cards played and tricks collected. The exercise includes instructions, a stub implementation, a reference solution, and a comprehensive test suite covering various game scenarios including loops and different penalty card interactions.

(repo-wide) · high confidence

A new concept exercise named \new-passport\ has been added to the Elixir track. This exercise is designed to teach users how to use the \with\ expression to handle success paths and specific errors, specifically focusing on chaining operations and using \else\ clauses for error handling within a bureaucratic simulation scenario.

exercises/concept/new-passport/.meta · high confidence

A new concept exercise, paint-by-number, has been added to the Elixir track. This exercise is designed to help learners understand bitstrings, including literals, the \\<\<\>\>\ special form, the \::\ binary size modifier, construction, and pattern matching. The provided solution demonstrates calculating palette bit sizes and manipulating bitstring pictures by prepending, retrieving, dropping, and concatenating pixels.

exercises/concept/paint-by-number/.docs, exercises/concept/paint-by-number/.meta · high confidence

The Diffie-Hellman practice exercise now includes a reference solution in \.meta/example.ex\ that implements private key generation, public key calculation, and shared secret derivation using Erlang's \:crypto.mod\_pow\. Metadata in \.meta/config.json\ defines the exercise structure, authors, and blurb, while \.meta/tests.toml\ maps the canonical test cases to their descriptions.

exercises/practice/diffie-hellman/.meta · high confidence

The Forth exercise now includes a canonical reference implementation in \.meta/example.ex\ and its associated metadata in \.meta/config.json\. The solution implements a stack-based evaluator supporting arithmetic operations (+, -, \*, /), stack manipulation (DUP, DROP, SWAP, OVER), and user-defined word definitions, along with case-insensitivity and proper error handling for stack underflow, division by zero, and unknown words. This provides a complete example for learners to compare against their own implementations.

exercises/practice/forth/.meta, exercises/practice/tournament/.meta, exercises/practice/twelve-days/.meta · high confidence

A new concept exercise has been added to teach users about Elixir structs, including their definition, field initialization, and compile-time guarantees. The package includes the exercise configuration, design documentation outlining learning objectives, and an exemplar solution that demonstrates struct creation, pattern matching, and basic state management for a remote-controlled car.

exercises/concept/remote-control-car/.meta · high confidence

The stack-underflow concept exercise now includes the necessary project structure for learners, featuring a .formatter.exs for code formatting, a .gitignore to exclude build artifacts, and a lib/rpn\_calculator/exception.ex file where students are prompted to implement DivisionByZeroError and StackUnderflowError.

exercises/concept/stack-underflow · high confidence

The All Your Base exercise now includes a complete set of metadata and source files. A new \.meta/example.ex\ provides the reference implementation for converting numbers between bases, while \.meta/config.json\ defines the file structure and authorship. The \.meta/tests.toml\ file maps the canonical test cases, and standard project scaffolding files (\.formatter.exs\, \.gitignore\) have been added to support local development. The \lib/all\_your\_base.ex\ stub remains as the starting point for students.

exercises/practice/all-your-base/.meta · high confidence

The Kitchen Calculator concept exercise now includes a standard Mix project structure, featuring a \.formatter.exs\ for code formatting, a \.gitignore\ to exclude build artifacts, and a \lib/kitchen\_calculator.ex\ stub. The stub defines the \KitchenCalculator\ module with four functions (\get\_volume/1\, \to\_milliliter/1\, \from\_milliliter/2\, and \convert/2\) containing placeholder comments, providing the necessary starting point for learners to implement the volume conversion logic.

exercises/concept/kitchen-calculator · high confidence

The \list-ops\ and \simple-linked-list\ practice exercises now include stub source files (\lib/list\_ops.ex\ and \lib/linked\_list.ex\) that define the required module functions with empty bodies or placeholder comments, along with corresponding \.formatter.exs\ and \.gitignore\ files to support local development. This provides a starting point for learners to implement list operations (such as count, reverse, map, filter, fold, append, and concat) and a linked list data structure (including push, pop, peek, tail, and conversion methods) without relying on standard library functions like \Enum\ or \List\.

exercises/practice/list-ops · high confidence

New exercise stubs for Alphametics and Transpose have been added to the practice directory. Each exercise now includes a dedicated \.formatter.exs\ for Elixir code formatting, a \.gitignore\ tailored to the Mix build environment, and a \lib/\<exercise\>.ex\ file containing the module definition, type specs, and documentation examples for the \solve\ and \transpose\ functions respectively.

exercises/practice/alphametics, exercises/practice/transpose · high confidence

A new concept exercise for Boutique Inventory has been added, providing a starter module with stubbed functions for sorting inventory by price, filtering items with missing prices, updating item names, increasing quantities, and calculating total quantities.

exercises/concept/boutique-inventory · high confidence

The High Score concept exercise now includes a new hints.md file providing guidance on using Elixir's Map module functions (put, delete, update, keys) and an introduction.md file explaining maps and module attributes as constants. The instructions.md file has been updated to define the HighScore module functions (new, add\_player, remove\_player, reset\_score, update\_score, get\_players) and their expected behaviors, ensuring learners have the necessary context and support to complete the exercise.

(repo-wide) · high confidence

New documentation files (instructions, hints, and introduction) have been added for the 'Mensch ärgere dich nicht' concept exercise. This exercise teaches users how to use Elixir's Stream module for lazy evaluation, covering tasks like simulating dice rolls, chaining stream operations, and using function capture for testability.

exercises/concept/mensch-aergere-dich-nicht/.docs · high confidence

The RPN Calculator exercise now includes structured documentation files (hints, instructions, and introduction) to guide users through implementing error handling in Elixir. The introduction explains the distinction between error-raising functions (ending in \!\) and those returning \{:ok, value}\ or \:error\, and details the \try .. rescue\ construct for handling exceptions. The instructions define three tasks: implementing a raw error-raising function, wrapping operations to return standard success/failure tuples, and passing error messages through rescue blocks. Hints provide specific guidance on using the \.\ operator for function invocation and pattern matching on error structs.

(repo-wide) · high confidence

New practice exercises for Accumulate and Flatten Array have been added to the track. Each exercise includes a standard Elixir project structure with \.formatter.exs\ and \.gitignore\ files, along with a module stub (\lib/accumulate.ex\ and \lib/flatten\_array.ex\) containing the function signature and documentation examples for users to implement.

exercises/practice/accumulate, exercises/practice/flatten-array · high confidence

The Basketball Website concept exercise has been added to teach the Elixir Access Behaviour for extracting deeply nested data. The provided solution demonstrates using the access syntax (e.g., \data\[path\]\) to traverse data structures, while the design documentation clarifies that this approach differs from using \get\_in\ or static access operators, and notes limitations regarding structs.

exercises/concept/basketball-website/.meta · high confidence

The Beer Song practice exercise now includes its configuration metadata and a reference example solution. A new config.json file defines the exercise's authors, contributors, source information, and the specific file paths for the solution, test, and example files. An example.ex file has been added to .meta, providing a complete implementation of the BeerSong module that handles verse generation for 0, 1, 2, and generic bottle counts, as well as lyrics generation for a range of verses. Additionally, a tests.toml file has been created to map specific test cases to their descriptions, ensuring the exercise's test suite is properly structured and documented.

(repo-wide) · high confidence

The Custom Set practice exercise now provides an official reference implementation in \.meta/example.ex\, allowing users to view a working solution after completing the exercise. This change is accompanied by the addition of a \config.json\ file that defines the exercise metadata (including the blurb "Create a custom set type") and explicitly maps the solution, test, and example file paths, ensuring the exercise is properly configured for the v3 track structure.

exercises/practice/custom-set/.meta · high confidence

The D&D Character exercise now includes a canonical example solution (\.meta/example.ex\) that implements the \DndCharacter\ module with functions to calculate ability modifiers and generate random characters, alongside a \config.json\ file defining the exercise's authors, source, and file structure. The \tests.toml\ file has been synchronized to map specific test cases for ability modifiers and character generation, ensuring the exercise aligns with the canonical problem specifications.

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

The grade-school practice exercise now includes a complete project structure with a \.formatter.exs\ for code formatting, a \.gitignore\ for Mix artifacts, and a \.meta/config.json\ defining the solution, test, and example file paths along with author metadata. A stub implementation (\lib/school.ex\) is provided for users to fill in, while the \.meta/example.ex\ contains the reference solution implementing the \School\ module with \new/0\, \add/3\, \grade/2\, and \roster/0\ functions. The test suite is defined in \.meta/tests.toml\, specifying which canonical test cases are included or excluded.

(repo-wide) · high confidence

The Grep practice exercise now provides an official reference implementation in \.meta/example.ex\, allowing users to view a complete solution after completing the exercise. This is accompanied by a new \.meta/config.json\ file that defines the exercise's metadata, including the blurb, source, and file paths, as well as a \tests.toml\ file that maps test cases to their descriptions. This change standardizes the exercise structure within the v3 track.

exercises/practice/grep/.meta · high confidence

The bank-account practice exercise has been added to the Elixir track, providing a starter project structure. This includes a \.formatter.exs\ for code formatting, a \.gitignore\ tailored for Mix artifacts, and the \lib/bank\_account.ex\ module containing the \BankAccount\ API. The module defines the \account\ opaque type and stubs the \open\, \close\, \balance\, \deposit\, and \withdraw\ functions with their respective specs, allowing users to implement the concurrent bank account logic.

exercises/practice/bank-account · high confidence

A new concept exercise has been added to help learners understand bitstrings and tail-call recursion in Elixir. The package includes a configuration file defining the learning objectives, an exemplar solution demonstrating how to encode and decode DNA sequences using binary data, and a design document outlining the specific concepts (bitstrings, tail-call-recursion) and prerequisites (recursion, charlists, pattern-matching) covered.

(repo-wide) · high confidence

The Simple Cipher exercise has been added to the track, providing the scaffolding for users to implement a Vigenère cipher. This includes the stub implementation in lib/simple\_cipher.ex with encode, decode, and generate\_key functions, a corresponding test file, and an example solution in .meta/example.ex. The exercise metadata in .meta/config.json defines the file structure, authors, and blurb, while .meta/tests.toml specifies which test cases are included. A .formatter.exs file is also provided to ensure consistent code formatting for the exercise project.

exercises/practice/dominoes/.meta, exercises/practice/palindrome-products/.meta, exercises/practice/simple-cipher/.meta · high confidence

The list-ops exercise is now fully configured with a new .meta/config.json file that defines the solution, test, and example file paths, along with contributor metadata and a blurb. An example solution (.meta/example.ex) has been added, implementing basic list operations (count, reverse, map, filter, foldl, foldr, append, concat) using recursive Kernel functions while avoiding external modules like Enum or List. The tests.toml file has been created to map canonical test cases, including specific handling for fold operations where some tests are marked as reimplemented or excluded.

exercises/practice/bob/.meta, exercises/practice/list-ops/.meta, exercises/practice/secret-handshake/.meta · high confidence

The Elixir track has been initialized with a complete configuration structure, including \config.json\ defining the track's exercises, concepts, and metadata. Development tooling is established via \.formatter.exs\ (integrating Markdown and Doctest formatters), \.dialyzer\_ignore.exs\ for static analysis, and \.prettierrc\ for document formatting. Essential documentation files such as \README.md\, \CONTRIBUTING.md\, \HELLO.md\, and \CODE\_OF\_CONDUCT.md\ are added to guide contributors, alongside standard repository files like \LICENSE\ and \.gitignore\.

(repo-wide) · high confidence

The nth-prime exercise is now available with a complete starter structure. A solution example has been added at .meta/example.ex, and the exercise metadata (config.json) defines the file paths, blurb, and authorship. Test cases are specified in tests.toml, and standard Elixir project files (.formatter.exs, .gitignore) are included to support local development.

exercises/practice/nth-prime/.meta · high confidence

Added the 'Name Badge' concept exercise to the Elixir track, providing configuration, design documentation, and an exemplar solution. This exercise teaches learners about \nil\, truthiness, pattern matching, and the \if\ macro by implementing a function that formats employee name badges, including handling optional department names.

exercises/concept/name-badge/.meta · high confidence

A new concept exercise has been added to teach users about Elixir processes, PIDs, and the \Process\ module. The package includes a configuration file defining the solution and test paths, a design document outlining learning objectives and prerequisites, and an exemplar solution that implements a simple process-based number machine using \spawn\ and message passing.

exercises/concept/take-a-number/.meta · high confidence

A new concept exercise for the Elixir track has been introduced, focusing on teaching tuples and pattern matching. The exercise requires learners to implement a module that converts common US baking measurements (cups, fluid ounces, teaspoons, tablespoons) to and from milliliters using tuple-based data structures. The provided metadata and design documentation outline the specific learning objectives, prerequisites, and the expected solution structure.

exercises/concept/kitchen-calculator/.meta · high confidence

The Leap exercise now includes a \.meta\ directory containing \config.json\, \example.ex\, and \tests.toml\. The configuration file defines the exercise metadata, including authors, contributors, source information, and the specific files for the solution, test, and example implementations. The \example.ex\ file provides a reference implementation for determining leap years, while \tests.toml\ lists the canonical test cases that validate the logic for common and leap years.

exercises/practice/leap/.meta · high confidence

A new concept exercise named 'Top Secret' has been added to the Elixir track, focusing on the Abstract Syntax Tree (AST). This exercise teaches users how to parse strings into ASTs, understand their structure, and traverse them using \Macro.prewalk\. The solution involves decoding secret messages by extracting function names and arities from the AST, providing practical experience with Elixir's metaprogramming foundations without requiring knowledge of macros or quote/unquote.

exercises/concept/top-secret/.meta · high confidence

A new concept exercise for the Boutique Inventory track has been introduced, designed to teach the use of the Enum module (including map, reduce, and sort\_by) and the Enumerable protocol. The release includes the exercise configuration, design documentation outlining learning objectives and prerequisites, and an exemplar solution demonstrating the expected implementation patterns.

exercises/concept/boutique-inventory/.meta · high confidence

Adds a new concept exercise, 'City Office', which guides users through writing module and function documentation (\@moduledoc\, \@doc\) and type specifications (\@spec\) in Elixir. The exercise includes a starter implementation in \lib/form.ex\ with functions for handling form fields, along with comprehensive instructions, hints, and an introduction covering types, custom types, and documentation syntax.

exercises/concept/city-office/.docs · high confidence

The repository now includes a comprehensive set of shell and Elixir scripts in the bin/ directory to support the track's development workflow. These scripts automate the bootstrapping of new practice exercises, validate code formatting and autogenerated files, check concept coverage and exercise ordering, run the Dialyzer static analysis tool, and execute the full test suite against example solutions. A new script also fetches the latest version of the configlet tool, ensuring consistent tooling across environments.

bin · high confidence

A new practice exercise has been added for parsing Smart Game Format (SGF) files in Elixir. The \SgfParsing\ module provides a \parse/1\ function that accepts an encoded SGF string and returns either a parsed \Sgf\ tree structure or an error message. The exercise includes standard Elixir project scaffolding, such as a \.formatter.exs\ for code formatting and a \.gitignore\ file to exclude build artifacts and dependencies.

exercises/concept/high-score/.meta, exercises/concept/need-for-speed, exercises/practice/sgf-parsing · high confidence

Added a new concept exercise, 'Top Secret', which teaches users how to work with Elixir's Abstract Syntax Tree (AST). The exercise requires implementing functions to convert code strings into ASTs, parse specific AST nodes to extract function names based on arity, and handle function definitions with guards, effectively introducing metaprogramming concepts like quoting and macro traversal.

exercises/concept/top-secret/.docs · high confidence

A new concept exercise, \dancing-dots\, has been added to teach users how to define and use Elixir behaviours, including defining callbacks, providing default implementations with \@impl\, and using the \use\ macro. The exercise includes configuration files, design documentation outlining learning objectives, and an exemplar solution demonstrating how to implement the \DancingDots.Animation\ behaviour with modules like \DancingDots.Flicker\ and \DancingDots.Zoom\.

exercises/concept/dancing-dots/.meta · high confidence

A new concept exercise named \dancing-dots\ has been added to the track. This exercise teaches the use of Elixir behaviours, providing a \DotGroup\ module that demonstrates how to apply a list of animations to a group of dots via callback functions like \init/1\ and \handle\_frame/3\. The exercise includes stub modules (\DancingDots.Animation\, \DancingDots.Flicker\, \DancingDots.Zoom\) for learners to implement, along with a \Dot\ struct and standard project configuration files.

exercises/concept/dancing-dots · high confidence

Added the 'gotta-snatch-em-all' concept exercise, which teaches users how to use Elixir's \MapSet\ module for managing unique collections of trading cards. The exercise includes instructions, hints, and a stub implementation for functions that create, modify, and query sets, such as adding cards, trading, removing duplicates, and finding intersections or unions across multiple collections.

exercises/concept/gotta-snatch-em-all · high confidence

Added a new concept exercise, \library-fees\, which introduces users to date and time manipulation in Elixir. The exercise provides a stub module with functions for parsing datetime strings, checking if a time is before noon, calculating return dates, determining days late, checking for Mondays, and calculating late fees. The addition includes standard project configuration files like \.formatter.exs\ and \.gitignore\ to support the exercise structure.

exercises/concept/library-fees · high confidence

Added a new concept exercise for the \with\ special form. The exercise guides users through implementing a passport renewal workflow that chains multiple function calls (\enter\_building\, \find\_counter\_information\, \stamp\_form\, \get\_new\_passport\_number\) and handles various outcomes, including happy paths and specific error cases like coffee breaks or closed offices.

exercises/concept/new-passport/.docs · high confidence

A new concept exercise, \take-a-number-deluxe\, has been added to teach the use of GenServers in Elixir. This exercise guides users through implementing an embedded system for a 'Take-A-Number' machine, covering key GenServer concepts such as state management, callbacks (\init\, \handle\_call\, \handle\_cast\, \handle\_info\), timeouts, and error handling. The provided solution demonstrates best practices for structuring a GenServer-based application.

exercises/concept/take-a-number-deluxe/.meta · high confidence

Added a new concept exercise, \take-a-number-deluxe\, which guides users in implementing a GenServer-based number queue system. The exercise provides stubs for client API functions (\start\_link\, \report\_state\, \queue\_new\_number\, \serve\_next\_queued\_number\, \reset\_state\) and server callbacks in \lib/take\_a\_number\_deluxe.ex\, along with supporting modules for queue management (\TakeANumberDeluxe.Queue\) and state handling (\TakeANumberDeluxe.State\) that include validation logic and queue operations.

(repo-wide) · high confidence

A new practice exercise has been added for the \rectangles\ track, providing a starter module \Rectangles\ with a \count/1\ function stub intended to count ASCII rectangles in a string input. The exercise includes standard Elixir project configuration files, such as \.formatter.exs\ for code formatting and \.gitignore\ to exclude build artifacts and dependencies.

exercises/practice/rectangles · high confidence

The Pascal's Triangle practice exercise now includes a canonical example solution in \.meta/example.ex\ and a structured configuration file (\config.json\) that defines the exercise's metadata, including authors, contributors, file paths, and a blurb. A \tests.toml\ file has also been added to map specific test cases to their descriptions, enabling better test selection and validation for learners.

exercises/practice/pascals-triangle/.meta · high confidence

The Poker practice exercise now includes a reference solution in \.meta/example.ex\ and configuration metadata in \.meta/config.json\. The solution implements the \best\_hand/1\ function to determine the highest scoring poker hand from a list, handling standard hand rankings (from high card to straight flush) and tie-breaking rules, including support for multiple decks and Ace-low straights. The metadata file defines the exercise's blurb, source, and file structure for the track.

exercises/practice/hexadecimal/.meta, exercises/practice/poker/.meta · high confidence

The Scale Generator exercise now includes its complete project structure and metadata. This adds the \.meta/config.json\ file defining the exercise's authors, contributors, and file paths, alongside the \.meta/example.ex\ solution file that implements the \ScaleGenerator\ module (including functions for chromatic scales, flat scales, and pattern-based scale generation). The stub file \lib/scale\_generator.ex\ is provided with function signatures and documentation for users to implement, while \tests.toml\ maps the test cases to the problem specification, and standard Elixir configuration files (\.formatter.exs\, \.gitignore\) are included to support the local development environment.

exercises/practice/scale-generator/.meta · high confidence

The run-length-encoding and scrabble-score exercises now include .meta/config.json files that define authors, contributors, file paths, and descriptions, alongside new .meta/example.ex files that provide official reference implementations for each exercise.

exercises/practice/run-length-encoding/.meta, exercises/practice/scrabble-score/.meta · high confidence

A change to existing behaviour in exercises/concept/file-sniffer/assets — 2 commits, 6 files.

exercises/concept/file-sniffer/assets · medium confidence · unverified

The freelancer-rates exercise now includes structured documentation files: instructions.md defines the four tasks (calculating daily rate, discounted price, monthly rate, and workdays in budget), introduction.md explains Elixir integers and floats, hints.md provides guidance on relevant Kernel and Float functions, and introduction.md.tpl serves as a template for concept integration.

exercises/concept/freelancer-rates/.docs · high confidence

The Bank Account exercise now provides an example solution using Elixir's GenServer to handle concurrent transactions, replacing previous approaches that did not leverage process isolation. The \.meta\ directory has been restructured to include a \config.json\ defining the solution, test, and example file paths, a \tests.toml\ mapping specific test cases (including those for concurrency and error handling), and a \design.md\ explaining why certain state-transition tests (like reopening accounts) are skipped in this language. Users will now see an example implementation that manages account state via process messages, ensuring correct behavior for open, close, balance, deposit, and withdraw operations in a concurrent environment.

exercises/practice/bank-account/.meta · high confidence

The existing exercise stubs, including their Elixir module files, formatter configurations, and gitignore rules, have been moved into the exercises/practice directory. This reorganization structures the repository to clearly separate practice exercises from other content.

(repo-wide) · high confidence

The File Sniffer concept exercise now includes dedicated documentation files: \instructions.md\ defines the task of verifying file uploads by matching extensions and binary signatures against media types, \introduction.md\ explains Elixir's binary data handling and pattern matching, and \hints.md\ provides guidance on using pattern matching and binary literals. These files replace the previous inline or template-based documentation structure for this exercise.

exercises/concept/bird-count/.docs, exercises/concept/file-sniffer/.docs, exercises/concept/log-level/.docs · high confidence

The File Sniffer concept exercise has been updated to handle unknown file inputs gracefully. The solution logic now returns \nil\ when a file extension or binary signature is not recognized, rather than raising an error or returning a default value. This change ensures that the exercise correctly tests pattern matching on binary data and edge cases where the file format cannot be identified.

exercises/concept/file-sniffer/.meta · high confidence

The Gigasecond exercise metadata has been updated to align with the v3 track structure. A new config.json file now explicitly defines the solution, test, and example file paths, lists the authors and contributors, and includes the exercise blurb and source information. The example solution has been moved to .meta/example.ex, and the tests.toml file has been regenerated to reflect the current test specifications, including the exclusion of the 'does not mutate the input' test case.

exercises/practice/gigasecond/.meta · high confidence

The starter code for the Hello World exercise in the \lib/hello\_world.ex\ file has been changed to return "Goodbye, Mars!" instead of the expected "Hello, World!". This behavioral change in the provided stub will cause tests to fail immediately upon running them, requiring users to manually correct the return value to complete the exercise.

exercises/practice/hello-world/.meta · high confidence

The Lasagna concept exercise documentation has been reorganized to improve clarity and consistency. A new hints.md file has been added, providing specific guidance for each of the five tasks, including references to Elixir functions, integers, strings, and operators. The instructions.md file has been updated to clearly define the expected functions (expected\_minutes\_in\_oven, remaining\_minutes\_in\_oven, preparation\_time\_in\_minutes, total\_time\_in\_minutes, alarm) with their arguments and return values. The introduction.md file has been expanded to cover basics like variables, modules, named functions, arity, naming conventions, the standard library, and code comments, with a new introduction.md.tpl template file added to unify introduction contents across exercises.

exercises/concept/lasagna/.docs · high confidence

The Lasagna exercise has been restructured for the v3 curriculum, moving from a practice exercise to a concept exercise focused on 'basics'. The configuration now uses the 'exemplar' file for solution references instead of 'example', and includes a specific blurb describing the learning objectives. The design documentation has been updated to reflect the new scope, emphasizing variables, functions, and basic data types, while the analyzer rules have been refined to check for specific function calls within the solution.

exercises/concept/lasagna/.meta · high confidence

The Lasagna concept exercise now includes a \.formatter.exs\ file to enforce consistent code formatting via \mix format\, and a \.gitignore\ file to exclude build artifacts and dependencies. The main source file \lib/lasagna.ex\ has been updated to use polite instructional comments (replacing 'TODO:') for the functions students need to implement.

exercises/concept/lasagna · high confidence

The Markdown practice exercise now includes a complete solution implementation in .meta/example.ex, which parses Markdown syntax (headers, bold, italic, lists) into HTML. The exercise metadata in .meta/config.json has been updated to define the solution, test, and example file paths, and includes contributor information. A new .formatter.exs file configures the Mix project for code formatting, and a .gitignore file excludes standard Elixir build artifacts. The test suite in tests.toml has been synchronized with canonical data, including specific test cases for various header levels, list handling, and edge cases like h7 headers being treated as paragraphs.

exercises/practice/markdown/.meta · high confidence

The RPN Calculator concept exercise has been restructured to align with the new v3 exercise format. The configuration now points to a dedicated exemplar solution file instead of the previous example structure, and includes a specific icon and blurb. The exercise design has been updated to focus on learning objectives for errors, raising, rescuing, and the \!\ suffix convention, while explicitly excluding exception definitions and \throw\/\catch\. The provided exemplar solution demonstrates these concepts by implementing \calculate!\, \calculate\, and \calculate\_verbose\ functions that handle operations using \try-rescue\ blocks.

exercises/concept/rpn-calculator/.meta · high confidence

The Resistor Color exercise has been refactored to align with the \resistor-color-duo\ and \resistor-color-trio\ exercises by removing the \colors\ function and requiring students to implement a \code/1\ function that accepts an atom (e.g., \:black\) and returns its corresponding integer value. The provided stub in \lib/resistor\_color.ex\ and the example solution in \.meta/example.ex\ now use a map keyed by atoms, and the test configuration in \.meta/tests.toml\ explicitly excludes the \Colors\ test case to reflect this behavioral change.

exercises/practice/resistor-color/.meta · high confidence

The Space Age exercise has been updated to handle invalid input gracefully. Instead of crashing or returning undefined behavior, the \SpaceAge.age\_on/2\ function now returns an \{:error, "not a planet"}\ tuple when a planet name that is not one of the eight solar system planets is provided. This change aligns the exercise with the canonical test suite, which includes a specific test case for this error condition, and ensures users learn to implement proper error handling for unexpected inputs.

exercises/practice/space-age/.meta · high confidence

Concept exercises now include .formatter.exs files to enforce consistent code formatting via mix format, and their lib stubs use comments instead of RuntimeErrors to guide implementation. This change improves the development experience by ensuring code style consistency and providing clearer, non-executing instructions for students.

(repo-wide) · high confidence

The Hamming, Nucleotide Count, and RNA Transcription exercises have been updated to use the new charlist syntax (e.g., \~c"...") in their documentation examples and type specifications. Additionally, each exercise now includes a standard Mix project structure, featuring .formatter.exs for code formatting, .gitignore files tailored to the specific package name, and lib stubs that define the module interfaces for users to implement.

exercises/practice/hamming, exercises/practice/nucleotide-count, exercises/practice/rna-transcription · high confidence

A new default template for exercise READMEs has been introduced, providing a consistent structure for students. This template includes the exercise description, specific instructions for running tests using \mix test\, and guidance on handling pending tests (unskipping via \@tag :pending\ or \ExUnit.configure\). It also links to available resources and includes sections for source credits and submitting incomplete solutions, ensuring a uniform onboarding experience across Elixir exercises.

config · high confidence

The stub files for several concept exercises (including bird-count, community-garden, german-sysadmin, mensch-aergere-dich-nicht, name-badge, take-a-number, and wine-cellar) have been updated to replace RuntimeErrors with descriptive comments. This change improves the learning experience by providing clearer guidance on what needs to be implemented, rather than throwing errors when the stub code is run.

(repo-wide) · high confidence

The documentation for the Elixir RPG Character Sheet exercise has been refreshed to align with the new IO concept. The introduction now explicitly covers \IO.puts\, \IO.write\, \IO.gets\, and \IO.inspect\ with examples. Hints have been added to guide learners through implementing the five steps (welcome, ask name, class, level, and combine) using standard IO functions and string manipulation. A new debug guide explains that IO tests require capturing output, making \IO.inspect\ debugging unavailable for this specific exercise.

exercises/concept/high-school-sweetheart/.docs, exercises/concept/language-list/.docs, exercises/concept/rpg-character-sheet/.docs · high confidence

The dot-dsl practice exercise now includes a dedicated .meta/config.json file that defines the file structure (solution, test, example, and editor files) and provides metadata such as the blurb and source attribution. Additionally, the example solution has been moved to .meta/example.ex, implementing the Dot module with a macro-based DSL to construct graphs, nodes, and edges using the Graph API.

exercises/practice/dot-dsl/.meta · high confidence

The Sum of Multiples exercise metadata has been refreshed to align with the latest canonical data. The .meta/config.json file now explicitly lists authors, contributors, and the specific file paths for the solution, test, and example files, along with a blurb and source attribution. A new .meta/example.ex file provides a reference implementation for the exercise. Additionally, the tests.toml file has been updated to include all canonical test cases, ensuring that learners are tested against the complete set of requirements, including edge cases like factors of zero and large limits.

exercises/practice/flatten-array/.meta, exercises/practice/hamming/.meta, exercises/practice/sum-of-multiples/.meta · high confidence

The Wordy practice exercise now includes its canonical metadata configuration, an example solution, and a synchronized test manifest. The new config.json defines the exercise's blurb, source, and file structure, while the example.ex file provides a reference implementation for parsing and evaluating simple math word problems. The tests.toml file has been updated to reflect the current canonical test suite, ensuring that the exercise's test cases are aligned with the official problem specifications.

exercises/practice/luhn/.meta, exercises/practice/triangle/.meta, exercises/practice/wordy/.meta · high confidence

Add initial test suite for the Rational Numbers exercise; Add test helper for stack-underflow exercise; Add test suite for Community Garden concept exercise; Added Pig Latin exercise tests for Elixir; Added test helper to configure ExUnit and load example files; Added test suite for Boutique Inventory concept exercise; Added test suite for D&D character generation; Added test suite for Hamming distance exercise; Added test suite for Pascal's Triangle exercise; Added test suite for the Point of View exercise; Added test suite for the Sieve of Eratosthenes exercise; Added test suite for the new Affine Cipher practice exercise; Added test suites for Beer Song and Collatz Conjecture exercises; Added test suites for multiple practice exercises; Added tests for RPN Calculator exception handling; Added tests for RPN Calculator output handling; Added tests for the Mensch Ärgere Dich Nicht concept exercise; Added tests for the RPN Calculator Inspection concept exercise; Added tests for the take-a-number-deluxe GenServer exercise; Initial test suite for the RPN Calculator concept exercise.

Concept and practice exercises now include standardized mix.exs files, providing a consistent build environment for learners. These files define the application structure, set the version to 0.1.0 (with one exception at 1.0.0), and configure the project to start as permanent in production. Most exercises have a commented-out Elixir version requirement, while concept exercises omit this constraint entirely, ensuring a uniform starting point for all tracks.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 68.

• Code Health 98
• Architecture 89
• Maturity 52
• Readiness 73
• Security 90

• 300 commits — 280 feature/other, 20 fixes

• exercises/practice — 141 commits
• .github/workflows — 63 commits
• exercises/concept — 57 commits
• (root) — 13 commits
• concepts/bitstrings — 2 commits
• concepts/structs — 2 commits
• .github/dependabot.yml — 1 commit
• bin/check_autogenerated_files.sh — 1 commit
• bin/check_formatting.sh — 1 commit
• bin/fetch-configlet — 1 commit
• bin/generate_practice_exercise.sh — 1 commit
• bin/test_exercises.sh — 1 commit
• concepts/access-behaviour — 1 commit
• concepts/basics — 1 commit
• concepts/binaries — 1 commit
• concepts/bit-manipulation — 1 commit
• concepts/enum — 1 commit
• concepts/errors — 1 commit
• concepts/floating-point-numbers — 1 commit
• concepts/if — 1 commit

• fix: Elixir - Language List - Fixed a shallow test (#1399)
• fix: Fix AllYourBase to follow problem specs (#1370)
• fix: Fix LSP dialyzer errors due to invalid Clock type (#1604)
• fix: Fix Map.fetch return value (#1352)
• fix: Fix printf usage with strings containing variables (#1335)
• fix: Fix a wrong function signature (#1441)
• fix: Fix binary shortcut notation name and link in hints (#1561)
• fix: Fix dead links to hexdocs.pm (#1327)
• fix: Fix decimal to binary youtube link (#1411)
• fix: Fix failing link checks (#1558)
• fix: Fix grammatical issue in introduction.md (#1412)
• fix: Fix hint in kitchen calculator (#1496)
• fix: Fix isbn_verifier test differs from problem-specifications (#1249)
• fix: Fix misleading type_from_binary instructions in file-sniffer (#1638)
• fix: Fix types in complex numbers (#1467)
• fix: fix nth-prime typespec (#1634)
• fix: fix(bottle-song): allow 0 as parameter in quantifier/1 and bottle/1 typespecs (#1375)
• fix: fix(german-sysadmin): refer to diacritics as non-ASCII letters (#1645)
• fix: fix: pin plot_2 in order to check equality (#1360)
• fix: saddle-points: Fix row values in instructions (#1312)
• …and 280 more

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

exercism/elixir 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.