PDF gerado usando o pacote de ferramentas em código aberto mwlib. Veja http://code.pediapress.com/ para mais informações.PDF generated at: Thu, 21 Oct 2010 09:46:16 UTC

Linguagem de ProgramaçãoLISP

ConteúdoPáginas

Lisp 1Common Lisp 7Scheme 9Clojure 12

ReferênciasFontes e Editores da Página 14Fontes, Licenças e Editores da Imagem 15

Licenças das páginasLicença 16

Lisp 1

Lisp

LispParadigma multiparadigma: funcional, procedural, orientada a objetos

Surgido em 1958

Criado por John McCarthy

Compiladores internos

Dialetos: Common Lisp, Scheme, Emacs Lisp, Autolisp, Arc, Clojure, Newlisp, Lush, Arc

Influenciou Logo, Smalltalk, Ruby, Dylan

Lisp é uma família de linguagens de programação concebida por John McCarthy em 1958. Num célebre artigo, elemostra que é possível usar exclusivamente funções matemáticas como estruturas de dados elementares (o que épossível a partir do momento em que há um mecanismo formal para manipular funções: o Cálculo Lambda deAlonzo Church). Durante os anos de 1970 e 1980, Lisp se tornou a principal linguagem da comunidade deinteligência artificial, tendo sido pioneiro em aplicações como administração automática de armazenamento,linguagens interpretadas e programação funcional.O seu nome vem de LISt Processing (a lista é a estrutura de dados fundamental desta linguagem). Tanto os dadoscomo o programa são representados como listas, o que permite que a linguagem manipule o código fonte comoqualquer outro tipo de dados.Existem diversos dialetos de Lisp, sendo os mais conhecidos o Common Lisp e o Scheme.

HistóriaLisp é uma família de linguagens que possui uma longa história. As primeiras idéias-chave para a linguagem foramdesenvolvidas por John McCarthy em 1956, durante um projeto de pesquisa em inteligência artificial. A primeiraimplementação da linguagem se dá no inverno de 1958.[1] A motivação de McCarthy surgiu da idéia de desenvolveruma linguagem algébrica para processamento de listas para trabalho em IA (inteligência artificial). Esforços para aimplementação de seus primeiros dialetos foram empreendidos no IBM 704, IBM 7090, DEC PDP-1, DEC PDP-6 eDEC PDP-10. O dialeto principal entre 1960 e 1965 foi o Lisp 1.5.No início dos anos 1970, houve outros doisdialetos predominantes, desenvolvidos através de esforços anteriores: MacLisp e Interlisp.Apesar das primeiras implementações do Lisp terem sido realizados nos IBM 704 e 7090, trabalhos posterioresconcentraram-se nos DEC PDP-6 e PDP-10, este último sendo o baluarte do Lisp e das pesquisas em IA (inteligênciaartificial) em lugares como o MIT (Massachussets Institute of Tecnology) e as Universidades de Stanford eCarnegie-Mellon até metade dos anos 1970. O computador PDP-10 e seu antecessor, o PDP-6 eram por definição,especialmente adequados para o Lisp, por possuirem palavras de 36 bits e endereços de 18 bits. Esta arquiteturapermitia um registro de um cons cell (par pontuado) em uma única palavra de memória, em instruções simplesextraíam o seu car e cdr. Esses computadores possuíam também poderosas instruções de pilha, que proporcionavamrápida chamada a funções; porém suas limitações em 1973 eram evidentes: suportavam um pequeno número depesquisadores utilizando o Lisp e seu endereçamento em 18 bits limitava o espaço dos programas. Uma resposta parao problema de endereçamento foi o desenvolvimento do "Lisp Machine",um computador dedicado especialmente àtarefa de trabalhar com a linguagem. Outra solução foi a utilização de computadores de uso geral com maiorcapacidade de endereçamento, como o DEC VAX e o S1 Mark IIA.

Lisp 2

