<?xml version="1.0" encoding="utf-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	>
<channel>
	<title>Comments on: Uniqueness Typing</title>
	<atom:link href="http://www.snell-pym.org.uk/archives/2008/05/02/uniqueness-typing/feed/" rel="self" type="application/rss+xml" />
	<link>http://www.snell-pym.org.uk/archives/2008/05/02/uniqueness-typing/</link>
	<description>Sarah and Alaric Snell-Pym living in interesting times</description>
	<pubDate>Wed, 19 Nov 2008 22:20:59 +0000</pubDate>
	<generator>http://wordpress.org/?v=2.5</generator>
		<item>
		<title>By: alaric</title>
		<link>http://www.snell-pym.org.uk/archives/2008/05/02/uniqueness-typing/#comment-73417</link>
		<dc:creator>alaric</dc:creator>
		<pubDate>Fri, 02 May 2008 10:39:48 +0000</pubDate>
		<guid isPermaLink="false">http://www.snell-pym.org.uk/?p=771#comment-73417</guid>
		<description>&lt;p&gt;Yeah, Python's good in that respect. Strings and tuples (both major data structures) are immutable. There's mutable lists which work like a subclass of tuples. And so on.&lt;/p&gt;

&lt;p&gt;Functional programming has demonstrated that mutation isn't quite as useful as was once thought; and ongoing experiments in programming language implementation (particularly with relation to increasing parallelism) are showing that mutation isn't quite as cheap as was once thought :-)&lt;/p&gt;
</description>
		<content:encoded><![CDATA[<p>Yeah, Python's good in that respect. Strings and tuples (both major data structures) are immutable. There's mutable lists which work like a subclass of tuples. And so on.</p>

<p>Functional programming has demonstrated that mutation isn't quite as useful as was once thought; and ongoing experiments in programming language implementation (particularly with relation to increasing parallelism) are showing that mutation isn't quite as cheap as was once thought <img src='http://www.snell-pym.org.uk/wp-includes/images/smilies/icon_smile.gif' alt=':-)' class='wp-smiley' /> </p>]]></content:encoded>
	</item>
	<item>
		<title>By: Ben</title>
		<link>http://www.snell-pym.org.uk/archives/2008/05/02/uniqueness-typing/#comment-73411</link>
		<dc:creator>Ben</dc:creator>
		<pubDate>Fri, 02 May 2008 08:11:26 +0000</pubDate>
		<guid isPermaLink="false">http://www.snell-pym.org.uk/?p=771#comment-73411</guid>
		<description>&lt;p&gt;I am coming to the opinion that mutable strings by default is a design flaw. Ruby is annoying, even a comparison to a constant string has to create a new string each time (I think). It's freeze method doesn't help much, because it's not on by default.&lt;/p&gt;

&lt;p&gt;Cocoa has data structures which are immutable in the base class, and have mutable derived classes. Everything takes and returns immutable things by default. It works well, but it is down to trust -- I think you want to enforce this in the compiler or at runtime, so it's not good enough.&lt;/p&gt;

&lt;p&gt;C++ has the const modifer, which again works very well but is the wrong way round by default. It's too easy to forget it, then find that you can't practically use something as a const because a non-modifying access function is missing the modifier. A mutable modifier would be better.&lt;/p&gt;

&lt;p&gt;Still doesn't enforce it though. How about a const/mutable modifier that on the first cast, made it irrevocably const or mutable, and using the wrong way exceptions?&lt;/p&gt;

&lt;p&gt;This is probably more pragmatic than correct, though.&lt;/p&gt;
</description>
		<content:encoded><![CDATA[<p>I am coming to the opinion that mutable strings by default is a design flaw. Ruby is annoying, even a comparison to a constant string has to create a new string each time (I think). It's freeze method doesn't help much, because it's not on by default.</p>

<p>Cocoa has data structures which are immutable in the base class, and have mutable derived classes. Everything takes and returns immutable things by default. It works well, but it is down to trust -- I think you want to enforce this in the compiler or at runtime, so it's not good enough.</p>

<p>C++ has the const modifer, which again works very well but is the wrong way round by default. It's too easy to forget it, then find that you can't practically use something as a const because a non-modifying access function is missing the modifier. A mutable modifier would be better.</p>

<p>Still doesn't enforce it though. How about a const/mutable modifier that on the first cast, made it irrevocably const or mutable, and using the wrong way exceptions?</p>

<p>This is probably more pragmatic than correct, though.</p>]]></content:encoded>
	</item>
</channel>
</rss>
