# Tag Archives: FP

# Monad (functional programming) – Wikipedia

# Functional Programing in Data Science Projects

“Functional Programing in Data Science Projects” by Nathanael Weill https://link.medium.com/UiysKbFl16

# Algebraic Data Type vs Algebraic Data Structure

**Algebraic Data Type**:

- Product Type
- Sum Type: Either

Functor (map) :

# Introduction to functional programming with Python examples

# The “Bible of Functional Programming” 《Structure and Interpretation of Computer Programs》

# Kevlin Henney 2017 – Functional C++

Very good presentation of Functional C++ by the guru Kevlin Henney.

Piping (Functional Composition) in Channels Asynchronously Concurrency:

h

…

# Functional C++ for Fun and Profit

# Functional Programming in C++

# Functional Programming Python: Lambdas, Decorators, and Other Magic

https://dev.to/codemouse92/dead-simple-python-lambdas-decorators-and-other-magic-5gbf

Python is multi-paradigm: OO or FP.

Useful Functional Programming Techniques :

**Closure**: local variables**Resursion**: stop unlimiting looping**Lambdas**: anonymous function for 1-time throw-away functions- Nested Function: function returns a function as result.
**Decorators**: wrap an existing function with additional features without modifying it.

# OO vs FP in Java language

# What the heck is polymorphism? – DEV Community

https://dev.to/jvanbruegge/what-the-heck-is-polymorphism-nmh

Examples: Generics

# Quora: What is an ALGEBRA structure

What is an algebra? by Tikhon Jelvis https://www.quora.com/What-is-an-algebra/answer/Tikhon-Jelvis?ch=3&share=2dd8711d&srid=oZzP

“Basically, an algebra is just an algebraic structure. It’s some set A along with some number of functions closed over the set. It’s a generalization over the structures we normally study: a group is an algebra, a ring is an algebra, a lattice is an algebra… etc.

Algebras have different “signatures” which specify the functions it has. For example, a group is an algebra that has an identity element, a function of one argument and a function of two arguments.

That is, a group with a carrier set A is just a tuple:

⟨A, 0:A, −:A→A, +:A×A→A⟩

For uniformity, we can write all of these as functions in the form An→A, where n is the “arity” of a function—the number of arguments it has. The identity element is a function A0→A, which just identifies a single element from A. Thus, we can talk about the signature of an algebra as the arities of its functions.

A group would be (0, 1, 2) while a ring would be (0, 0, 1, 2, 2).

Generally, the functions of an algebra have to be associative. Sometimes, we also look at other laws—for example, we might want to study algebras with commutative operations like Abelian groups.

So the intuition for an algebra in general is that it’s any structure like a group, a ring or whatever else we like. As the name “structure” implies, these additional operations on a set expose the internal structure of its elements:

a group describes symmetries, a lattice describes a partial order and so on.

The study of algebras, then, can be thought of as the study of “structured sets” in general.”

# The Software War : Object-Oriented Programming (OOP) vs Functional Programming (FP)

The “war” of **OOP** vs *FP* is akin to **Applied Math** vs *Pure Math*.

The formers (OOP & Applied Math) are not “rigourous” but practical, compared to the laters (FP & Pure Math) which are elegant but too abstract for popular usage.

OOP: SmallTalk and its followers – C++, C#, Objective-C, Java…

FP: LISP and its followers – Haskell, Clojure, …

The “hybrid” (OOP&FP): Scala, Kotlin (Google: Java ‘cousin’), Swift (Apple: Objective -C ‘cousin’), F# (MicroSoft)

The “cons” of OOP, which are bad for concurrency / parallel computing in multi-cored CPU:

- State changed
- Side-effect
- Mutability of data
- Polymorphism

https://blog.cleancoder.com/uncle-bob/2014/11/24/FPvsOO.html

# State in Functions: Cache, Lazy + Memoization, and Counter

How to keep state (counter, threshold, etc) in Functional Programming without BAD side effect ?

https://dzone.com/articles/functionalfun-states-in-functions-cache-lazy-and-c

# Choosing a Programming Language

# Crash course in Category Theory

**Key Point**:

Haskell & any FP compiler don’t check the Category Theory proof if your codes (eg. fmap) follow Functor’s Laws (eg. Preserve structure, identity) or Monad’s Laws !

# Android Architecture Simplified with Kotlin

