The current stable release series. Guile's reference manual is also included in each Guile distribution and should be accessible via Emacs' Info mode once you have installed Guile. A recent Scheme standard supported by Guile. This report includes an overview of Scheme and a formal definition of the language and its standard libraries. Contains proposals for a number of Scheme extensions. Many of these tend to exist in one form or the other in a lot of the different Schemes, but can have wildly different interfaces.
The SRFI process is essentially aimed at making these non-standard features more standard, without actually being standard see also: obfuscated. They are supposed to just accept it, or to report problems and hope that the source code owners will choose to work on them. Free software aims to work reliably just as much as non-free software does, but it should also empower its users by making its workings available. This is useful for many reasons, including education, auditing and enhancements, as well as for debugging problems.
The ideal free software system achieves this by making it easy for interested users to see the source code for a feature that they are using, and to follow through that source code step-by-step, as it runs. In Emacs, good examples of this are the source code hyperlinks in the help system, and edebug.
Then, for bonus points and maximising the ability for the user to experiment quickly with code changes, the system should allow parts of the source code to be modified and reloaded into the running program, to take immediate effect.
Guile is designed for this kind of interactive programming, and this distinguishes it from many Scheme implementations that instead prioritise running a fixed Scheme program as fast as possible—because there are tradeoffs between performance and the ability to modify parts of an already running program.
Since the 2. The file will be named guile- version. The current version is 3. This will install the Guile executable guile , the Guile library libguile and various associated header files and support libraries. It will also install the Guile reference manual.
This will also be installed in your info directory. A whirlwind tour shows how Guile can be used interactively and as a script interpreter, how to link Guile into your own applications, and how to write modules of interpreted and compiled code for use with Guile.
Everything introduced here is documented again and in full by the later parts of the manual. For readers new to Scheme, this chapter provides an introduction to the basic ideas of the Scheme language. This material would apply to any Scheme implementation and so does not make reference to anything Guile-specific. Provides an overview of programming in Scheme with Guile. It covers how to invoke the guile program from the command-line and how to write scripts in Scheme.
It also introduces the extensions that Guile offers beyond standard Scheme. Provides an overview of how to use Guile in a C program. It discusses the fundamental concepts that you need to understand to access the features of Guile, such as dynamic types and the garbage collector.
It explains in a tutorial like manner how to define new data types and functions for the use by Scheme programs. This part of the manual documents the Guile API in functionality-based groups with the Scheme and C interfaces presented side by side. Describes some important modules, distributed as part of the Guile distribution, that extend the functionality provided by the Guile Scheme core. Describes GOOPS, an object oriented extension to Guile that provides classes, multiple inheritance and generic functions.
In examples and procedure descriptions and all other places where the evaluation of Scheme expression is shown, we use some notation for denoting the output and evaluation results of expressions. Some procedures produce some output besides returning a value.
Next: Hello Scheme! This chapter presents a quick tour of all the ways that Guile can be used. It also explains how best to report any problems that you find. In its simplest form, Guile acts as an interactive interpreter for the Scheme programming language, reading and evaluating Scheme expressions the user enters from the terminal. A Guile script is simply a file of Scheme code with some extra information at the beginning which tells the operating system how to invoke Guile, and then tells Guile how to handle the Scheme code.
Here is a trivial Guile script. See Guile Scripting , for more details. The Guile interpreter is available as an object library, to be linked into applications using Scheme as a configuration or extension language. Here is simple-guile. In addition to all usual functions provided by Guile, it will also offer the function my-hostname.
When Guile is correctly installed on your system, the above program can be compiled and linked like this:. When it is run, it behaves just like the guile program except that you can also call the new my-hostname function.
You can link Guile into your program and make Scheme available to the users of your program. You can also link your library into Guile and make its functionality available to all users of Guile. A library that is linked into Guile is called an extension , but it really just is an ordinary object library. The following example shows how to write a simple extension for Guile that makes the j0 function available to Scheme code.
This C source file needs to be compiled into a shared library. A shared library can be loaded into a running Guile process with the function load-extension. The j0 is then immediately available:. For more on how to install your extension, see Installing Site Packages.
Guile has support for dividing a program into modules. By using modules, you can group related code together and manage the composition of complete programs from largely independent parts. For more details on the module system beyond this introductory material, See Modules.
Guile comes with a lot of useful modules, for example for string processing or command line parsing. Additionally, there exist many Guile modules written by other Guile hackers, but which have to be installed manually. Here is a sample interactive session that shows how to use the ice-9 popen module which provides the means for communicating with other processes over pipes together with the ice-9 rdelim module that provides the function read-line.
You can create new modules using the syntactic form define-module. All definitions following this form until the next define-module are placed into the new module. One module is usually placed into one file, and that file is installed in a location where Guile can automatically find it. The following session shows a simple example. For more on how to install your module, see Installing Site Packages.
You do this by writing a small Scheme file that defines the module and call load-extension directly in the body of the module. Any problems with the installation should be reported to bug-guile gnu. If you find a bug in Guile, please report it to the Guile developers, so they can fix it. They may also be able to suggest workarounds when it is not possible for you to apply the bug-fix or install a new version of Guile yourself. Before sending in bug reports, please check with the following list that you really have found a bug.
Before reporting the bug, check whether any programs you have loaded into Guile, including your. Also, see whether the problem happens in a freshly started Guile without loading your. If the problem does not occur then, you must report the precise contents of any programs that you must load into Guile in order to cause the problem to occur.
When you write a bug report, please make sure to include as much of the information described below in the report. If you have a Scheme program that produces the bug, please include it in the bug report. If your program is too big to include, please try to reduce your code to a minimal test case.
If you can reproduce your problem at the REPL, that is best. Give a transcript of the expressions you typed at the REPL. If the manifestation of the bug is a Guile error message, it is important to report the precise text of the error message, and a backtrace showing how the Scheme program arrived at the error. If your bug causes Guile to crash, additional information from a low-level debugger such as GDB might be helpful. Instead of invoking Guile as usual, invoke the wrapper script, type run to start the process, then backtrace when the crash comes.
Include that backtrace in your report. In this chapter, we introduce the basic concepts that underpin the elegance and power of the Scheme language. Readers who already possess a background knowledge of Scheme may happily skip this chapter. For the reader who is new to the language, however, the following discussions on data, procedures, expressions and closure are designed to provide a minimum level of Scheme understanding that is more or less assumed by the chapters that follow.
The style of this introductory material aims about halfway between the terse precision of R5RS and the discursiveness of existing Scheme tutorials. For pointers to useful Scheme resources on the web, please see Further Reading. This section discusses the representation of data types and values, what it means for Scheme to be a latently typed language, and the role of variables.
We conclude by introducing the Scheme syntaxes for defining a new variable, and for changing the value of an existing variable. Sometimes, of course, you can tell from the code what the type of an expression will be. If you have a line in your program that sets the variable x to the numeric value 1, you can be certain that, immediately after that line has executed and in the absence of multiple threads , x has the numeric value 1.
Or if you write a procedure that is designed to concatenate two strings, it is likely that the rest of your application will always invoke this procedure with two string parameters, and quite probable that the procedure would go wrong in some way if it was ever invoked with parameters that were not both strings. Nevertheless, the point is that there is nothing in Scheme which requires the procedure parameters always to be strings, or x always to hold a numeric value, and there is no way of declaring in your program that such constraints should always be obeyed.
Instead, the types of variables and expressions are only known — in general — at run time. If you need to check at some point that a value has the expected type, Scheme provides run time procedures that you can invoke to do so. But equally, it can be perfectly valid for two separate invocations of the same procedure to specify arguments with different types, and to return values with different types.
The next subsection explains what this means in practice, for the ways that Scheme programs use data types, values and variables. Scheme provides many data types that you can use to represent your data. Primitive types include characters, strings, numbers and procedures. Compound types, which allow a group of primitive and compound values to be stored together, include lists, pairs, vectors and multi-dimensional arrays.
In addition, Guile allows applications to define their own data types, with the same status as the built-in standard Scheme types. As a Scheme program runs, values of all types pop in and out of existence. Sometimes values are stored in variables, but more commonly they pass seamlessly from being the result of one computation to being one of the parameters for the next.
Consider an example. Then a numeric value is created as the result of calculating the length of the string. A second numeric value is created by doubling the calculated length. Finally the program creates a list with two elements — the doubled length and the original string itself — and stores this list in a program variable.
All of the values involved here — in fact, all values in Scheme — carry their type with them. A number, a string, a list, whatever. A variable, on the other hand, has no fixed type. A variable — x , say — is simply the name of a location — a box — in which you can store any kind of Scheme value. So the same variable in a program may hold a number at one moment, a list of procedures the next, and later a pair of strings.
For example:. In Scheme, a semicolon marks the beginning of a comment that continues until the end of the line. So the lines beginning ;; are comments. Changing the value of an already existing variable is very similar, except that define is replaced by the Scheme syntax set! Remember that variables do not have fixed types, so new-value may have a completely different type from whatever was previously stored in the location named by variable-name.
Both of the following examples are therefore correct. In these examples, value and new-value are literal numeric or string values. In general, however, value and new-value can be any Scheme expression. Even though we have not yet covered the forms that Scheme expressions can take see About Expressions , you can probably guess what the following set!
Note: this is not a complete description of define and set! If, however, you are already familiar with the structure of Scheme, you may like to read about those missing pieces immediately by jumping ahead to the following references. This section introduces the basics of using and creating Scheme procedures. It discusses the representation of procedures as just another kind of Scheme value, and shows how procedure invocation expressions are constructed. We then explain how lambda is used to create new procedures, and conclude by presenting the various shorthand forms of define that can be used instead of writing an explicit lambda expression.
One of the great simplifications of Scheme is that a procedure is just another type of value, and that procedure values can be passed around and stored in variables in exactly the same way as, for example, strings and lists.
When we talk about a built-in standard Scheme procedure such as open-input-file , what we actually mean is that there is a pre-defined top level variable called open-input-file , whose value is a procedure that implements what R5RS says that open-input-file should do. Note that this is quite different from many dialects of Lisp — including Emacs Lisp — in which a program can use the same name with two quite separate meanings: one meaning identifies a Lisp function, while the other meaning identifies a Lisp variable, whose value need have nothing to do with the function that is associated with the first meaning.
In these dialects, functions and variables are said to live in different namespaces. In Scheme, on the other hand, all names belong to a single unified namespace, and the variables that these names identify can hold any kind of Scheme value, including procedure values. For example, call-with-current-continuation is a very important standard Scheme procedure, but it also has a very long name!
Or you could just leave call-with-current-continuation as it was. In this expression, procedure can be any Scheme expression whose value is a procedure. Most commonly, however, procedure is simply the name of a variable whose value is a procedure. For example, string-append is a standard Scheme procedure whose behaviour is to concatenate together all the arguments, which are expected to be strings, that it is given. So the expression. Similarly, string-length is a standard Scheme procedure that returns the length of a single string argument, so.
Each of the parameters in a procedure invocation can itself be any Scheme expression. Since a procedure invocation is itself a type of expression, we can put these two examples together to get. You may be wondering what happens if the two examples are combined the other way round.
If we do this, we can make a procedure invocation expression that is syntactically correct:. Scheme has lots of standard procedures, and Guile provides all of these via predefined top level variables. All of these standard procedures are documented in the later chapters of this reference manual.
To do this, you can use the famous lambda syntax. The behaviour of the new procedure is determined by the sequence of expressions and definitions in the body of the procedure definition. When invoked, the new procedure returns a value that is the value of the last expression in the body.
Then the full lambda expression might look like this:. We noted in the previous subsection that the procedure part of a procedure invocation expression can be any Scheme expression whose value is a procedure. So we can use a lambda expression directly in a procedure invocation, like this:. Since it is so common in Scheme programs to want to create a procedure and then store it in a variable, there is an alternative form of the define syntax that allows you to do just that.
So, for example, the definition of make-combined-string in the previous subsection could equally be written:. This kind of procedure definition creates a procedure that requires exactly the expected number of arguments.
There are two further forms of the lambda expression, which create a procedure that can accept a variable number of arguments:. Prior to Guile 2. These are no longer provided by default, and instead have been moved to Curried Definitions. It could be argued that the alternative define forms are rather confusing, especially for newcomers to the Scheme language, as they hide both the role of lambda and the fact that procedures are values that are stored in variables in the same way as any other kind of value.
So far, we have met expressions that do things, such as the define expressions that create and initialize new variables, and we have also talked about expressions that have values , for example the value of the procedure invocation expression:. It discusses the side effects that evaluation can have, explains how each of the various types of Scheme expression is evaluated, and describes the behaviour and use of the Guile REPL as a mechanism for exploring evaluation.
In Scheme, the process of executing an expression is known as evaluation. Evaluation has two kinds of result:. Of the expressions that we have met so far, define and set! In general, though, this is extremely difficult.
It is also unnecessary; instead, we can quite happily define the behaviour of a Scheme program by specifying how Scheme executes a program as a whole, and then by describing the value and side effects of evaluation for each type of expression individually. When a literal data expression is evaluated, the value of the expression is simply the value that the expression describes. The evaluation of a literal data expression has no side effects.
This manual specifies the read syntax for each such data type in the section that describes that data type. Some data types do not have a read syntax. Procedures, for example, cannot be expressed as literal data; they must be created using a lambda expression see Creating a Procedure or implicitly using the shorthand form of define see Lambda Alternatives. When an expression that consists simply of a variable name is evaluated, the value of the expression is the value of the named variable.
The evaluation of a variable reference expression has no side effects. If key is then modified by. If there is no variable with the specified name, evaluation of the variable reference expression signals an error. This is where evaluation starts getting interesting! As already noted, a procedure invocation expression has the form. The value of the procedure invocation expression is the value of the last evaluated expression in the procedure body. The side effects of calling the procedure are the combination of the side effects of the sequence of evaluations of expressions in the procedure body.
Note that the complete side effects of evaluating a procedure invocation expression consist not only of the side effects of the procedure call, but also of any side effects of the preceding evaluation of the expressions procedure , arg1 , arg2 , and so on. In the evaluation of the outermost expression, the interpreter can now invoke the procedure value obtained from procedure with the value obtained from arg1 as its arguments. The resulting value is a numeric value that is the length of the argument string, which is When a procedure invocation expression is evaluated, the procedure and all the argument expressions must be evaluated before the procedure can be invoked.
Special syntactic expressions are special because they are able to manipulate their arguments in an unevaluated form, and can choose whether to evaluate any or all of the argument expressions. Why is this needed? Consider a program fragment that asks the user whether or not to delete a file, and then deletes the file if the user answers yes.
If the outermost if … expression here was a procedure invocation expression, the expression delete-file file , whose side effect is to actually delete a file, would already have been evaluated before the if procedure even got invoked! Therefore if must be special syntax, not a procedure.
Other special syntaxes that we have already met are define , set! The rules for evaluating each special syntactic expression are specified individually for each special syntax. For a summary of standard special syntax, see See Syntax Summary. Consider for example,. If the list has more than one element, my-last applies itself to the cdr. In Scheme this can be used on an arbitrarily long list argument. A proper tail call is only available from certain contexts, namely the following special form positions,.
The above are just core functions and special forms. It will be noted there are a lot of places which could potentially be tail calls, for instance the last call in a for-each , but only those explicitly described are guaranteed. In this mode, Guile repeatedly reads in the next Scheme expression that the user types, evaluates it, and prints the resulting value. The REPL is a useful mechanism for exploring the evaluation behaviour described in the previous subsection. Wherever you see an example of the form.
This subsection lists the most commonly used Scheme syntactic expressions, simply so that you will recognize common special syntax when you see it. For a full description of each of these syntaxes, follow the appropriate reference. For an introduction to environments, see See About Closure.
Note that this is not the same as a procedure which returns its last argument, because the evaluation of a procedure invocation expression does not guarantee to evaluate the arguments in order.
The procedure created by the lambda expression can refer to and mutate the captured bindings, and the values of those bindings persist between procedure calls. We said earlier that a variable name in a Scheme program is associated with a location in which any kind of Scheme value may be stored. Although the value that is stored in that location may change, the location to which a given name refers is always the same.
We can illustrate this by breaking down the operation of the define syntax into three parts: define. A collection of associations between names and locations is called an environment. It is also possible to create environments other than the top level one, and to create variable bindings, or name-location associations, in those environments. This ability is a key ingredient in the concept of closure; the next subsection shows how it is done.
We have seen how to create top level variables using the define syntax see Definition. It is often useful to create variables that are more limited in their scope, typically as part of a procedure body. These syntaxes are described in full later in the manual see Local Bindings. Here our purpose is to illustrate their use just enough that we can see how local variables work. For example, the following code uses a local variable s to simplify the computation of the area of a triangle given the lengths of its three sides.
In the example of the previous subsection, we glossed over an important point. The body of the let expression in that example refers not only to the local variable s , but also to the top level variables a , b , c and sqrt. If the body of the let expression is evaluated in the context of the local let environment, how does the evaluation get at the values of these top level variables?
More generally, every environment except for the top level one has a reference to its containing environment, and the interpreter keeps searching back up the chain of environments — from most local to top level — until it either finds a variable binding for the required identifier or exhausts the chain.
This description also determines what happens when there is more than one variable binding with the same name. Suppose, continuing the example of the previous subsection, that there was also a pre-existing top level variable s created by the expression:.
Then both the top level environment and the local let environment would contain bindings for the name s. When evaluating code within the let body, the interpreter looks first in the local let environment, and so finds the binding for s created by the let syntax. When evaluating code outside the let body, the interpreter looks up variable names in the top level environment, so the name s refers to the top level variable. Within the let body, the binding for s in the local environment is said to shadow the binding for s in the top level environment.
This subsection takes a brief diversion to explain what lexical scope means in general and to present an example of non-lexical scoping. You may even be wondering how the situation could possibly — and usefully — be otherwise. To demonstrate that another kind of scoping is possible, therefore, and to compare it against lexical scoping, the following subsection presents an example of non-lexical scoping and examines in detail how its behavior differs from the corresponding lexically scoped code.
Up: Lexical Scope [ Contents ][ Index ]. The question to focus on here is: what does the identifier currency-abbreviation refer to in the currency-string function? The second function french-currency-string works precisely by taking advantage of this behaviour. According to the rules of lexical scoping, the currency-abbreviation in currency-string refers to the variable location in the innermost environment at that point in the code which has a binding for currency-abbreviation , which is the variable location in the top level environment created by the preceding define currency-abbreviation … expression.
In Scheme, therefore, the french-currency-string procedure does not work as intended. This begs the question of how the Emacs Lisp behaviour can be implemented in Scheme. In general, this is a design question whose answer depends upon the problem that is being addressed.
In this case, the best answer may be that currency-string should be redesigned so that it can take an optional third argument.
This third argument, if supplied, is interpreted as a currency abbreviation that overrides the default. It is possible to change french-currency-string so that it mostly works without changing currency-string , but the fix is inelegant, and susceptible to interrupts that could leave the currency-abbreviation variable in the wrong state:.
The key point here is that the code does not create any local binding for the identifier currency-abbreviation , so all occurrences of this identifier refer to the top level variable. After the let expression has been evaluated, the local environment that was created is simply forgotten, and there is no longer any way to access the binding that was created in this environment. If the same code is evaluated again, it will follow the same steps again, creating a second new local environment that has no connection with the first, and then forgetting this one as well.
If the let body contains a lambda expression, however, the local environment is not forgotten. Instead, it becomes associated with the procedure that is created by the lambda expression, and is reinstated every time that that procedure is called. In detail, this works as follows. The result is that the procedure body is always evaluated in the context of the environment that was current when the procedure was created.
This is what is meant by closure. The next few subsections present examples that explore the usefulness of this concept. This example uses closure to create a procedure with a variable binding that is private to the procedure, like a local variable, but whose value persists between procedure calls. When make-serial-number-generator is called, it creates a local environment with a binding for current-serial-number whose initial value is 0, then, within this environment, creates a procedure.
The local environment is stored within the created procedure object and so persists for the lifetime of the created procedure. Every time the created procedure is invoked, it increments the value of the current-serial-number binding in the captured environment and then returns the current value.
Note that make-serial-number-generator can be called again to create a second serial number generator that is independent of the first. Every new invocation of make-serial-number-generator creates a new local let environment and returns a new procedure object with an association to this environment.
This example uses closure to create two procedures, get-balance and deposit , that both refer to the same captured local environment so that they can both access the balance variable binding inside that environment. The value of this variable binding persists between calls to either procedure. Note that the captured balance variable binding is private to these two procedures: it is not directly accessible to any other code.
It can only be accessed indirectly via get-balance or deposit , as illustrated by the withdraw procedure. An important detail here is that the get-balance and deposit variables must be set up by define ing them at top level and then set! Using define within the let body would not work: this would create variable bindings within the local let environment that would not be accessible at top level. A frequently used programming model for library code is to allow an application to register a callback function for the library to call when some particular event occurs.
It is often useful for the application to make several such registrations using the same callback function, for example if several similar library events can be handled using the same application code, but the need then arises to distinguish the callback function calls that are associated with one callback registration from those that are associated with different callback registrations. Here is an example of declarations using this solution in C:.
In Scheme, closure can be used to achieve the same functionality without requiring the library code to store a user-data for each callback registration. As far as the library is concerned, handler-proc is a procedure with no arguments, and all the library has to do is call it when the appropriate event occurs. Closure is the capture of an environment, containing persistent variable bindings, within the definition of a procedure or a set of related procedures.
The following example shows how closure can be used to emulate the ideas of objects, methods and encapsulation in Scheme. This procedure acts as an account object with methods get-balance , deposit and withdraw. To apply one of the methods to the account, you call the procedure with a symbol indicating the required method as the first parameter, followed by any other parameters that are required by that method.
In this part of the manual, we explain how to use Guile in this mode, and describe the tools that Guile provides to help you with script writing, debugging, and packaging your programs for distribution. Guile also has many extensions that go beyond these reports. Some of the areas where Guile extends standard Scheme are:. Many features of Guile depend on and can be changed by information that the user provides either before or when Guile is started. Below is a description of what information to provide and how to provide it.
Guile processes its arguments from left to right, recognizing the switches described below. For examples, see Scripting Examples. By default, Guile will read a file named on the command line as a script. Any command-line arguments arg It is possible to name a file using a leading hyphen, for example, -myfile.
In this case, the file name must be preceded by -s to tell Guile that a script file is being named. Scripts are read and evaluated as Scheme source code just as the load function would. After loading script , Guile exits. Evaluate expr as Scheme code, and then exit. Run interactively, prompting the user for expressions and evaluating them. The specified extensions are tried in the order given on the command line, and before the default load extensions.
Make function the entry point of the script. After loading the script file with -s or evaluating the expression with -c , apply function to a list containing the program name and the command-line arguments—the list provided by the command-line function. A -e switch can appear anywhere in the argument list, but Guile always invokes the function as the last action it performs. This is weird, but because of the way script invocation works under POSIX, the -s option must always come last in the list.
The function is most often a simple symbol that names a function that is defined in the script. It can also be of the form module-name symbol , and in that case, the symbol is looked up in the module named module-name. As a shorthand you can use the form symbol It is equivalent to module-name main , where module-name is symbol Treat a final -s option as if it occurred at this point in the command line; load the script here.
This switch is necessary because, although the POSIX script invocation mechanism effectively requires the -s option to appear last, the programmer may well want to run the script before other actions requested on the command line. Read more command-line arguments, starting from the second line of the script file.
See The Meta Switch. The option --use-srfi expects a comma-separated list of numbers, each representing a SRFI module to be loaded into the interpreter before evaluating a script file or starting the REPL. Additionally, the feature identifier for the loaded SRFIs is recognized by the procedure cond-expand when this option is used. See R6RS Incompatibilities , for some caveats. See R7RS Incompatibilities , for some caveats. Start with the debugging virtual machine VM engine. Using the debugging VM will enable support for VM hooks, which are needed for tracing, breakpoints, and accurate call counts when profiling.
The debugging VM is slower than the regular VM, though, by about ten percent. See VM Hooks , for more information. By default, the debugging VM engine is only used when entering an interactive session.
When executing a script with -s or -c , the normal, faster VM is used by default. Note that, despite the name, Guile running with --no-debug does support the usual debugging facilities, such as printing a detailed backtrace upon error. The only difference with --debug is lack of support for VM hooks and the facilities that build upon it see above.
Do not load the initialization file,. This option only has an effect when running interactively; running scripts does not load the. See Init File. While this program runs, listen on a local port or a path for REPL clients. If p starts with a number, it is assumed to be a local port on which to listen.
We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book.
We recommend this License principally for works whose purpose is instruction or reference. This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.
Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics. The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.
If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent.
An image format is not Transparent if used for any substantial amount of text. The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License. You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License.
You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3. You may also lend copies, under the same conditions stated above, and you may publicly display copies.
Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects. If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed as many as fit reasonably on the actual cover, and continue the rest onto adjacent pages.
If you publish or distribute Opaque copies of the Document numbering more than , you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material.
If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy directly or through your agents or retailers of that edition to the public.
It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document. You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it.
In addition, you must do these things in the Modified Version:. If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. These titles must be distinct from any other section titles. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by or through arrangements made by any one entity.
If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.
The author s and publisher s of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.
You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.
0コメント