目錄

• What-is-Functional-Programming

  • What-is-side-effects

  • What-is-a-Pure-Function

  • What-is-Functional-Programming

  • What-is-a-Functional-Programming-Language

  • Features-of-functional-languages

  • Benefits-of-functional-programming

• Functional-Programming-in-iOS

  • Masonry

  • PromiseKit

  • Swift

• Functional-Programming-in-Android

  • Glide

• What-is-Reactive-Programming

• What-is-Functional-Reactive-Programming

• Functional-Reactive-Programming-in-iOS

  • ReactiveCocoa

  • RxSwift

• Functional-Reactive-Programming-in-Android

  • RxJava

  • Retrofit

• References

What is Functional Programming

第一部分概念較多, 如果沒有耐心看下去的話, 可直接看重點標注的定義

What is side effects

Let's take a look at the first pair with this example

public int square(int x) {
    return x * x;
}

Here, the input you're used to thinking about is int x, and the output you're used to is also an int

public void processNext() {
    Message message = InboxQueue.popMessage();

    if (message != null) {
        process(message);
    }
}

The second piece of code has hidden inputs and outputs. It requires things, and causes things, but you could never guess what just by looking at the API

These hidden inputs and outputs have an official name: "side-effects"

Are Side Effects Bad?

we have to trust that the the hidden expectations of the original programmer were correct, and will remain correct as time marches on

Can we test this code? Not in isolation. Unlike a circuit board, we can't just plug into its inputs and check its outputs

What is a Pure Function

A function is called 'pure' if all its inputs are declared as inputs - none of them are hidden - and likewise all its outputs are declared as outputs

What is Functional Programming

Functional programming is about writing pure functions, about removing hidden inputs and outputs as far as we can, so that as much of our code as possible just describes a relationship between inputs and outputs

What is a Functional Programming Language

A functional programming language is one that supports and encourages programming without side-effects

Features of functional languages

• First-Class Functions - Functional programming requires that functions are first-class, which means that they are treated like any other values and can be passed as arguments to other functions or be returned as a result of a function

• Pure Function - 函數的結果只受函數參數影響, 且不影響外部變量 / 函數內部不使用能被外部函數影響的變量

• Immutable Data - Purely functional programs typically operate on immutable data. Instead of altering existing values, altered copies are created and the original is preserved

• Lazy Evaluation - Since pure computations are referentially transparent they can be performed at any time and still yield the same result. This makes it possible to defer the computation of values until they are needed, that is, to compute them lazily

• Recursion

Recursion is heavily used in functional programming as it is the canonical and often the only way to iterate. Functional language implementations will often include tail call optimisation to ensure that heavy recursion does not consume excessive memory

Lazy evaluation avoids unnecessary computations and allows, for example, infinite data structures to be defined and used

In functional programming, programs are executed by evaluating expressions

In contrast with imperative programming where programs are composed of statements which change global state when executed. Functional programming typically avoids using mutable state

Benefits of functional programming

Functional programming is known to provide better support for structured programming than imperative programming. To make a program structured it is necessary to develop abstractions and split it into components which interface each other with those abstractions. Functional languages aid this by making it easy to create clean and simple abstractions. It is easy, for instance, to abstract out a recurring piece of code by creating a higher-order function, which will make the resulting code more declarative and comprehensible

Functional programs are often shorter and easier to understand than their imperative counterparts

Since various studies have shown that the average programmer's productivity in terms of lines of code is more or less the same for any programming language, this translates also to higher productivity

Functional Programming in iOS

Masonry

iOS開發中鏈式函數編程的典例:

make.centerY.equalTo(self.view).offset(100);

如何實現類似masonry的鏈式函數編程呢? (引自深入淺出－iOS函數式編程的實現 && 響應式編程概念)

有一個Person類, 它的兩個方法如下

- (void)run{
    NSLog(@"run");
}

- (void)study {
    NSLog(@"study")
}

要實現這樣的效果

person.run().study().run();

我們可以這樣做

- (Person * (^)())run {  
    Person * (^block)() = ^() {            
        NSLog(@"run");           
        return self;        
    };       
    return block;
}

- (Person * (^)())study {
    Person * (^block)() = ^()  {            
        NSLog(@"study"); 
        return self;        
    };
    return block;
}

事實上masonry也是這么實現的

- (MASConstraint * (^)(id))equalTo {
    return ^id(id attribute) {
        return self.equalToWithRelation(attribute, NSLayoutRelationEqual);
    };
}

PromiseKit

我們來看看PromiseKit實現UI Animation的例子(更多例子, 請參考PromiseKit官網)

[UIView promiseWithDuration:0.3 animations:^{
    view.frame = CGRectOffset(view.frame, 0, -100);
}].then(^{
    return [self doWork];
}).catch(^(NSError *error){
    [[UIAlertView …] show];
}).finally(^{
    view.frame = CGRectOffset(view.frame, 0, +100);
})

Swift

盡管我不認為Swift是一門函數式編程語言(對于語言的討論可以參考Which Programming Languages Are Functional?), 但是相比于Objective-C來說Swift最大優點就是