I hate Android Architecture since it is based on OO Java, Kotlin is FP cousin of Java, hopefully it could simplify the Android Architecture by getting rid of the complex OO architecture. Here Antonio attempts to simplify it with more terse Kotlin codes, albeit still in the OO architecture spirit.

# Goodbye OO, Welcome FP

**OO** = Object-Oriented, eg. Smalltalk, C++, Java

**FP** = Functional Programming, aka “**Mathematical**” Programming Language eg. Lisp, Haskell, Scala (hybrid OO+FP), Kotlin (hybrid OO+FP).

Three “**weaknesses**” (also “strengths”) of OO :

1. Inheritance

2. Polymorphism

3. Encapsulation

# Kotlin+FP = Kategory

**Tail Recursion in Kotlin:**

**The Cost of Kotlin**:

**“Gang of Four” Design Pattern with Kotlin**

# FP Style: Collection Pipeline

# Higher Order Components

**Functional Programming in Javascript:**

https://medium.freecodecamp.org/higher-order-components-the-ultimate-guide-b453a68bb851

# Quora: Functional Programming / Side Effect / Monads

# “Arrow “: Functional Kotlin

`Λrrow`

is a functional programming library for the Kotlin programming language born from the fusion of KΛTEGORY and funKTionale.

Kategory and Funktionale were the two most relevant FP libraries for Kotlin in 2017.

# Functional Programming : Batch Data Processing

# OOP 与 FP 笔记

# Lambda Calculus – The Math Behind Functional Programming

Functional Programming (FP) Languages : Lisp, Haskell, Scala, Kotlin, etc.

Other non-FP influenced by Lambda Calculus: Python, Ruby, Javascript, Java 8, C++

Inventor of Lambda Calculus : Alonzo Church (1903 – 1995), whose student in Princeton University (1936-1938) was Alan Turing (The Father of **Artificial Intelligence**).

Lambda Calculus is not : another Differential Calculus !

**Note**: Calculus has a meaning of manipulating symbolic expressions : either in functions (differentiation, integration) or computations.

Lambda Calculus is almost programming!

**I. Syntax of Lambda Calculus**:

eg.

Notice: it has only one parameter “x”.

- Function definition:
- Identifier reference:
- Function application:

**II. ****Currying 柯里化 :** (named after Haskell Curry ) for ** multiple** parameters.

eg.

written by “**Currying**” as :

Syntactic Sugar语法糖 : a notational shorthand. Eg. “cubic”

cubic = λ x . x * x * x

**III. Binding**: Every parameter (aka variable) must be declared (*syntactically binding*).

eg.

here, x is **bound, **but z is **FREE** (error!)

**IV. Two Execution Methods: **

1.

- rename variables to avoid conflict

2.

**Eager**evaluation strategy : Right to Left (innermost expression first to outermost) or**Lazy**evaluation strategy : Left to Right (outermost expression first to innermost) – don’t compute the value of an expression until you need to – (*save memory space and computing time*)- Most
**FP**are.**Lazy** - Most
**Procedural**(**Imperative**) languages (C, Fortran, Basic, …) are.**Eager**

**V. Lambda Calculus fulfilling the 3 conditions for “Turing Complete”** **Computation** :

