Mutability - Revision history

Adamcolton at 16:22, 4 October 2019

2019-10-04T16:22:28Z

← Older revision		Revision as of 16:22, 4 October 2019
Line 11:		Line 11:
	How would you add a memoization wrapper? Specifically, to a concurrent Fibonacci call.		How would you add a memoization wrapper? Specifically, to a concurrent Fibonacci call.

	== ~~Ternary~~ ==		== States ==
	~~Mutability really has 3 variants~~		There are two base states:
	* ~~Writeable : value is~~ mutable and ~~this reference is allowed~~ to ~~mutate~~ it		* Mutable
	* Mutable ~~: value~~ is ~~mutable~~ but ~~this reference~~ can'~~t mutate~~ it.		* Immutable
	* Immutable : ~~No writeable reference exists.~~		but that's not enough because something may be mutable to one instance and immutable to another. So it becomes
			* Mutable
			* Fluid
			* Immutable
			Fluid means that our copy is read only, but someone may have a writeable copy. Immutable means that the data cannot change. We can create immutable instances by making them immutable at construction, but we'd like to be able to have a mutable instance and when some criteria is met, lock it. This may introduce a new state (though it may not be necessary)
			* Lockable
			* Mutable
			* Fluid
			* Immutable
			If A calls B and A has a lockable instance of X, it can pass X in as Mutable and guarantee when B returns that X is still mutable.

			These states are also coercible:
			* Lockable
			* Mutable : Lockable
			* Fluid : Mutable, Lockable
			* Immutable

	=== Expressions ===		=== Expressions ===
Line 26:		Line 41:

	This is one of the places where using the same bytecode for the compiler and runtime will be advantageous. If a function is immutable and it's arguments are known at compile time, the compiler can run the function and replace the return value.		This is one of the places where using the same bytecode for the compiler and runtime will be advantageous. If a function is immutable and it's arguments are known at compile time, the compiler can run the function and replace the return value.

			== Message Passing ==
			A can pass a mutable X to B as a message.

	[[Category:Gryphon]]		[[Category:Gryphon]]

Adamcolton at 14:31, 18 September 2019

2019-09-18T14:31:19Z

← Older revision		Revision as of 14:31, 18 September 2019
Line 11:		Line 11:
	How would you add a memoization wrapper? Specifically, to a concurrent Fibonacci call.		How would you add a memoization wrapper? Specifically, to a concurrent Fibonacci call.

	~~[[Category~~:~~Gryphon]]~~		== Ternary ==
			Mutability really has 3 variants
			* Writeable : value is mutable and this reference is allowed to mutate it
			* Mutable : value is mutable but this reference can't mutate it.
			* Immutable : No writeable reference exists.

	=== Expressions ===		=== Expressions ===
Line 22:		Line 26:

	This is one of the places where using the same bytecode for the compiler and runtime will be advantageous. If a function is immutable and it's arguments are known at compile time, the compiler can run the function and replace the return value.		This is one of the places where using the same bytecode for the compiler and runtime will be advantageous. If a function is immutable and it's arguments are known at compile time, the compiler can run the function and replace the return value.

			[[Category:Gryphon]]

Adamcolton at 17:39, 17 September 2019

2019-09-17T17:39:29Z

← Older revision		Revision as of 17:39, 17 September 2019
Line 17:		Line 17:
	if a.Foo() \|\| a.Bar() {...}		if a.Foo() \|\| a.Bar() {...}
	If a.Bar can mutate a and \|\| is evaluated lazily, this is a good spot for bugs to hide.		If a.Bar can mutate a and \|\| is evaluated lazily, this is a good spot for bugs to hide.

			== Functions ==
			Functions can infer if they are immutable. A function that does not call any functions with side effects or mutate it's arguments is immutable.

			This is one of the places where using the same bytecode for the compiler and runtime will be advantageous. If a function is immutable and it's arguments are known at compile time, the compiler can run the function and replace the return value.

Adamcolton: Created page with "Mutability will be explicit. Variables are mutable or immutable. == Mono Mute == One idea I like but I'm not sure about it's feasibility; there can only ever be one mutable ..."

2019-09-17T17:35:23Z

Created page with "Mutability will be explicit. Variables are mutable or immutable. == Mono Mute == One idea I like but I'm not sure about it's feasibility; there can only ever be one mutable ..."

New page

Mutability will be explicit.

Variables are mutable or immutable.

== Mono Mute ==
One idea I like but I'm not sure about it's feasibility; there can only ever be one mutable reference. For linear stack calls, this is easy. If we disallow any form of global mutable, it's also easy.

The only complicating factor is concurrency. If I have a mutable reference that I want to share with a concurrent call, then there's two references.

=== Case Study ===
How would you add a memoization wrapper? Specifically, to a concurrent Fibonacci call.

[[Category:Gryphon]]

=== Expressions ===
It might be good to disallow mutable calls in expressions.
if a.Foo() || a.Bar() {...}
If a.Bar can mutate a and || is evaluated lazily, this is a good spot for bugs to hide.