{"id":12209,"date":"2014-07-01T12:04:28","date_gmt":"2014-07-01T16:04:28","guid":{"rendered":"http:\/\/blog.xamarin.com\/?p=12209"},"modified":"2014-07-01T12:04:28","modified_gmt":"2014-07-01T16:04:28","slug":"introduction-to-f-with-xamarin","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/xamarin\/introduction-to-f-with-xamarin\/","title":{"rendered":"Introduction to F# with Xamarin"},"content":{"rendered":"

\t\t\t\t\"rachel-reese\"<\/a>Rachel Reese (@RachelReese<\/a>) is a long-time software engineer and math geek who recently relocated to Nashville, TN to work at Firefly Logic. Rachel is an ASPInsider and an F# MVP. You can catch her at Xamarin Evolve 2014, where you can learn from industry leaders and Xamarin experts<\/a>to advance your projects and career.<\/em><\/p>\n

This blog post is part of our continuing celebration of F# Week at Xamarin! Celebrate by getting your own F# t-shirt<\/a>!<\/em><\/p>\n

Why F#?<\/strong>\nLet\u2019s first dig into a few of my favorite reasons to consider F#<\/a> for your next Xamarin project: type inference, units of measure, type providers, as well as the ever-crucial clarity and conciseness of code.<\/p>\n

Type Inference<\/strong>\nPeople often underestimate the benefits of type inference, but the ability to clear out the type definitions from code and concentrate on the code itself, instead of all the clutter around the declaration, is tremendous. Consider this example (from here<\/a>, via here<\/a>):<\/p>\n

C#:<\/p>\n

\n    public static Tree<KeyValuePair<A, bool>> DiffTree<A>(Tree<A> tree, Tree<A> tree2)\n    {\n        return XFoldTree((A x, Func<Tree<A>, Tree<KeyValuePair<A, bool>>> l, Func<Tree<A>, Tree<KeyValuePair<A, bool>>> r, Tree<A> t) => (Tree<A> t2) =>\n            Node(new KeyValuePair<A, bool>(t2.Data, object.ReferenceEquals(t, t2)),\n                 l(t2.Left), r(t2.Right)),\n            x => y => null, tree)(tree2);\n    }\n<\/pre>\n
The equivalent F# is much easier on the eyes. The code itself might still be incomprehensible, but it is at least not drowning in required type definitions. It\u2019s no longer necessary to filter through all the extra information before trying to understand what\u2019s happening.<\/p>\n
\nlet DiffTree(tree,tree2) =\n    XFoldTree (fun x l r t t2 ->\n        let (Node(x2,l2,r2)) = t2\n        Node((x2,t===t2), l l2, r r2)) (fun _ _ -> Leaf) tree tree2\n<\/pre>\n
For more information on type inference, see the F# for Fun and Profit<\/a> website. There are some fabulous examples of how it works, and how to troubleshoot the errors that sometimes show up.<\/p>\n
Units of Measure<\/strong>\nUnits of measure are types that allow one to add unit information to a numeric type in F#. Once a value is tagged with a unit type, it can only be combined with other values that have that same unit. For example, if we want to track distances and times, it\u2019s possible to create:<\/p>\n
\n[<Measure>] type s\n[<Measure>] type m\n<\/pre>\n
Then, when we define a new value, we can easily associate our new unit with it:<\/p>\n
\nlet time = 30<s>\nlet distance = 10<m>\n<\/pre>\n
The compiler will error if we try to add the two values, but it is possible to divide them:<\/p>\n
\nlet velocity = distance\/time\n<\/pre>\n
If we hover over this declaration, the tooltip for this value will show:<\/p>\n
\nval velocity : int<m\/s>\n<\/pre>\n
All scientific computing will benefit from enforcing units (game physics!) but it doesn\u2019t have to be exclusively the domain of science. Think about using pixel, USD, or Fahrenheit, among others!<\/p>\n
It\u2019s also possible to use generic units of measure in a function. For example, we\u2019d like to calculate a perimeter, given some distances. We can declare the function like so:<\/p>\n
\nlet perimeter = (x:int,<'distance>) (y:int<'distance>) = 2*x + 2*y\n<\/pre>\n
In this manner, we\u2019re able to utilize one function for many different units of measure. As long as the units for a single given call are the same, the code will compile. However, the compiler will still throw an error if we try to call perimeter with two different units. To wit:<\/p>\n
\n\/\/ Compiler error: The unit of measure 'ft' does not match the unit of measure 'm'\nlet p_1 = perimeter 10<m> 4<m>\nlet p_2 = perimeter 2<ft> 3<m>\n<\/pre>\n
Type Providers<\/strong>\nType providers are a mechanism that allows F# code to access typed information from external data sources with no code generation, all in just a few lines of code. They are a revolution in data access! F# was the first enterprise-grade language to have type providers, and is still the only .NET language to have them. So, if we want to use a type provider in our Xamarin project, we\u2019ll need to use F#!<\/p>\n
There are many, many type providers available, but I\u2019ll concentrate on two that are especially useful with Xamarin projects today \u2013 the SQLProvider<\/a> and the Freebase Provider<\/a>.<\/p>\n
SQLProvider<\/strong><\/p>\n
The SQLProvider provides access to MS SQL Server, SQLite, PostgreSQL, Oracle, MySQL, ODBC, and MS Access databases. Since SQLite is a tremendously common database to hook up with both iOS and Android applications, let\u2019s take a look at what\u2019s required to use the SQLProvider type provider to connect to a SQLite database in an F# Xamarin project!<\/p>\n
First, we declare a type. We\u2019ll need to change this to include the connection string, as well as the path to the mono.sqlite.dll.<\/p>\n
\ntype sql = SqlDataProvider\n<\/pre>\n
At this point, we\u2019re ready to go. To show off the SQLite provider, let\u2019s build a quick port of the Xamarin Tasky app (see original here). We\u2019ll need to create just a couple of functions for our data layer: GetIncompleteTasks, AddTask, UpdateTask, and DeleteTask. However, first we need to get the data context:<\/p>\n
\nlet ctx = sql.GetDataContext ()\n<\/pre>\n
Every time we type `ctx`, we\u2019ll get code completion on the remaining pieces:<\/p>\n
\"2014-07-01_1414\"<\/a><\/p>\n
As well as tooltips, which show that the information coming back from SQLite is fully typed:<\/p>\n
\"2014-07-01_1415\"<\/a><\/p>\n
Once we have set up the data context, creating the methods we need is as easy as pie. Let\u2019s declare a type for the return data, to use in our queries:<\/p>\n
\ntype task = { Description : string; mutable Complete : bool; }\n<\/pre>\n
Then, to return the incomplete tasks, we use the familiar query syntax:<\/p>\n
\nlet GetIncompleteTasks () =\n    query { for data in ctx.``[main].[tasks]`` do\n                where (data.complete = 0L)\n                select {Description=data.task; Complete = false}}\n            |> Sql.toList\n<\/pre>\n
This returns an F# list of tasks, where complete is false. That\u2019s it. No messy ORMs to contend with, no long data access libraries to futz with; we only need a database connection and a query. Adding a task is just as easy, we need to create a new task, update the two fields (“<-” is the F# assignment operator), and finally, submit our updates.<\/p>\n
\nlet AddTask description =\n    let newTask = ctx.``[main].[tasks]``.Create()\n    newTask.task <- description\n    newTask.complete <- 0L\n    ctx.SubmitUpdates()\n<\/pre>\n
Freebase<\/strong><\/p>\n
The Freebase.com web site describes itself as a community-curated database. They currently have a list of nearly 44 million topics, and over 2.5 billion facts. Connecting our app in to all their data is simple, with the Freebase type provider! We merely need to get the context, and start querying.<\/p>\n
The Freebase database is especially exciting because the data is returned with additional units of measure. In the example above, when the results are returned, and in the tooltips, we can see that the particle charge is shown in coulombs!<\/p>\n
\"2014-07-01_1422\"<\/a><\/p>\n
As with all type providers, the Freebase provider also has code completion into the structure of our data source. It frees us up to explore the data!<\/p>\n
\"2014-07-01_1423\"<\/a><\/p>\n
Keep an eye out on the Xamarin Blog for Part 2 of Getting Started with Xamarin and F#, where I’ll discuss using F# to build amazing cross-platform, native apps.<\/p>\n
 \t\t<\/p>\n","protected":false},"excerpt":{"rendered":"
Rachel Reese (@RachelReese) is a long-time software engineer and math geek who recently relocated to Nashville, TN to work at Firefly Logic. Rachel is an ASPInsider and an F# MVP. You can catch her at Xamarin Evolve 2014, where you can learn from industry leaders and Xamarin expertsto advance your projects and career. This blog […]<\/p>\n","protected":false},"author":1936,"featured_media":39167,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[2],"tags":[4],"class_list":["post-12209","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-developers","tag-xamarin-platform"],"acf":[],"blog_post_summary":"
Rachel Reese (@RachelReese) is a long-time software engineer and math geek who recently relocated to Nashville, TN to work at Firefly Logic. Rachel is an ASPInsider and an F# MVP. You can catch her at Xamarin Evolve 2014, where you can learn from industry leaders and Xamarin expertsto advance your projects and career. This blog […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/posts\/12209","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/users\/1936"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/comments?post=12209"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/posts\/12209\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/media\/39167"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/media?parent=12209"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/categories?post=12209"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/tags?post=12209"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}