**Unbounded**“**Storage**” (*not necessarily a physical device*) – generate arbitrarily complicated values in a variable or many functions without bound.**Arithmetic**– Church numerals (Peano arithmetic using functions): eg z=0, s= z+ 1 => 1 = λ s z . s z => 2 = λ s z . s ( s z ) … => 7= λ s z . s (s(s(s(s(s(s(z )))))))**Control Flow**– TRUE =*λ**t f . t*/ FALSE =*λ**t f . f / BoolAnd =**λ**x y . x y FALSE /**BoolOr =**λ**x y . x TRUE y /*Repetition by Recursion*(Y Combinator*)

Conclusion:Lambda Calculus = “Computer on paper”

**VI. Type** – Consistent Model (notation “**:**“)

eg. *λ** x **: I **. x + 3 ( I is Integer Type) *

*=> The result (x + 3) is also Type I since by inference “+” is of Type I -> I*

**Reference**: “Good Math” by Mark Chu-Carroll https://www.amazon.com/Good-Math-Computation-Pragmatic-Programmers/dp/1937785335/

# Explore Kotlin’s Advanced Functional Programming

Since May 2017 Kotlin released by Google, 12.8% Java developers have converted to Kotlin, yet they still keep to the OO spirit of Java (for Interoperability) , not taking full advantage of FP capability of Kotlin. The OO Design Patterns of Android Java still being used instead of the FP more elegant “Monadic” Design.

1. **Interview with Kotlin Designer:**

**2. Android Studio 3.0 Released **: https://www.androidauthority.com/android-studio-3-released-810099/

2a. **Android Studio** **v3.0** with Kotlin built-in & many improvements.

(The previous stable v2.3 needs seperate Kotlin plug-in)

2c: **Gradle upgrade**

https://zhuanlan.zhihu.com/p/30722989

3. **Inner / Infix Function**

http://thetechnocafe.com/more-about-functions-in-kotlin/

4. **Test** (**Mockito**)

https://proandroiddev.com/improve-your-tests-with-kotlin-in-android-pt-1-6d0b04017e80

https://proandroiddev.com/improve-your-tests-with-kotlin-in-android-pt-2-f3594e5e7bfd

**Kluent library:**

https://proandroiddev.com/improve-your-tests-with-kotlin-in-android-pt-3-104e1c9f77cc

5. **Function vs Procedure vs Method** – **Kotlin** simplifies all 3 into 1 : **Function **which always returns a value or UNIT.

6. Kotlin has which Java lacks … “**with**“, “?”, …

https://blog.simon-wirtz.de/kotlin-features-miss-java/

7. Kotlin **Operator Overloadin**g aka “Convention”: ‘plus’ / ‘+’

https://blog.simon-wirtz.de/kotlin-conventions-operator-overloading/

8. **JVM Byte Code Generation**:

https://blog.simon-wirtz.de/kotlin-on-the-jvm-byte-code-generation/

9. **Reified** Types

https://blog.simon-wirtz.de/kotlin-reified-types/

10. **SICP: Sequence as conventional interfaces: eg. flatmap, map, reduce, fold**

https://dzone.com/articles/conventional-interfaces-in-functional-programming

11.Kotlin中**extensions**的用法

https://zhuanlan.zhihu.com/weiweidaolai/27537731

12. **Generic : **Kotlin入门(11)江湖绝技之特殊函数

https://zhuanlan.zhihu.com/aqi00/28302792

13. Array <String>: Kotlin入门(4)声明与操作数组

https://zhuanlan.zhihu.com/aqi00/27744799

14. **ViewPager** (Horizontal Swipe)

https://www.raywenderlich.com/169774/viewpager-tutorial-android-getting-started-kotlin

15. **Kotlin 1.2 Beta **& **Multiplatform iOS**

https://blog.jetbrains.com/kotlin/2017/11/kotlinconf-keynote-recap/

16. **Kotlin Edu ( Android Studio 3.0)**

https://www.jetbrains.com/education/kotlin-edu/

17. **Kotlin Style Guide**

https://android.github.io/kotlin-guides/style.html

18.** Android Layout Foundamental** – **ConstraintLayout**

https://developer.android.com/guide/topics/ui/declaring-layout.html

19. **Android SDK **

https://www.raywenderlich.com/171148/android-sdk-versions-tutorial-2

20. **Javalin v1.0** – Web Framework for Java + Kotlin

https://jaxenter.com/javalin-1-0-is-here-138750.html

21. **Ten Modern Features **(Kotlin, Clojure, Javascript, Swift…)

22. **Function literals with receiver**

https://blog.simon-wirtz.de/function-literals-with-receiver-quick-introduction/#page

23. **Sealed classes**: (restricted types no “else”)

https://mindorks.com/course/advance-kotlin/chapter/id/1

24. **Android Intent**

https://www.raywenderlich.com/171071/android-intents-tutorial-kotlin

25. **Top kotlin tutorials**

26. Kotlin **Contexts** & **Shared Preferences**

https://blog.stylingandroid.com/kotlin-contexts-sharedpreferences/

27. **Delegation – but not Inheritance (which takes all)**

https://blog.kotlin-academy.com/superpowers-of-kotlin-delegation-e6bd9ff8026c

28. **Functions or Properties Reference (cool *)**

29. **Web Framework** **ktor**:

# What is a Monoid / Monad – in Scala Functional Programming

**Monoid** = an **Algebraic** structure (“Algebra” ) with: Associativity & Identity

**Monad = Monoid + Endo-Functors**

https://livebook.manning.com/#!/book/functional-programming-in-scala/chapter-10/37

# Deep Learning is Functional Programming

Functional Programming “**Clojure**“-based DeepLearning :

https://medium.com/towards-data-science/functional-programming-for-deep-learning-bc7b80e347e9