Displaying 1 to 20 from 23 results

eslint-plugin-immutable - ESLint plugin to disable all mutation in JavaScript.

  •    Javascript

This is an ESLint plugin to disable all mutation in JavaScript. Think this is a bit too restrictive? Well if you're using Redux and React, there isn't much reason for your code to be mutating anything. Redux maintains a mutable pointer to your immutable application state, and React manages your DOM state. Your components should be stateless functions, translating data into Virtual DOM objects whenever Redux emits a new state. These ESLint rules explicitly prohibit mutation, effectively forcing you to write code very similar to Elm in React. There's no reason to use let in a Redux/React application, because all your state is managed by either Redux or React. Use const instead, and avoid state bugs altogether.

immutability-helper - mutate a copy of data without changing the original source

  •    Javascript

Note that this module has nothing to do with React. However, since this module is most commonly used with React, the docs will focus on how it can be used with React. React lets you use whatever style of data management you want, including mutation. However, if you can use immutable data in performance-critical parts of your application it's easy to implement a fastshouldComponentUpdate() method to significantly speed up your app.

immudb - world’s fastest immutable database

  •    Go

immudb is a database with built-in cryptographic proof and verification. It can track changes in sensitive data and the integrity of the history will be protected by the clients, without the need to trust the server. It can operate as a key-value store or as relational database (SQL).

immutable-css - A css linter for immutable selectors

  •    Javascript

Best practices suggest avoiding overriding styles from vendor libraries to prevent unwanted side effects. Base library styles should not be altered – or as Harry Roberts describes, base styles should be treated as Immutable CSS. See the interactive web app.




timm - Immutability helpers with fast reads and acceptable writes

  •    Javascript

I know, I know... the world doesn't need yet another immutability library, especially with the likes of ImmutableJS and seamless-immutable around.And yet... I felt the urge, at least just to cover my limited needs. ImmutableJS is a solid, comprehensive and highly-performant solution, but this power comes at a price: mixing up ImmutableJS's Maps and Lists with your plain objects can cause some friction, and reading those objects (in my case, more often than writing them) isn't that convenient.

immutable-cursor - 👊 Immutable cursors incorporating the Immutable

  •    Javascript

In Immutable.js' cursor implementation, all applicable parts of it's native interface are exposed as first-class citizens directly on the cursor, allowing for a rich mutative API. Each cursor however, holds it's own reference to the root state, which quickly leads to issues with the integrity of the root state when updates are made from derived cursors - i.e not included in a chained sequence with the root cursor.

plait - A fast, minimal JavaScript framework for building isomorphic reactive web components.

  •    Javascript

Plait is a minimal JavaScript framework for building isomorphic reactive web components. It is loosely based on The Elm Architecture and Elm's StartApp. Inspired by the experience of writing reactive applications in Elm, Plait is an attempt at achieving a similar application architecture with a minimal amount of JavaScript.


immutable - neatly packages immutable equivalents to JavaScript's Objects and Arrays.

  •    Javascript

This project is no longer actively supported. If anyone is interested in becoming the new maintainer, don't hesitate to contact me (hughfdjackson@googlemail.com). The go-to immutable library is https://github.com/facebook/immutable-js.

persistent-hash-trie - Pure string:val storage, using structural sharing

  •    Javascript

This project is no longer actively supported. If anyone is interested in becoming the new maintainer, don't hesitate to contact me (hughfdjackson@googlemail.com). For an alternative, consider https://npmjs.org/package/mori.

redux-freeze - Redux middleware that prevents state from being mutated anywhere in the app

  •    Javascript

Redux middleware that prevents state from being mutated anywhere in the app. When mutation occurs, an error will be thrown by the runtime. This is useful during development mode to ensure that no part of the app accidentally mutates the state.

built_redux - an implementation of redux written in dart that enforces immutability

  •    Dart

built_redux is a state management library written in dart that enforces immutability. built_redux is not only an implementation of redux, but also a framework for building middleware and reducers in a type safe manner.

flutter_built_redux - Built_redux provider for Flutter.

  •    Dart

built_redux bindings for Flutter. For the same reason you would want to use redux with react.

freeze - An immutability helper for Go

  •    Go

Package freeze enables the "freezing" of data, similar to JavaScript's Object.freeze(). A frozen object cannot be modified; attempting to do so will result in an unrecoverable panic. Freezing is useful for providing soft guarantees of immutability. That is: the compiler can't prevent you from mutating an frozen object, but the runtime can. One of the unfortunate aspects of Go is its limited support for constants: structs, slices, and even arrays cannot be declared as consts. This becomes a problem when you want to pass a slice around to many consumers without worrying about them modifying it. With freeze, you can guard against these unwanted or intended behaviors.

jetset - RESTful API fetching and caching for React apps, backed by an immutable state tree

  •    Javascript

Stop re-solving the problems of fetching, caching, and managing state for your RESTful API, so you can focus on your React app's unique needs. This last one will provide some of the value of GraphQL + Relay without all the dependencies and complex set-up.

qfactom - kdb+ wrapper library for interacting with the factom client (factomd) and wallet (factom-walletd) applications via the v2 REST APIs

  •    C

qfactom is a kdb+ wrapper library designed to interact with the Factom blockchain via the factomd client (factomd) and wallet (factom-walletd) REST APIs. The library allows records, in the form of kdb+ tables, lists etc, to be easily secured on the Factom blockchain through the use of simple q function. Entries made to Factom chains can serve as a Proof of Existence, enabling cryptographically secure audit trails to be constructed. Data stored on existing Factom chains, like those used to hold Stock market prices, can also be easily extracted and coverted to kdb+ table format, see example. Combining the speed and scalability of kdb+, with the security and scalability of Factom, enables millions of records to be secured quickly and safely.

lasca-compiler - Lasca is Scala shifted towards Haskell.

  •    C

Lasca is Scala shifted towards Haskell. Lasca is a LLVM-based statically or dynamically typed strict functional programming language. Simplified OCaml if you will.

hyperfiddle - a Hypermedia Function

  •    Clojure

Hyperfiddle isolates your web clients from I/O, so your code can stay pure. If React.js is managed DOM, Hyperfiddle is managed network and database. This enables a new kind of composable primitive for constructing web software, with paradigm-changing implications. The hardest part of web dev is I/O: data sync between database, various services, UI and then back to the database. An async, slow, failure-prone concern wired throughout the full stack, and the reason why we all code the same web boilerplate over and over again, year after year – a collosal, industry-wide failure to abstract.

ftor - ftor enables ML-like type-directed, functional programming with Javascript including reasonable debugging

  •    Javascript

Please note: The experience gained from this project has resulted in a completely new approach: scriptum. ftor will need at least another six month to reach a more stable status (as of Feb., 2018). It has a great impact on the way Javascript is encoded, but there are no best practices yet, so conceptual details may still change.