A dynamic scripting language for .NET.
A contract-driven, Native AOT-ready .NET 10 SDK for Solana — independently implemented from pinned Anza Solana SDK, Agave, and SPL source contracts. Source-generated JSON with no reflection; typed RPC and multiplexed WebSocket streaming; Ed25519 and BLS12-381 keys/signatures; program instructions and bounded state decoding; and exact legacy/v0/V1 transaction wire formats verified against Rust-compatible vectors. Ships as one package bundling the Core, Wallet, Rpc, and Programs functional assemblies plus a minimal packaging facade.
Functional.DotNet is a C# library designed to enrich the functional programming experience within the .NET ecosystem. This package offers a suite of powerful, easy-to-use functional constructs and utilities, enabling developers to write more expressive, concise, and reliable code.
Result pattern implementation for functional error handling in C#. Provides Result<T> and Result types for railway-oriented programming, eliminating exceptions for expected failures. Foundation for functional programming patterns and robust error handling.
A lightweight library of component-model-like types and functionality that are useful in common .NET programming scenarios.
# ThrowAway **ThrowAway** is a pragmatic and efficient C# library that marries functional programming concepts with traditional procedural error handling. It is designed to elegantly manage the dichotomy between successful outcomes (`Values`) and error states (`Failures`) by leveraging the power of the **Option** type. This hybrid approach makes it easy to write expressive, functional code while still integrating seamlessly with conventional try-catch exception handling. ## Overview In many C# applications, error handling is either bogged down by traditional exception logic or forced into a rigid functional style. ThrowAway bridges these two worlds by offering: - **Explicit Functional Handling:** Model success and failure as first-class citizens with Option types. - **Seamless Procedural Integration:** Implicit conversions let you work with Options as if they were plain values - while automatically throwing a `HasFailedException` when an Option is in a failed state. This allows you to mix functional transformations with traditional try-catch error management. ## Key Features - **Dual Outcomes:** Every operation returns an Option that encapsulates either a valid result (`Value`) or an error (`Failure`). - **Implicit Conversions:** Options automatically convert to their underlying type. When an Option represents a failure, an exception is thrown, enabling smooth integration with procedural exception handling. - **Rich Functional API:** A suite of extension methods (like `Map`, `FlatMap`, `Match`, `Filter`, `Transpose`, and `Use`) enables chaining and composing operations in a functional style. - **No Nulls:** Being struct-based, Options guarantee non-null instances, improving type safety. - **Hybrid Error Handling:** Combines the explicitness of functional error handling with the convenience of procedural exception handling. - **Robust Exception Wrapping:** Methods like `CatchFailure` and `CatchAll` convert exceptions into failed Options, maintaining consistency in error handling. - **Seamless Unwrapping:** `TryUnwrap` lets you extract both the value and the failure message without additional boilerplate.
Basic statistics with some probability library. Includes common distributions (Bernoulli, Binomial, Poisson, Student's and Normal), random number generators from some of the distributions, summary statistics for a sample, Z-Test, Student's T-Test, special functions (Error, Gamma, Beta and Regularized Incomplete Beta).
.Net 6 based library offering chess-related blazor components and functions for chess programming.
Provides functional-style extensions for C# 's function type.
Railway Oriented Programming is a coding concept that involves using a library's built-in functions to control program execution flow based on success or error track. By doing so, functional code can be written that allows for chaining of functions without the need for error checking.
Lightweight, functional result and option types for .NET, with extensions for ASP.NET Core and Refit integration. Simplifies error handling and functional programming patterns.
ComPDFKit is the SDK and API product which is provided by PDF Technologies, and allows developers or companies to integrate into macOS, Windows, Linux, iOS, Android, and Web platforms. Download and integrate ComPDFKit for .NetFramework to obtain the ability to process PDF files with the following functionalities. Contact us for the license to trial for free: https://www.compdf.com/contact-us Features: - PDF Viewer: Provide multiple display modes and themes. Allow to search and select text, zoom, navigate, and rearrange text. - PDF Annotation: Create, delete, edit, import, export, flatten, set permissions, properties, etc. - PDF Editor: Split, merge, insert, delete, replace, extract images, rotate, exchange, etc. - Edit PDF: PDF text, images. - PDF Conversion: Convert PDF to PDF/A - Forms: Generate, fill, sign, and flatten PDF forms. - PDF Encryption - PDF Comparison - PDF Redaction - PDF Optimization - Digital Signature - Measurement Contact: - Trial License: https://www.compdf.com/contact-us - Details of the PDF Functionalities: https://www.compdf.com/pdf-sdk/features-list - Developerment Guides: https://www.compdf.com/guides/windows - SDK for Other Package and Programming Platforms: https://www.compdf.com/contact-us
A functional approach to returning a guaranteed result and avoiding null reference checks in a strongly-typed way.
An ultra-high performance, struct-based, enterprise-grade Result pattern implementation for modern .NET.
Bunch of serializers of F# types to MongoDB
Dew.Math.Core is the portable, pure managed edition of the Dew.Math library. It provides the same high-level matrix and vector programming model, expression parser, probability and optimization toolkit, and special function support without linking to any native runtime components. This enables maximum compatibility across platforms and runtime environments. Core Numerical Capabilities (Managed): - Dense matrix and vector operations with operator overloading and method-based APIs - QR, LU, SVD and eigenvalue routines using high-quality managed linear algebra kernels - Complex number and real-valued computation with full vectorization in managed code - Sparse matrix representations with iterative solver support - Probability distributions, histogramming, random generators, Monte Carlo workflows - Nonlinear optimization, curve fitting, regression models, trust-region and gradient methods - Vectorized expression parsing for symbolic-style expression and simulation pipelines - Polynomial and spline interpolation, numerical integration and differentiation - Special function suite including Bessel, Airy, Gamma-related, Legendre and elliptic functions Portability Model: - No native libraries required (zero unmanaged dependencies) - Runs on Windows, Linux, macOS, iOS, Android, MAUI, Uno, WASM, Unity*, cloud functions and plugins - Targets netstandard2.0, net8.0, and net9.0 Use Dew.Math.Core when you need **maximum portability** in libraries, shared simulation engines, tooling, mobile deployments, WebAssembly environments, or plugin architectures.
Modern, testable database access library using DbProviderFactory with Result monad pattern for explicit error handling. Features IDbCommandExecutor interface for easy mocking, command factory pattern for separation of concerns, and fluent parameter API. Supports SQL Server, PostgreSQL, MySQL, Oracle, SQLite, and ODBC for universal database connectivity.
F# MVC for WPF is a small, yet powerful framework, designed for building WPF applications in F#. With strong support for MVC, functional, asynchronous and event-driven programming, it will enable you to build your solution quickly, without the need to sacrifice type system or testability.
Functional programming library for C#
A functional Result pattern implementation for .NET, providing type-safe error handling without exceptions. This library implements the Railway Oriented Programming pattern with Result, Ok, Error types and comprehensive extension methods.
General-purpose utility classes, extension methods, and helper functions for common programming tasks.
A utility library for transforming values using delegates
PrimeFuncPack Core.TaggedUnion is a core library for .NET consisting of Tagged Union targeted for use in functional programming.
Portable AForge Genetic provides genetic programming functionality to the AForge.NET Framework on mobile and tablet devices.
This library supports functional programming using F# on ASP.NET.
PrimeFuncPack Core is a functional programming pack for .NET consisting of the fundamentals: Optional and Result monads, Failure type, Tagged Union, Unit type, and functional interfaces (SAM interfaces), as well as the useful extensions. The Pack supports both asynchronous and synchronous programming models.
The core library for DropBear.Codex providing Result pattern, error handling, and telemetry infrastructure for .NET 9+ applications. Features type-safe error handling, functional extensions, and OpenTelemetry integration.
A lightweight functional programming library for .NET providing Result and Maybe types for railway-oriented programming and error handling.
A library contains common code related to functional programming with logger based on LanguageExt.
A comprehensive C# library enhancing functional programming capabilities with type-safe monads (Maybe, Result), discriminated unions (Any), and robust error handling. Features include: domain-driven design support, enhanced Entity Framework integration, testable time management, JSON utilities, and LINQ extensions. Built for modern C# development with focus on maintainability, testability, and functional programming principles.
Contains the functional programming paradigm; unions in both disjointed- and tagged flavors.
PrimeFuncPack Core.Taggeds is a core pack for .NET consisting of fundamental tagged types targeted for use in functional programming: Optional and Result monads, Tagged Union, as well as the convert extensions.
Composer is an extensible Compositional Architecture framework, providing a set of functionality such as Inversion of Control container (IoC), Dependency Injection (DI), Plug-in framework, Aspect Oriented Programming (AOP), Configurability and Composability for components.
Adds ASP.NetCore methods and extensions to the Capgemini.SerializableResult NuGet
A Result pattern library for .NET with typed errors, Railway-Oriented pipelines, and automatic flow diagrams generated from your code. Provides Result<T>, Result<T,TError>, ErrorsOf<T1..T8>, rich domain errors (ValidationError, ForbiddenError, NotFoundError, ConflictError) with TagKey<T> metadata, ResultContext for entity/correlation/tenant tracking, and full async pipeline support via Bind, Map, Ensure, Tap. Companion packages add pipeline visualization, ASP.NET Core, FluentValidation, OpenTelemetry, HTTP integration, and Roslyn safety analyzers.
PrimeFuncPack Core.Func.Extensions is a core library for .NET consisting of extensions for functional interfaces (SAM interfaces) targeted for use in functional programming - IAsyncFunc/IAsyncValueFunc and IFunc, both asynchronous (Task and ValueTask based) and synchronous.
[.NET 4.6.1+] - DisposableObservable: a class for creating Observable sequences with TPL easily as Observable.Create - [IObservable].Serialize: wrap all subscriptions into a single ISubject against the sourcing observable - [IObservable].AsAsync: execute all functions on TPL - [IObservable].Fork: add another subscription to the observable creating a new child observable stream - [IObservable].Where(filter, elseObservable): apply the where in the usual way, and generate an Else observable to continue work in the other case - [IObservable].ToJson: serialize in Json all values - [IObservable].ToCSV: serialize in CSV columns all values (configurable delimiter) - [IObservable].OnLastOrDefault: do something when observable completes - ObservableStreamReader: route binary data from a Stream to subscribers
A library contains common code related to functional programming in ASP.NET Core based on LanguageExt.
A companion library to Endofunk.FX providing functional wrappers around: - System.Net - Newtonsoft.Json
A methods to operate collections and flow control. Please see github to get-started guide: https://github.com/andriyshevchenko/collections. Using a C# 6.0 static import required. Extensive use of C# 7.0 ValueTuple's
The Full Picture API exposes a set of the admin functionality of Full Picture to make it easy for you to build integrations with your own systems. It serves as an interface between your software programs and facilitates their interaction with Full Picture. We're continuing to expand the amount of functionality our API offers.
Functional Reactive Programming Library for .NET. https://github.com/jerometerry/potassium http://www.jerometerry.com/potassium/
Enhances Entity Framework Core with functional programming patterns and DDD-friendly features. Includes base entity classes, soft delete support, audit trails, query filters, optimistic concurrency, PostgreSQL integration, query performance monitoring, and domain event handling. Perfect for building maintainable and scalable data access layers in modern .NET applications.
Command Line GUI includes a command line arguments parser library Fonlow.CommandLineGui.Core.dll for constructing .NET command line programs with complex arguments. You define a data model class decorated by some attributes for representing arguments. The core library will parse the command line arguments and populate the Plain Old CLR Object which is the router of the functionality of your command line program. And the Core library may also generates CLI help page as illustrated in https://a.fsdn.com/con/app/proj/commandlinegui/screenshots/Standard.PNG/182/137 Command Line GUI is a host program that generates GUI for existing command line programs. .NET command line programs constructed through the core library could become a plugin of Command Line GUI and have the GUI generated. You may use the core library to wrap existing command line programs like Robocopy, and the wrapper may become a plugin, thus a native command line program could easily have a GUI.
A small functional programming language for .NET. Its syntax is based on Python but whitespaces are ignored. Everything is an expression. The language runtime is embeddable, its AST is accesible and it compiles to portable pcode. There's an REPL you can play with and the project includes lots of unit tests. Example of factorial: f = lambda x: (x*f(x-1)) if x > 1 else 1; f(4) returns 24.0 See details, examples and instructions in the project site.