Ο Bart de Smet έγραψε ένα πολύ καλο blog post για όσους θέλουν να πάρουν μια
μικρή γεύση από την ομορφιά και την δύναμη του λ-λογισμου.

To ενδιαφέρον στην προσπάθεια είναι ότι o Bart μας παρουσιάζει την untyped εκδοχή του λογισμού χρησιμοποιώντας το dynamic feautre της C# 4.0!!!

Διαβάζοντας το post είδα ότι λείπει ο Y combinator... οποτε ορίστε μια εκδοχή που σκέφτηκα...

            Func<Func<dynamic, dynamic>, dynamic> fd = x => x;
            dynamic Y = fd(f => fd(x => f(fd(y => x(x)(y))))(fd(x => f(fd(y => x(x)(y))))));
            Y(fd(f => fd(x => f(x))))(42);

Remarks:

Επειδή ο compiler δεν με αφήνει να παω από lambda σε dynamic
dynamic f = x => x; // type error
Αντί να κάνω συνεχεια new Func<dynamic, dynamic>(x => x)(οπως γίνεται στο post), σκέφτηκα να χρησιμοποιήσω μια μικρή συνάρτηση
ώστε να προσπεράσω τον περιορισμό.
dynamic f = fd(x => x);

(Παρεμπιπτόντως, αυτή είναι η πρώτη φορα που χρησιμοποιώ το νέο dynamic feature :))

Τα Concepts δυστυχώς δεν θα είναι στο νέο Standard της C++.
Για μένα αυτό ήταν το πιο σημαντικό feature... θα έδινε τέλος στα απίστευτα template error messages... και θα έκανε πραγματικότητα το
όραμα του Stepanov για pure generic programming.

http://lambda-the-ultimate.org/node/3518#comment-50071

Η C++ πριν από 10 χρονια ήταν η αγαπημένη μου γλώσσα... (Είναι η γλώσσα με τα περισσότερα βιβλία στην βιβλιοθήκη μου)
Είχα πει ότι θα ξανά-γράψω C++ όταν θα έχω Concepts, δυστυχώς πλέον είναι πολύ μακριά.

Νομίζω ότι κόσμος χρειάζεται μια νέα multi-paradigm system-oriented γλώσσα.

It was The Golden Age of Grotesque

Κατά καιρούς συναντώ πολύ όμορφα κομμάτια κώδικα στο web. Ένα από αυτά είναι και

η toy regex engine που εντόπισα στο blog του Charles Cook.

Για το code archive μου... παραθέτω την υλοποίηση σε F# που εμπνεύστηκα

let char c (s : string) = seq { if s.Length > 0 && s.[0] = c then yield s.Substring(1) }

let (=>) l r s = seq { for sl in l s do for sr in r sl -> sr }

let (<|>) l r s = seq { yield! l s; yield! r s }

let rec (<*>) e s = seq { yield s; yield! (e => (<*>) e) s }

let (<+>) e = e => (<*>) e

// example c(a|d)+r
let pattern = char 'c' => (<+>) (char 'a' <|> char 'd') => char 'r'

Ο Erik Lippert στο τελευταίο του blog post, έθεσε ένα απλό προβληματάκι.
Ακολουθεί η λύση που έκανα post.

#r "FSharp.PowerPack.dll"

let format (words : seq<string>) =
  let rec format (words : LazyList<string>) acc =
      match words with
          | LazyList.Nil -> string.Empty
          | LazyList.Cons(first, LazyList.Nil) -> first
          | LazyList.Cons(first, LazyList.Cons(second, LazyList.Nil)) -> acc + first + " and " + second
          | LazyList.Cons(first, rest) ->  acc + first + ", " |> format rest 
          
  let listOfWords = LazyList.of_seq words  
  "{" + (format  listOfWords string.Empty) + "}"


["ABC"; "DEF"; "G"; "H" ] |> format
["ABC"; "DEF" ] |> format 
["ABC"] |> format
[] |> format

