Creating lists in F#

Lists in F# are type safe and immutable. Type safety means that all elements in the list must be of the same type. Immutability implies that once the list is created we cannot add new elements to it. Instead, a new list will be created with the elements of the old list copied to the new list along with the new value(s) we want to add to it.

Here’s how to declare an empty list:

let myFirstList = [];

The ‘::’ operator is used to add a new item to the head of the list:

Read more of this post

Creating substrings in F#

Reading a chunk of a string into another string is based on the position of the characters in the string. The characters in the string form an array of chars and we can read parts of it by referring to the required array positions of the characters. This is no different from popular OOP languages like C# and Java. The only difference is the syntax.

Let’s start with the following string:

let longString = "The message couples the distressed heat before a purchase."

The random sentence generator site has a lot of similar meaningless sentences for testing.

The most simplistic application of substrings is to read one character:¨

Read more of this post

Data type conversion in F#

F# has much the same primitive data types as C#. Here are some examples:

let integer = 123
let floating = 23.
let dec = 24M
let bool = true
let text = "This is some string"
let character = 'c'

Occasionally we may need to convert one primitive type to another.

Read more of this post

Infix operators in F#

F# makes the distinction between “prefix” and “infix” functions. The word prefix means that something comes before something else. Prepositions in many Indo-European languages, like “in”, “for” and “on” in English are examples of prefixes, they are placed in front of another word, most often a noun: in the house, at the station, for that purpose.

Prefix functions are how we most often define and call functions in F#. The function name comes first which is then followed by the function arguments.

Here’s a function that adds two numbers:

let addTwoNumbers x y = x + y

Unsurprisingly we call the above function as follows:

Read more of this post

Embedded functions in F#

F# allows us to declare a function within a function. The embedded function will only be visible within the encasing function. Indentation is important in this case as the embedded function can also span multiple rows.

Consider the following function:

let calculate x = 
    printfn "Your input parameter was %i" x
    let embedded y z = 
        printfn "%s" "Running the embedded function"
        let a = (x + y) * 2
        x + y + a
    let finalRet = embedded 5 4
    printfn "The result is %i" (finalRet)

let calculateRes = calculate 5

Read more of this post

Function composition in F#

F# lets us build new functions that consists of other functions using the composition operators >> and <<. The direction of the arrows determines how the individual constituent functions are linked.

Consider the following simple functions:

let incrementByOne x = x + 1
let triple x = x * 3
let halve x = x / 2
let double x = x * 2

A common feature of each function is that each accepts a single parameter and has a return value. The input and return types are also identical. These functions are good candidates for function composition.

Here’s how to do it:

Read more of this post

Forward piping in F#

In F# it’s possible to chain function calls and feed the return value of each function to the next using the forward type operator which looks like this: |> . We can literally read it as “pipe forward”.

If we have a function that increments an integer like this…:

let incrementByOne x = x + 1

Then we normally call it as follows:

let res = incrementByOne 10

With forward piping we can supply the input parameter first as follows:

Read more of this post


A great site

iReadable { }

.NET Tips & Tricks

Robin Sedlaczek's Blog

Developer on Microsoft Technologies

HarsH ReaLiTy

A Good Blog is Hard to Find

Ricos Blog zu Softwaredesign- und architektur

Ideen und Gedanken rund um Softwaredesign und -architektur, Domain-Driven Design, C# und Windows Azure

the software architecture

thoughts, ideas, diagrams,enterprise code, design pattern , solution designs

Technology Talks

on Microsoft technologies, Web, Android and others

Software Engineering

Web development

Disparate Opinions

Various tidbits

chsakell's Blog

Anything around ASP.NET MVC,WEB API, WCF, Entity Framework & AngularJS

Cyber Matters

Bite-size insight on Cyber Security for the not too technical.

Guru N Guns's

OneSolution To dOTnET.

Johnny Zraiby

Measuring programming progress by lines of code is like measuring aircraft building progress by weight.

%d bloggers like this: