SCL Types - Revision history

Hannu Niemisto: /* Effect types */

2013-06-27T13:50:15Z

Effect types

← Older revision		Revision as of 13:50, 27 June 2013
Line 94:		Line 94:
	<pre>		<pre>
	executeTwice :: (() -> <e> ()) -> <e> ()		executeTwice :: (() -> <e> ()) -> <e> ()
	executeTwice f = { f () ; f () }		executeTwice f = do f () ; f ()

	(.) :: (b -> <e2> c) -> (a -> <e1> b) -> (a -> <e1,e2> c)		(.) :: (b -> <e2> c) -> (a -> <e1> b) -> (a -> <e1,e2> c)
	(f . g) x = f (g x)		(f . g) x = f (g x)
	</pre>		</pre>

Tuukka Lehtonen at 19:43, 6 September 2012

2012-09-06T19:43:04Z

← Older revision		Revision as of 19:43, 6 September 2012
Line 1:		Line 1:
			[[Category: Simantics Constraint Language]]
	== Basic types ==		== Basic types ==

Hannu Niemisto: /* Effect types */

2012-09-05T10:16:34Z

Effect types

← Older revision		Revision as of 10:16, 5 September 2012
Line 76:		Line 76:
	SCL functions are [http://en.wikipedia.org/wiki/Referential_transparency_(computer_science) referentially transparent] which means that they are like mathematical functions always returning the same value for the same parameters and not causing any observable side-effects. This seems extremely restrictive because most of the programs are written in order to generate some kind of side-effects and even completely mathematical algorithms involve functions that are not referentially transparent such as generation of random numbers.		SCL functions are [http://en.wikipedia.org/wiki/Referential_transparency_(computer_science) referentially transparent] which means that they are like mathematical functions always returning the same value for the same parameters and not causing any observable side-effects. This seems extremely restrictive because most of the programs are written in order to generate some kind of side-effects and even completely mathematical algorithms involve functions that are not referentially transparent such as generation of random numbers.

	This policy does not however restrict expressive power of the language because functions can return and manipulate ''descriptions of computations''. These computations are then executed some external means. Two different ways of handling computations in SCL are monads and effect types. The former concept is described [http://www.haskell.org/haskellwiki/Monad_tutorials_timeline (in)numerable] times in different Haskell tutorials, for example [http://ertes.de/articles/monads.html], and is defined with the machinery already described. Effect types are not applicable to as large range of different computation concepts as monads are but they are easier to work with.		This policy does not however restrict expressive power of the language because functions can return and manipulate ''descriptions of computations''. These computations are then executed by some external means. Two different ways of handling computations in SCL are monads and effect types. The former concept is described [http://www.haskell.org/haskellwiki/Monad_tutorials_timeline (in)numerable] times in different Haskell tutorials, for example [http://ertes.de/articles/monads.html], and is defined with the machinery already described. Effect types are not applicable to as large range of different computation concepts as monads are but they are easier to work with.

	An effectful computation has type <effects> value. The type after angle brackets is the type of the value obtained by the computation. Side-effects that might happen during computation are listed inside of angle brackets. Effect types must always occur as a return type of a function. Here are some examples of functions with side-effects:		An effectful computation has type <effects> value. The type after angle brackets is the type of the value obtained by the computation. Side-effects that might happen during computation are listed inside of angle brackets. Effect types must always occur as a return type of a function. Here are some examples of functions with side-effects:

Hannu Niemisto: /* Effect types */

2012-09-05T10:05:35Z

Effect types

← Older revision		Revision as of 10:05, 5 September 2012
Line 76:		Line 76:
	SCL functions are [http://en.wikipedia.org/wiki/Referential_transparency_(computer_science) referentially transparent] which means that they are like mathematical functions always returning the same value for the same parameters and not causing any observable side-effects. This seems extremely restrictive because most of the programs are written in order to generate some kind of side-effects and even completely mathematical algorithms involve functions that are not referentially transparent such as generation of random numbers.		SCL functions are [http://en.wikipedia.org/wiki/Referential_transparency_(computer_science) referentially transparent] which means that they are like mathematical functions always returning the same value for the same parameters and not causing any observable side-effects. This seems extremely restrictive because most of the programs are written in order to generate some kind of side-effects and even completely mathematical algorithms involve functions that are not referentially transparent such as generation of random numbers.

	This policy does not however restrict expressive power of the language because functions can return and manipulate ''descriptions of computations''. These computations are then executed some external means. Two different ways of handling computations in SCL are monads and effect types. The former concept is described [http://www.haskell.org/haskellwiki/Monad_tutorials_timeline (in)numerable] times in different Haskell tutorials, for example [http://ertes.de/articles/monads.html], and is defined with the machinery already described. ~~We describe next the latter concept~~.		This policy does not however restrict expressive power of the language because functions can return and manipulate ''descriptions of computations''. These computations are then executed some external means. Two different ways of handling computations in SCL are monads and effect types. The former concept is described [http://www.haskell.org/haskellwiki/Monad_tutorials_timeline (in)numerable] times in different Haskell tutorials, for example [http://ertes.de/articles/monads.html], and is defined with the machinery already described. Effect types are not applicable to as large range of different computation concepts as monads are but they are easier to work with.

	~~Effectful~~ computation has type <effects> value. The type after angle brackets is the type of the value obtained by the computation. Side-effects that might happen during computation are listed inside of angle brackets. Here are some examples of functions with side-effects:		An effectful computation has type <effects> value. The type after angle brackets is the type of the value obtained by the computation. Side-effects that might happen during computation are listed inside of angle brackets. Effect types must always occur as a return type of a function. Here are some examples of functions with side-effects:
	<pre>		<pre>
	randomBetween :: Double -> Double -> <Nondet> Double		randomBetween :: Double -> Double -> <Nondet> Double
Line 84:		Line 84:
	claim :: Resource -> Resource -> Resource -> <WriteGraph> ()		claim :: Resource -> Resource -> Resource -> <WriteGraph> ()
	randomLiteral :: Double -> Double -> <Nondet,WriteGraph> Resource		randomLiteral :: Double -> Double -> <Nondet,WriteGraph> Resource
			</pre>

			Effect types are much like type constraints: you can mostly ignore them when using functions. All effects you use are automatically collected and added to the type signature of the defined function (or checked against type annotation if provided).

			Like type classes, effects form a hierarchy. For example WriteGraph inherits ReadGraph and a function both reading and writing to graph is annotated only with <WriteGraph> effect.

			Like types, effects can also be abstracted with effect variables. This is important when defining generic functions that manipulate possibly effectful functions:
			<pre>
			executeTwice :: (() -> <e> ()) -> <e> ()
			executeTwice f = { f () ; f () }

			(.) :: (b -> <e2> c) -> (a -> <e1> b) -> (a -> <e1,e2> c)
			(f . g) x = f (g x)
	</pre>		</pre>

Hannu Niemisto: /* Effect types */

2012-09-05T09:47:15Z

Effect types

← Older revision		Revision as of 09:47, 5 September 2012
Line 80:		Line 80:
	Effectful computation has type <effects> value. The type after angle brackets is the type of the value obtained by the computation. Side-effects that might happen during computation are listed inside of angle brackets. Here are some examples of functions with side-effects:		Effectful computation has type <effects> value. The type after angle brackets is the type of the value obtained by the computation. Side-effects that might happen during computation are listed inside of angle brackets. Here are some examples of functions with side-effects:
	<pre>		<pre>
	randomBetween : Double -> Double -> <Nondet> Double		randomBetween :: Double -> Double -> <Nondet> Double
	resourceByUri : String -> <ReadGraph> Resource		resourceByUri :: String -> <ReadGraph> Resource
	claim : Resource -> Resource -> Resource -> <WriteGraph> ()		claim :: Resource -> Resource -> Resource -> <WriteGraph> ()
	randomLiteral : Double -> Double -> <Nondet,WriteGraph> Resource		randomLiteral :: Double -> Double -> <Nondet,WriteGraph> Resource
	</pre>		</pre>

Hannu Niemisto: /* Effect types */

2012-09-05T09:46:42Z

Effect types

← Older revision		Revision as of 09:46, 5 September 2012
Line 78:		Line 78:
	This policy does not however restrict expressive power of the language because functions can return and manipulate ''descriptions of computations''. These computations are then executed some external means. Two different ways of handling computations in SCL are monads and effect types. The former concept is described [http://www.haskell.org/haskellwiki/Monad_tutorials_timeline (in)numerable] times in different Haskell tutorials, for example [http://ertes.de/articles/monads.html], and is defined with the machinery already described. We describe next the latter concept.		This policy does not however restrict expressive power of the language because functions can return and manipulate ''descriptions of computations''. These computations are then executed some external means. Two different ways of handling computations in SCL are monads and effect types. The former concept is described [http://www.haskell.org/haskellwiki/Monad_tutorials_timeline (in)numerable] times in different Haskell tutorials, for example [http://ertes.de/articles/monads.html], and is defined with the machinery already described. We describe next the latter concept.

	Effectful computation has type <effects> value. The type after angle brackets is the type of the value obtained by the computation. Side-effects that might happen during computation are listed inside of angle brackets. Here are some examples:		Effectful computation has type <effects> value. The type after angle brackets is the type of the value obtained by the computation. Side-effects that might happen during computation are listed inside of angle brackets. Here are some examples of functions with side-effects:
	<pre>		<pre>
	randomBetween : Double -> Double -> <Nondet> Double		randomBetween : Double -> Double -> <Nondet> Double
	resourceByUri : String -> <ReadGraph> Resource		resourceByUri : String -> <ReadGraph> Resource
	claim : Resource -> Resource -> Resource -> <WriteGraph> ()		claim : Resource -> Resource -> Resource -> <WriteGraph> ()
			randomLiteral : Double -> Double -> <Nondet,WriteGraph> Resource
	</pre>		</pre>

Hannu Niemisto: /* Effect types */

2012-09-05T09:44:54Z

Effect types

← Older revision		Revision as of 09:44, 5 September 2012
Line 76:		Line 76:
	SCL functions are [http://en.wikipedia.org/wiki/Referential_transparency_(computer_science) referentially transparent] which means that they are like mathematical functions always returning the same value for the same parameters and not causing any observable side-effects. This seems extremely restrictive because most of the programs are written in order to generate some kind of side-effects and even completely mathematical algorithms involve functions that are not referentially transparent such as generation of random numbers.		SCL functions are [http://en.wikipedia.org/wiki/Referential_transparency_(computer_science) referentially transparent] which means that they are like mathematical functions always returning the same value for the same parameters and not causing any observable side-effects. This seems extremely restrictive because most of the programs are written in order to generate some kind of side-effects and even completely mathematical algorithms involve functions that are not referentially transparent such as generation of random numbers.

	This policy does not however restrict expressive power of the language because functions can return and manipulate ''descriptions of computations''. These computations are then executed some external means. Two different ways of handling ~~side-effects~~ in SCL are monads and effect types. The former concept is described [http://www.haskell.org/haskellwiki/Monad_tutorials_timeline (in)numerable] times in different Haskell tutorials, for example [http://ertes.de/articles/monads.html], and is defined with the machinery already described.		This policy does not however restrict expressive power of the language because functions can return and manipulate ''descriptions of computations''. These computations are then executed some external means. Two different ways of handling computations in SCL are monads and effect types. The former concept is described [http://www.haskell.org/haskellwiki/Monad_tutorials_timeline (in)numerable] times in different Haskell tutorials, for example [http://ertes.de/articles/monads.html], and is defined with the machinery already described. We describe next the latter concept.

			Effectful computation has type <effects> value. The type after angle brackets is the type of the value obtained by the computation. Side-effects that might happen during computation are listed inside of angle brackets. Here are some examples:
			<pre>
			randomBetween : Double -> Double -> <Nondet> Double
			resourceByUri : String -> <ReadGraph> Resource
			claim : Resource -> Resource -> Resource -> <WriteGraph> ()
			</pre>

Hannu Niemisto: /* Effect types */

2012-09-05T09:35:53Z

Effect types

← Older revision		Revision as of 09:35, 5 September 2012
Line 76:		Line 76:
	SCL functions are [http://en.wikipedia.org/wiki/Referential_transparency_(computer_science) referentially transparent] which means that they are like mathematical functions always returning the same value for the same parameters and not causing any observable side-effects. This seems extremely restrictive because most of the programs are written in order to generate some kind of side-effects and even completely mathematical algorithms involve functions that are not referentially transparent such as generation of random numbers.		SCL functions are [http://en.wikipedia.org/wiki/Referential_transparency_(computer_science) referentially transparent] which means that they are like mathematical functions always returning the same value for the same parameters and not causing any observable side-effects. This seems extremely restrictive because most of the programs are written in order to generate some kind of side-effects and even completely mathematical algorithms involve functions that are not referentially transparent such as generation of random numbers.

	This policy does not however restrict expressive power of the language because functions can return and manipulate ''descriptions of computations''. These computations are then executed some external means. Two different ways of handling side-effects in SCL are monads and effect types. The former concept is described [http://www.haskell.org/haskellwiki/Monad_tutorials_timeline (in)numerable] times in different Haskell tutorials, ~~so we avoid creating yet another tutorial by pointing some good ones:~~		This policy does not however restrict expressive power of the language because functions can return and manipulate ''descriptions of computations''. These computations are then executed some external means. Two different ways of handling side-effects in SCL are monads and effect types. The former concept is described [http://www.haskell.org/haskellwiki/Monad_tutorials_timeline (in)numerable] times in different Haskell tutorials, for example [http://ertes.de/articles/monads.html], and is defined with the machinery already described.
	* [http://ertes.de/articles/monads.html]

Hannu Niemisto: /* Effect types */

2012-09-05T09:27:09Z

Effect types

← Older revision		Revision as of 09:27, 5 September 2012
Line 76:		Line 76:
	SCL functions are [http://en.wikipedia.org/wiki/Referential_transparency_(computer_science) referentially transparent] which means that they are like mathematical functions always returning the same value for the same parameters and not causing any observable side-effects. This seems extremely restrictive because most of the programs are written in order to generate some kind of side-effects and even completely mathematical algorithms involve functions that are not referentially transparent such as generation of random numbers.		SCL functions are [http://en.wikipedia.org/wiki/Referential_transparency_(computer_science) referentially transparent] which means that they are like mathematical functions always returning the same value for the same parameters and not causing any observable side-effects. This seems extremely restrictive because most of the programs are written in order to generate some kind of side-effects and even completely mathematical algorithms involve functions that are not referentially transparent such as generation of random numbers.

	This policy does not however restrict expressive power of the language because functions can return and manipulate ~~description~~ of computations ~~to be done~~. These computations is then executed some means ~~external to SCL~~. Two different ways of handling side-effects in SCL are monads and effect types. The former concept is described [http://www.haskell.org/haskellwiki/Monad_tutorials_timeline (in)numerable] times in different Haskell tutorials, so we avoid creating yet another tutorial by pointing some good ones:		This policy does not however restrict expressive power of the language because functions can return and manipulate ''descriptions of computations''. These computations are then executed some external means. Two different ways of handling side-effects in SCL are monads and effect types. The former concept is described [http://www.haskell.org/haskellwiki/Monad_tutorials_timeline (in)numerable] times in different Haskell tutorials, so we avoid creating yet another tutorial by pointing some good ones:
	* [http://ertes.de/articles/monads.html]		* [http://ertes.de/articles/monads.html]

Hannu Niemisto: /* Effect types */

2012-09-05T09:26:10Z

Effect types

← Older revision		Revision as of 09:26, 5 September 2012
Line 74:		Line 74:
	== Effect types ==		== Effect types ==

	SCL functions are [http://en.wikipedia.org/wiki/Referential_transparency_(computer_science) referentially transparent] which means that they are like functions ~~in mathematics~~ always returning the same value for the same parameters and not causing any observable side-effects. This seems extremely restrictive because most of the programs are written in order to generate some kind of side-effects and even completely mathematical algorithms involve functions that are not referentially transparent such as generation of random numbers.		SCL functions are [http://en.wikipedia.org/wiki/Referential_transparency_(computer_science) referentially transparent] which means that they are like mathematical functions always returning the same value for the same parameters and not causing any observable side-effects. This seems extremely restrictive because most of the programs are written in order to generate some kind of side-effects and even completely mathematical algorithms involve functions that are not referentially transparent such as generation of random numbers.

	This policy does not however restrict expressive power of the language because functions can return and manipulate description of computations to be done. These computations is then executed some means external to SCL. Two different ways of handling side-effects in SCL are monads and effect types. The former concept is described [http://www.haskell.org/haskellwiki/Monad_tutorials_timeline (in)numerable] times in different Haskell tutorials, so we avoid creating yet another tutorial by pointing some good ones:		This policy does not however restrict expressive power of the language because functions can return and manipulate description of computations to be done. These computations is then executed some means external to SCL. Two different ways of handling side-effects in SCL are monads and effect types. The former concept is described [http://www.haskell.org/haskellwiki/Monad_tutorials_timeline (in)numerable] times in different Haskell tutorials, so we avoid creating yet another tutorial by pointing some good ones:
	* [http://ertes.de/articles/monads.html]		* [http://ertes.de/articles/monads.html]