The newbie feeling

I read a blog post:http://blog.recursivity.com/post/9204470867/the-problem-with-the-scala-community that triggered me to write this post.

I do not know the Scala community so I can not agree or disagree with the conclusion:

“I love the Scala community and the eco-system around the language, but quite frankly, to foster the continued growth of the community, we need to call out the small minority of bullies on their bullshit whenever it occurs: being able to confuse and intellectually intimidate newbies to the language and community is not proving your supposed “intellectual superiority”, it is merely a reflection of an insecure ego and social incompetence.”

I do think that as a person we can not know everything of everything and even if we could one moment in time the world will change and we have to learn the new thing.

So we have two option: stick with what we know or accept the newbie feeling.

When you are a newbie you will make mistakes. My grant parents had the following text on a tile:”The only man who never makes mistakes is the man who never does anything.” I just found out it is a quote from Theodore Roosevelt (thanks Google).

So if we want to progress we have to accept the newbie feeling, accept the insecurity and make mistakes.

When we want to progress we have several options, one option is to learn it all by yourself, another is to accept the support of the community.

The community can support you in two ways:

• one is provide knowledge
• the other to provide mentorship

I think a programming language community is able to provide knowledge, that is nature of the community. To provide mentorship is something else and it is very hard to provide it on line.

So as a newbie look for knowledge on line and find mentorship somewhere else.

The difference between SelectMany and Select in LINQ

This is follow up on my previous blog post:Adding xml strings in C# using LINQ.

In the previous post I showed that LINQ can be used to to manipulate XElements and strings. LINQ managed the transformation between the classes.

XElement result =
  from x1 in el1
  from x2 in el2
  select x1.Substring(0, x1.LastIndexOf("<")) + x2.Substring(x2.IndexOf(">") + 1);

el1, el2 and the result are XElements and x1, x2 and the object before select are strings.

In the example there are two XElements and the compiler requires that we implement SelectMany. If delete SelectMany we get the following error:

In case we have one XElement we expect that the following will compile:

private static XElement ToUpper(XElement el)
{
  XElement result =
  from x in el
  select x.ToUpper();

  return result;
}

It does not: “'System.Xml.Linq.XElement' does not contain a definition for 'Select'”

So we implement Select:

public static XElement Select(this XElement el, Func<string, XElement> f)
{
  return SelectMany(el, f, (x, y) => y);
}

Again it does not compile: “Cannot implicitly convert type 'string' to 'System.Xml.Linq.XElement'”

So we add an extra conversion:

private static XElement ToUpper(XElement el)
{
  XElement result =
  from x in el
  select XElement.Parse(x.ToUpper());

  return result;
}

This time it works:

var el = XElement.Parse("<a><b>1</b><b>2</b></a>");
Console.WriteLine(string.Format("ToUpper: {0}", ToUpper(el)));

Results in:

as expected.

Another way to solve the issue is to add a dummy line and use SelectMany:

private static XElement ToUpper(XElement el)
{
  XElement result =
  from x in el
  from dummy in XElement.Parse("<dummy></dummy>")
  select x.ToUpper();

  return result;
}

with the same result.

Update: more information at: http://msdn.microsoft.com/en-us/library/bb546168.aspx

Adding xml strings in C# using LINQ

This is follow up on my previous blog post:Adding xml strings in F# using computation expressions. The text is nearly identical, the language is C# instead of F#.

In some cases classes are enhanced wrappers of simple classes. For instance in .NET:

• DateTime is a point in time and provides, among others things, extra functionality related to representing date and time formats.
• XElement is an xml string and provides, among others things, checks to determine the validity of the xml string.
• Option can contain a value and can tell you if there is value available.

Sometimes you have to deal with underling class and reuse some of the functionality of the wrapper. In this case you could consider using LINQ. We first define the Return, Bind and SelectMany functions to create the required functions.

For details more details see:

• Functional Programming in C#: Classic Programming Techniques for Modern Projects (Wrox Programmer to Programmer)
• Real World Functional Programming: With Examples in F# and C#
• Monads in C#–1. Introduction

All excellent resources.