On 1 April 1925, I was sick in bed ... In the morning my brother Emile (ten years my senior) came into my bedroom and said: "Well, Raymond, today is April Fool's Day, and I will fool you as you have never been fooled before!" I waited all day for him to fool me, but he didn't.

“Avoid Success at All Costs!” ... ήταν το ανεπίσημο slogan της Haskell.
Οι εποχές άλλαξαν... και το platonic realm ~"αντικατοπτρίζει"~ τον πραγματικό κόσμο.
Ένα από τα καλύτερα tech-science-books που διάβασα το 2008.

Όσοι φίλοι ενδιαφέρονται για parallel programming, τότε σίγουρα θα βρούν εξαιρετικά ενδιαφέρουσα την παρουσίαση που έκανε
ο Daniel Moth πριν από μερικούς μήνες στην Αθηνα.

Την ώρα που παρακολουθούσα το code demo ... μου ήρθε η ιδέα να κάνω abstract το recursive tree traversal και
να "κρύψω" το parallelism πίσω από την "μαγική" fold.

Μετά από λίγο πειραματισμό με το νέο Parallel API, κατέληξα σε αυτό:

interface IBinaryTreeNode<out T>
{
   IBinaryTreeNode<T> Left { get; }
   IBinaryTreeNode<T> Right { get; }
   T Data { get; }
}

static TResult FoldBinaryTree<TInput, TResult>(IBinaryTreeNode<TInput> treeNode, Func<TInput, TResult, TResult, TResult> accumulatorFunc, Func<TResult> seedFunc)
{
   if (treeNode == null) return seedFunc();

   Future<TResult> leftFuture = new Future<TResult>(() => FoldBinaryTree(treeNode.Left, accumulatorFunc, seedFunc));
   leftFuture.Start();
   Future<TResult> rightFuture = new Future<TResult>(() => FoldBinaryTree(treeNode.Right, accumulatorFunc, seedFunc));
   rightFuture.Start();

   return accumulatorFunc(treeNode.Data, leftFuture.Value, rightFuture.Value);
}

int numberOfNodes = FoldBinaryTree(treeNode, (_, numberOfLeftChildren, numberOfRightChildren) => 1 + numberOfLeftChildren + numberOfRightChildren, () => 0);

The future is parallel

Εδώ και μια βδομάδα έχω κατεβάσει και παίζω με το VS 2010 και την C# 4.0. Τα Parallel Extensions έχουν μονοπωλήσει την προσοχή μου και
η C# συνεχίζει να προσθέτει νέες cool δυνατότητες.
Αυτό όμως που ήταν μια ευχάριστη "μικρή" έκπληξη είναι μια απλή-ταπεινή μέθοδο στην Enumerable class. Ο λόγος γίνεται για την Zip, μια συνάρτηση που κάνει το εξής απλό:
Παίρνει δυο IEnumerables και κάνει apply ένα lambda στα ζευγάρια-items των sequences, και επιστρέφει ένα enumerable από τα results που "συλλέξαμε", μετά το διαδοχικό application του lambda.
Ένα απλό παράδειγμα νομίζω ότι θα δώσει μια καλύτερη εικόνα.

IEnumerable<string> result = new[] { 1, 2, 3 }.Zip(new[] { "one", "two", "three" }, (first, second) => first + " : " + second);

//result = ["1 : one", "2 : two", "3 : three"]

Αποδίδοντας φόρο τιμής στην Haskell (που με σύστησε με την Zip), αποφάσισα να υλοποιησω σε C# το sequence των Fibonacci.
Ένα από τα πιο όμορφα κομμάτια κώδικα σε Haskell.

fibs = 0 : 1 : [ a + b | (a, b) <- zip fibs (tail fibs)]

static IEnumerable<int> Fib()
{
   yield return 0;
   yield return 1;
   foreach (int number in Fib().Zip(Fib().Skip(1), (first, second) => first + second))
      yield return number;
}