Swift為iOS編程世界引入了一個新的范式: 函數式范式

我們來看這樣一個例子(代碼的含義比較簡單, 就不解釋了)

var evens = [Int]()
for i in 1...10 {
  if i % 2 == 0 {
    evens.append(i)
  }
}
println(evens)

使用Functional Filtering可以寫成這樣

func isEven(number: Int) -> Bool {
  return number % 2 == 0
}
evens = Array(1...10).filter(isEven)
println(evens)

運用Swift的closures以上代碼還可以簡化成

evens = Array(1...10).filter { (number) in number % 2 == 0 }
println(evens)

更甚

evens = Array(1...10).filter { $0 % 2 == 0 }
println(evens)

Functional Programming in Android

Glide

Glide作為新生代Android圖片庫的代表, 和Fresco都是值得推薦的

Glide, Fresco與Picasso的比較可以參考[ Android ] Fresco 與 Picasso 、Glide 的比較和Picasso&Glide&Fresco比較

Glide的使用非常簡單和函數式

// For a simple view:
@Override public void onCreate(Bundle savedInstanceState) {
  ...
  ImageView imageView = (ImageView) findViewById(R.id.my_image_view);

  Glide.with(this).load("http://goo.gl/gEgYUd").into(imageView);
}

// For a simple image list:
@Override public View getView(int position, View recycled, ViewGroup container) {
  final ImageView myImageView;
  if (recycled == null) {
    myImageView = (ImageView) inflater.inflate(R.layout.my_image_view, container, false);
  } else {
    myImageView = (ImageView) recycled;
  }

  String url = myUrls.get(position);

  Glide
    .with(myFragment)
    .load(url)
    .centerCrop()
    .placeholder(R.drawable.loading_spinner)
    .crossFade()
    .into(myImageView);

  return myImageView;
}

What is Reactive Programming

以下是Wiki Reactive Programming的定義

reactive programming is a programming paradigm oriented around data flows and the propagation of change

其實響應式這個概念很早就有了, 例如

• 當你操作鍵盤時, 電腦對按鍵進行中斷響應

• 當你瀏覽網站時, 頁面對點擊頁面按鈕的響應

那么響應式編程的目的是什么呢? 我們來看這樣一個經典的例子(引自Wiki Reactive Programming)

For example, in an imperative programming setting, a b c

a = b + c would mean that a is being assigned the result of b+c in the instant the expression is evaluated

and later, the values of b and c can be changed with no effect on the value of a

However, in reactive programming, the value of a would be automatically updated based on the new values

而響應式編程也是很早就有的了, 例如

• iOS開發中的KVC

• Android開發中的Broadcast

從中可以看出一點, 所謂的響應式編程很多是基于event bus或observer的, 那么有沒有一種更友好, 更強大, 更智能的響應式編程呢?

答案就是本文的主題: Functional Reactive Programming

What is Functional Reactive Programming

按照"國際慣例", 先看下Wiki FRP的定義

Functional reactive programming (FRP) is a programming paradigm for reactive programming (asynchronous dataflow programming) using the building blocks of functional programming (e.g. map, reduce, filter)

簡單來說

Functional Reactive Programming = Functional Programming + Reactive Programming

由此, 函數響應式編程集合了兩家之所長

那為什么是Functional Programming和Reactive Programming在"一起"了呢? 我認為因為他們兩者都最"合適"

• 函數式編程的這種輸入輸出特性, 本身就帶著些響應式的味道

• 響應式以往的實現都沒有函數式這樣的: 簡潔, 流暢(想想鏈式的絲滑)和高度統一(想想filter, map, 再對比下各種廣播觀察者event bus云云)

Functional Reactive Programming in iOS

ReactiveCocoa

在iOS開發中, 現在一說到函數響應式或MVVM首先想到的應該就是ReactiveCocoa了

我們來看一個ReactiveCocoa的例子(引自ReactiveCocoa Tutorial – The Definitive Introduction: Part 1/2)

[[[self.usernameTextField.rac_textSignal
    map:^id(NSString *text) {
        return @(text.length);
    }]
    filter:^BOOL(NSNumber *length) {
        return [length integerValue] > 3;
    }]
    subscribeNext:^(id x) {
        NSLog(@"%@", x);
    }];

FilterAndMapPipeline.png

RxSwift

iOS開發中, 如果你已經使用Swift語言開發, 除了ReactiveCocoa還可以考慮RxJava

它的最大優勢就是屬于ReactiveX旗下的Swift版本, 精通了RxSwift就可以無縫切換至RxJS, RxJava, RxAndroid,Rx.Net, RxRuby...

我們來看一個用RxSwift實現UITableView的例子(引自 【RxSwift系列】用RxSwift實現一個UITableView（一）)

ViewModel的方法看起來應該是這樣的

PS: 在真實應用中, 數據應該是通過網絡請求解析JSON數據而獲得來的

import Foundation
import RxSwift
import RxDataSources

class ViewModel: NSObject {