public static classXmlMonad
{
  //monad
 public staticXElement Return(this stringtext)
  {
    try
   {
      returnXElement.Parse(text);
    }
    catch(XmlException exc)
    {
      returnXElement.Parse(String.Format("<XmlException>{0}</XmlException>", exc.Message));
    }
  }

  public staticXElement Bind(thisXElement el, Func<string, XElement> f)
  {
    try
   {
      returnf(el.ToString());
    }
    catch(XmlException exc)
    {
      returnXElement.Parse(String.Format("<XmlException>{0}</XmlException>", exc.Message));
    }
  }

  public staticXElement SelectMany(thisXElement el, Func<string, XElement> f, Func<string, string, string> select)
  {
    returnel.Bind(text => f(text).Bind(x => select(text, x).Return()));
  }
}

We can now define a add function that will xml elements by using a string manipulation:

private static XElement Add(XElement el1, XElement el2)
{
  XElement result =
  from x1 in el1
  from x2 in el2
  select x1.Substring(0, x1.LastIndexOf("<")) + x2.Substring(x2.IndexOf(">") + 1);

  return result;
}

Add in action:

var el1 = XElement.Parse("<a><b>1</b><b>2</b></a>");
var el2 = XElement.Parse("<a><b>3</b><b>4</b></a>");

Console.WriteLine(string.Format("Add: {0}", Add(el1,el2)));

Results in:

When we change the xml into:

var el2 = XElement.Parse("<c><b>3</b><b>4</b></c>");

The result is:

Adding xml strings in F# using computation expressions

In some cases types are enhanced wrappers of simple types. For instance in .NET:

• DateTime is a point in time and provides, among others things, extra functionality related to representing date and time formats.
• XElement is an xml string and provides, among others things, checks to determine the validity of the xml string.
• Option can contain a value and can tell you if there is value available.

Sometimes you have to deal with underling type and reuse some of the functionality of the wrapper. In this case you could consider using computation expressions.

This is a simple xml example. We create a xmlBuilder and reuse the validation logic of XElement:

open System
open System.Xml
open System.Xml.Linq

type xmlBuilder()=
    member x.Bind(el:XElement,(f:string -> XElement)) =
        try
            f(el.ToString())
        with
            | :? XmlException as exc -> XElement.Parse(String.Format("<XmlException>{0}</XmlException>", exc.Message))
    member x.Return(text) = 
        try
            XElement.Parse(text)
        with
            | :? XmlException as exc -> XElement.Parse(String.Format("<XmlException>{0}</XmlException>", exc.Message))

The string “123” creates an error:

let xml = new xmlBuilder()

let error =
    xml { 
            return "123"
        }

val error : XElement = <XmlException>Data at the root level is invalid. Line 1, position 1.</XmlException>

The expression can now be used to reuse sting functions:

let toUpper el =
    xml { 
            let! x = el
            return x.ToUpper()
        }

let el = XElement.Parse("<a><b>1</b><b>2</b></a>")
let result1 = el |> toUpper 

val result1 : XElement = <A>
  <B>1</B>
  <B>2</B>
</A>

In the same way we can define a simple add function for xml:

let (+) (el1:XElement) (el2:XElement) =
    xml { 
            let! x1 = el1
            let! x2 = el2
            return x1.Substring(0, x1.LastIndexOf("<")) + x2.Substring(x2.IndexOf(">") + 1)
        }

let el1 = XElement.Parse("<a><b>1</b><b>2</b></a>")
let el2 = XElement.Parse("<a><b>3</b><b>4</b></a>")
let result2 = el1 + el2

val result2 : XElement =
  <a>
  <b>1</b>
  <b>2</b>
  <b>3</b>
  <b>4</b>
</a>

let el3 = XElement.Parse("<c><b>3</b><b>4</b></c>")
let result3 = el1 + el3

val result3 : XElement = <XmlException>The 'a' start tag on line 1 position 2 does not match the end tag of 'c'. Line 7, position 3.</XmlException>

This may not be in line with the concept of information hiding, but it can help you in case you have to deal with the simple type to get the work done.

What is the USP of the monad?

I am preparing an introductory article on monads for a Dutch software magazine. It is intended for .NET developers. I have to restrict myself so I am looking for the Unique Selling Point (USP) of the monad.

This is the list of selling points I could find. I left out selling points of specific monads and used the formulation of Wikipedia:

1. Monads are a kind of abstract data type constructor that encapsulate program logic instead of data in the domain model.
2. Control structure/inspection.
3. Hiding complexity with syntactic sugar.
4. Composition : monads chain actions together to build a pipeline.
5. To express input/output (I/O) operations and changes in state without using language features that introduce side effects.

I put them in the order of most favorite to least favorite.

My remarks:

1. Monads are a kind of abstract data type constructor that encapsulate program logic instead of data in the domain model.