It's official... Η F# θα είναι μέρος του Visual Studio 2010, first class citizen με τις υπόλοιπες γλώσσες. Για περισσότερες πληροφορίες διαβάστε το post του Don Syme.

Το LogiComix κυκλοφόρησε!!! Μετά από αναμονή (κυριολεκτικά) ετών, το έχω επιτέλους στα χερια μου.
Πολλά ευχαριστώ και συγχαρητήρια στους Απόστολο Δοξιάδη, Χρίστο Παπαδημητριου, Αλέκο Παπαδάτο και Annie Di Donna.
Μέσα στην καθημερινή ηλιθιότητα που μας περιβάλλει, τέτοιες προσπάθειες αποτελούν πνευματικές οάσεις.

Ένα συναρπαστικό Κυριακάτικο απόγευμα με περιμένει.

Δυο άρθρα για F# από το msdn...

• Use Functional Programming Techniques in the .NET Framework
• Build Concurrent Apps From Simple F# Expressions

Το πρώτο είναι μια εισαγωγή από τον Ted Neward και το δεύτερο αφορά asynchronous programming με τα asynchronous-computational workflows.

Το όνομα FSharp αρχίζει να ακούγεται όλο και περισσότερο

Ευχάριστα νέα για τους φίλους της F#, καθώς έχουμε στα χερια μας το πρώτο release της productized πλέον F#. Έχουμε πολλά νέα καλούδια και μπορούμε να τα συνοψίσουμε σε:

• F# Scripting Improvements
• F# Project System Improvements
• Units of Measure (Εντυπωσιακό language feature για scientific/financial και όχι μονο applications... για όσους θέλουν να δώσουν "προσωπικότητα" στα απρόσωπα floats/decimals)
• Splitting of F# into the FSharp.Core.dll and the F# PowerPack on CodePlex

Η F# ειναι μια εντυπωσιακή-cutting edge-γλώσσα που μπορεί να κάνει την διαφορα σε δύσκολα projects με υψηλές απαιτήσεις... δεν ξέρω εάν θα γίνει ποτε mainstream-αλλα είναι πολύ cool ότι ακόμα περισσότεροι προγραμματιστές θα γνωρίσουν το πνεύμα της Ocaml μέσα από την F#... υπάρχει ελπίδα!!

Happy F# coding

Από πολύ μικρός θυμάμαι ότι γοητευόμουν από τα αινιγματώδη μονοπάτια της λογικής...
Ειδικά τα αυτοαναφορικά παράδοξα μου προκαλούσουν αμηχανία και δέος...
Αυτό που είδα σήμερα... μου προκαλεί... γέλια

Χθες μετά το 19o community event... σε συζήτηση που είχα με τους φίλους (Γιώργο Καπνιά, Παναγιώτη Καναβό και Νίκο Κανελλόπουλο) επεσε στο τραπέζι η ιδέα να γράψω μια έκδοση της Function ΟΛΟΓΡΑΦΩΣ σε F#...

Πριν από λίγο "έκλεψα" 30 λεπτά από την δουλειά μου και είπα να "ξεσκάσω" λίγο με κάτι small and fun... κατέληξα σε αυτό...

let one_digit n = 
   match n with
   | '1' -> "ΕΝΑ"
   | '2' -> "ΔΥΟ"
   | '3' -> "ΤΡΙΑ"
   | '4' -> "ΤΕΣΣΕΡΑ"
   | '5' -> "ΠΕΝΤΕ"
   | '6' -> "ΕΞΙ"
   | '7' -> "ΕΠΤΑ"
   | '8' -> "ΟΚΤΩ"
   | '9' -> "ΕΝΝΕΑ"
   | _ -> ""