AplicabilidadeLisp é uma linguagem madura, concebida atenciosamente, altamente portável, linguagem de força industrial com aqual desenvolvedores sérios em todo o mundo contam para:• Ferramenta rápida e altamente personalizável para fazer coisas do dia a dia.• Aplicações grandes, complexas e críticas as quais seriam impossíveis desenvolver em outra linguagem.• Prototipação rápida e Rapid Application Development (RAD).• Aplicações de alta disponibilidade, principalmente aquelas que necessitam de mudanças após a etapa inicial.A linguagem teve um grande sucesso em software do ramo de negócios, engenharia, processamento de documentos,hipermídia (incluindo a Web), matemática, gráficos e animação (Mirai), inteligência artificial e processamento delinguagem natural. Uma das grandes vantagens de Lisp é que ela trata o programa como dado, possibilitando assimum programa inteiro ser dado como entrada de um outro, coisa que não acontece em outras linguagens como C ePascal. E usada algumas vezes para definir todos os aspectos de uma aplicação, ou apenas o motor de processamentointerno, ou apenas a interface do usuário; e ainda é usada com rotina para prover linguagens de comando interativas,linguagens de macro ou script e linguagens extensoras de sistemas comerciais.

Características TécnicasA linguagem LISP é interpretada, onde o usuário digita expressões em uma linguagem formal definida e recebe devolta a avaliação de sua expressão. Deste ponto de vista podemos pensar no LISP como uma calculadora, que aoinvés de avaliar expressões aritméticas avalia expressões simbólicas, chamadas de expressões. Cada programa emLISP, é, portanto, uma expressão. As expressões são de tamanho indefinido e tem uma estrutura de árvore binária. Aestrutura de utilização da memória disponível é na forma de listas, pois livra o programador da necessidade de alocarespaços diferentes para o programa e para os dados, fazendo com que os dados e os programas sejam homogêneos,característica única da linguagem LISP. Suas principais características são:• Tipos de dados: átomo e a lista. É com apenas esses dois tipos de dados que se constroem as expressões-S, as

estruturas basilares de LISP.• Fraca Tipagem: LISP, em relação a outras linguagens funcionais mais recentes, é fracamente tipado, o que causa

complicações, já que operações que acessam as suas estruturas de dados são tratadas como funções.• Funções de ordem elevada: Linguagens funcionais tipicamente suportam funções de ordem elevada (exemplo:

função de uma função de uma função de uma…).• Avaliação Ociosa: É o que ocorre quando uma função aninhada executa uma computação desnecessária para a

avaliação da função que a chama, aumentando o tempo de execução.• Concorrência (multitarefa): A concorrência nas linguagens imperativas tradicionais é relativamente complexa; o

programador é o responsável pela sincronização de todas as tarefas (a multitarefa no paradigma procedural é tãosofisticada quanto um GOTO). Em contraste, as linguagens funcionais intrinsecamente nos oferecemoportunidades para a concorrência: A partir do momento em que uma função tem mais de um parâmetro, estesparâmetros devem em princípio ser avaliados simultaneamente (note que os parâmetros seriam as funçõescorrespondentes às tarefas a serem executadas); A partir deste ponto, a responsabilidade pela sincronização dastarefas passa do programador para o compilador (as modernas linguagens funcionais orientadas a multitarefadispõe de mecanismos através dos quais o programador pode guiar o compilador). Todavia, as linguagensfuncionais orientadas a multitarefa permitem ao programador trabalhar em um nível muito mais elevado do que aslinguagens imperativas destinadas a este mesmo fim.

• Um alto nível de abstração, especialmente quando as funções são utilizadas, suprimindo muitos detalhes daprogramação e minimizando a probabilidade da ocorrência de muitas classes de erros;

• A não dependência das operações de atribuição permite aos programas avaliações nas mais diferentes ordens. Estacaracterística de avaliação independente da ordem torna as linguagens funcionais as mais indicadas para aprogramação de computadores maciçamente paralelos;

Lisp 3

• A ausência de operações de atribuição torna os programas funcionais muito mais simples para provas e análisesmatemáticas do que os programas procedurais.

E como desvantagem, destacamos:• Uma menor eficiência para resolver problemas que envolvam muitas variáveis (ex. contas de banco) ou muitas

atividades seqüenciais são muitas vezes mais fáceis de se trabalhar com programas procedurais ou programasorientados a objeto.

O Common Lisp permite várias representações diferentes de números. Estas representações podem ser divididas em4 tipos: hexadecimais, octais, binários e decimais. Estes últimos podem ser divididos em 4 categorias: inteiros,racionais, ponto flutuante e complexos.

