Design

Scheme (to pronounce “skim'”) is a Computer programming language derived from the functional language Lisp, created in the Années 1970 with the Massachusetts Institute off Technology (MIT) by Gerald Jay Sussman and Guy L. Steele.

The goal of the creators of the language was to purify the Lisp language by preserving the essential aspects, flexibility and the expressive power. Design thus has an extremely simple syntax, with a very limited number of key words. As in Lisp, the prefixed notation makes it possible to be freed from the operators of precedence. Moreover, the power of the macros of Design enables him to adapt to any problem, in particular to return it Orienté object and thus multi-paradigm.

The specification of Design specifies that all the products must optimize the case of the final Récursion.

The types of source data of Design are the Boolean ones, the numbers, which can be whole of indefinite size, rational or complex, the characters or the symbols, which are variables.

To these types of composite data are added following: character strings, vectors, directed pairs, associative lists, lists, tables of chopping and a generic particular type, the S-expression, of which all the other standards derive, making possible the Métaprogrammation , i.e. the possibility of extending the language with new special operators.

Examples of code

The variable are typified dynamically and their range is lexical:

(define var1 been worth)

(let ((var2 been worth)) …)

Lists : (idiots 1 (idiots 2 (idiots 3 (idiots 4 '()))))

This concatenation can be shortened in (list 1 2 3 4) or in '(1 2 3 4)

Functions : they are defined like lambda-expressions (define fun (lambda (arg1 arg2) …)) or more simply (define (fun arg1 arg2) …)

Application to a list: (apply fun (list value1 value2))

conditional Evaluations : (cond (test1 expr1) (test2 expr2) … (else exprn)) and too (yew condition then-expr else-expr)

Example 1 - calculation of a factorial: (define (factorial N) (yew (= N 0) 1 (* N (factorial (- N 1))))) (factorial 5) ; ; => 120

Example 2 - definition of a function map, which applies an lambda-expression (which raises its argument squared) to all the elements of a list: (define (map F lst) (cond ((no one? lst) lst) (else (idiots (F (because lst)) (map F (cdr lst)))))) (map (lambda (X) (* X X)) '(1 2 3 4)) ; ; => (1 4 9 16)

Tail-recursive versions of the two preceding examples: (define (factorial N) (let loop ((fact 1) (N N)) (cond ((= N 0) fact) (else (loop (* N fact) (- N 1)))))) (factorial 5) ; ; => 120

(define (map F lst) (C ((lst lst (cdr lst)) (LMBO '() (idiots (F (because lst)) LMBO))) ((no one? lst) (reverse LMBO)))) (map (lambda (X) (* X X)) '(1 2 3 4)) ; ; => (1 4 9 16)

Implementations

Design is, with Common Lisp, most popular Lisp. The language is defined by document R6RS ( Revised6 Report one the Algorithmic Language Scheme : Sixth revision of the report/ratio on the algorithmic language Design ).

The principal implementations of Design are:

  • At Design, an interpreter free Design and commercial compiler for Microsoft Windows and several systems Unix
  • Chicken is compiler Design-towards-C.
  • Guile is the language of extension of project GNU. The Scheme interpreter is a library which can be used like language as script for applications.
  • PLT Design, a succession of programs including an interpreter (MzScheme), graphic development tools (MrEd), an editor directed pedagogy (DrScheme), and different components including of the libraries Component object model (COM) and ODBC.
  • Scsh or Shell Design is a product R5RS usable like language of script system and interpreter of orders.
  • Gauche is a multilingual product R5RS under license BSD, for programmers and system administrators.
  • Bigloo is a compiler Design-towards-C and Design-towards-Java which produces achievable compact and fast ones, equipped of a relatively significant number of libraries.
  • STklos is a free product of the Scheme language of the University of Nice which is light and effective.
  • the software of Retouche of image S Gimp includes an interpreter of a language derived from Design, SIOD (Design In One Defun) for scripter (called script-fu) certain handling of image.
  • Of other products is on schemers.org FAQ

External bonds

  • the standard Design.
  • a collection of resources.
  • Design Requests for Implementation (SRFI)
  • “Structure and Interpretation off Computer Programs” Abelson and Sussman. A course of exceptional quality, with video online. This book exceeds the framework of the teaching of the language, and teaches the bases of the computer programming languages. Is used as support of course since many years to MIT.
  • '' How to Design Programs ''. Another course of Design.
  • '' Teach Yourself Design ''. Another course, intended for the beginners.
  • '' The Scheme Programming Language '' writes by R. Kent Dybvig.
  • a library of articles of research gives bonds towards the original articles which gave rise to the language.
  • Course of Design Some courses of design based on the courses given in 1st year of deug mias
  • Course of design into video by Abelson & Sussman of MIT
  • a French forum on Design

Beats-smg: Design

Random links:1831 en literatura | Large scales | Freddy, the nightmare of your nights | Aoufous | Aidan O' Brien | Radio trg