let two_digits n = 
   match n with
   | (one, two) -> match one with
                  | '1' -> match two with
                           | '1' -> "ΕΝΤΕΚΑ"
                           | '2' -> "ΔΩΔΕΚΑ"
                           | _ -> "ΔΕΚΑ" + (one_digit two)
                  | '2' -> "ΕΙΚΟΣΙ" + (one_digit two)
                  | '3' -> "ΤΡΙΑΝΤΑ" + (one_digit two)
                  | '4' -> "ΣΑΡΑΝΤΑ" + (one_digit two)
                  | '5' -> "ΠΕΝΗΝΤΑ" + (one_digit two)
                  | '6' -> "ΕΞΗΝΤΑ" + (one_digit two)
                  | '7' -> "ΕΒΔΟΜΗΤΑ" + (one_digit two)
                  | '8' -> "ΟΓΔΟΝΤΑ" + (one_digit two)
                  | '9' -> "ΕΝΕΝΗΝΤΑ" + (one_digit two) 
                  | '0' -> (one_digit two)
                  | _ -> ""

let three_digits n = 
   match n with
   | (one, two, three) -> match one with
                           | '1' -> "ΕΚΑΤΟ " + (two_digits (two, three))
                           | '2' -> "ΔΙΑΚΟΣΙΑ " + (two_digits (two, three))
                           | '3' -> "ΤΡΙΑΚΟΣΙΑ " + (two_digits (two, three))
                           | '4' -> "ΤΕΤΡΑΚΟΣΙΑ " + (two_digits (two, three))
                           | '5' -> "ΠΕΝΤΑΚΟΣΙΑ " + (two_digits (two, three))
                           | '6' -> "ΕΞΑΚΟΣΙΑ " + (two_digits (two, three))
                           | '7' -> "ΕΠΤΑΚΟΣΙΑ " + (two_digits (two, three))
                           | '8' -> "ΟΚΤΑΚΟΣΙΑ " + (two_digits (two, three))
                           | '9' -> "ΕΝΝΙΑΚΟΣΙΑ " + (two_digits (two, three))
                           | '0' -> (two_digits (two, three))
                           | _ -> ""

let four_digits n = 
   match n with
   | ('1', two, three, four) -> "ΧΙΛΙΑ " + (three_digits (two, three, four))
   | (one, two, three, four) -> (one_digit one) + " ΧΙΛΙΑΔΕΣ " + (three_digits (two, three, four))

let five_digits n =
   match n with
   | ('1', two, three, four, five) -> (two_digits ('1', two)) + " ΧΙΛΙΑΔΕΣ " + (three_digits (three, four, five))
   | (one, two, three, four, five) -> match (one, two) with
                                       | ('0', '0') -> three_digits (three, four, five)
                                       | ('1', '1') -> (two_digits ('1', two)) + " ΧΙΛΙΑΔΕΣ " + (three_digits (three, four, five))
                                       | ('1', '2') -> (two_digits ('1', two)) + " ΧΙΛΙΑΔΕΣ " + (three_digits (three, four, five))
                                       | ( _ , '1') -> (two_digits (one, '0')) + "MIA ΧΙΛΙΑΔΕΣ " + (three_digits (three, four, five))
                                       | ( _ , '3') -> (two_digits (one, '0')) + " ΤΡΕΙΣ ΧΙΛΙΑΔΕΣ " + (three_digits (three, four, five))
                                       | ( _ , '4') -> (two_digits (one, '0')) + " ΤΕΣΣΕΡΙΣ ΧΙΛΙΑΔΕΣ " + (three_digits (three, four, five))
                                       | ( _ , _ ) -> (two_digits (one, two)) + " ΧΙΛΙΑΔΕΣ " + (three_digits (three, four, five))