Implementação das ListasOriginalmente, em Lisp havia duas estruturas de dados fundamentais: o átomo e a lista; o átomo pode ser numérico,ou alfanumérico. Exemplos de átomos: atomo1, a, 12, 54, bola, nil.O átomo nil representa o valor nulo e ao mesmo tempo representa uma lista vazia. A lista é a associação de átomosou outras listas (numa lista chamamos de elementos a cada um dos itens) representandos entre parêntesis. Exemplode lista:(esta lista contém 5 átomos)((jose (22 solteiro)) (antonio (15 casado)))Normalmente a implementação de uma lista é um encadeamento de pares em que o ponteiro à esquerda do paraponta para o elemento correspondente da lista e em que o ponteiro à direita do par aponta para a restante lista.

[ . ]

| |

| +---- ponteiro para a restante lista (quando for o último, aponta para nil)

+-------- ponteiro para o conteúdo do elemento

[ . ] +→[ . ] +→[ . ] +→[ . ] +→[ . ]

| | | | | | | | | | | | | |

| +---+ | +---+ | +---+ | +---+ | +--> nil

esta lista contém 5 átomos

Avaliação dados: os átomos quando avaliados retornam eles mesmos. As listas, quando avaliadas, são funções, ondeo primeiro elemento representa o nome da função e os elementos seguintes são os argumentos para esta função.Exemplos de função:(+ 3 4)> 7(* 5 (+ 2 5))> 35(car (quote (a b)))> aNormalmente, as implementações de Lisp providenciam um ambiente interactivo de avaliação de expressões. Osexemplos acima apresentam a interacção com uma implementação de Lisp. Como pode ser visto também, umprograma Lisp pode confundir um programador inexperiente porque requer o uso de muitos parênteses, o que lherendeu um trocadilho anglófono para o nome da linguagem: LISP = Lots of Irritating Stupid Parentheses (tradução:Montes de Irritantes Parênteses Estúpidos), ou então LISP = Linguagem Infernal Somente de Parênteses.

Lisp 4

Existe o mito de que Lisp é uma linguagem que só funciona com um interpretador. Na realidade, todos os dialetosrelevantes de Lisp têm compiladores. Alguns dialetos, o compilador é uma função que se pode invocar a partir decódigo normal para transformar uma lista (que descreve uma função) numa função invocável. Programas Lispcomerciais são tipicamente compilados por motivos de eficiência mas a semântica do Lisp permite que oprogramador possa usar programas interpretados e programas compilados ao mesmo tempo. A maioria dos usosinterpretados ocorrem interactivamente, para invocar programas compilados a partir de código escrito por umprogramador. Há exemplos disso acima onde se apresenta o resultado interactivo de invocar funções compiladas.

