Scene 1

Scene 2

1 Introdução ao Paradigma  2 Subprogramas  3 Listas  4 Programação Recursiva  5 Conclusões finais  6 Referencias

Scene 3

Historia do Paradigma  Surgimento  Influencia

Scene 4

Criado em 1930  Criador:  Alonzo  Church   serviu como base para a criação do LISP

Scene 5

Avaliação de funções matemáticas Evitar estados ou dados mutáveis Tem ênfase nas expressões ao invés de comandos Cálculo de valores com dados imutáveis.

Scene 6

Modularização  Passagem de parâmetros  Escopo

Scene 7

Modularização  Quando encontramos um problema real, que é grande e complexo. Podemos dividi-lo em partes para solucioná-lo por etapas mais simples. Ou seja, Dividir para conquistar. As partes divididas podem ser tratadas separadamente, assim podem ser feitas alterações em uma, sem alterar as demais. As partes básicas de um sistema são desenvolvidas e depois conectadas entre si com uma principal.

Scene 8

Em  Haskell  por exemplo temos o  module  onde podemos encontrar um agrupamento de funções e em um  module  podemos importar as definições de outros através do  import.

Scene 9

Passagem de parâmetros e Escopo Na programação funcional é importante conhecer o conceito de funções puras. As funções puras estão relacionadas aos  efeitos colaterais.  As funções puras não modificam o escopo ao redor delas. Elas também devem receber pelo menos um parâmetro e retornar um valor, seja um dado ou uma função. Assim o retorno de uma função pura será sempre o mesmo. O que torna os testes e manutenções mais fáceis de serem aplicados.

Scene 10

No exemplo abaixo podemos observar uma função simples onde primeiro definimos um nome para ela ( square), em seguida dois pontos, e o tipo do dado de entrada e o de saída. Na segunda linha passamos o nome da função e o parâmetro. Depois definisse a operação que será realizada.

O nome da função sendo definida; os parâmetros formais; O resultado, definido de acordo com os parâmetros.

Scene 11

Uma lista é uma coleção  de elementos de um dado tipo. Para todo tipo  “x”  existe uma  lista [x]  para seus elementos. para criar uma lista em Haskell basta definir seu nome e atribuir os valores dentro de um colchete Nome = [conteúdo] E para chamar ela, é só digitar o nome escolhido Nome

Scene 12

Letras::[Char] Letras = [’ a’,’b’,’c’,’d ’] Retorno “ abcd ” Inteiros::[Int]  Inteiros = [1,2,3,4,5,]  Retorno [1,2,3,4,5] Booleanos::[ Bool ] Booleanos = [False,  True , False]  Retorno [False,  True , False] Tuplas ::[( Int,Char )]  Tuplas  = [(1,’o’),(2,’i’),(3,’e’)] Retorno [(1,’o’),(2,’i’),(3,’e’)] Palavras::[[Char]] Palavras = [“rodrigo", [’ v’,’a’,’s’,’c’,’o ’]] Retorno [“rodrigo”, vasco ]

Scene 13

Uma lista é composta sempre de dois segmentos: cabeça  ( head ) e corpo ( tail ). A cabeça da lista é sempre o primeiro  elemento, e o corpo é o restante

Definindo lista Lista=[1,2,3,4,5,6] --  Ex : Head Head  Lista [1] --  Ex :  Tail Tail  Lista [2,3,4,5,6]

Scene 14

Logica de  Haskell  em auto preenchimento

Ls1=[1..10]  		-- [1,2,3,4,5,6,7,8,9,10] Ls2=[1,3..10]  	-- [1,3,5,7,9] Ls3=[10,8..0]  	-- [10,8,6,4,2,0]

Scene 15

Recursividade é o mecanismo de programação no qual uma definição de função refere-se ao próprio objeto sendo definido. A recursividade é um mecanismo básico para repetições nas linguagens funcionais.

Scene 16

fib   ::   Int   ->   Int fib n     |  n   ==  0   =   0     |  n  ==  1   =   1     |  n  >   1   =  fib (n - 2 )  +  fib (n - 1 )

Scene 17

fib  5  fib 3 + fib 4  (fib 1 + fib 2) + (fib 2 + fib 3)  (1 + (fib 0 + fib 1)) + ((fib 0 + fib 1) + (fib 1 + fib 2))  (1 + (0 + 1)) + ((0 + 1) + (1 + (fib 0 + fib 1))) (1 + 1) + (1 + (1 + (0 + 1)))  2 + (1 + (1 + 1))  2 + (1 + 2) 2 + 3 5

Scene 18

fatorial   ::   Integer   ->  Integer   fatorial n     |  n  ==  0   =   1     |  n  >   0   =  fatorial (n - 1 ) * n

Scene 19

fatorial 4   	fatorial 3 * 4   	(fatorial 2 * 3) * 4   	((fatorial 1 * 2) * 3) * 4   	(((fatorial 0 * 1) * 2) * 3) * 4   	(((1 * 1) * 2) * 3) * 4   	((1 * 2) * 3) * 4   	(2 * 3) * 4   	6 * 4        	24

Scene 20

Alguns dos nossos problemas poderiam ser resolvidos com base no modelo funcional, com o processamento paralelo e algo que pode ser muito difícil para outros paradigmas como o orientado a objetos.

Scene 21

Fácil manutenção Processamento em paralelo Facilidade nos testes e na busca por bugs

Mais complexo de apender para que programa em linguagens imperativas

Scene 22

http://www.decom.ufop.br/romildo/2018-1/bcc222/slides/progfunc.pdf http://www.facom.ufu.br/~madriana/PF/hs4.pdf https://medium.com/ trainingcenter /programação-funcional-para-iniciantes-9e2beddb5b43 https://medium.com/tableless/entendendo-programa%C3%A7%C3%A3o-funcional-em-javascript-de-uma-vez-c676489be08b learnyouahaskell.com The Craft of Functional Proagramming-Second edition-Simon Thompson Concepts in Programming Languages by John C. Mitchell Haskell

Scene 23

FRANCISCO HONYCLEYTTON REBOUCAS SENA MATHEUS SANTOS SOARES PAULO ISAC DE LIMA SILVA THOMAZ JEFFERSON DA SILVA

Paradigma de Programação Funcional

 http://www.decom.ufop.br/romildo/2018-1/bcc222/slides/progfunc.pdf http://www.facom.ufu.br/~madriana/PF/hs4.pdf https://medium.com/ trainingcenter /programação-funcional-para-iniciantes-9e2beddb5b43 https://medium.com/tableless/entendendo-programa%C3%A7%C3%A3o-funcional-em-javascript-de-uma-vez-c676489be08b learnyouahaskell.com The Craft of Functional Proagramming-Second edition-Simon Thompson Concepts in Programming Languages by John C. Mitchell Haskell  

Paradigma de Programação Funcional

Scene 1 (0s)

Scene 2 (20s)

Scene 3 (53s)

Scene 4 (1m 1s)

Scene 5 (1m 25s)

Scene 6 (1m 52s)

Scene 7 (2m 7s)

Scene 8 (2m 48s)

Scene 9 (3m 36s)

Scene 10 (5m 5s)

Scene 11 (5m 49s)

Scene 12 (6m 26s)

Scene 13 (8m 45s)

Scene 14 (9m 40s)

Scene 15 (12m 3s)

Scene 16 (12m 44s)

Scene 17 (14m 35s)

Scene 18 (16m 59s)

Scene 19 (17m 43s)

Scene 20 (19m 35s)

Scene 21 (19m 59s)

Scene 22 (20m 17s)

Scene 23 (20m 42s)