let six_digits n = 
   match n with
   | (one, two, three, four, five, six) -> match one with
                                          | '1' -> "EKATON " + (five_digits (two, three, four, five, six))
                                          | '2' -> "ΔΙΑΚΟΣΙΕΣ " + (five_digits (two, three, four, five, six))
                                          | '3' -> "ΤΡΙΑΚΟΣΙΕΣ " + (five_digits (two, three, four, five, six))
                                          | '4' -> "ΤΕΤΡΑΚΟΣΙΕΣ " + (five_digits (two, three, four, five, six))
                                          | '5' -> "ΠΕΝΤΑΚΟΣΙΕΣ " + (five_digits (two, three, four, five, six))
                                          | '6' -> "ΕΞΑΚΟΣΙΕΣ " + (five_digits (two, three, four, five, six))
                                          | '7' -> "ΕΠΤΑΚΟΣΙΕΣ " + (five_digits (two, three, four, five, six))
                                          | '8' -> "ΟΚΤΑΚΟΣΙΕΣ " + (five_digits (two, three, four, five, six))
                                          | '9' -> "ΕΝΝΙΑΚΟΣΙΕΣ " + (five_digits (two, three, four, five, six))
                                          | '0' -> (five_digits (two, three, four, five, six))
                                          | _ -> ""

let money_to_textual (n : int) =
   let internal_money_to_textual n = 
      match n with
      | [one] -> one_digit one
      | one :: two :: [] -> two_digits (one, two)
      | one :: two :: three :: [] -> three_digits (one, two, three)
      | one :: two :: three :: four :: [] -> four_digits (one, two, three, four)
      | one :: two :: three :: four :: five :: [] -> five_digits (one, two, three, four, five)
      | one :: two :: three :: four :: five :: six :: [] -> six_digits (one, two, three, four, five, six)
      | x :: xs -> ""
      | [] -> ""
   internal_money_to_textual (List.of_seq (n.ToString()))

Δεν έχω τεστάρει όλα τα corner cases... και ούτε υλοποίησα (millions) οποτε το αφήνω σαν άσκηση για όσους φίλους πειραματιστούν με τον κώδικα... Τα 30 λεπτά πέρασαν και δυστυχώς πρέπει να σταματήσω το hacking με την F#... back to work

IronPython και IronRuby... δυο "δυναμικές" γλώσσες στον "στατικό" κόσμο του CLR...
Κοινός παρονομαστής τους το Dynamic Language Runtime.
Το DLR είναι μια από τις τεχνολογίες που ήθελα από καιρό να μελετήσω, αλλα λόγο του περιορισμένου χρόνου όλο το ανέβαλα.
Τελικά βρήκα τον χρόνο που ήθελα και με αφορμή ένα άρθρο στο msdn magazine για compiler writing, σκέφτηκα να κάνω port τον toy-compiler του άρθρου σε DLR.
Και καθώς χρησιμοποιώ το blog μου και ως code repository για τα διαφορα pet project μου... είπα να μοιραστώ τον DLR "Good for nothing" compiler

(Για να γίνει compile το project χρειάζονται τα (Microsoft.Scripting.Core.dll, Microsoft.Scripting.dll), και θα τα βρείτε στο distribution της IronPython 2.0)

