• Stars
    star
    393
  • Rank 105,432 (Top 3 %)
  • Language
    F#
  • License
    MIT License
  • Created about 8 years ago
  • Updated 15 days ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

FSharp implementation of Facebook GraphQL query language.

FSharp.Data.GraphQL

F# implementation of Facebook GraphQL query language specification.

Publish to GitHub Publish to NuGet

Join the chat at https://gitter.im/FSharp-Data-GraphQL/community

Installing project templates

Type the following commands to install the template for creating web applications:

From GitHub: dotnet new -i "FSharp.Data.GraphQL::2.0.0-ci-*" --nuget-source "https://nuget.pkg.github.com/fsprojects/index.json"

From NuGet: dotnet new -i "FSharp.Data.GraphQL::2.0.0"

Quick start

open FSharp.Data.GraphQL
open FSharp.Data.GraphQL.Types

type Person =
    { FirstName: string
      LastName: string }

// Define GraphQL type 
let PersonType = Define.Object(
    name = "Person",
    fields = [
        // Property resolver will be auto-generated
        Define.AutoField("firstName", StringType)
        // Asynchronous explicit member resolver
        Define.AsyncField("lastName", StringType, resolve = fun context person -> async { return person.LastName })
    ])

// Include person as a root query of a schema
let schema = Schema(query = PersonType)
// Create an Exector for the schema
let executor = Executor(schema)

// Retrieve person data
let johnSnow = { FirstName = "John"; LastName = "Snow" }
let reply = executor.AsyncExecute(Parser.parse "{ firstName, lastName }", johnSnow) |> Async.RunSynchronously
// #> { data: { "firstName", "John", "lastName", "Snow" } } 

It's type safe. Things like invalid fields or invalid return types will be checked at compile time.

ASP.NET / Giraffe / WebSocket (for GraphQL subscriptions) usage

See the AspNetCore/README.md

Demos

GraphiQL client

Go to the GraphiQL sample directory. In order to run it, build and run the Star Wars API sample project with Debug settings - this will create a Giraffe server compatible with the GraphQL spec, running on port 8086. Then what you need is to run node.js graphiql frontend. To do so, run npm i to get all dependencies, and then run npm run serve | npm run dev - this will start a webpack server running on http://localhost:8090/ . Visit this link, and GraphiQL editor should appear. You may try it by applying following query:

{
  hero(id:"1000") {
    id,
    name,
    appearsIn,
    homePlanet,
    friends {
      ... on Human {
        name
      }
      ... on Droid {
        name
      }
    }
  }
}

Relay.js starter kit

A second sample is a F#-backed version of of popular Relay Starter Kit - an example application using React.js + Relay with Relay-compatible server API.

To run it, build FSharp.Data.GraphQL and FSharp.Data.GraphQL.Relay projects using Debug settings. Then start server by running server.fsx script in your FSI - this will start a relay-compatible F# server on port 8083. Then build node.js frontend by getting all dependencies (npm i) and running it (npm run serve | npm run dev) - this will start webpack server running React application using Relay for managing application state. You can visit it on http://localhost:8083/ .

In order to update client schema, visit http://localhost:8083/ and copy-paste the response (which is the introspection query result from the current F# server) into data/schema.json.

Stream features

The stream directive now has additional features, like batching (buffering) by interval and/or batch size. To make it work, a custom stream directive must be placed inside the SchemaConfig.Directives list, this custom directive containing two optional arguments called interval and preferredBatchSize:

let customStreamDirective =
    let args = [|
        Define.Input(
            "interval",
            Nullable IntType,
            defaultValue = Some 2000,
            description = "An optional argument used to buffer stream results. ")
        Define.Input(
            "preferredBatchSize",
            Nullable IntType,
            defaultValue = None,
            description = "An optional argument used to buffer stream results. ") |]
    { StreamDirective with Args = args }
let schemaConfig =
    { SchemaConfig.Default with
        Directives = [
            IncludeDirective
            SkipDirective
            DeferDirective
            customStreamDirective
            LiveDirective ] }

This boilerplate code can be easily reduced with a built-in implementation:

let streamOptions =
    { Interval = Some 2000; PreferredBatchSize = None }
let schemaConfig =
    SchemaConfig.DefaultWithBufferedStream(streamOptions)

Live queries

The live directive is now supported by the server component. To support live queries, each field of each type of the schema needs to be configured as a live field. This is done by using ILiveFieldSubscription and ILiveQuerySubscriptionProvider, which can be configured in the SchemaConfig:

type ILiveFieldSubscription =
    interface
        abstract member Identity : obj -> obj
        abstract member TypeName : string
        abstract member FieldName : string
    end

and ILiveFieldSubscription<'Object, 'Identity> =
    interface
        inherit ILiveFieldSubscription
        abstract member Identity : 'Object -> 'Identity
    end

and ILiveFieldSubscriptionProvider =
    interface
        abstract member HasSubscribers : string -> string -> bool
        abstract member IsRegistered : string -> string -> bool
        abstract member AsyncRegister : ILiveFieldSubscription -> Async<unit>
        abstract member TryFind : string -> string -> ILiveFieldSubscription option
        abstract member Add : obj -> string -> string -> IObservable<obj>
        abstract member AsyncPublish<'T> : string -> string -> 'T -> Async<unit>
    end

To set a field as a live field, call the Register extension method. Each subscription needs to know an object identity, so it must be configured on the Identity function of the ILiveFieldSubscription. Also, the name of the Type and the field inside the ObjectDef needs to be passed along:

let schemaConfig = SchemaConfig.Default
let schema = Schema(root, config = schemaConfig)
let subscription =
    { Identity = fun (x : Human) -> x.Id
      TypeName = "Hero"
      FieldName = "name" }

schemaConfig.LiveFieldSubscriptionProvider.Register subscription

With that, the field name of the hero is now able to go live, being updated to clients whenever it is queried with the live directive. To push updates to subscribers, just call Publish method, passing along the type name, the field name and the updated object:

let updatedHero = { hero with Name = "Han Solo - Test" }
schemaConfig.LiveFieldSubscriptionProvider.Publish "Hero" "name" updatedHero

Client Provider

Our client library now has a completely redesigned type provider. To start using it, you will first need access to the introspection schema for the server you are trying to connect. This can be done with the provider in one of two ways:

  1. Provide the URL to the desired GraphQL server (without any custom HTTP headers required). The provider will access the server, send an Introspection Query, and use the schema to provide the types used to make queries.
type MyProvider = GraphQLProvider<"http://some.graphqlserver.development.org">
  1. Provide an introspection json file to be used by the provider. Beware though that the introspection json should have all fields required by the provider. You can get the correct fields by running our standard introspection query on the desired server and saving it into a file on the same path as the project using the provider:
type MyProvider = GraphQLProvider<"swapi_schema.json">

From now on, you can start running queries and mutations:

let operation = 
    MyProvider.Operation<"""query q {
      hero (id: "1001") {
        name
        appearsIn
        homePlanet
        friends {
          ... on Human {
            name
            homePlanet
          }
          ... on Droid {
            name
            primaryFunction
          }
        }
      }
    }""">()

// This is a instance of GraphQLProviderRuntimeContext.
// You can use it to provider a runtime URL to access your server,
// and optionally additional HTTP headers (auth headers, for example).
// If you use a local introspection file to parse the schema,
// The runtime context is mandatory.
let runtimeContext =
  { ServerUrl = "http://some.graphqlserver.production.org"
    CustomHttpHeaders = None }

let result = operation.Run(runtimeContext)

// Query result objects have pretty-printing and structural equality.
printfn "Data: %A\n" result.Data
printfn "Errors: %A\n" result.Errors
printfn "Custom data: %A\n" result.CustomData

// Response from the server:
// Data: Some
//   {Hero = Some
//   {Name = Some "Darth Vader";
// AppearsIn = [|NewHope; Empire; Jedi|];
// HomePlanet = Some "Tatooine";
// Friends = [|Some {Name = Some "Wilhuff Tarkin";
// HomePlanet = <null>;}|];};}

// Errors: <null>

// Custom data: map [("documentId", 1221427401)]

For more information about how to use the client provider, see the examples folder.

Middleware

You can create and use middleware on top of the Executor<'Root> object.

The query execution process through the use of the Executor involves three phases:

  • Schema compile phase: this phase happens when the Executor<'Root> class is instantiated. In this phase, the Schema map of types is used to build a field execute map, which contains all field definitions alongside their field resolution functions. This map is used later on in the planning and execution phases to retrieve the values of the queried fields of the schema.

  • Operation planning phase: this phase happens before running a query that has no execution plan. This phase is responsible for analyzing the AST document generated by the query, and building an ExecutionPlan to execute it.

  • Operation execution phase: this phase is the phase that executes the query. It needs an execution plan, so, it commonly happens after the operation planning phase.

