Joy (programming language): Difference between revisions

Revision as of 15:20, 6 December 2007

Latest revision as of 13:51, 24 May 2025

(120 intermediate revisions by 86 users not shown)

Line 1:

{{Short description|Programming language}}

A linguagem de programação JOY é uma linguagem de programação

{{Original research|date=May 2009}}

puramente funcional que foi produzida por Manfred von Thun

{{Infobox programming language

na Universidade de La Trobe em Melbourne, Australia.

|name = Joy

|logo =

|paradigm = [[multi-paradigm programming language|multi-paradigm]]: [[functional programming|functional]], [[concatenative programming language|concatenative]], [[Stack-oriented programming language|stack-oriented]]

|year = 2001

|designer = Manfred von Thun

|developer = Manfred von Thun<br>John Cowan

|latest release version = March 17, 2003

|latest release date = March 17, 2003

|typing = [[strong typing|strong]], [[dynamic typing|dynamic]]

|implementations = Joy0, Joy1, "Current Joy", "John Cowan's Joy", "JoyJ (Joy in jvmm)"

|dialects =

|influenced_by = [[Scheme (programming language)|Scheme]], [[FP (programming language)|FP]], [[Forth (programming language)|Forth]]

|influenced = [[Factor (programming language)|Factor]], Cat, V, Trith

}}

The '''Joy programming language''' in [[computer science]] is a [[purely functional programming language]] that was produced by Manfred von Thun of [[La Trobe University]] in [[Melbourne]], [[Australia]]. Joy is based on composition of functions rather than [[lambda calculus]]. It was inspired by the [[Function-level programming|function-level programming style]] of [[John Backus]]'s [[FP (programming language)|FP]].<ref>{{cite web|title=A Conversation with Manfred von Thun|author=Manfred von Thun|url=http://www.nsl.com/papers/interview.htm|access-date=May 31, 2013|date=December 12, 2003|quote=" In the early 1980s I came across the famous Backus paper "Can programming be liberated from the von Neumann style," and I was immediately intrigued by the higher level of programming in his FP."}}</ref>

JOY é baseada na composição de funções, melhor que calculos Lambda.

It has turned out to have many similarities to [[Forth (programming language)|Forth]], due not to design but to an independent evolution and convergence.{{Citation needed|date=October 2024}}

Mostrou ter muita semelhanças a Forth, Foi projetada como um tipo

de evolução paralela e convergente.

== Overview ==

JOY é incomun (com exceção para linguagens de programação a nivel

de função e algumas esotericas, como a UNLAMBDA) em que falta um

operador LAMBDA e portanto a falta de parametros formais.

Para ilustrar isto com um exemplo comum, isto é, como a função

quadrada pode ser definida em uma linguagem de programação

imperativa (C):