This point can be split into two aspects of monads:

1. The monadic type is a wrapper of a data type (If M is the name of the monad and t is a data type, then "M t" is the corresponding type in the monad).
2. The functions: read (unit) and bind.

I think that the ability to have both access to the functionality of the wrapper and the original data type and a way to transform solution between the two is the most valuable selling point.

2. Control structure/inspection.

The monad is an excellent way to encapsulate inspection logic. Most monad tutorials start with the maybe monad because it is a simple example. It also shows the value of the monadic approach by hiding inspection plumbing.

3. Hiding complexity with syntactic sugar.

I think that the popularity of LINQ in C# and VB.NET is a proof that hiding complexity with syntactic sugar has its value.

4. Composition: monads chain actions together to build a pipeline.

In F# computation expressions or monads are also described as workflows. So this could be the USP. Sequence expression are a proof of the value of composition.

5. To express input/output (I/O) operations and changes in state without using language features that introduce side effects.

This is the least relevant point for a .NET developer. I do understand that this the most relevant one for a developer in a pure language or one that want to reduce the number of side effects.

Please feel free to add a command in case I missed a selling point or you have a better way to order the them.

WTF is a Monad by Robert C. Martin in F#

I have read some material describing Computation Expressions and knew computation expressions are the F# implementation of monads, but I did know why one should use a monad.

A few days ago saw the video of presentation by Robert C. Martin (Uncle Bob) at the Norwegian Developers Conference called “WTF is a Monad” and now it makes sense to me.

It is a proven way of solving problems. If you:

• have a problem in one domain
• you can transform it to another domain
• solve the problem in the other domain
• and can transform it back

you have a solution.

I have translated some of the code of the presentation to F#. I tried to stay as close to the original code as possible and did not do much refactoring. I skipped the last two examples (distributions an state).

Update: I did not implement the examples that required lift. I have not figured out how to do that. I have created the lift myself (details: http://bugsquash.blogspot.com/2010/12/notes-on-haskell-functors-and-f.html)

I like to thank Robert for the permission to share the code. Feel free to add improvements in the comments.

//Non-Monadic dots

let dotsToN (d:string) =
    d.Length

let result1 = dotsToN "....."

let nToDots (n:int) =
    new string('.', n)

let result2 = nToDots 5

let addDots da db =
    let a = dotsToN da
    let b = dotsToN db
    nToDots (a+b)

let result3 = addDots "..." "..."

//Monadic dots

let dotResult = nToDots

let dotBind d (f:int -> string) =
    d |> dotsToN |> f

let addDots' da db =
    dotBind da (fun a ->
        dotBind db (fun b ->
            dotResult (a + b)))
    
let result4= addDots' "..." "..."

//dot-Monad
type dotBuilder()=
    member x.Bind(d,(f:int -> string)) = d |> dotsToN |> f
    member x.Return(n) = new string('.', n)

let dot = new dotBuilder()

let addDots'' da db =
    dot { let! x = da
          let! y = db
          return x + y
        }

let result5= addDots'' "..." "..."

let multiplyDots da db =
    dot { let! x = da
          let! y = db
          return x*y
        }

let result6= multiplyDots "..." "..."

let dcd dt du =
    dot { let! tens = dt
          let! units = du
          return (10 * tens + units)
        }

let result7= dcd "..." "....."

// In Clojure the monad gets the lift for free
// In F# we have to create it ourselves
// More info: http://bugsquash.blogspot.com/2010/12/notes-on-haskell-functors-and-f.html --
//

let liftDots_1 f a1 = 
    dot { 
            let! x1 = a1 
            return f x1 
        }

let liftDots_2 f a1 a2 = 
    dot { 
            let! x1 = a1
            let! x2 = a2
            return f x1 x2
        }

let liftDots_4 f a1 a2 a3 a4 = 
    dot { 
            let! x1 = a1
            let! x2 = a2
            let! x3 = a3
            let! x4 = a4
            return f x1 x2 x3 x4
        }

let substractDots = liftDots_2 (-)

let result7a= substractDots "....." ".."

let mean4 a b c d = (a+b+c+d)/4

let dmean4 = liftDots_4 mean4

let result7b= dmean4 "..." ".." "..." "...."

//
//complex number (inspection)
//

open System.Numerics

let c_0 = Complex.Zero
let c_1 = Complex.One
let c_i = Complex.ImaginaryOne

type complexBuilder()=
    member b.Return(x:float) = new Complex(x,0.0) 
    member b.Bind((c:Complex),(f:float -> Complex)) = 
        if c.Imaginary = 0.0 then
            f c.Real
        else 
            failwithf "Imaginary"
   
let complex = new complexBuilder()

let addComplex c1 c2 =
    complex { let! x = c1
              let! y = c2
              return x + y
            }

let result8= addComplex c_1 c_1;;
let result9= addComplex c_1 c_i;; //System.Exception: Imaginary
let result10= addComplex c_i c_i;; //System.Exception: Imaginary

//null

type noNullBuilder()=
    member b.Return(mv) = mv 
    member b.Bind(mv,f) = if (mv = null) then null else f mv

let nuNull = new noNullBuilder()

// int can not be null in .Net

let fragile (a:string) (b:string) (c:string) =
    if (a= null||b=null||c=null)
    then
        "CRASH"
    else
        a + b + c

let result11 = fragile "a" "b" "c"
let result12 = fragile "a" null "c" //"CRASH"

let safeFragile (a:string) (b:string) (c:string) =
    nuNull { let! x = a
             let! y = b
             let! z = c
             return x + y + z
            }

let result13 = safeFragile "a" "b" "c"
let result14 = safeFragile "a" null "c" //val result14 : string = null

//List
let l_a = [1;2;3]
let l_b = [4;5;6]

let addList = seq {for a in l_a do
                    for b in l_b do 
                    yield a+b
                  }|> Seq.toList

let multList = seq {for a in l_a do
                    for b in l_b do 
                    yield a*b
                  }|> Seq.toList

//helper for the demo
let flatten l = 
    let rec flatten' l result =
        match l with 
        |[] -> result
        |h::t -> flatten' t (h@result)
    flatten' (l|>List.rev) []

let result15 = flatten [[1;2;3];[7;8;9]]

type listBuilder()=
    member b.Return(v) = [v]
    member b.Bind(mv,f) = mv |> List.map f |> flatten

let list = new listBuilder()

let addList' a b = list {
                       let! x = a
                       let! y = b
                       return x + y 
                    }