All the phases wrap the needed data to do the phase job inside a context object. They are expressed internally by functions:

let internal compileSchema (ctx : SchemaCompileContext) : unit =
  // ...

let internal planOperation (ctx: PlanningContext) : ExecutionPlan =
  // ...

let internal executeOperation (ctx : ExecutionContext) : AsyncVal<GQLResponse> =
  // ...

That way, in the compile schema phase, the schema is modified and execution maps are generated inside the SchemaCompileContext object. During the operation planning phase, values of the PlanningContext object are used to generate an execution plan, and finally, this plan is passed alongside other values in the ExecutionContext object to the operation execution phase, wich finally uses them to execute the query and generate a GQLResponse.

With that being said, a middleware can be used to intercept each phase and customize them as necessary. Each middleware must be implemented as a function with a specific signature, and wrapped inside an IExecutorMiddleware interface:

type SchemaCompileMiddleware =
    SchemaCompileContext -> (SchemaCompileContext -> unit) -> unit

type OperationPlanningMiddleware =
    PlanningContext -> (PlanningContext -> ExecutionPlan) -> ExecutionPlan

type OperationExecutionMiddleware =
    ExecutionContext -> (ExecutionContext -> AsyncVal<GQLResponse>) -> AsyncVal<GQLResponse>

type IExecutorMiddleware =
    abstract CompileSchema : SchemaCompileMiddleware option
    abstract PlanOperation : OperationPlanningMiddleware option
    abstract ExecuteOperationAsync : OperationExecutionMiddleware option

Optionally, for ease of implementation, concrete class to derive from can be used, receiving only the optional sub-middleware functions in the constructor:

type ExecutorMiddleware(?compile, ?plan, ?execute) =
    interface IExecutorMiddleware with
        member _.CompileSchema = compile
        member _.PlanOperation = plan
        member _.ExecuteOperationAsync = execute

Each of the middleware functions act like an intercept function, with two parameters: the context of the phase, the function of the next middleware (or the actual phase itself, wich is the last to run), and the return value. Those functions can be passed as an argument to the constructor of the Executor<'Root> object:

let middleware = [ ExecutorMiddleware(compileFn, planningFn, executionFn) ]
let executor = Executor(schema, middleware)

A simple example of a practical middleware can be one that measures the time needed to plan a query. The results of which get returned as part of the Metadata of the planning context. The Metadata object is a Map<string, obj> implementation that acts like a bag of information to be passed through each phase, until it is returned inside the GQLResponse object. You can use it to thread custom information through middleware:

let planningMiddleware (ctx : PlanningContext) (next : PlanningContext -> ExecutionPlan) =
    let watch = Stopwatch()
    watch.Start()
    let result = next ctx
    watch.Stop()
    let metadata = result.Metadata.Add("planningTime", watch.ElapsedMilliseconds)
    { result with Metadata = metadata }

Built-in middleware

There are some built-in middleware inside FSharp.Data.GraphQL.Server.Middleware package:

QueryWeightMiddleware

This middleware can be used to place weights on fields of the schema. Those weightened fields can now be used to protect the server from complex queries that could otherwise be used in DDOS attacks.

When defining a field, we use the extension method WithQueryWeight to place a weight on it:

let resolveFn (h : Human) =
  h.Friends |> List.map getCharacter |> List.toSeq

let field =
  Define.Field("friends", ListOf (Nullable CharacterType),
    resolve = resolveFn).WithQueryWeight(0.5)

Then we define the threshold middleware for the Executor. If we execute a query that ask for "friends of friends" in a recursive way, the executor will only accept nesting them 4 times before the query exceeds the weight threshold of 2.0:

let middleware = [ Define.QueryWeightMiddleware(2.0) ]

ObjectListFilterMiddleware

This middleware can be used to automatically generate a filter for list fields inside an object of the schema. This filter can be passed as an argument for the field on the query, and recovered in the ResolveFieldContext argument of the resolve function of the field.

For example, we can create a middleware for filtering list fields of an Human object, that are of the type Character option:

let middleware = [ Define.ObjectListFilterMiddleware<Human, Character option>() ]

The filter argument is an object that is mapped through a JSON definition inside an filter argument on the field. A simple example would be filtering friends of a hero that have their names starting with the letter A:

query TestQuery {
    hero(id:"1000") {
        id
        name
        appearsIn
        homePlanet
        friends (filter : { name_starts_with: "A" }) {
            id
            name
        }
    }
}