Functions in Joy lack [[Parameter (computer science)|formal parameters]]. For example, a function that squares a numeric input can be expressed as follows:<ref>{{cite web|title=An informal tutorial on Joy |url=http://www.latrobe.edu.au/phimvt/joy/j01tut.html |url-status=dead |archive-url=https://web.archive.org/web/20111007030359/http://www.latrobe.edu.au/phimvt/joy/j01tut.html |archive-date=October 7, 2011 }}</ref>

DEFINE square == dup * .

In Joy, everything is a function that takes a [[stack (data structure)|stack]] as an argument and returns a stack as a result. For instance, the numeral '5' does not represent an integer constant, but instead a short program that pushes the number 5 onto the stack.

int square(int x) {

return x*x;

}

* The '''dup''' operator simply duplicates the top element of the stack by pushing a copy of it.

* The '''*''' operator pops two numbers off the stack and pushes their product.

So the square function makes a copy of the top element, and then multiplies the two top elements of the stack, leaving the square of the original top element at the top of the stack, with no need for a formal parameter. This makes Joy concise, as illustrated by this definition of [[quicksort]]:<ref>{{cite web|title=Sequence Library |url=http://www.latrobe.edu.au/phimvt/joy/seqlib.joy |url-status=dead |archive-url=https://web.archive.org/web/20111007030359/http://www.latrobe.edu.au/phimvt/joy/seqlib.joy |archive-date=October 7, 2011 }}</ref>

<pre><nowiki>

A variavel X é um parametro formal que é substituido pelo valor

DEFINE qsort ==

real a ser multiplicado quando a função é chamada. Agora aki como

[small]

a função seria definida em uma linguagem funcional (esquema)

[]

[uncons [>] split]

[swapd cons concat]

binrec.

</nowiki></pre>

== Mathematical purity ==

Joy is a [[concatenative programming language]]: "The concatenation of two programs denotes the composition of the functions denoted by the two programs".<ref>{{cite web|title=Mathematical Foundations of Joy |url=http://www.latrobe.edu.au/phimvt/joy/j02maf.html |url-status=dead |archive-url=https://web.archive.org/web/20111007025556/http://www.latrobe.edu.au/phimvt/joy/j02maf.html |archive-date=October 7, 2011 }}</ref>

== See also ==

* [[RPL_(programming_language)|RPL]]

(define square

* [[Concatenative programming language]]

(lambda (x)

(* x x)))

== References ==

<references/>

==External links==

* {{Webarchive|url=https://web.archive.org/web/20120907202347/https://www.latrobe.edu.au/phimvt/joy.html|title=Official Joy Programming Language Website (La Trobe University)}}

* [http://www.kevinalbrecht.com/code/joy-mirror/index.html Joy homepage mirror]

* [https://github.com/Wodan58/Joy Joy source code] (GitHub-Archive)

* {{cite journal|first=Paul|last=Freneger|authorlink=Paul Freneger|title=The JOY of forth|journal=[[ACM SIGPLAN Notices]]|volume=38|issue=8|date=August 2003|url=http://portal.acm.org/citation.cfm?id=944579.944583 |pages=15–17 |doi=10.1145/944579.944583|url-access=subscription}}

* {{cite journal|first1=Manfred|last1=von Thun|authorlink1=Manfred von Tuhn|first2=Reuben|last2=Thomas|authorlink2=Reuben Thomas|title=Joy: Forth's Functional Cousin|journal=Proceedings of the 17th EuroForth Conference|url=http://www.complang.tuwien.ac.at/anton/euroforth/ef01/thomas01a.pdf|date=October 9, 2001}}

* {{Cite web| url = http://www.drdobbs.com/architecture-and-design/228701299 | author = Christopher Diggins | title = What is a Concatenative Language | date = December 31, 2008 | publisher = Dr. Dobbs | volume =33}}

* {{cite journal|first=Stevan|last=Apter|title=Functional Programming in Joy and K|journal=Vector|url=http://www.vector.org.uk/archive/v214/joy214.htm|access-date=2011-02-28|archive-url=https://web.archive.org/web/20080828115345/http://www.vector.org.uk/archive/v214/joy214.htm|archive-date=2008-08-28|url-status=dead}}

* [https://github.com/metazip/mjoy mjoy, an interpreter in Lazarus for drawings with turtle graphics] (Subset of Joy)

* [https://concatenative.org/wiki/view/Joy%20of%20Postfix Joy of Postfix Calculator App] (Subset of Joy)

[[Category:Programming languages]]

Há diferentes formas, mas ainda usando o parametro formal X dessa

[[Category:Concatenative programming languages]]

maneira. Agora aqui é como a função quadrada seria definida em JOY

[[Category:Stack-oriented programming languages]]

[[Category:Functional languages]]

[[Category:Academic programming languages]]

[[Category:Programming languages created in 2001]]

DEFINE square == dup * .

[[Category:2001 software]]

[[Category:Dynamic programming languages]]

[[Category:Dynamically typed programming languages]]

Explicando: em JOY tudo é uma função que leva uma pilha como

[[Category:High-level programming languages]]

argumento e retorna uma pilha como resultado. Por exemplo, o

numero 5, não é, como pode parecer, um inteiro constante, mas

ao invés um programa curto que empurra o número 5 sobre a pilha.

O operador (*) joga dois numeros pra fora da pilha e coloca de

volta o produto deles. O operador DUP, duplica o elemento q esta

no topo da pilha, simplismente tirando da pilha uma copia do mesmo

Assim esa definição da função quadrada diz fazer uma cópia do

elemento do topo da pilha e então multiplicar os dois elementos

do topo, deixando o quadrado do elemento original no toipo da pilha

. Isto é, não necessitando de parametro formal. Esta designação da

a JOY conscisão e poder, como ilustrado por essa definição de QUICKSORT

DEFINE qsort ==

[small]

[]

[uncons [>] split]

[[swap] dip cons concat]

binrec .

"binrec" é uma das varias combinações recursivas de JOY, implementando

recursão binária. Espera quatro programas no topo da pilha que

representam a condição de terminação (se a lista é "pequena"

(1 ou 0 elementos) já é ordenada), o que fazer se a condição de

terminação é conhecida (neste caso nada), o que fazer por padrão

(dividir a lista em dois, compararando cada elemento como o "pivô")

e finalmente o que fazer no final (inserir o "pivô" entre os dois

)