Intro programacion funcional

Programación funcional con Swift

- Concurrencia
- Test
- Tolerante a errores

Las funciones imperativas pueden tener efectos secundarios,
como cambiar el valor de cálculos realizados previamente.
Imperativo
Las funciones declarativas, el valor generado por una función
depende exclusivamente de los argumentos alimentados a la función.
Al eliminar los efectos secundarios se puede entender
y predecir el comportamiento de un programa mucho más fácilmente.
Declarativo

Stateless
struct User {
var id: Int
var name: String
var isActive: Bool
}
class KeyboardViewController: UIInputViewController {
var nameActiveUsers:[String] = []
var users: [User] = []
override func viewDidLoad() {
super.viewDidLoad()
users = [User(id: 1, name: "Juan", isActive: true),
User(id: 2, name: "Pedro", isActive: false),
User(id: 3, name: "Alan", isActive: true),
User(id: 4, name: "Pablo", isActive: false)]
getNameActiveUsers()
print(nameActiveUsers)
}
func getNameActiveUsers(){
var activeUsers = [User]()
for user in users{
if user.isActive{
activeUsers.append(user)
}
}
activeUsers.sort { (user1, user2) -> Bool in
return user1.id < user2.id
}
for active in activeUsers{
nameActiveUsers.append(active.name)
}
}
}

Stateless
struct User {
var id: Int
var name: String
var isActive: Bool
}
super.viewDidLoad()
}
for user in users{
if user.isActive{
}
}
}
}
}
}
Orientado

a instrucciones
Imperativo
Deﬁno “cómo” se realiza un proceso para alcanzar un resultado.

Stateless
struct User {
var id: Int
var name: String
var isActive: Bool
}
Orientado

a expresiones
Declarativo
super.viewDidLoad()
let users = [User(id: 1, name: "Juan", isActive: true),
print(getNameActiveUsers(users: users))
}
func getNameActiveUsers(users: [User]) -> [String]{
return users.filter{$0.isActive}
.sorted{$0.id < $1.id}
.map{$0.name}
}
}
“Di qué quieres, pero no cómo lo quieres”

Stateless
struct User {
var id: Int
var name: String
var isActive: Bool
}
super.viewDidLoad()
let users = [User(id: 1, name: "Juan", isActive: true),
print(getNameActiveUsers(users: users))
}
func getNameActiveUsers(users: [User]) -> [String]{
return users.filter{$0.isActive}
.sorted{$0.id < $1.id}
.map{$0.name}
}
}
super.viewDidLoad()
}
for user in users{
if user.isActive{
}
}
}
}
}
}
// [“Juan”, “Alan”]
// [“Juan”, “Alan”]

Funciones de primera clase
func getURLFromString(url:String) -> URL{
return URL(string: url)!
}
super.viewDidLoad()
let urlImage = “https://www.apple.com.mx"
let url = getURLFromString(url: urlImage)
}
Un lenguaje de programación se dice que tiene Funciones de primera clase cuando
las funciones en ese lenguaje son tratadas como cualquier otra variable.

Funciones de primera clase
func getImage(urlImage: String) -> UIImage{
let url = getURLFromString(url: urlImage)
let data = getDataFromURL(url:url)
let image = getImageFromData(data: data)
return image
}
}
func getDataFromURL(url: URL) -> Data{
return try! Data(contentsOf: url)
}
func getImageFromData(data:Data) -> UIImage{
return UIImage(data: data)!
}

Funciones de orden Super
Pueden tomar otra función como parámetro:
}
}
}
func getImage(url: String, completion: (Data) -> UIImage) -> UIImage{
let url = getURLFromString(url: url)
return completion(data)
}
let image = getImage(url: urlImage, completion: getImageFromData)

Pueden tomar otra función como parámetro:
}
}
}
func getImage(url: String, completion: (Data) -> UIImage) -> UIImage{
let url = getURLFromString(url: url)
return completion(data)
}
let image = getImage(url: urlImage, completion: getImageFromData)
Firma de la función
(Data) -> UIImage

Pueden devolver una función de salida:
func getImage(urlImage: String) -> (CGRect) -> UIImage {
return {
let image = self.getImageFromData(data: self.getDataFromURL(url: self.getURLFromString(url: urlImage)))
image.draw(in: $0)
return image
}
}
let imageWithSize = image(CGRect(x: 0, y: 0, width: 50, height: 50))