let result16 = addList' l_a l_b

let multList' a b = list {
                       let! x = a
                       let! y = b
                       return x * y 
                    }

let result17 = multList' l_a l_b

//distribution example see Expert F# of Don Syme page 239..244
//state http://fsharpcode.blogspot.com/2008/12/f-state-monad-type-state-state-state-of.html

LINQ to XML, when lazy is too lazy in F# (and C# )

 

Today a F# program did not work as expected. This is a small example I created:

let xml ="<a><b>1</b><b>2</b></a>"
let doc = XDocument.Parse(xml)

let getXElements_b (doc:XDocument) =
let els = doc.Root.Elements(XName.Get("b"))
els

//test
let result1 = doc |> getXElements_b |> Seq.toList
//val result1 : XElement list = [<b>1</b>; <b>2</b>]
//the expected result 

let proces (el:XElement) =
XElement(XName.Get("c")) |> el.ReplaceWith

doc |> getXElements_b |> Seq.iter proces

let result2 =  doc.ToString();;
//val result2 : string = "<a>
//  <c />
//  <b>2</b>
//</a>"

This is not the expected result. I expected:

val result2 : string = "<a>
<c />
<c />
</a>"

I can fix it by changing the getXElements_b function:

let getXElements_b (doc:XDocument) =
let els = doc.Root.Elements(XName.Get("b")) |> Seq.toList
els

With this adjustment everything works fine. It seems that I have to force the the computation.

This is a problem in C# too.

private void GetXml()
{
var xml = "<a><b>1</b><b>2</b></a>";
var doc = XDocument.Parse(xml);
var els = doc.Root.Elements(XName.Get("b"));

foreach (var el in els)
{
el.ReplaceWith(new XElement(XName.Get("c")));
}

txtResult.Text = doc.ToString();
}

produces:

<a>
  <c />
  <b>2</b>
</a>

When I step with the debuger through the code the foreach is only one time triggered.

With support of Google I found the following document:

http://msdn.microsoft.com/en-us/library/bb308960.aspx

You can learn something new everyday.

Interesting links:

The "Halloween Problem" for XML APIs:

http://blogs.msdn.com/b/mikechampion/archive/2006/07/20/672208.aspx

Query Composition using Functional Programming Techniques in C# 3.0:

http://blogs.msdn.com/b/ericwhite/archive/2006/10/04/fp-tutorial.aspx