louthy/language-ext

★ 7,048C#Audience · developerComplexity · 3/5Setup · easy

Mindmap

mindmap
  root((repo))
    What it does
      Functional C# patterns
      Safer predictable code
    Core Features
      Option types no null
      Immutable collections
    Advanced Features
      Parser combinators
      Effects system IO
    Distribution
      NuGet packages
      Optional add-ons

mindmap root((repo)) What it does Functional C# patterns Safer predictable code Core Features Option types no null Immutable collections Advanced Features Parser combinators Effects system IO Distribution NuGet packages Optional add-ons

Click or tap to explore — scroll the page freely

Things people build with this

USE CASE 1

Replace nullable references with Option types to eliminate null-reference crashes throughout a C# codebase.

USE CASE 2

Build composable operation pipelines where each step can succeed or fail without throwing exceptions.

USE CASE 3

Add immutable collections to prevent hard-to-trace state mutations in large shared codebases.

Tech stack

C#.NETNuGet

Getting it running

Difficulty · easy Time to first run · 30min

Requires configuring global namespace imports in the project after installing via NuGet.

No license information is mentioned in the explanation.

In plain English

language-ext is a C# library that brings functional programming patterns into the C# language. The goal is to make it easier to write code in a declarative style, where you describe what a program should produce rather than giving it step-by-step instructions. The library draws inspiration from functional languages like Haskell and F# and provides tools that C# does not include by default. The library addresses a common problem in large codebases: hidden complexity. Traditional object-oriented C# code often manages state in ways that are hard to trace, and errors can appear unexpectedly because many operations can change shared data. Functional programming tries to reduce this by preferring data that cannot be changed after creation, making functions predictable, and handling errors as values rather than exceptions. language-ext builds these habits into C# without requiring a switch to a different language. The feature set covers a wide range of functional programming tools. There are types for representing optional values (so code never has to use null and risk crashes), ways to compose operations that might fail, immutable collection types, functional streams for working with sequences of data, parser combinators for building text parsers from smaller pieces, and an effects system for managing input and output in a controlled way. There is also a package for working with Reactive Extensions and another for bridging to F#. The library is distributed as several NuGet packages, the standard way to share .NET code. The core package is LanguageExt.Core. Optional add-ons cover streaming, parsing, F# interop, and reactive programming. Installation is straightforward: add the package through NuGet and configure a few global namespace imports in the project. The author acknowledges that some of the naming and style choices are non-standard for C# and are intended to feel closer to functional language conventions. The full README is longer than what was shown.

Copy-paste prompts

Prompt 1

Using language-ext, rewrite this C# method that returns null on failure to use Option instead, and show how to chain operations on the result.

Prompt 2

How do I install LanguageExt.Core via NuGet and configure the global namespace imports so I can use it across my C# project?

Prompt 3

Show me how to use language-ext Either type to handle errors as values instead of exceptions in a C# service layer.

Prompt 4

Using language-ext immutable collections, rewrite this C# code that mutates a shared List to a safe functional version.

Open on GitHub → Explain another repo

← louthy on gitmyhub — every repo by this author, as a profile.

Verify against the repo before relying on details.