Τον νομο του Moore φαντάζομαι ότι τον ξέρετε...Τον Νομο του Γιάννη όμως????
Λοιπόν, ο Γιάννης Σμαραγδάκης ισχυρίζεται ότι η παραγωγικότητα των προγραμματιστών διπλασιάζεται κάθε 6 χρονια!!!
Όπως λέει και ο ίδιος...(I'm only half serious, but half is enough)
Δοκίμασα στην πράξη τον ισχυρισμό του, και το αποτέλεσμα είναι ότι με την αγαπημένη μου F# ολοκληρώσαμε το  προτεινόμενο σύστημα μέσα σε 10 λεπτά!

let circularly_shift list =
   let rec inner_circularly_shift list counter =
      match counter with
         | 0 -> []
         | _ -> match list with
                  | [] -> []
                  | x :: xs -> 
                     let head_shift = xs @ [x]
                     head_shift :: inner_circularly_shift head_shift (counter - 1)
   inner_circularly_shift list list.Length

let space_join = List.fold1_left (fun first second -> first + " " + second)
let space_split = String.split [' ']

let system list = list  |> List.map (fun item -> space_split item)
                        |> List.map (fun item -> circularly_shift item) 
                        |> List.flatten
                        |> List.map (fun item -> space_join item)
                        |> List.sort (fun first second -> first.CompareTo(second))
                        |> Set.of_seq

let result = system ["1 2 3"; "3 2 1"]

Κλείνοντας, να αναφέρω ότι xθες ενημερώθηκα πως ο Γιάννης Σμαραγδάκης εκλέχτηκε αναπληρωτής καθηγητής στο ΕΚΠΑ, με γνωστικό αντικείμενο Τεχνολογία Λογισμικού...πολλά συγχαρητήρια και απο εμενα

Είναι πραγματικά εντυπωσιακό ποσο έχει αλλάξει αυτή η απλή "γλωσσούλα" που λεγόταν C#...

Έχουν περάσει ανεπιστρεπτί οι εποχές που η C# ήταν απλά ένα java clone. Πλέον, ο C# κώδικας μπορεί να προκαλέσει πονοκέφαλο ακόμα και στους πιο έμπειρους Java coders.

Σήμερα για παράδειγμα, χρειάστηκε να βρω όλες τις αναδιατάξεις ενός συνόλου...
Μετά από μιση ώρα πειραματισμού κατέληξα σε αυτό...

static IEnumerable<T> Concat<T>(this T head, IEnumerable<T> tailItems)
{
  yield return head;
  foreach (var item in tailItems)
    yield return item;
}

static IEnumerable<T> AllExcept<T>(this IEnumerable<T> items, int skipIndex)
{
  return items.Where((item, index) => index != skipIndex);
}

static IEnumerable<IEnumerable<T>> Permute<T>(this IEnumerable<T> values, int count)
{
  if (count == 0)
    return new List<IEnumerable<T>> { new List<T>() };
  else
    return from headIndexPair in values.Select((item, index) => new { Item = item, Index = index })
           from tailRemainder in Permute(values.AllExcept(headIndexPair.Index), count - 1)
           select headIndexPair.Item.Concat(tailRemainder);
}

static void Main(string[] args)
{
  foreach (var list in new[] {1, 2, 3}.Permute(3))
  {
    foreach (var item in list)
      Console.Write("{0}", item);

    Console.WriteLine();
  }
}

Forgive me father for I have sinned

Πριν από χρονια διάβασα το Code του Charles Petzold... ένα εκπληκτικό βιβλίο που
πραγματικά σε διδάσκει και σε γεμίζει με χαρά και θαυμασμό, ίσως το μοναδικό του είδους από τα βιβλία της Microsoft Press.

Αφήνοτας για λίγο στην άκρη τα βιβλία για .Net-WPF, επανέρχεται με ένα νεο βιβλίο με τίτλο "Τhe annotated Τuring", και από ότι διαβάζω θα είναι στο πνεύμα του Cοde... Ο Petzold είναι ένας χαρισματικός συγγραφέας (programmer) και είμαι ιδιαιτερα χαρούμενος που θα μας μιλήσει για τον Turing και το έργο του. Σε αναμονή λοιπόν, για ένα βιβλίο που νομίζω ότι θα γίνει classic.

Στο 12o Dotnetzone event, παρουσίασα μια βιβλιοθήκη για pattern matching με regular expressions... To διαφορετικό είναι ότι δεν περιορίζεται μονο σε character streams, αλλα κάνει match <T> streams, όπου το <T> οτιδήποτε (polymorphic type value).

Ένα κλασικό παράδειγμα είναι να κάνω pattern matching σε ένα bitstream που μου έρχεται από διαφορα files...
Stream: 1110101111110000111111000111
pattern: 1110(0|1)0111
Result: 1110101111110000111111000111
ή να βρω κάποιο συγκεκριμένο pattern στα δεκαδικά ψηφία του π (3.14159265358979323846264338327950288419716939937510...)

Κάποια παραδείγματα χρήσης

var pattern = true.Seq(true).Seq(false);
var matchPattern = pattern.Match(new[] { true, true, true, false});

var pattern = 1.Seq(2).Seq(3.Alt(4));
var matchPattern = pattern.Match(new[] { 1, 2, 3, 5});

var pattern = '1'.Seq('2').Seq('3'.Plus()).Seq('4');
var matchPattern = pattern.Match("12333345");

Κάποιες βασικές ιδέες που χρησιμοποίησα στην υλοποίηση
1. Internal DSL for patterns
2. parser combinators for patterns and execution
3. Infinite Lists (Wizard book-Streams)

Όσοι φίλοι μελετήσουν τον κώδικα, θα δουν πως μπορούμε να κάνουμε higher order functional programming με την C# 3.0 και να δομήσουμε τον κώδικα (και την σκέψη μας) με έναν αρκετά διαφορετικό τρόπο...purity + unit tests == zero debugging time

Το Project Euler, είναι ένα πολύ ενδιαφέρον site για τους φίλους των μαθηματικών, που όμως διαθέτουν μια κλίση προς το coding.

Όπως διαβάζω στο site "Project Euler exists το encourage, challenge, and develop the skills and enjoyment of anyone with an interest in the fascinating world of mathematics."
Τα προβλήματα ποικίλλουν σε δυσκολία, κάποια είναι brute force oriented, ενώ άλλα χρειάζονται την μαθηματική κομψότητα για να μειώσουν το search space. Τα πιο εύκολα είναι τα κλασικά brute force (είναι η αδυναμία μου...elegant brute force προγράμματα)

Ένα κλασικό παράδειγμα είναι να βρούμε Πυθαγόρειες τριάδες
Σε Haskell   

[ (a, b, c) | a <- [ 1 .. n ], b <- [ a + 1 .. n ], c <- [ b + 1 .. n ], (a * a) + (b * b) == (c * c) ]

και για τους φίλους της C#

var triples =  from a in Enumerable.Range(1, n)
               from b in Enumerable.Range(a + 1, n)
               from c in Enumerable.Range(b + 1, n)
               where (a * a) + (b * b) == c * c
               select new { a, b, c };

Παρατηρώντας τις δυο υλοποιήσεις, συνειδητοποιώ την εντυπωσιακή ομοιότητα... πως φαίνεται ότι ο άνθρωπος που σχεδίασε τα LINQ comprehensions έχει Haskell background... Δείξε μου τον κώδικά σου, να σου πω ποιός είσαι 
 

Σήμερα ανακάλυψα ότι το A Mathematician’s Apology του G. Η. Hardy είναι available on-line

Πρόσφατα, χρειάστηκε να βρω τo Inheritance Chain κάποιου type, απλό και βαρετό... αλλα
(για να το κάνω πιο ενδιαφέρον) σκέφτηκα ότι είναι μια κλασική περίπτωση "αναμορφισμου", και ότι αυτό που χρειάζομαι είναι την κλασική συνάρτηση Unfold.
Με τα extension methods μπορώ να προσθέσω την ανάλογη δυνατότητα, και ο τελικός κώδικας να γίνει small and readable (I love C#)

  static class Program
  {
    static IEnumerable<T> Unfold<T>(this T value, Func<T, T> func)
    {      
      while(true)
      {
        yield return value;
        value = func(value);
      }
    }

    static IEnumerable<T> WhileIsNotNull<T>(this IEnumerable<T> values)
    {
      return values.TakeWhile(n => n != null);
    }

    static void Main(string[] args)
    {
      foreach (var value in typeof(int).Unfold(type => type.BaseType).WhileIsNotNull())
        Console.WriteLine(value);
    }
  }