Create Open XML Word document in F#

I needed a word document. I created it with the Open XML SDK and F# and posted the snippet at fssnip.net.

1: //reference to the Open Office SDK

2: #r @"C:\Program Files (x86)\Open XML SDK\V2.0\lib\DocumentFormat.OpenXml.dll"

3: //reference to the package

4: #r "WindowsBase"

5:

6: open DocumentFormat.OpenXml

7: open DocumentFormat.OpenXml.Wordprocessing

8: open DocumentFormat.OpenXml.Packaging

9:

10: let testString = "This is a test"

11: let printXml text =

12: printfn "xml: %s" text

13:

14: let createBody (text:string) =

15: let text = new Text(text)

16: let run = new Run()

17: run.AppendChild(text) |> ignore

18: let para = new Paragraph()

19: para.AppendChild(run)|> ignore

20: let body = new Body()

21: body.AppendChild(para)|> ignore

22: body

23:

24: printXml (createBody testString).InnerXml

25:

26: let createDocument (text:string) =

27: let body = createBody text

28: let doc = new Document()

29: doc.AppendChild(body) |> ignore

30: doc

31:

32: printXml (createDocument testString).InnerXml

33:

34: let createWordprocessingDocument (filepath:string) text=

35: using (WordprocessingDocument.Create(filepath, WordprocessingDocumentType.Document)) (fun doc ->

36: let mainPart = doc.AddMainDocumentPart();

37: mainPart.Document <- createDocument text

38: )

39:

40: let result3 = createWordprocessingDocument @"D:\Tmp\test1.docx" testString

val testString : string

Full name: Snippet.testString

type: string
implements: System.IComparable
implements: System.ICloneable
implements: System.IConvertible
implements: System.IComparable
implements: seq
implements: System.Collections.IEnumerable
implements: System.IEquatable

val printXml : string -> unit

Full name: Snippet.printXml

val text : string

type: string
implements: System.IComparable
implements: System.ICloneable
implements: System.IConvertible
implements: System.IComparable
implements: seq
implements: System.Collections.IEnumerable
implements: System.IEquatable

val printfn : Printf.TextWriterFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.printfn

val createBody : string -> 'a

Full name: Snippet.createBody

Multiple items
val string : 'T -> string

Full name: Microsoft.FSharp.Core.Operators.string

--------------------

type string = System.String

Full name: Microsoft.FSharp.Core.string

type: string
implements: System.IComparable
implements: System.ICloneable
implements: System.IConvertible
implements: System.IComparable
implements: seq
implements: System.Collections.IEnumerable
implements: System.IEquatable

val text : 'a

namespace Microsoft.FSharp.Text

val run : 'a

val ignore : 'T -> unit

Full name: Microsoft.FSharp.Core.Operators.ignore

val para : 'a

val body : 'a

val createDocument : string -> 'a

Full name: Snippet.createDocument

val doc : 'a

val createWordprocessingDocument : string -> 'a -> 'b

Full name: Snippet.createWordprocessingDocument

val filepath : string

type: string
implements: System.IComparable
implements: System.ICloneable
implements: System.IConvertible
implements: System.IComparable
implements: seq
implements: System.Collections.IEnumerable
implements: System.IEquatable

val using : 'T -> ('T -> 'U) -> 'U (requires 'T :> System.IDisposable)

Full name: Microsoft.FSharp.Core.Operators.using

val doc : 'a (requires 'a :> System.IDisposable)

type: 'a
implements: System.IDisposable

val mainPart : 'a

val result3 : 'a

Full name: Snippet.result3

It is a direct transformation of the C# code from the help file of the Open XML SDK:

public static void CreateWordprocessingDocument(string filepath)

{

    // Create a document by supplying the filepath. 

    using (WordprocessingDocument wordDocument =

        WordprocessingDocument.Create(filepath, WordprocessingDocumentType.Document))

    {

        // Add a main document part. 

        MainDocumentPart mainPart = wordDocument.AddMainDocumentPart();

        // Create the document structure and add some text.

        mainPart.Document = new Document();

        Body body = mainPart.Document.AppendChild(new Body());

        Paragraph para = body.AppendChild(new Paragraph());

        Run run = para.AppendChild(new Run());

        run.AppendChild(new Text("Create text in body - CreateWordprocessingDocument"));

    }

}

F# Winform

When you want to make a F# winform application and you don’t want to open an extra console when you start the application.

How can you do this (F# version 1.9.6.2)?

1. Create a F# application:

[Edit- thanks Brian ]

2. Open the project properties

3. In the application tab change the output type

 

4. Add reference to the System.Windows.Forms

5. Add your code.

6. Run your app

7. Close.

8. Add your own details.

Creating a parser with F#

I want to write my own html-parser. That is one of the reasons I am learning F#. I have read all the documentation that is available in the three published F# books and tried to build some simple parsers myself and downloaded the examples of Chris Smith.

This resulted in a naïve development approach: start with lexer, than create the parser, compose the AST and finally build your application that consumes the AST.

One of the lessons learned: when you want to create a parser you have to start with analyses of the text type. In case you can step through the text and can determine the action after each token a lexer is what you need. In case the action is determined by server tokens you need a parser.

Example of program that needs a lexer:

• A program that replacing digits by roman numerals.
  
• A simple encryptor
  

Example of program that needs a lexer and a parser:

• Xml-parser
  
• Code

F# union types in C#

An other name for union types is discriminated unions.

I was interested what a union type looks and behaves in C#.

I build small demo applcation:

private void nudTest_ValueChanged(object sender, EventArgs e)
{
int x = Convert.ToInt32(nudTest.Value);

if(PsA.resultOfVote(x).IsYes())
{
lblResult.Text = "Yes";
}

if(PsA.resultOfVote(x).IsNo())
{
lblResult.Text = "No";
}

if(PsA.resultOfVote(x).IsMaybe())
{
lblResult.Text = PsA.resultOfVote(x).Maybe1.ToString();
}

}

The object created by F# looked like this:

I called the dll PsA.

F# union type

A new thing in F# for a C# programmer  is a union type. At first I thought it was an enumeration (enum).

#light

type YesNo =
    | Yes
    | No

let resutlOfQuestion x =
    if x then
        Yes
    else
        No
//val resutlOfQuestion : bool -> YesNo

resutlOfQuestion true;;
//> val it : YesNo = Yes
resutlOfQuestion false;;
//> val it : YesNo = No

But wait, there is more:

#light

type YesNoMaybe =
    | Yes
    | No
    | Maybe of int
    
let resultOfVote x =
    if x = 0 then
        No
    elif x >= 100 then
        Yes
    else
        Maybe x
        
resultOfVote 0;;
//> val it : YesNoMaybe = No
resultOfVote 50;;
//> val it : YesNoMaybe = Maybe 50
resultOfVote 120;;
//> val it : YesNoMaybe = Yes 

 

So a union type is a garbage can, you could put in everything you like (or don’t like).

F# by example

At the moment I am preparing new version of the OoxAcceleratorRss program.

I build previous version with C# and was quite successful and wanted to improve it. I ran into some problems which are html-related and I got stuck. I had to design and build a better html parser. One that is able to correct all kinds of html errors.

I read that one of the features of F# is the lexer and the parser. So I intend to learn F#.