This filter is mapped by the middleware inside an ObjectListFilter definition:

type FieldFilter<'Val> =
    { FieldName : string
      Value : 'Val }

type ObjectListFilter =
    | And of ObjectListFilter * ObjectListFilter
    | Or of ObjectListFilter * ObjectListFilter
    | Not of ObjectListFilter
    | Equals of FieldFilter<System.IComparable>
    | GreaterThan of FieldFilter<System.IComparable>
    | LessThan of FieldFilter<System.IComparable>
    | StartsWith of FieldFilter<string>
    | EndsWith of FieldFilter<string>
    | Contains of FieldFilter<string>
    | FilterField of FieldFilter<ObjectListFilter>

And the value recovered by the filter in the query is usable in the ResolveFieldContext of the resolve function of the field. To easily access it, you can use the extension method Filter, wich returns an ObjectListFilter option (it does not have a value if the object doesn't implement a list with the middleware generic definition, or if the user didn't provide a filter input).

Define.Field("friends", ListOf (Nullable CharacterType),
    resolve = fun ctx (d : Droid) -> 
        ctx.Filter |> printfn "Droid friends filter: %A"
        d.Friends |> List.map getCharacter |> List.toSeq)

By retrieving this filter from the field resolution context, it is possible to use client code to customize the query to run against a database, for example, and extend your GraphQL API features.

LiveQueryMiddleware

This middleware can be used to quickly allow your schema fields to be able to be queried with a live directive, assuming that all of them have an identity property name that can be discovered by a function, IdentityNameResolver:

/// A function that resolves an identity name for a schema object, based on a object definition of it.
type IdentityNameResolver = ObjectDef -> string

For example, if all of our schema objects have an identity field named Id, we could use our middleware like this:

let schema = Schema(query = queryType)

let middleware = [ Define.LiveQueryMiddleware(fun _ -> "Id") ]

let executor = Executor(schema, middleware)

The IdentityNameResolver is optional, though. If no resolver function is provided, this default implementation of is used. Also, notifications to subscribers must be done via Publish of ILiveFieldSubscriptionProvider, like explained above.

Using extensions to build your own middleware

You can use extension methods provided by the FSharp.Data.GraphQL.Shared package to help building your own middleware. When making a middleware, often you will need to modify schema definitions to add features to the schema defined by the user code. The ObjectListFilter middleware is an example, where all fields that implements lists of a certain type needs to be modified, by accepting an argument called filter.

As field definitions are immutable by default, generating copies of them with improved features can be hard work sometimes. This is where the extension methods can help: for example, if you need to add an argument to an already defined field inside the schema compile phase, you can use the method WithArgs of the FieldDef<'Val> interface:

let field : FieldDef<'Val> = // Search for field inside ISchema
let arg : Define.Input("id", StringType)
let fieldWithArg = field.WithArgs([ arg ])

To see the complete list of extensions used to augment definitions, you can take a look at the TypeSystemExtensions module contained in the FSharp.Data.GraphQL.Shared package.

More Repositories

1

Paket

A dependency manager for .NET with support for NuGet packages and Git repositories.
F#
1,987
star
2

FAKE

FAKE - F# Make
F#
1,273
star
3

awesome-fsharp

A curated list of awesome F# frameworks, libraries, software and resources.
1,142
star
4

Avalonia.FuncUI

Develop cross-plattform GUI Applications using F# and Avalonia!
F#
841
star
5

FSharpPlus

Extensions for F#
F#
821
star
6

FSharp.Data

F# Data: Library for Data Access
F#
803
star
7

fantomas

FSharp source code formatter
F#
742
star
8

FSharpx.Extras

Functional programming and other utilities from the original "fsharpx" project
F#
676
star
9

Rezoom.SQL

Statically typechecks a common SQL dialect and translates it to various RDBMS backends
F#
665
star
10

SQLProvider

A general F# SQL database erasing type provider, supporting LINQ queries, schema exploration, individuals, CRUD operations and much more besides.
F#
558
star
11

ProjectScaffold

A prototypical .NET solution (file system layout and tooling), recommended for F# projects
F#
514
star
12

FSharp.Formatting

F# tools for generating documentation (Markdown processor and F# code formatter)
F#
455
star
13

IfSharp

F# for Jupyter Notebooks
Jupyter Notebook
441
star
14

Argu

A declarative CLI argument parser for F#
F#
433
star
15

FsHttp

A lightweight F# HTTP library by @SchlenkR and @dawedawe
F#
413
star
16

FsUnit

FsUnit makes unit-testing with F# more enjoyable. It adds a special syntax to your favorite .NET testing framework.
F#
413
star
17

fsharp-companies

Community curated list of companies that use F#
370
star
18

fsharp-cheatsheet

This cheatsheet aims to succinctly cover the most important aspects of F# 6.0.
F#
319
star
19

zarchive-fsharpbinding

Archive of F# Language Bindings for Open Editors
Emacs Lisp
307
star
20

FSharpLint

Lint tool for F#
F#
297
star
21

FSharp.TypeProviders.SDK

The SDK for creating F# type providers
F#
296
star
22

pulsar-client-dotnet

Apache Pulsar native client for .NET (C#/F#/VB)
F#
288
star
23

FSharp.Control.Reactive

Extensions and wrappers for using Reactive Extensions (Rx) with F#.
F#
283
star
24

FsReveal

FsReveal parses markdown and F# script file and generates reveal.js slides.
F#
257
star
25

SwaggerProvider

F# generative Type Provider for Swagger
F#
257
star
26

FSharpx.Collections

FSharpx.Collections is a collection of datastructures for use with F# and C#.
F#
244
star
27

FSharp.Data.Adaptive

On-demand adaptive/incremental data for F# https://fsprojects.github.io/FSharp.Data.Adaptive/
F#
241
star
28

FSharp.Json

F# JSON Reflection based serialization library
F#
218
star
29

fsharp-language-server

F#
215
star
30

fsharp-ai-tools

TensorFlow API for F# + F# for AI Models eDSL
F#
212
star
31

FSharp.Data.SqlClient

A set of F# Type Providers for statically typed access to MS SQL database
F#
207
star
32

FsLexYacc

Lexer and parser generators for F#
F#
201
star
33

Fleece

Json mapper for F#
F#
195
star
34

Chessie

Railway-oriented programming for .NET
F#
189
star
35

ExcelFinancialFunctions

.NET Standard library providing the full set of financial functions from Excel.
F#
187
star
36

FsXaml

F# Tools for working with XAML Projects
F#
171
star
37

FSharp.Control.AsyncSeq

Asynchronous sequences for F#
F#
159
star
38

FSharp.UMX

F# units of measure for primitive non-numeric types
F#
150
star
39

Paket.VisualStudio

Manage your Paket (http://fsprojects.github.io/Paket/) dependencies from Visual Studio!
C#
148
star
40

ExcelProvider

This library is for the .NET platform implementing a Excel type provider.
F#
139
star
41

FsBlog

Blog aware, static site generation using F#.
CSS
133
star
42

TickSpec

Lean .NET BDD framework with powerful F# integration
F#
131
star
43

SIMDArray

SIMD enhanced Array operations
F#
128
star
44

FSharp.Configuration

The FSharp.Configuration project contains type providers for the configuration of .NET projects.
F#
115
star
45

FSharp.Interop.Dynamic

DLR interop for F# -- works like dynamic keyword in C#
F#
93
star
46

FSharpx.Async

Asynchronous programming utilities for F#
F#
93
star
47

FSharp.Management

The FSharp.Management project contains various type providers for the management of the machine.
F#
89
star
48

FSharp.Control.TaskSeq

A computation expression and module for seamless working with IAsyncEnumerable<'T> as if it is just another sequence
F#
83
star
49

AzureStorageTypeProvider

An F# Azure Type Provider which can be used to explore Blob, Table and Queue Azure Storage assets and easily apply CRUD operations on them.
F#
83
star
50

Foq

A unit testing framework for F#
F#
78
star
51

FSharp.Azure.Storage

F# API for using Microsoft Azure Table Storage service
F#
75
star
52

FSharp.ViewModule

Library providing MVVM and INotifyPropertyChanged support for F# projects
F#
74
star
53

FSharp.Text.RegexProvider

A type provider for regular expressions.
F#
73
star
54

FSharp.Core.Fluent

Fluent members for F# FSharp.Core functions
F#
71
star
55

Mechanic

F#
68
star
56

Incremental.NET

A library for incremental computations. Based on janestreet/incremental (https://github.com/janestreet/incremental) for OCaml.
F#
67
star
57

FSharp.Collections.ParallelSeq

Parallel (multi-core) sequence operations
F#
67
star
58

FSharp.Quotations.Evaluator

A quotations evaluator/compiler for F# based on LINQ expression tree compilation
F#
67
star
59

FSharp.Linq.ComposableQuery

Compositional Query Framework for F# Queries, based on "A Practical Theory of Language-Integrated Query"
F#
67
star
60

OpenAPITypeProvider

F# type provider for Open API specification
F#
65
star
61

FSharp.Data.Toolbox

F# Data-based library for various data access APIs
F#
57
star
62

FSharp.AWS.DynamoDB

F# wrapper API for AWS DynamoDB
F#
56
star
63

DynamoDb.SQL

SQL-like external DSL for querying and scanning Amazon DynamoDB
F#
54
star
64

fsharp-hashcollections

Library providing fast hash based immutable map and set
F#
53
star
65

FsRandom

A purely-functional random number generator framework designed for F#
F#
51
star
66

Z3Fs

Simple DSL to solve SMT problems using Z3 API in F#
F#
51
star
67

FSharp.Data.JsonSchema

F#
49
star
68

SyntacticVersioning

Helper tool to verify semantic version changes based on API surface area changes
F#
46
star
69

fantomas-for-vs

Visual Studio Formatter for F#
HTML
45
star
70

FSharp.Compatibility

Compatibility libraries for F#
F#
44
star
71

Interstellar

Cross-platform desktop apps in F# using web tech - https://www.nuget.org/packages/Interstellar.Core/
F#
42
star
72

FSharp.Compiler.PortaCode

The PortaCode F# code format and corresponding interpreter. Used by Fabulous and others.
F#
42
star
73

FSharp.Interop.PythonProvider

Early experimental F# type provider for python
F#
41
star
74

FSharp.CloudAgent

Allows running F# Agents in a distributed manner using Azure Service Bus.
F#
39
star
75

FSharp.Data.TypeProviders

F# Type Providers for SqlDataConnection, SqlEntityConnection, ODataService, WsdlService and EdmxFile using .NET Framework generators
F#
38
star
76

Roslyn.FSharp

Roslyn read-only API to work with F# code (via bridge to FSharp.Compiler.Service)
F#
36
star
77

FnuPlot

An F# wrapper for gnuplot charting library
F#
35
star
78

GraphProvider

A state machine type provider
F#
35
star
79

fantomas-tools

Collection of tools used when developing for Fantomas
F#
34
star
80

LocSta

An F# library for composing state-aware functions by @SchlenkR
JavaScript
33
star
81

fsharp-linting-for-vs

Visual Studio Linter for F#
C#
33
star
82

FSharp.Span.Utils

Makes Span/ReadOnlySpan easy to use from F#.
F#
33
star
83

FSharp.Data.Xsd

XML Type Provider with schema support
F#
32
star
84

zarchive-sublime-fsharp-package

F# development tools for SublimeText 3
Python
32
star
85

.github

The place to request for projects to be added or removed from the incubation space
28
star
86

Zander

Regular expression for matrix information. I.e. parse structured blocks of information from csv or excel files (or similar 2d matrixes)
F#
27
star
87

zarchive-xamarin-monodevelop-fsharp-addin

(No longer Used) F# Editing Support In MonoDevelop and Xamarin Studio
F#
27
star
88

FSharp.Compiler.CodeDom

An F# CodeDOM implementation (based on the old F# Power Pack)
F#
25
star
89

FsMath3D

F# 3D Math Library for realtime applications
F#
22
star
90

S3Provider

Experimental type provider for Amazon S3
F#
22
star
91

BioProviders

F# library for accessing and manipulating bioinformatic datasets.
F#
22
star
92

ReasoningEngine

Symbolic analysis of discrete dynamical systems
F#
22
star
93

FSharp.Data.WsdlProvider

An implementation of the WsdlProvider compatible with netfx and netcore
F#
22
star
94

FSharpPerf

A set of performance test scripts for the F# compiler.
F#
20
star
95

MarkerClustering

A component to cluster map markers.
F#
19
star
96

DynamicsCRMProvider

A type provider for Microsoft Dynamics CRM 2011.
F#
16
star
97

Amazon.SimpleWorkflow.Extensions

Extensions to AmazonSDK's SimpleWorkflow capabilities to make it more intuitive to use
F#
16
star
98

Canopy.Mobile

Canopy testing framework for mobile apps
F#
14
star
99

LSON

Lisp inspired serialization (intended for when you don't even want to take a dependency on JSON serializer)
F#
14
star
100

FSharp.Codecs.Redis

FSharp redis codecs based on Fleece patterns
F#
13
star