Pipelines
func |> <T,U,V> (_ first: @escaping (T) -> U, second: @escaping (U) -> V) -> (T)->V{
return {second(first($0))}
}
infix operator |> : AdditionPrecedence

Pipelines
return {
let image = self.getURLFromString
|> self.getDataFromURL
|> self.getImageFromData
image(urlImage)
image.draw(in: $0)
return image
}
}
}
return {
image.draw(in: $0)
return image
}
}
Antes
Después

Pipelines
return {
let image = self.getURLFromString
|> self.getDataFromURL
|> self.getImageFromData
image(urlImage)
image.draw(in: $0)
return image
}
}
}
return {
image.draw(in: $0)
return image
}
}
Composición
De funciones

Patron Result
Esto es similar al tipo Opcional nativo de Swift:
el “some” es que tiene un valor, y el “none” es que no tiene.
Es parecido a las promesas en Javascript
enum Result<S,E>{
case success(_ :S)
case failure(_ :E)
}

Patron Result
class NotificationParser {
private func serializeResponse(mapString:String) -> [String: Any]?{
return try! JSONSerialization.jsonObject(with: mapString.data(using: .utf8)!, options: [.allowFragments]) as? [String: Any]
}
func parseSomething(mapString: String, completion: @escaping(_ success: Bool, _ object: Any?) -> Void) {
guard let dataJSON = serializeResponse(mapString: mapString) else {
return completion(false, nil)
}
if dataJSON["success"] != nil {
if dataJSON["success"] as! Bool {
if let responseDictionary = dataJSON["data"] as? NSDictionary {
let response = User.from(responseDictionary)
print("CreateAccount: (response!)")
completion(true,response)
} else {
completion(false, nil)
}
}else{
if let responseDictionary = dataJSON["errors"] as? NSArray {
let errors = ErrorsResponse.from(responseDictionary)
print("Valores del modelo errors: (errors!)")
completion(false,errors?.first)
} else {
completion(false, ErrorsResponse.from(["status":0,"message":"duplicate"]))
}
}
} else {
completion(false, nil)
}
}
}

Patron Result
enum ErrorType{
case notSerialized
case notInternet
case serverError(String)
case messageErrorEmpty
}
extension ErrorType{
var description:String {
switch self {
case .notSerialize:
print("Not Serilized")
return "Error From Server"
case .notInternet:
print("there are not connection")
return "Not Internet Conection"
case .serverError (let message):
return message
case .messageErrorEmpty:
return ""
}
}
}
class NotificationParser{
private func serializeResponse(mapString:String) -> [String: Any]?{
return try! JSONSerialization.jsonObject(with: mapString.data(using: .utf8)!, options: [.allowFragments]) as? [String: Any]
}
func parseSomething(mapString:String, completion: @escaping (Result<User,ErrorType>) -> Void){
guard let dictionary = serializeResponse(mapString: mapString) else {
return completion(.failure(.notSerialized))
}
guard let success = dictionary["success"] as? Bool else{
guard let errorMessage = dictionary["message"] as? String else{
return completion(.failure(.messageErrorEmpty))
}
return completion(.failure(.serverError(errorMessage)))
}
guard let responseDictionary = dictionary["data"] as? Dictionary else{
return completion(.failure(.notSerialized))
}
let response = User.from(responseDictionary)
print("CreateAccount: (response!)")
completion(.success(response))
}
}

Patron Result
class NotificationViewControler:UIViewController {
let manager = Managers.shareInstance
super.viewDidLoad()
self.manager.createUser(email:email, password:password, completion: { [weak self] response in
guard let strongself = self else{ return }
switch response{
case .success(let user):
strongSelf.titleLabel.text = user.name
case .failure(let error):
showAlertOK(error.description)
}
}
}
}

Curry
Apply
Pure
Monad
Future
FlatMap
Reduce

Beneﬁcios
- Código concurrente.
- Menos errores. Ya que la mayoría de tu código será con constantes.
- Fácil de testar. Ya que un objeto se puede considera valido desde su creación,
de ser así se va a considerar válido durante toda su existencia.
- Código paralelisable. Que se puede ejecutar en cores diferentes al mismo tiempo.
- Tolerante a fallos gracias al patron Result

Más información
https://functionalhub.thinkiﬁc.com/collections

Intro programacion funcional

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Intro programacion funcional

Similar to Intro programacion funcional (20)

More from NSCoder Mexico

More from NSCoder Mexico (20)

Recently uploaded

Recently uploaded (20)

Intro programacion funcional