Displaying 1 to 20 from 25 results

folktale - A standard library for functional programming in JavaScript

  •    Javascript

Folktale is a standard library for functional programming in JavaScript. Folktale is written for ECMAScript 2015 platforms, but it uses a subset of features that can be safely backported to platforms as old as ECMAScript 3. If you're running your program in an older platform, you'll need es5-shim and es6-shim.

Mach7 - Functional programming style pattern-matching library for C++

  •    C++

Pattern matching is an abstraction mechanism that can greatly simplify source code. Commonly, pattern matching is built into a language to provide better syntax, faster code, correctness guarantees and improved diagnostics. Mach7 is a library solution to pattern matching in C++ that maintains many of these features. All the patterns in Mach7 are user-definable, can be stored in variables, passed among functions, and allow the use of open class hierarchies. Next example demonstrates that the library can deal efficiently and in a type-safe manner with non-polymorphic classes like boost::variant as well.

static-land - Specification for common algebraic structures in JavaScript based on Fantasy Land

  •    Javascript

This is a specification for common algebraic structures in JavaScript based on Fantasy Land.Fantasy Land uses methods to define interfaces that a type must implement in order to support a particular Algebra. For example values of a type that implements the Monoid algebra must have fantasy-land/empty and fantasy-land/concat methods on them.

witchcraft - Monads and other dark magic for Elixir

  •    Elixir

Witchcraft is a library providing common algebraic and categorical abstractions to Elixir. Monoids, functors, monads, arrows, categories, and other dark magic right at your fingertips. You shouldn't have to learn another language just to understand powerful abstractions! By enabling people to use a language that they already know, and is already in the same ballpark in terms of values (emphasis on immutability, &c), we can teach and learn faster.

Functional C#

  •    CSharp

Simple Functional Programming Library for C#. It introduces several features found in programming languages like F#. It is built in a compositional fashion starting from Pattern Matching and building on that to support Object Expressions, Tuples, Active Patterns, ADTs.

derive4j - Java 8 annotation processor and framework for deriving algebraic data types constructors, pattern-matching, morphisms, (near future: optics and typeclasses)

  •    Java

tl;dr Show me how to write, say, the Either sum type with Derive4J!.This project has a special dedication to Tony Morris' blog post Debut with a catamorphism. I'm also very thankful to @sviperll and his adt4j project which was the initial inspiration for Derive4J.

datum - pure functional and generic programming for Erlang

  •    Erlang

datum is a pure functional and generic programming for Erlang. It had its origins in Purely Functional Data Structures by Chris Okasaki, on implementing a various higher rank functional abstractions and patterns, on dealing with scrap your boilerplate and gaining experience from other functional languages primary Scala and Haskell. The library is still testing the limits of functional abstractions in Erlang. The latest version of the library is available at its master branch. All development, including new features and bug fixes, take place on the master branch using forking and pull requests as described in contribution guidelines.

tidy - Typed functional programming inside Python.

  •    Python

NOTE: Tidy is still under development and this repository is not yet ready for public consumption. Most development is going on in the underlying typy repository for now. Tidy aims to address these concerns by embedding a typed functional programming language cleanly into Python, as a library. You can install Tidy by running pip install tidy today.

cl-algebraic-data-type - Algebraic data types in Common Lisp

  •    Common

CL-ALGEBRAIC-DATA-TYPE, or ADT, is a library for defining algebraic data types in a similar spirit to Haskell or Standard ML, as well as for operating on them. which will define a new type maybe, with a unary constructor just, and a nullary constructor nothing. The t represents the data type of that field.

dataenum - Algebraic data types in Java.

  •    Java

DataEnum allows you to work with algebraic data types in Java. You can think of it as an enum where every individual value can have different data associated with it.

momi - Monadic middleware

  •    Javascript

In other words, the StateT(Future)-structure might be considered the Middleware monad. This packages exposes the Middleware monad, comprised of State from fantasy-states and Future from Fluture. Besides the monad itself, it also exposes some utility functions and structures for practically applying Middleware. One such utility is the App class, which allows composition of functions over Middleware to be written more like what you are used to from middleware as it comes with Connect, Express or Koa.

vctrs - Vector types

  •    R

