REInfer - Runtime Extended Inference for json data.

  •        2

REInfer performs Runtime Extended type Inference on json data. Compared to traditional types, the extended types incorporate some numerical information, such as the number of times a field appears in the data, or the number of times it is null. A facility is provided to compare inferred types. This follows the idea of a diff algorithm which takes two values and returns the difference. The difference consists of a common part plus two deltas. Deltas are applied using a sum operation for extended types. The diff algorithm borrows and extends ideas from abduction for shape analysis, applied to type theory instead of program logic.

https://github.com/cristianoc/REInfer

Dependencies:

react : ^16.2.0
react-dom : ^16.2.0
reason-react : >=0.4.0

Tags
Implementation
License
Platform

   




Related Projects

reason-scripts - :beginner: Create a ReasonML and React development environment

  •    Javascript

Reason Scripts provides a JS-like development environment for developing web apps with the Reason programming language and React. It bootstraps an environment to automatically compile all Reason code to JS, provide features like reloading and bundling, and seamlessly use JS code from Reason. Make sure to install bs-platform globally using npm instead of yarn.

Eta - A powerful language for building scalable systems on the JVM

  •    Haskell

Eta is a pure, lazy, strongly typed functional programming language on the JVM. It is a dialect of Haskell on the JVM. It is pure by default which means that calling a function with the same arguments will yield the same results every time. It is lazy by default which means that data stays in unevaluated state until a function needs to peek inside.

quack - :baby_chick: A multi-paradigm programming language with gradual and duck typing that targets PHP and JS

  •    PHP

Quack is a type-safe, multi-paradigm programming language. Quack enables you to write consistent and legible code, and run it on different platforms. You can optionally provide type annotations for your values, although it isn't really necessary because we rely on duck and gradual typing. The Quack compiler is being built to be decidable by propagation and with a strong type inference.

Reason - Simple, fast & type safe code that leverages the JavaScript & OCaml ecosystems

  •    OCaml

Reason lets you write simple, fast and quality type safe code while leveraging both the JavaScript & OCaml ecosystems. Reason is not a new language; it's a new syntax and toolchain powered by the battle-tested language, OCaml. Reason gives OCaml a familiar syntax geared toward JavaScript programmers, and caters to the existing NPM/Yarn workflow folks already know.


vscode-reasonml - OCaml & Reason support for Visual Studio Code

  •    TypeScript

There is an #editorsupport channel on the Reason discord server. If you would like to discuss an idea or need help or have other feedback you can usually find me (@freebroccolo) idling there. The Reason installation steps also installs Merlin for you, so you can skip the Merlin installation in the next section.

gluon - A static, type inferred and embeddable language written in Rust.

  •    Rust

Gluon is a small, statically-typed, functional programming language designed for application embedding. Statically typed - Static typing makes it easier to write safe and efficient interfaces between gluon and the host application.

urweb - The Ur/Web programming language

  •    Standard

Ur is a programming language in the tradition of ML and Haskell, but featuring a significantly richer type system. Ur is functional, pure, statically typed, and strict. Ur supports a powerful kind of metaprogramming based on row types. This type safety is just the foundation of the Ur/Web methodology. It is also possible to use metaprogramming to build significant application pieces by analysis of type structure. For instance, the demo includes an ML-style functor for building an admin interface for an arbitrary SQL table. The type system guarantees that the admin interface sub-application that comes out will always be free of the above-listed bugs, no matter which well-typed table description is given as input.

kotlin - Statically Typed Programming Language for the JVM

  •    Java

Kotlin is a statically typed programming language that compiles to JVM byte codes and JavaScript. Java programming language has certain limitations and problems that are either impossible or very hard to fix due to backward-compatibility issues. This new statically typed JVM-targeted language free of the legacy has features include compilation at least as fast as Java, variable type inference, higher-order functions (closures), extension functions, code in interfaces, first-class delegation etc

bs-react-native - BuckleScript bindings for React Native

  •    OCaml

Great that you want to use Reason with React Native! To get everything running are just a couple of steps. Let's assume that you already have a React Native project. Otherwise follow the React Native instructions until you have your app running. and start the watcher with yarn run watch if you haven't done it yet.

Seed7

  •    C

Interpreter and compiler for the Seed7 programming language.

gocaml - :camel: Practical statically typed functional programming language implementation with Go and LLVM

  •    Go

GoCaml is subset of OCaml in Go based on MinCaml using LLVM. GoCaml adds many features to original MinCaml. MinCaml is a minimal subset of OCaml for educational purpose. It is statically-typed and compiled into a binary. This project aims incremental compiler development for my own programming language. Type inference, closure transform, mid-level IR are implemented.

alpaca - Functional programming inspired by ML for the Erlang VM

  •    Erlang

Alpaca is a statically typed, strict/eagerly evaluated, functional programming language for the Erlang virtual machine (BEAM). At present it relies on type inference but does provide a way to add type specifications to top-level function and value bindings. It was formerly known as ML-flavoured Erlang (MLFE). Please see the rebar3 plugin documentation for more details.

typed - Improvements to PHP's type system in userland: generics, typed lists, tuples and structs

  •    PHP

This package is a mere proof of concept about what's possible in PHP's userland to improve type checking. It adds support for type inference, generics, union types, typed lists, tuples and structs. Because all is done in userland, there are limitations on what syntax is possible. The following examples all show the manual type configuration. There are some cases where type inference falls short, and you have to fall back on manually defining them. You might also prefer the manual approach, for clarity's sake.

Kallax - PostgreSQL typesafe ORM for the Go language

  •    Go

Kallax is a PostgreSQL typesafe ORM for the Go language. It aims to provide a way of programmatically write queries and interact with a PostgreSQL database without having to write a single line of SQL, use strings to refer to columns and use values of any type in queries.

infernu - Type inference and checking for a safer JavaScript.

  •    Haskell

Static type inference for JavaScript. Inside every big ugly language there is a small beautiful language trying to come out.

finitio - Finitio is a language for validating, coercing and documenting data.

  •    Javascript

Finitio is a data language. For now, it is limited to a data definition language (DDL). Think "JSON/XML schema", but a slightly different way, that puts the emphasis on precision. Finitio comes with a dedicated type system for defining data and a theory, called information contracts, for interoperability with programming and data exchange languages. Please join the google group for questions and discussions about Finitio.

typedlua - An Optional Type System for Lua

  •    Lua

Please note that Typed Lua is not being actively maintained, as we are now working on the Titan Programming Language. Typed Lua is a typed superset of Lua that compiles to plain Lua. It provides optional type annotations, compile-time type checking, and class-based object oriented programming through the definition of classes, interfaces, and modules.