    func getUsers() -> Observable<[SectionModel<String, User>]> {
    return Observable.create { (observer) -> Disposable in
        let users = [User(followersCount: 19_901_990, followingCount: 1990, screenName: "Marco Sun"),
            User(followersCount: 19_890_000, followingCount: 1989, screenName: "Taylor Swift"),
            User(followersCount: 250_000, followingCount: 25, screenName: "Rihanna"),
            User(followersCount: 13_000_000_000, followingCount: 13, screenName: "Jolin Tsai"),
            User(followersCount: 25_000_000, followingCount: 25, screenName: "Adele")]
        let section = [SectionModel(model: "", items: users)]
        observer.onNext(section)
        observer.onCompleted()
        return AnonymousDisposable{}
    }
}

viewDidLoad()方法是這樣的

override func viewDidLoad() {

    super.viewDidLoad()
    view.addSubview(tableView)
    tableView.registerClass(TableViewCell.self, forCellReuseIdentifier: reuseIdentifier)

    viewModel.getUsers()
        .bindTo(tableView.rx_itemsWithDataSource(dataSource))
        .addDisposableTo(disposeBag)
}

Functional Reactive Programming in Android

RxJava

The example below shows what you may already be familiar with:

It calls to the web service, uses a callbacks interface to pass the successful result to the next web service call, define another success callback, and then moves on to the next web service request

As you can see, this results in two nested callbacks

Old Style

// The "Nested Callbacks" Way
    public void fetchUserDetails() {
        // first, request the users...
        mService.requestUsers(new Callback<GithubUsersResponse>() {
            @Override
            public void success(final GithubUsersResponse githubUsersResponse,
                                final Response response) {
                Timber.i(TAG, "Request Users request completed");
                final List<GithubUserDetail> githubUserDetails = new ArrayList<GithubUserDetail>();
                // next, loop over each item in the response
                for (GithubUserDetail githubUserDetail : githubUsersResponse) {
                    // request a detail object for that user
                    mService.requestUserDetails(githubUserDetail.mLogin,
                                                new Callback<GithubUserDetail>() {
                        @Override
                        public void success(GithubUserDetail githubUserDetail,
                                            Response response) {
                            Log.i("User Detail request completed for user : " + githubUserDetail.mLogin);
                            githubUserDetails.add(githubUserDetail);
                            if (githubUserDetails.size() == githubUsersResponse.mGithubUsers.size()) {
                                // we've downloaded'em all - notify all who are interested!
                                mBus.post(new UserDetailsLoadedCompleteEvent(githubUserDetails));
                            }
                        }

                        @Override
                        public void failure(RetrofitError error) {
                            Log.e(TAG, "Request User Detail Failed!!!!", error);
                        }
                    });
                }
            }

            @Override
            public void failure(RetrofitError error) {
                Log.e(TAG, "Request User Failed!!!!", error);
            }
        });
    }

Now, let’s look at the same functionality written with RxJava

public void rxFetchUserDetails() {
        //request the users
        mService.rxRequestUsers().concatMap(Observable::from)
        .concatMap((GithubUser githubUser) ->
                        //request the details for each user
                        mService.rxRequestUserDetails(githubUser.mLogin)
        )
        //accumulate them as a list
        .toList()
        //define which threads information will be passed on
        .subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread())
        //post them on an eventbus
        .subscribe(githubUserDetails -> {
            EventBus.getDefault().post(new UserDetailsLoadedCompleteEvent(githubUserDetails));
        });
    }

RetroFit

現在Android很火的RetroFit結合RxJava就可以寫出"動人"的函數響應式實現來

NetworkUtil.getTestObjectRxApi().getTestObjects()
        .doOnNext(new Action1<Map<String, List<TestObjectBean>>>() {
            @Override
            public void call(Map<String, List<TestObjectBean>> stringListMap) {
                Logger.e(Thread.currentThread().getName());
                TestObjectBean testObjectBean = stringListMap.get("results").get(0);
                Logger.d("objectId = " + testObjectBean.getOb());
                testObjectBean.setOb("new id");
            }
        })
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<Map<String, List<TestObjectBean>>>() {
            @Override
            public void onCompleted() {
                Logger.e(Thread.currentThread().getName());
                Logger.d("completed");
            }

            @Override
            public void onError(Throwable e) {
                Logger.e(e.getMessage());
            }

            @Override
            public void onNext(Map<String, List<TestObjectBean>> stringListMap) {
                Logger.e(Thread.currentThread().getName());
                for (TestObjectBean testObjectBean : stringListMap.get("results")) {
                    Logger.d(testObjectBean);
                }
            }
        });

References

• What Is Functional Programming?

• Which Programming Languages Are Functional?

• Functional programming

• Tail recursion

• Swift Functional Programming Tutorial

• 淺談函數式編程和函數響應式編程

• 深入淺出－iOS函數式編程的實現 && 響應式編程概念

• Wiki Reactive Programming

• [ Android ] Fresco 與 Picasso 、Glide 的比較

• Picasso&Glide&Fresco比較

• Java Functional Reactive 編程

• ReactiveCocoa vs RxSwift - pros and cons? [closed]

• 【RxSwift系列】用RxSwift實現一個UITableView（一）

• What is Functional Reactive Programming?

更多文章, 請支持我的個人博客