The short-term goal of vctrs specify the behavior of functions that combine different types of vectors. This will help reason about functions that combine different types of input (e.g. c(), ifelse(), rbind()). The vctrs type system encompasses base vectors (e.g. logical, numeric, character, list), S3 vectors (e.g. factor, ordered, Date, POSIXct), and data frames; and can be extended to deal with S3 vectors defined in other packages, as described in vignette("extending-vctrs"). Understanding and extending vctrs requires some effort from developers, but it is our hope that the package will be invisible to most users. Having an underlying theory that describes what type of thing a function should return will mean that you can build up an accurate mental model from day-to-day use, and you will be less surprised by new functions.

safe-types - Type safe utils inspired from the Rust language for writing better TypeScript/Flow.

  •    TypeScript

Type safe utils inspired from the Rust language for writing better JavaScript. Written in typescript with support for flow definitions. This library started out as an experiment both to learn Rust concepts as well as to determine whether some of Rust's types can be mapped to TypeScript and improve the safety of TypeScript/JavaScript. It's my opinion that a library like this requires a 100% TypeScript environment to provide security of JS types. Without the TypeScript compiler and tooling, these primitives may make your data more opaque rather than provide insight and clarity into the many states application data can be in. Using an editor like vscode can bridge that gap somewhat since it provides built in intellisense via the typescript language server.

dart_meta_types - a code gen solution for defining sealed classes, data classes, and enum classes for dart

  •    Dart

a code gen solution for defining sealed classes, data classes, and enum classes for dart. examples. See meta_types/example for examples on how to write model definitions.

macros - A more powerful C/C++ preprocessor.

  •    Haskell

The venerable C preprocessor (cpp) – the part of the compilation process that interprets hash-prefixed directives such as #include and #define, and substitutes for the macros defined by the latter – is undoubtedly one of the backbones of the C/C++ ecosystem. However, its macro functionality suffers from known limitations: macros may not call themselves recursively, meaningfully work with mutable state or introduce syntax that does not obey the shape of either single keywords or function calls. This severely limits its utility for metaprogramming, necessitating the proliferation of idiosyncratic boilerplate-generation tools of high complexity but limited scope such as Yacc or Qt's moc. This project is an attempt to create a Turing-complete general-purpose preprocessor for C and C++ that is powerful enough to subsume all of the above and more: indeed, we shall aim to be able to build on top of either C or C++ in the way the latter was originally built upon the former, while seamlessly blending in with existing code as the C preprocessor does.

purescript-data-algebrae - Reified operations for several common data structures.

  •    PureScript

[1]. Basic means that these are literally just data structures. The docs on Pursuit will tell you everything you need, as each constructor of the data type represents each possible action. [2]. Mutation-only means that none of these allow you to access the data. This is a deliberate choice: your interpreter implementations can be written safe in the knowledge that none of the intermediate state is actually required externally, so it doesn't need to be preserved. If we care about performance, this means that we are free to write stateful interpreters that modify values in place using the ST operations or even a Ref.

RemoteDataK - Algebraic data type (ADT) to represent the state of data that is loading from/to remote sources/destinations

  •    Kotlin

RemoteData is useful to represent the state of data, when it is loading from/to a remote source/destination. Using RemoteData is pretty straightforward, it is however meant to be used in a functional style.

elixir_fun_land - Algebraic Data Types for Elixir: Both functional and fun.

  •    Elixir

FunLand adds Behaviours to define Algebraic Data Types ('Container' data types) to Elixir, including many helpful operations with them. Where applicable, an ADT implementation for Elixir's built-in types like Lists, Maps, Strings and Functions are included. FunLand is based on ideas of the Fantasy Land JavaScript specification for Algebraic Data Types, as well as the implementations of ADTs in other languages, such as Haskell and Idris.

aifad - AIFAD - Automated Induction of Functions over Algebraic Data Types

  •    OCaml

AIFAD stands for Automated Induction of Functions over Algebraic Data Types and is an application written in OCaml that improves decision tree learning by supporting significantly more complex kinds of data. This allows users to more conveniently describe the data they want to learn functions on and can improve the accuracy and complexity of resulting models. Handles multi-valued attributes. This has already become widespread among decision tree learners, but some implementations still only support binary ones.

We have large collection of open source products. Follow the tags from Tag Cloud >>

Open source products are scattered around the web. Please provide information about the open source projects you own / you use. Add Projects.