
	Where results make sense

Topic: Strict function

Related Topics

F sharp programming language

Lazy evaluation

ML programming language

Purely functional

Haskell programming language

In the News (Sun 20 Dec 09)

Northern Trust

Marvin Harrison

Peter Chernin

Gary Locke

Match Play

Penelope Cruz

Mickey Rourke

AR Rahman

Danny Boyle

Hugh Jackman

	Strict function - Wikipedia, the free encyclopedia
		A strict programming language is one in which user-defined functions are always strict.
		Operationally, a strict function is one which always evaluates its argument, a non-strict function is one which may not evaluate some of its arguments.
		Functions having more than one parameter may be strict or non-strict in each parameter independently, as well as jointly strict in several parameters simultaneously.
	en.wikipedia.org /wiki/Strict_function (225 words)

	PlanetMath: convex function (Site not responding. Last check: 2007-10-13)
		is a strictly convex function, or a strictly concave function, respectively.
		We may generalize the above definition of a convex function to an that of an extended real-valued function whose domain is not necessarily a convex set.
		This is version 22 of convex function, born on 2001-10-15, modified 2006-10-29.
	planetmath.org /encyclopedia/StrictlyConvexFunction.html (300 words)

	Evaluation strategy - Wikipedia, the free encyclopedia
		Under Church encoding, eager evaluation of operators maps to strict evaluation of functions; for this reason, strict evaluation is sometimes called "eager".
		If a parameter to a function call is a reference that might be accessible by another thread of execution, its contents are copied to a new reference that is not; when the function call returns, the updated contents of this new reference are copied back to the original reference ("restored").
		Under Church encoding, lazy evaluation of operators maps to non-strict evaluation of functions; for this reason, non-strict evaluation is sometimes referred to as "lazy".
	en.wikipedia.org /wiki/Strict_evaluation (1401 words)

	29+ Evidences for Macroevolution: Glossary
		Strict convergence of both function and structure is very rare, except in trivial cases.
		Functions are not simply anything that appears "useful"; this is a subjective teleological notion.
		A function of a certain structure is a particular consequence of that structure responsible for that structure's continued existence in terms of reproductive success.
	www.talkorigins.org /faqs/comdesc/glossary.html (1441 words)

	CS242: Vocabulary
		The failure of traditional stack-based implementations of procedure calls in the presence of "first-class" functions (functions that can be passed as procedure parameters and returned as procedure results).
		Function that takes other functions as arguments or returns a function as its result.
		A function is parametrically polymorphic if it has one implementation that can be applied to arguments of different types.
	www.stanford.edu /class/cs242/readings/vocabulary.html (1468 words)

	[No title] (Site not responding. Last check: 2007-10-13)
		However, when the basic type of a function is declared, then a more strict type checking will be enforced inside of that function.
		The function call_other() is defined to return an unknown type, as the compiler has no way of knowing the return type.
		Functions that are private in object A can not be called through call_other() in another object.
	aragorn.uio.no /nanvaent/manpages/lpc/types/general (839 words)

	Tackling JavaScript strict warnings- Page 2
		That is, a function which returns a value must have that return as the last line, but if it does not return a value at all, it's ok and will not have any warnings.
		This is the same as the "function functionName does not always return a value", except you did not declare a function name in the function definition.
		This means your usage of the function was not necessarily correct.
	javascriptkit.com /javatutors/serror2.shtml (266 words)

	Standard ML
		ML has higher-order functions: functions can be passed as arguments, stored in data structures, and returned as results of function calls.
		Functions can be statically nested within other functions; this lexical scoping mechanism gives the ability to create "new" functions at run time.
		Function polymorphism allows a single function declaration (such as filter_list) to operate on lists of integers, lists of strings, lists of integer-lists, and so on, avoid needless duplication of code.
	www.spelman.edu /~compsci/cis346/smlnj/sml.html (778 words)

	No Title
		As we saw, a function's argument is evaluated before it is substituted in the function's body (or ``passed'', in the case of built-in functions).
		Strict evaluation seems more efficient when the argument appears more than once in the body, while lazy evaluation seems better only when the argument does not appear at all.
		is bound to an ordinary function, and the evaluation of this function is strict.
	www.cis.upenn.edu /~cis500/Fall98/lecturenotes/03/html (1412 words)

	[No title]
		A function is said to be strict if the result is undefined when it is applied to undefined argument(s) and said to be non-strict otherwise.¡`Ì ©W ª,T Hóª ¨Lazy Evaluation Strategy Lazy evaluation is one where evaluation of an argument only starts when it is required first time.
		In lazy languages, function arguments may be infinite data structures (especially lists), the components of which are evaluated as needed.
		Argument of terminate is another function findroot that generate a list of possible solutions by using function gen. In eager evaluation, sqrt is a non terminating function but it terminates for lazy evaluation.
	www.cse.iitd.ernet.in /~saroj/lazy.ppt (3685 words)

	Lecture Notes for CSE 130
		The last segment of the definition shows how a function is defined when there a multiple cases (or conditions) to consider.
		Note this style where a function is defined in terms of "simpler" functions with "where" (3-5).
		An easy utility function is tail, which takes a list, removes the first element, and returns the rest of the list (yes, there is also a function called head).
	users.sdsc.edu /~ludaesch/CSE130/ln5.html (1883 words)

	[No title]
		Functional programming languages, such as Haskell and ML, make a radical departure from imperative languages such as C/C++, Pascal, and to a lesser degree, Lisp (Lisp was the first functional language, but it is not purely functional).
		Functions are defined in a recursive-inductive fashion, where a base case and one or more inductive cases are provided.
		In this function, the execution duration is passed as a separate parameter to the function, and it is not a value in the search tuple.
	www.engr.uconn.edu /~jeffm/Papers/funcprog.html (4797 words)

	Perl Basics
		All the commands are really functions, and they can be called with or without the parentheses, so long as there is no ambiguity.
		Functions can be used before defined, but normally they are defined in packages which are imported into Perl script files which use them.
		function in our example package creates an object in such a way (although there are no requirements that it do so).
	www.cs.wcupa.edu /~rkline/Perl/perl-basics.html (2451 words)

	Computation Structures Group- MIT- LCS
		pH is an attempt to draw together the lazy functional community (as represented by Haskell) and the dataflow community (as represented by Id and Sisal).
		Strictness analysis techniques widen the scope of this idea, by allowing parallel evaluation of any strict function argument.
		Strict (almost)-functional languages, such as SML or Scheme, often re-introduce assignment, but at the cost of specifying a precise sequential evaluation order for all programs, even when it would not otherwise be required.
	www.csg.lcs.mit.edu /projects/languages/ph-manifesto.html (1275 words)

	gmane.comp.lang.haskell.cafe
		I've seen two definitions of a 'strict function', which I'm trying to unite in my mind: 1) f is strict iff f __ = __.
		2) f is strict iff it forces evaluation of its arguments.
		It allows you to look at a function and ask: if I demand the result in WHNF (which I know will happen if the function is called at runtime) what demand will that place on other expressions, variables and arguments.
	comments.gmane.org /gmane.comp.lang.haskell.cafe/14013 (1188 words)

	Lambda Calculus
		A function abstraction is an expression for a function.
		A strict function evaluates all of its arguments; the conditional is therefore a non-strict function.
		It requires the evaluation of an actual parameter before it is passed to, or substituted in, a function.
	www.csse.monash.edu.au /~lloyd/tildeFP/Lambda/Ch/01.Calc.html (1168 words)

	Flash MX 2004 -- Strict data typing
		Although strict data typing is relevant only at compile time, it can increase performance at runtime by making your scripts run faster.
		Using strict typing also helps to ensure that you do not attempt to access properties or methods that are not part of an object's type.
		Another advantage of strict data typing is that Flash MX 2004 automatically shows code hints for built-in objects when they are strictly typed.
	livedocs.macromedia.com /flash/mx2004/main_7_2/00000780.html (716 words)

	LCLint Sample - Strict Checks
		dbase.c: (in function db_keyGet) dbase.c:68,26: Undocumented use of file static db A checked global variable is used in the function, but not listed in its globals clause.
		Although no internal state in the calling function is used or modified directly, internal state in a called function is used or modified.
		eref.c: (in function eref_alloc) eref.c:32,48: Parameter to sizeof is type employee: sizeof(employee) Parameter to sizeof operator is a type.
	lclint.cs.virginia.edu /samples/db/strictchecks/index.html (779 words)

	Haskell: [Q] strictness of monadic bind
		Now I come to the result that for a monad to work, bind must be strict in (at least) one argument: a <- e fun e >>= fun both must be strict in e I didnt find anything about that by scimming the report, but the GHC manual mentiones stuff like that.
		A function f is strict when f __ = __, where __ is "bottom" (an erroneous value or non-terminating computation, Haskell's formal semantics doesn't distinguish that).
		Technically all functions have one argument, so they are simply either strict or not, but since Haskell uses currying to express multi-argument functions, we may also say that a function is strict wrt.
	www.codecomments.com /message246079.html (1311 words)

	MUSHclient : Lua : Script to check that you use local variables inside functions
		This helps prevent common errors like misspelling variable names in functions, or accidentally assigning to a global variable when a local one would be more sensible.
		require "strict" function f () a = 2 --> error: assign to undeclared variable 'a' print (b) --> error: variable 'b' is not declared function g () --> error: assign to undeclared variable 'g' end -- g end -- f f ()
		A sensible strategy in these cases would be to put "local" in front of variables and functions that are really supposed to only exist inside the scope of the local function.
	www.gammon.com.au /forum/?id=7335 (388 words)

	Tackling JavaScript strict warnings (Site not responding. Last check: 2007-10-13)
		Before we get into the types of strict warnings, let me show you how to find them first.
		outside the function (even after the function definition, since functions don't execute until we call them).
		statement on a variable name you defined earlier in the function or at a higher scope (say, in the global scope outside all functions).
	javascriptkit.com /javatutors/serror.shtml (413 words)

	PostgreSQL 8.0.7 Documentation
		The first time a user-defined function in a particular loadable object file is called in a session, the dynamic loader loads that object file into memory so that the function can be called.
		In the case of a function returning a set of tuples, the setup steps can all be done once during the first call of the function.
		When function arguments or return types are defined as polymorphic types, the function author cannot know in advance what data type it will be called with, or need to return.
	www.commandprompt.com /community/pgdocs8/xfunc-c (4633 words)

	PHP Resources -> PHP Reference (Site not responding. Last check: 2007-10-13)
		This function will be faster, as it doesn't compare all elements, it stops when it founds the good one.
		Reply/addition to melissa at hotmail dot com's note about in_array being much slower than using a key approach: associative arrays (and presumably normal arrays as well) are hashes, their keys are indexed for fast lookups as the test showed.
		I needed a function where I could see if only part of an array element matched so I wrote this function to do it, it also searches keys of the array if required (only useful for associative arrays).
	www.php-resources.org /php_reference/res_function.in-array.php (2321 words)

	Perl Data (Site not responding. Last check: 2007-10-13)
		They are also distinct from function names or Perl keywords ($sort is distinct from the sort built-in function, $while is not the keyword while).
		Note: The textbook and online reference are not clear which functions modify the parameter passed to it (for example chomp and chop) and which ones return the modified parameter.
		Note that the use of my restricts the scope of a variable when used within a function, for example, using my in front of $var on line 19 restricts the scope of $var to that function.
	www.cs.engr.uky.edu /~paulp/CS216PerlData.html (1085 words)

	Flashcomguru.com - Strict Typing and the Communication Classes
		If you want strict type checking you can't dynamically add properties and methods that you have not declared and expect the compiler not to complain - at least not with the dot operator.
		If you want strict type checking and you want to add properties and methods to a NetStream you have to declare that you are going to do that in advance or use the [] operator.
		Strict type checking is always more work up front on the theory that it will pay off later.
	www.flashcomguru.com /articles/strict_typing.cfm (1471 words)

	No Title (Site not responding. Last check: 2007-10-13)
		All function prototypes must be declared outside of functions; they may be placed in header files.
		If a (named) constant is going to be passed as an argument to a function, declare it with const rather than defining it with #define, so that type-checking may be performed.
		I included such comments so that the samples could be used as tutorials on the use of these library functions and system calls.
	www.eecs.tulane.edu /courses/cpsc355/handouts/programming_guide.html (1418 words)

	merd, polymorphism and type inference
		In a closed world we know every instance of a function, whereas in a open world we must allow the programmer to add new instance without changing the local meaning.
		The function calls are separated in two categories: permissive and strict.
		This solution is of course less precise: this would make the "times" function strict.
	merd.sourceforge.net /polymorphism.html (1396 words)

	S-Box Design: A Literature Survey
		Cusick works on counting the number of functions "which satisfy the SAC of order n-4." This is related to the probability that a random selection will have the given SAC level.
		This could become important if these inverse functions are used in the decryption process, for it would be desirable for any changes in the ciphertext to affect all bits in the plaintext in a random fashion, especially if there is not much redundancy in the original plaintext.
		A function is said to satisfy the SAC if complementing a single bit results in the output of the function being complemented with a probability of a half.
	www.ciphersbyritter.com /RES/SBOXDESN.HTM (6597 words)

	Pragmas
		However, deprecations are not reported for (a) uses of a deprecated function within its defining module, and (b) uses of a deprecated function in an export list.
		Normally, if GHC decides a function is “too expensive” to inline, it will not do so, nor will it export that unfolding for other modules to use.
		constructor is scrutinised and the floats passed to a non-strict function for example, they will have to be reboxed (this is done automatically by the compiler).
	www.reed.edu /~carlislp/ghc6-doc/users_guide/pragmas.html (1005 words)

Try your search on: Qwika (all wikis)