Exemplos de Funções(quote expressão)Retorna a expressão diretamente, sem tentar qualquer forma da avaliação. Ex: (quote jose) retorna jose, e (quote(jose silva)) retorna (jose silva).'expressãoSignifica o mesmo que (quote expressão). Ex: 'jose retorna jose, e '(jose silva) retorna (jose silva).(eval expressão)força a avaliar a expressão. Ex: Embora '(+ 3 4) simplesmente retorna (+ 3 4), (eval '(+ 3 4)) força a avaliar o (+ 3 4)e portanto retorna 7.(car lista)Retorna o primeiro elemento da lista. Ex: (car '(jose silva)) retorna jose. Entre os vários dialetos de Lisp, há alguns(por exemplo, ISLISP) que permitem o nome first como alternativa para car.(cdr lista)Retorna a lista sem o primeiro elemento. Ex: (cdr '(jose da silva)) retorna (da silva). Há dialetos que usam o nomerest como alternativa para cdr.(cons atomo lista)Adiciona átomo ao início da lista. Ex: (cons 'jose '(da silva)) retorna (jose da silva).Funções matemáticas:

+ (Adição)

- (Subtração)

* (Multiplicação)

/ (Divisão)

MacrosO grande diferencial de Lisp são as macros. As macros são completamente diferentes das que se encontram em C,pois estas somente fazem substituição de texto, enquanto que em Lisp as macros são programas que geramprogramas.

Uso de LispLisp foi utilizado para desenvolver o primeiro sistema computacional de matemática simbólica, o Macsyma.Ele também é utilizado como linguagem de extensão do software de CAD AutoCAD, desenvolvido pela AutoDesk.O editor de textos Emacs também utiliza Lisp como linguagem de extensão. Segundo o seu próprio autor, RichardStallman, Lisp foi o responsável por tornar o Emacs tão popular, pois o fato da linguagem de extensão dele ser tãopoderosa permite que ele seja estendido muito além do que se imaginava que ele originalmente poderia fazer.A ITA software desenvolveu um sistema de reserva de passagens chamado Orbitz em LISP, ele é utilizado por diversas companhias aéreas. A Simbolics criou um sistema de modelagem 3D que depois foi adquirido pela IZWare

Lisp 5

e atualmente se chama Mirai, ele foi utilizado nos efeitos do filme Senhor dos Anéis.O LISP foi utilizado pelo Paul Graham para desenvolver o sistema de e-commerce da Viaweb, que posteriormentefoi vendido para o Yahoo por US$ 40 milhões, na época da bolha da internet.

Exemplos de código

Expressões Lambda((lambda (arg) (+ arg 1)) 5)

Resultado: 6

FatorialCommon Lisp:

(defun fatorial (n)

(if (= n 0)

1

(* n (fatorial (- n 1)))))

Scheme:

(define fatorial

(lambda (n)

(if (= n 0)

1

(* n (fatorial (- n 1))))))

Embora as definições acima pareçam correctas, para evitar o transbordamento da pilha pode ser preferível usar asseguintes.Common Lisp:

(defun fatorial (n)

(do ((i n (- i 1))

(resultado 1 (* resultado i)))

((= i 0) resultado)))

Scheme:

(define fatorial

(lambda (n)

(let f ((i n) (resultado 1))

(if (= i 0)

resultado

(f (- i 1) (* resultado i))))))

Na maioria dos dialetos modernos de Lisp usam-se inteiros de precisão numérica indefinida:

(fatorial 40)

⇒ 815915283247897734345611269596115894272000000000

(length (write-to-string (fatorial 10000)))

Lisp 6

⇒ 35660 ; dígitos no resultado de (fatorial 10000)

(/ (fatorial 10000) (fatorial 9998))

⇒ 99990000 ; resultado exato

Naqueles dialetos também usam-se números racionais de precisão numérica indefinida. Por exemplo, no CommonLisp se pode ter esta interacção:

pi

⇒ 3.141592653589793

(rationalize pi) ; aproximação do valor como número racional

⇒ 245850922/78256779

(* (rationalize pi) (fatorial 40)) ; o resultado é um número racional

⇒ 66864508220128937516859865761265220075208572928000000000/26085593

(- (/ (* (rationalize pi) (fatorial 40))

(fatorial 40))

(rationalize pi))

⇒ 0 ; o resultado da aritmética racional é exato

[1] BERGIN, Thomas J.; GIBSON, Richard G.. History of Programming Languages II. New York: ACM Press, Addison-Wesley, 1996. pag.864. ISBN 0-201-89502-1

Ligações externas• http:/ / www-formal. stanford. edu/ jmc/ history/ lisp/ lisp. html• http:/ / www-formal. stanford. edu/ jmc/ lisp20th/ lisp20th. html• http:/ / www. gigamonkeys. com/ book/• http:/ / www. paulgraham. com/ onlisp. html• Linguagem LISP (http:/ / www. dca. ufrn. br/ ~adelardo/ lisp/ ) (em Common Lisp)• Introdução à Linguagem Lisp (http:/ / www. gia. ist. utl. pt/ Lisp9596/ Lisp9596. html)• Grupo de usuários no Brasil (http:/ / lisp-br. void. cc/ )• Lisp para Autocad - AutoLisp (http:/ / www. autolisp. com. br)

Common Lisp 7

Common Lisp

Common LispParadigma Multiparadigma, funcional, Orientação a Objetos

Surgido em 1984, 1994 para o ANSI Common Lisp

Criado por Comitê ANSI X3J13, presidido por Guy L. Steele Jr.

Estilo detipagem:

forte, dinâmica

Compiladores CLISP, Steel Bank Common Lisp, Embeddable Common Lisp, Armed Bear Common Lisp, Clozure Common Lisp, AllegroCommon Lisp, GNU Common Lisp, Corman Common Lisp, LispWorks

Influenciadapor

Lisp, Scheme, Smalltalk

Influenciou Dylan, Clojure, Ruby

Common Lisp é uma implementação específica da linguagem de programação Lisp multi-paradigma que suportaprogramação funcional e procedural. Foi criada por Guy L. Steele nos anos 1980 a partir da linguagem Lisp com ointuito de combinar aspectos de diversos dialetos Lisp anteriores, incluindo Scheme. Foi proposto inicialmente onome de "Standard Lisp" para a linguagem, mas em virtude de de um dialeto Lisp já existir com este nome, sebuscou um nome similar, resultando no nome "Common Lisp"[1] . Em 1994 foi publicada no padrão ANSIInformation Technology - Programming Language - Common Lisp, registro X3.226-1994 (R1999).[2] . É bem maiore semânticamente mais complexa que Scheme uma vez que foi projetada para ser uma linguagem comercial e sercompatível com os diversos dialetos Lisp dos quais derivou.

Exemplos de código

Hello world(defun hello-world

(format t "Hello World"))

Entrada e Saída(defun pergunta (string)

(format t "~%~%~A" string)

(read))

(pergunta "Quantos anos voce tem? ")

Common Lisp 8

Loops(defun quadrados (inicio fim)

(do ((i inicio (+ i 1)))

((> i fim) 'fim)

(format t "~A ~A~%" i (* i i))))

Bibliografia• SEIBEL, PETER.(2005); Practical Common Lisp. Apress, 2005.• GRAHAM, Paul. Ansi Common Lisp. New Jersey: Prentice Hall, 1996. ISBN 0-13-370875-6• GRAHAM, PAUL.(1993); On Lisp. Prentice Hall, 1993. (Descreve técnicas avançadas para uso de macros)• STEELE, Guy L.. Common Lisp - The Language. Lexington: Digital Press, 1990. ISBN 1-55558-041-6• TOURETZKY, DAVID S.(1990); Common Lisp - A Gentle Introduction to Symbolic Computation. Benjamin

Cummings, Redwood City, 1990. ISBN 0-8053-0492-4

Ver também• Lisp• Scheme[1] BERGIN, Thomas J.; GIBSON, Richard G.. History of Programming Languages II. New York: ACM Press, Addison-Wesley, 1996. pag.

864. ISBN 0-201-89502-1[2] Página do Documento (http:/ / webstore. ansi. org/ RecordDetail. aspx?sku=ANSI+ INCITS+ 226-1994+ (R2004)) no sítio da ANSI

Ligações externas• (http:/ / www. cs. cmu. edu/ ~dst/ LispBook/ index. html) - Site do autor David S. Touretzky• (http:/ / www. cs. cmu. edu/ ~dst/ LispBook/ book. pdf) - Livro em pdf "Common Lisp: A Gentle Introduction to

Symbolic Computation de David S. Touretzky"• (http:/ / www. cs. cmu. edu/ Groups/ AI/ html/ cltl/ clm/ clm. html) - Livro "Common Lisp - The Language"

disponível em formato HTML• (http:/ / books. google. com. br/ books?id=FYoOIWuoXUIC& dq=Common+ Lisp+ the+ Language&

printsec=frontcover& source=bn& hl=pt-BR& ei=SwcHSoP6GZuqtgfL0emdBw& sa=X& oi=book_result&ct=result& resnum=4#PRA1-PA780,M1) - Livro "Common Lisp - The Language" pela Google books

• (http:/ / common-lisp. net/ ~dlw/ LispSurvey. html) - Implementações de Common Lisp• (http:/ / lib. store. yahoo. net/ lib/ paulgraham/ onlisp. pdf) - Livro do Paul Graham em pdf "On Lisp"

Scheme 9

Scheme

Scheme

Paradigma Multiparadigma: funcional e procedural

Surgido em 1975

Criado por Gerald Jay Sussman e Guy L. Steele Jr

Estilo de tipagem: forte, dinâmica

Compiladores MIT/GNU Scheme, Chez Scheme, SCM, GNU Guile, Ypsilon, PLT Scheme

Dialetos: Linguagem T

Influenciada por Lisp

Influenciou Cat, Common Lisp, Ruby, Dylan, Lua

Scheme é uma linguagem de programação multi-paradigma que suporta programação funcional e procedural. Foicriada por Guy L. Steele e Gerald Jay Sussman no outono de 1975, a partir da linguagem Lisp com o intuito deestudar a teoria dos atores de Carl Hewitt. O modelo de Hewitt era orientado a objeto (e influenciado peloSmalltalk). Os objetos eram chamados atores e as mensagens eram também atores. Sussman e Steele tiveram algumproblema no entender algumas das conseqüências do modelo a partir dos artigos de Hewitt e decidiram construiruma implementação de brinquedo de uma linguagem de atores visando experimentá-la. Escreveram um pequenointerpretador Lisp e adicionaram os mecanismos necessários para a criação de atores e envio de mensagens[1] .Existem dois padrões que definem a linguagem Scheme: o padrão oficial IEEE e um padrão popular chamado"Revisedn Report on the Algorithmic Language Scheme", abreviado como RnRS, onde n é o número de revisões.

CaracterísticasScheme adota uma filosofia minimalista, assim sendo, provê o mínimo de noções possíveis, e, na prática, qualqueroutra noção pode ser adicionada via bibliotecas, como todos os dialetos do Lisp, possui pouca sintaxe comparado àmaioria das outras linguagens. Devido à sua sintaxe completamete aninhada, não existem regras de precedência deoperadores e sua notação parentizada é usada para todas as chamadas de função, desta forma não há ambigüidadescomo as que são encontradas nas linguagens de notação infixa.

(5+3) seria assim: (+ 5 3)

(5+3)x2 seria assim: (* (+ 5 3) 2)

(8/2) seria assim: (/ 8 2)

O MIT usou desde a década de 80 até 2008 a linguagem Scheme em seu curso introdutório de programação. Olivro-texto usado na disciplina, "Structure and Interpretation of Computer Programs" (escrito por Gerald Sussman eHarold Abelson), ganhou notoriedade pela abordagem inovadora e pela incomum profundidade para um cursointrodutório.

Scheme 10

Exemplos de código em Scheme

Hello world (define hello-world

(lambda ()

(display "Hello World")

(newline)))

(hello-world)

ou simplesmente:

(display "Hello World")

RecursividadeCálculo do fatorial de um número:

(define (fatorial n)

(cond ((= n 0) 1)

(else (* n (fatorial (- n 1))))))

(fatorial 5)

;; => 120

Números PerfeitosExemplo de programa que mostra os n primeiros números perfeitos:

(define inverteListax

(lambda (lista1 lista2)

(if (null? lista1) lista2

(inverteListax (cdr lista1) (cons (car lista1) lista2)))))

(define inverteLista

(lambda (lista)

(inverteListax lista '())))

(define (perf n)

(let loop ((i 1)

(sum 0))

(cond ((= i n)

(= sum n))

(

(= 0 (modulo n i))

(loop (+ i 1) (+ sum i)))

(else

(loop (+ i 1) sum)))))

(define aux

(lambda (x n l)

(if (= x 0) l

Scheme 11

(if (perf n) (aux (- x 1) (+ n 1) (cons n l))

(aux x (+ n 1) l)))))

(define main

(lambda (x)

(aux x 1 '())))

(define perfeitos

(lambda (n)

(inverteLista (main n))))

CompiladoresAlguns compiladores de Scheme:• Bigloo;• Chez Scheme;• Chicken;• Gambit;• Gauche;• Guile;• Ikarus;• JScheme;• Kawa;• Larceny;• MIT/GNU Scheme [2];• Mosh [3];• PLT Scheme [4];• Pvts;• RScheme;• Scheme 48;• SCM;• SISC;• Stalin;• STk;• STklos;• TinyScheme;• Ypsilon [5].

Scheme 12

BibliografiaDYBVIG, R. Kent. The Scheme Programming Language: Ansi Scheme. New Jersey: Prentice Hall PTR, 1996.ISBN 0-13-454646-6 ABELSON, Harold; SUSSMAN, Gerald Jay; SUSSMAN Julie. Structure and Interpretation ofComputer Programs. New York: McGraw-Hill, 1996. ISBN 0-07-000484-6

Ver também• LISP[1] BERGIN, Thomas J.; GIBSON, Richard G.. History of Programming Languages II. New York: ACM Press, Addison-Wesley, 1996. pag.

864. ISBN 0-201-89502-1[2] http:/ / www. gnu. org/ software/ mit-scheme/[3] http:/ / code. google. com/ p/ mosh-scheme/[4] http:/ / www. plt-scheme. org/[5] http:/ / code. google. com/ p/ ypsilon/

Ligações externas• Schemers (http:/ / www. schemers. org) - Uma página de referência da linguagem

Clojure

Clojure

Paradigma funcional

Surgido em 2007

Criado por Rich Hickey

Estilo de tipagem: forte, dinâmica

Compiladores JVM, CLR

Dialetos: Lisp, Scheme, Common Lisp

Influenciada por Lisp, Prolog, ML, Haskell, Erlang

Licença: Eclipse Public License

Clojure, na informática, é uma variante moderna de Lisp, desenvolvida por Rich Hickey. Clojure roda sobre a JavaVirtual Machine (JVM).

Clojure 13

IntroduçãoClojure é um dialeto moderno da linguagem de programação Lisp, Scheme e Common Lisp e roda na Java VirtualMachine ou CLR (Common Language Runtime). É um paradigma de linguagem de programação funcional.Rich Hickey desenvolveu Clojure porque queria um Lisp moderno em programação funcional, que tivesse simbióticaa plataforma Java e concebido para multiconcorrência.Esta concorrência é caracteriza pelo conceito de identidades, que representam uma série de estados imutáveis aolongo do tempo e, tendo os valores imutáveis, qualquer número pode trabalhar em paralelo. Clojure fornece váriostipos de referência mutáveis para transição entre estados.

SintaxeComo a linguagem Lisp, a sintaxe Clojure é construída em S-expressions.

Característica da Linguagem• Uma linguagem compilada produzindo um bytecode JVM• Desenvolvimento dinâmico• Ênfase na recursividade• Concorrência

Exemplos(def x 5)

(cond (< x 10) "menor"

(> x 10) "maior")

Fontes e Editores da Página 14

Fontes e Editores da PáginaLisp  Fonte: http://pt.wikipedia.org/w/index.php?oldid=21680437  Contribuidores: Alchimista, Alexg, Antoniopessoa, António Leitão, Carlos28, E2mb0t, FML, GOE, Jonas AGX, Joyo, JoãoCarvalho, Juntas, Kensu, Leonardo.stabile, LeonardoG, LeonardoRob0t, Lvaruzza, Manuel Anastácio, Master, Mecanismo, Mschlindwein, Netsettler, OS2Warp, Rafael.afonso, Ricardo Ferreirade Oliveira, Rita.dos.santos, SallesNeto BR, Waldir, 68 edições anónimas

Common Lisp  Fonte: http://pt.wikipedia.org/w/index.php?oldid=20107103  Contribuidores: FML, Leonardo.stabile, Marcelo-Silva, Ricardo Ferreira de Oliveira, Vargenau, 13 ediçõesanónimas

Scheme  Fonte: http://pt.wikipedia.org/w/index.php?oldid=21762172  Contribuidores: FML, Fredmaranhao, Jovica, Leonardo.stabile, LeonardoG, Marcelo Reis, Rafael.afonso, Ricardo Ferreirade Oliveira, Ricvelozo, Villarinho, Waltercruz, 18 edições anónimas

Clojure  Fonte: http://pt.wikipedia.org/w/index.php?oldid=22101785  Contribuidores: Albmont, CommonsDelinker, Lzuliani, Mateus RM, PL Przemek, ThiagoRuiz, 3 edições anónimas

Fontes, Licenças e Editores da Imagem 15

Fontes, Licenças e Editores da ImagemImage:Lambda lc.svg  Fonte: http://pt.wikipedia.org/w/index.php?title=Ficheiro:Lambda_lc.svg  Licença: Public Domain  Contribuidores: Luks, Vlsergey, 1 edições anónimasFile:Clojure-glyph.svg  Fonte: http://pt.wikipedia.org/w/index.php?title=Ficheiro:Clojure-glyph.svg  Licença: desconhecido  Contribuidores: Tom Hickey and Rich Hickey

Licença 16

LicençaCreative Commons Attribution-Share Alike 3.0 Unportedhttp:/ / creativecommons. org/ licenses/ by-sa/ 3. 0/