Browse by Tags

• Covariance and Contravariance
• Performance
• Puzzles
• Recursion

• Mutating Readonly Structs

  Consider this program which attempts to mutate a readonly mutable struct. What happens? struct Mutable { private int x; public int Mutate() { this.x = this.x + 1; return this.x; } } class Test { public readonly Mutable m = new Mutable(); static void Main(string[] Read More... Posted Wednesday, May 14, 2008 7:10 AM by Eric Lippert | 24 Comments Filed under: C#, Immutability

• Trivial Projections Are (Usually) Optimized Away

  OK, computers aren't entirely dumb when it comes to LINQ. Here's an example of a place where we're a bit smarter. Consider the following query: IEnumerable<int> query = from n in number_array orderby n select n; Does this get transformed by the Read More... Posted Monday, May 12, 2008 6:57 AM by Eric Lippert | 7 Comments Filed under: Performance, C#, Immutability

• Why Do Initializers Run In The Opposite Order As Constructors? Part Two

  As you might have figured out, the answer to last week's puzzle is "if the constructors and initializers run in their actual order then an initialized readonly field of reference type is guaranteed to be non null in any possible call. That guarantee cannot Read More... Posted Monday, February 18, 2008 7:25 AM by Eric Lippert | 41 Comments Filed under: C#, Puzzles, Immutability

• Why Do Initializers Run In The Opposite Order As Constructors? Part One

  Pop quiz! What do you expect the output of this program to be? using System; class Foo { public Foo(string s) { Console.WriteLine("Foo constructor: {0}", s); } public void Bar() { } } class Base { readonly Foo baseFoo = new Foo("Base initializer"); public Read More... Posted Friday, February 15, 2008 3:01 PM by Eric Lippert | 27 Comments Filed under: C#, Puzzles, Immutability

• Immutability in C# Part Eleven: A working double-ended queue

  At long last, let's get to that double-ended queue. Sorry for leaving you in suspense! Last time we came up with a non-solution -- as commenters immediately discovered, the given algorithm and data structure are deeply inefficient. However, the basic Read More... Posted Tuesday, February 12, 2008 3:40 PM by Eric Lippert | 12 Comments Filed under: C#, Immutability

• deque.cs

  public interface IDeque<T> { T PeekLeft(); T PeekRight(); IDeque<T> EnqueueLeft(T value); IDeque<T> EnqueueRight(T value); IDeque<T> DequeueLeft(); IDeque<T> DequeueRight(); bool IsEmpty { get; } } public sealed class Deque<T> Read More... Posted Tuesday, February 12, 2008 3:14 PM by Eric Lippert | 6 Comments Filed under: C#, Immutability

• Immutability in C# Part 10: A double-ended queue

  Based on the comments, the implementation of a single-ended queue as two stacks was somewhat mind-blowing for a number of readers. People, you ain't seen nothing yet. Before we get into the actual bits and bytes of the solution, think for a bit about Read More... Posted Tuesday, January 22, 2008 7:15 AM by Eric Lippert | 28 Comments Filed under: C#, Immutability

• Immutability in C# Part Nine: Academic? Plus my AVL tree implementation

  Good Monday morning all. I have received a lot of good comments on this series so far that I thought I would speak to a bit. Academic? First and foremost, a number of people have asked questions which could be summed up as "isn't this just an academic Read More... Posted Monday, January 21, 2008 4:13 PM by Eric Lippert | 21 Comments Filed under: C#, Immutability

• Immutability in C# Part Eight: Even More On Binary Trees

  Last year we declared a relatively simple interface to represent an immutable binary tree. We noticed that it was different from every other interface that we've declared so far, in that it really said nothing at all about the immutability of the tree. Read More... Posted Friday, January 18, 2008 11:02 AM by Eric Lippert | 7 Comments Filed under: C#, Immutability

• Immutability in C# Part Seven: More on Binary Trees

  Lots of good comments on my previous post. To briefly follow up: One of the downsides of immutable tree implementations is that usually the tree must be built from the leaves up, which is not always convenient. We'll look at implementations which hide Read More... Posted Wednesday, December 19, 2007 12:01 PM by Eric Lippert | 21 Comments Filed under: C#, Recursion, Immutability

• Immutability in C# Part Six: A Simple Binary Tree

  OK, we've gotten pretty good at this by now. A straightforward implementation of an immutable generic binary tree requires little comment on the basics. A binary tree is either empty, or a value, left tree and right tree: public interface IBinaryTree<V> Read More... Posted Tuesday, December 18, 2007 11:30 AM by Eric Lippert | 12 Comments Filed under: C#, Recursion, Immutability

• Immutability in C# Part Five: LOLZ!

  My sadly soon-to-be-erstwhile coworker Cyrus made me a lolgeek shirt to go with this series of blog articles: Cyrus, needless to say, is a big goof. Thanks, dude! Read More... Posted Thursday, December 13, 2007 11:19 AM by Eric Lippert | 10 Comments Filed under: C#, Immutability

• Immutability in C# Part Four: An Immutable Queue

  An immutable queue is a bit trickier than an immutable stack, but we’re tough, we can handle it. First off, the interface is straightforward; enqueuing or dequeuing results in a new queue: public interface IQueue<T> : IEnumerable<T> { bool Read More... Posted Monday, December 10, 2007 7:04 AM by Eric Lippert | 33 Comments Filed under: C#, Immutability

• Immutability in C# Part Three: A Covariant Immutable Stack

  Now suppose we had a hypothetical future version of C# in which interface covariance worked, and we wanted a covariant immutable stack. That is, we want to be able to implicitly convert an IStack<Giraffe> to IStack<Mammal> . As we've already Read More... Posted Thursday, December 06, 2007 7:55 AM by Eric Lippert | 22 Comments Filed under: C#, Covariance and Contravariance, Immutability

• Immutability in C# Part Two: A Simple Immutable Stack

  Let’s start with something simple: an immutable stack. Now, immediately I hear the objection: a stack is by its very nature something that changes. A stack is an abstract data type with the interface void Push(T t); T Pop(); bool IsEmpty { get; } You Read More... Posted Tuesday, December 04, 2007 7:26 AM by Eric Lippert | 53 Comments Filed under: C#, Immutability