This is a curated list of F# project ideas including:
- “nice-to-have” projects for groups and individuals to take up as part of a curriculum or independent learning
- ways to contribute to the F# open source community.
It is a great inspiration for students to work on a real-world projects, contributing to an open-source community.
Please add project ideas using the following format:
### Example Project Name Description of project **Contact**: name (title, email | phone) **Tags**: comma, delimited, list, of, tags
Please submit your project ideas via Github pull request.
Type providers for interesting data sources
The F# type provider mechanism makes it possible to integrate external data sources into F#. One good example is the WorldBank type provider from F# Data, which implements type provider for a specific (and interesting) data source.
Another kind is the JSON type provider, which implements type provider for a speicfic data format (using type inference mechanism), but it can work with any JSON files.
There is a number of interesting data sources and creating a type provider for them would be an interesting project:
- Open government data sources: EU open data, UK open data and US open data
- Yahoo Finance type provider for accessing stock prices
- PDF type provider for extracting tables from PDF
- Various REST description formats like RAML, WADL an API Blueprint
Visual Editor for Domain Specific Languages
Domain specific languages (DSLs) give a powerful technique for writing reusable libraries (not just) in functional languages. Given a problem (i.e. processing lists), we design a set of reusable combinators (mapping, filtering, etc.). A specific problem (such as a task to multiply elements of two lists by some number and then combine them in some way) can then be easily solved just by using the available combinators.
The approach is used not just for list processing, but in many other areas - for composing user interfaces, specifying event handling, modelling financial contracts, etc. Here is an example of list processing (using F#):
List.zip (list1 |> List.map (fun x -> x * 10)) (list2 |> List.map (fun x -> x * -10)) |> List.iter (fun (a, b) -> printfn "left %d, right %d" a b)
The code can be quite nicely represented visually, showing how the data flow through the combinators:
The idea of this project is to design some editor (or, at least, visualizer) that can take code written using DSL and display it visually and allow the user to edit it. This should work for any DSL (although it may need to be annotated in some way).
In statically typed programming languages like F#, the type system is used to check that types of expressions are used correctly and are correctly composed (i.e. you call a function with an argument of a correct type).
The goal of this project is to create a “fuzzy” type system that can deal with such uncertainty in programs. For example, if the type system can tell us that the property
Name is a string in 99% of the cases, then that’s quite useful information!
This is probably more theoretical or experimental project, but it could be implemented as a simple language (i.e. for data processing) or it could be written as an additional checker on top of some F# type provider (or it could be integrated in a type provider). On the thoery side, there might be some connection with Fuzzy Logic.
NOTE: This is a temporary page; we are working on a new website that will provide a form for submitting and searching for projects.