Types from data: making structured data first-class citizens in F#

@article{Petek2016TypesFD,
  title={Types from data: making structured data first-class citizens in F\#},
  author={Tom{\'a}{\vs} Petř{\'i}{\vc}ek and Gustavo Guerra and Don Syme},
  journal={Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation},
  year={2016}
}
Most modern applications interact with external services and access data in structured formats such as XML, JSON and CSV. Static type systems do not understand such formats, often making data access more cumbersome. Should we give up and leave the messy world of external data to dynamic typing and runtime checks? Of course, not! We present F# Data, a library that integrates external structured data into F#. As most real-world data does not come with an explicit schema, we develop a shape… 

Figures from this paper

Lightweight Automated Structure Inference and Binding of Data Sources to Predefined Data Types
  • N. A. Hamid
  • Computer Science
    ACM Southeast Regional Conference
  • 2020
TLDR
This paper presents a methodology to facilitate retrieval and dynamic binding of online data sources (in common formats such as XML, CSV, JSON, fixed-width, etc.) to programmer-defined data types with minimal syntactic overhead and no scaffolding.
2 Using type providers in a novel way
TLDR
The design of a data exploration language that makes the task more accessible by embedding advanced programming concepts into a simple core language and significantly reduce the complexity of languages that one needs to understand in order to write scripts for exploring data.
Data Exploration through Dot-driven Development
TLDR
The design of a data exploration language that makes the task more accessible by embedding advanced programming concepts into a simple core language and significantly reduce the complexity of languages that one needs to understand in order to write scripts for exploring data.
Refinement kinds: type-safe programming with practical type-level computation
TLDR
This work introduces the novel concept of kind refinement, which is developed in the context of an explicitly polymorphic ML-like language with type-level computation, and validate the approach both formally and pragmatically by establishing the standard meta-theoretical results of type safety.
Foundations of a live data exploration environment
TLDR
A formal language that captures the structure of code written by data analysts and an algorithm for providing instant previews for the data exploration calculus that allows the user to modify code in an unrestricted way in a text editor is presented.
Value-Dependent Session Design in a Dependently Typed Language
TLDR
This work presents Sessions, a Resource Dependent EDSL for describing global session descriptions in the dependently typed language Idris, and demonstrates Sessions expressiveness by describing the TCP Handshake, a multi-modal server providing echo and basic arithmetic operations, and a Higher-Order protocol that supports an authentication interaction step.
CPEG: a typed tree construction from parsing expression grammars with regex-like captures
TLDR
Regular expression type is inferred from a given CPEG by the type inference that is formally developed in this paper, and it is proved the soundness and the uniqueness of thetype inference.
ptype-cat: Inferring the Type and Values of Categorical Variables
TLDR
This paper proposes a probabilistic type inference method that can identify the general categorical data type (including non-Boolean variables), and identifies the possible values of each categorical variable by adapting the existingtype inference method ptype.
A session type provider: compile-time API generation of distributed protocols with refinements in F#
TLDR
This library is the first practical development of MPST to support what the authors refer to as interaction refinements: a collection of features related to the refinement of protocols, such as message-type refinements (value constraints) and message value dependent control flow.
Typed concurrent functional programming with channels, actors and sessions
TLDR
This thesis provides the first integration of exception handling and asynchronous session types in a core functional language, Exceptional GV, and proves that it satis es preservation, global progress, and that it is con uent and terminating.
...
1
2
3
...

References

SHOWING 1-10 OF 31 REFERENCES
Dependent type providers
TLDR
This work shows that with dependent types it is possible to define a type provider mechanism that does not rely on code generation, and evaluates the practicality of this technique and explores future extensions.
LINQ: reconciling object, relations and XML in the .NET framework
TLDR
The .NET Language-Integrated Query (LINQ) framework, proposed for the next release of the .NET framework, approaches the problem of handling data from different data models by defining a pattern of general-purpose standard query operators for traversal, filter, and projection.
Strongly-Typed Language Support for Internet- Scale Information Sources
TLDR
The design and implementation of the type provider mechanism in F# 3.0 and its applications to typed programming with web ontologies, web-services, systems management information, database mappings, data markets, content management systems, economic data and hosted scripting are described.
Ur: statically-typed metaprogramming with type-level record computation
TLDR
Ad-hoc code generation is already in wide use in the popular Web application frameworks, and it is shown how that generation may be tamed using types, without forcing metaprogram authors to write proofs or forcing metAProgram users to write any fancy types.
IDE Integrated RDF Exploration, Access and RDF-Based Code Typing with LITEQ
TLDR
This demo presents a prototype of LITEQ that supports such a type mapping as well as autocompletion for NPQL queries.
Typing Massive JSON Datasets
TLDR
This paper sketches a typing algorithm that can be used to infer a succinct type from scratch for a collection of JSON objects, as well as to validate a dataset against a human-designed type and, if necessary, to adapt and improve this type.
Operations on Records
TLDR
The approach unifies and extends previous notions of records, bounded quantification, record extension, and parametrization by row-variables, within a framework based on typed Iambda-calcutus.
Gradual Typing for Objects
TLDR
This paper develops a gradual type system for object-based languages, extending the Ob < : calculus of Abadi and Cardelli, and shows that gradual typing and subtyping are orthogonal and can be combined in a principled fashion.
In the Age of Web: Typed Functional-First Programming Revisited
TLDR
This paper uses a practical case study as a starting point and looks at how the F# language and libraries approach the challenges posed by the web, and concludes that the holistic perspective is more important than each of the features in isolation.
Unifying Tables, Objects and Documents
This paper proposes a number of type-system and language extensions to natively support relational and hierarchical data within a statically typed object-oriented setting. In our approach SQL tables
...
1
2
3
4
...