hubFS: THE place for F#

If you define a type, say an interface, F# will not let you assign a null value to that type. I have a function MakeBlah which returns an IBlah option, all well and good in my cozy F# world. However F# clients will not be the only users of this functionality -- there are hundreds of thousands of lines of C# in our product which are perfectly happy with the null/not-null notion of optionality. So I write a MakeBlahOrNull function and attempt to return null from it. Fair enough, the documentation warns me it probably won't work. (I did something like (box obj :?> IBlah). It compiled, but caused an exception at runtime. Except under Mono, where it worked. Now that's interesting, isn't it?)

But I digress. The point is, one way for F# to make inroads is to play nice with other .NET code. What are the underlying reasons for disallowing these null values? Could we specially mark functions as returning nulls? There are vague rumors of this also in the documentation...

Thanks

Some comments:

• If your F# function takes an option type argument, your C# code can pass null instead of None.
• You can test all types for null by boxing them first.
• If you really need to generate a null of any type, you could write a simple generic helper function in C#, or -- as long as F# continues to allow inline IL for user code -- use 
  let mynull : 'a = (# "ldnull" : 'a #)
  

Correction: One shouldn't use null with value types, so the following is safer:

let mynull : 'a when 'a : not struct = (# "ldnull" : 'a #);;

The design rational is that null values are dangerous (or at least anonying) as there use will generally lead to a null reference exception at some point unless you are very careful. So F# actively discourages them, rather than banning them completely. The option type is a much better way to handle the presents or absence of a value.

Having said that F# should allow you to use null values for other language clients who may want that, the following should work:

type IToto =
  abstract lolo: int -> int

let toto() = ((null:obj):?>IToto)

But it looks like the code generation is a bit buggy at the moment, when I decompile to C# I see:

public static IToto toto()
{
    int num1 = 0.GetHashCode;
    return null;
}

So just use the inline IL that Stephan suggests for the moment.

---

Robert Pickering, MVP
http://strangelights.com

Hi,
you can also use the following trick to get a default value ("null" or 0 in case of integers, etc.) in F#:
let a:ISomething = (Array.zero_create 1).[0];;

If you need to initialize a class field to a default value, you can also use following:
[<DefaultValue>]
type SomeClass =
  val mutable sth : ISth

---

Tomas Petricek (Blog), C# MVP
My book: Real-world Functional Programming in .NET

Thanks all for the prompt replies! Agreed that null values are downright dangerous. I've wanted a .NET language for years that let me add a is-never-null to the type system and force-feed that through the call graph. Within F#, I get the heebie-jeebies whenever I call into the framework, wondering if I'll get a null back, and playing within a bigger system, I get similarly wobbly wondering whether someone will pass me a null.

I'm glad to hear I was on the right track but simply running into a code generation issue. I will ponder what I want to do in my code.

While I suppose this might just spur on those who won't think, standard functions in the Option module for going to and from the null/not-null world might at least make these things consistent for everyone. I suspect the logic and the syntax get quite colorful when this conversation extends to nullables. After all, a nullable value type is good and righteous thing in C#. I would imagine something like

MyFavoriteFSharpFunction >> Option.to_nullable

would make for pretty sensible reading.

You can extend the option module within your namespace using the following

module Option =
  let to_nullable x =
    match x with
    | Some v -> System.Nullable(v)
    | None -> System.Nullable()  

What is the type declaration to indicate that a variable might contain null?

I've got a situation where I want to hold a value returned from a call to a .NET function that might return null. Then later test against null -- but the test expression (value <> null) complains "A type parameter is missing a constraint 'when 'a : null"

NOTE: I know that I could wrap it inside a Some, but that adds extra clutter that I'd rather avoid -- by the time I've returned value to caller it won't be null; I'm just marking this local variable so that I can work with an incoming .NET object, which is inherently nullable.

EDIT: I got it to work by using Stephan's "mynull" definition; e.g. (value <> mynull). However, I'd still like a way to mark the variable type itself, rather than using such a work-around.

The simplest approach to achieve what you want is "box value <> null".

perfect -- thanks Stephan