👩‍👧 👷 ⚠️ Ne me trompez pas avec votre programmation fonctionnelle 🖕🏼 ☎️ 👨🏼‍🍳

Les adeptes de la programmation fonctionnelle aiment attirer les nouveaux arrivants avec des promesses d'expressivité parfaite du code, de correction à 100%, de facilité de support et de refactorisation, et parfois même de prédire les performances les plus élevées. Cependant, les développeurs expérimentés savent que cela ne se produit pas. La programmation est un travail difficile et les «pilules magiques» n'existent pas.

D'un autre côté, des éléments d'un style de programmation fonctionnel ont déjà pénétré dans des langages de programmation industriels tels que Swift et Kotlin. Les développeurs de ces langages connaissent bien la programmation fonctionnelle, ils ont donc pu l'utiliser «dans le petit», fournissant la plupart, mais pas la totalité, des composants nécessaires. Plus loin - plus il y a de parties de FI introduites dans les armes nucléaires industrielles, et mieux et plus complètement le soutien est mis en œuvre.

Pouvoir programmer dans un style fonctionnel est utile pour simplifier votre travail, et maintenant nous allons voir comment l'utiliser!

Vitaliy Bragilevsky est professeur de FP, de théorie des algorithmes et de calcul, auteur du livre "Haskell in Depth" et membre des comités Haskell 2020 et du comité de surveillance du compilateur GHC.

Bref historique

Les histoires de programmation fonctionnelle ne sont pas toujours vraies. Souvent, les gens parlent de la FA comme ça.

«Il était une fois dans une galaxie très lointaine, la programmation était simple, directe et bonne. Les algorithmes et les structures de données sont programmés et tout va bien - pas de problèmes!

Puis sont arrivées les personnes effrayantes ~~Sith~~ qui ont décidé que tous les programmes se composaient de classes: '' Programmation orientée objet pour tout le monde! Tout doit être écrit uniquement par de telles méthodes. ''

Quand ils ont gagné en force, il est devenu impossible de développer des logiciels - beaucoup de problèmes sont apparus. Pour sauver les malheureux développeurs qui souffrent, et il y a une programmation fonctionnelle. "

L'essentiel dans le salut est de dessiner une image magnifique et dénuée de sens.

Lorsque vous appliquez tout dans l'image, le bonheur, la paix et la tranquillité viendront et les problèmes de développement de logiciels seront résolus.

L'histoire est belle, mais en réalité tout est différent. C'est ainsi que je représente la programmation fonctionnelle et industrielle.

La programmation fonctionnelle est le laboratoire de Faraday - le berceau d'idées qui sont ensuite appliquées à la programmation industrielle.

Dans une conversation sur les langages de programmation industriels, les concepts de savoir s'ils sont fonctionnels ou non, qu'ils utilisent FP ou non, ne devraient pas être soulevés!

La principale mission du PC est de transmettre de bons éléments aux langues dominantes.

Vouloir transférer tout le monde sur des rails fonctionnels revient à forcer les scientifiques à mener des expériences comme Faraday - cela n'a aucun sens. Personne ne mène actuellement d'expériences sur l'électricité avec des méthodes aussi obsolètes.

Regardons des exemples.

Fonction John McCarthy

John McCarthy est l'un des créateurs de Lisp.

Fortran était le principal langage de programmation il y a 65 ans. Il a une déclaration conditionnelle:

        IF (I.NE.0) GOTO 40
        STMT-1
        STMT-2
40      STMT-3

I 0, «40».

, , . , XIF(M, N1,N2), , : N1 N2.

: «… » , .

— N1 N2. , ?

:

M==0 ? N1 : N2

. . , , - .

?

— . 1977 . « ?». — — , .

— , .

- :

c := 0 
for i := 1 step 1 until n do
    c := c + a[i]*b[i]

— .

. FP.

Def DotP = (Insert +) o (ApplyToAll x) o Transpose

— o, , , .

— — , , .

. .

, - Java . , , , .

, , :

, ;
;
;
.

, .

fun countLinesInFiles(fnames: List<String>): Int
    = fnames.map { File(it).readLines().size }
        .sum()

Kotlin, , . ?

, , . — «map» — . , : , . it — . — sum().

, map Kotlin, , . , . — readLines .

Haskell

, Haskell.

countLines :: FilePath -> IO Int
countLines = fmap (length . lines) . readFile 

countLinesInFiles :: [FilePath] -> IO Int
countLinesInFiles = fmap sum . traverse countLines

, , . Haskell , , .

. , : , Int — .

. «IO», Haskell , -. « », Int, IO Int. , .

. — Haskell. — FilePath, IO Int — . : , traverse — , «countLines».

. «. » ( o) — . , .

«f. g» — , «x» «f(g(x))». , . , . .

.

, , . — , .

UML-. : , , , , .

Swift

, , - . Swift , , .

protocol Shape {
    func area() -> Double
    func diameter() -> Double
}

class Circle: Shape {
    var r = 0.0
    init(radius: Double) {
        r = radius
    }
    func area() -> Double {
        return 3.14 * r * r
    }
    func diameter() -> Double {
        return 2 * r
    }
}

class Square: Shape {
    var s = 0.0
    init(size: Double) {
        s = size
    }
    func area() -> Double {
        return s * s
    }
    func diameter() -> Double {
        return sqrt(2) * s
    }
}

, .

: , , – , . .

, , .

func testShape(shape: Shape) {
    print(shape.area())
    print(shape.diameter())
}

. .

testShape(shape: Circle(radius: 5))
testShape(shape: Square(size: 5))

78.5
10.0
25.0
7.0710678118654755

, , , , - . – , .

Haskell

Haskell, , Swift.

data Shape = Circle Double | Square Double

area :: Shape -> Double
area (Circle r) = 3.14 * r * r
area (Square s) = s * s

diameter :: Shape -> Double
diameter (Circle r) = 2* r
diameter (Square s) = sqrt 2 * s

. , « » — . «» . .

— , , . Haskell — . , .

:

> area (Circle 5)
78.5
> diameter (Circle 5)
10.0
> area (Square 5)
25.0
 diameter (Square 5)
7.0710678118654755

— — , .

, Swift Haskell . , , , . , , — , — , , .

	Circle	Square
area	*	*
diameter	*	*

— , — . — , .

, : ? . .

, :

— ;
— , , , .

— .

, Swift.

Haskell…

data Shape = Circle Double | Square Double

… Swift .

enum Shape { 
    case Circle(radius: Double) 
    case Square(size: Double)
}

. «» , Swift «enum», . , .

Haskell…

area :: Shape -> Double 
    area (Circle r) = 3.14 * r * r 
    area (Square s) = s * s

… Swift .

extension Shape {
    var area: Double {
        switch self {
            case .Circle(let r): return 3.14 * r * r 
            case .Square(let s): return s * s
        }
    }
}

, — .

Kotlin:

sealed class Shape {
    data class Circle(val radius: Double): Shape() 
    data class Square(val size: Double): Shape()
}
fun area(sh: Shape): Double {
    return when (sh) {
        is Shape.Circle -> 3.14 * sh.radius * sh.radius 
        is Shape.Square -> sh.size * sh.size 
    }
}

, — .

, Kotlin Swift ? , , , . , -, .

. , , , , , .

	Circle	Square	x
area	*	*	?
diameter	*	*	?
f	?	?	?

, , , - — . . : — . , , .

	Circle	Square	x
area	*	*	+ ()
diameter	*	*	+ ()
f	+ ()	+ ()	?

. .

. . — - , — , . — .

— — . 20 , .

«Visitor». , , . , .
.
— .
.
.

, « », . . , — , .

, .

, : , , , . , .

Haskell. , , , «» ?

, «» — .

— «Composite». . , .

, Kotlin — .

val a = "Hello " 
val b = "world"
val c = a + b

, : «, ? ». , — - .

— HTTP-. Kotlin :

val a = HttpReq("f","v1") 
val b = HttpReq("f2","v2")
val c = a + b

Haskell , . HTTP- — . HTTP-.

. . - . — , — , . «optional chaining», , Swift.

if let johnsStreet = john.residence?.address?.street
{ /* SUCCESS */ } else { /* FAILURE */ }

, . «john» — .

?. , , false.
, .
.
— .

: , , . — . , else — . .

Swift . , , , : .

Haskell, .

case residence john >>= address >>= street of
    Just johnsStreet -> -- SUCCESS
    Nothing -> -- FAILURE

, «>>=» — . .

Swift «optional chaining» . Kotlin . Haskell , «>>=».

:

, , .
, Haskell.

. . , . , — , .

, — .

«» . — , . «», . « » .

— ?

. , — .

, — . Haskell «Build Systems a la Carte» . Distinguished Paper Award International Conference on Functional Programming (ICFP) - 2018 . Build-, .

Build- Build- — . .

data Store i k v

i — ;
k — , , ;
v — , , , .

— . — , . .

. , , . , - -, , .

— «Task» — .

newtype Task c k v = Task { run :: forall f. c f => (k -> f v) -> f v }

Haskell, . , — «f», . , .

? «k -> fv» — - . . . Build-.

— :

type Tasks c k v = k -> Maybe (Task c k v)

, , . «Maybe» — - «optional». , - - , .

Build-:

type Build c i k v = Tasks c k v -> k -> Store i k v
    -> Store i k v

. k, . — . , .

.

Make,
Shake — Make Haskell,
Bazel,
Excel.

. — Excel — . Excel — . , - . Make Excel - , .

—

.

— Haskell . , .

, . - — . , , . , .

, Haskell:

h :: [a] -> Int
h = length . filter p . map g . map f

— . - , :

map f — f;
map g — g;
filter p — : , , ;
length — — .

:

— , , … ! !

, .

Fusion

«fusion», .

«fusion»? -: :

c := 0
foreach (x : xs)
    if p(g(f(x)))
        then c := c + 1

, (!), (!). , , 2-3 .

, , , . — .

, .

GPU? !

Haskell, :

dotp :: Acc (Vector Float) -> Acc (Vector Float) -> Acc (Scalar Float) 
dotp xs ys = fold (+) 0 (zipWith (*) xs ys)

, Haskell: 2 , , . , Haskell GPU. GPU, : CUDA, Open CL — , . Accelerate Haskell — .

CUDA 100 , , . ! , . , .

— . ? a, b, c D.

f :: A -> B -> C -> D
f a b c = ...

, — . , :

f :: A -> B -> C -> D
f a :: B -> C -> D
f a b :: C -> D
f a b c :: D

, . , , - , . — , , .

, , Scala -.

f :: A -> (B , C) -> D
f a p = …
    f :: A -> B -> C -> D
    f a :: (B, C) -> D
    f a p :: D

: « , . , . , — ». .

, .

. Haskell 15 QuickCheck, .

, , :

reverse :: String -> String
reverse = ...

, . , .

> quickCheck (\s -> reverse (reverse s) == s)
    +++ OK, passed 100 tests.

, . , 100, , , .

, , . . Haskell 15 . . , Swift Kotlin .

, ?

abs :: Int -> Int 
abs x = if x < 0 then 0 - x else x

head :: [a] -> a --      ! 
head (x:_) = x 

example :: Int -> Int
example x = if abs x < 0 then head [] else x

, .

head :: [a] -> a --      ! 
head (x:_) = x

, head , — .

«head», ? , LiquidHaskell . LiquidHaskell — Haskell-.

{-@ abs :: Int -> { n : Int | 0 <= n } @-} 
abs :: Int -> Int 
abs x = if x < 0 then 0 - x else x

{-@ head :: { xs : [a] | 1 <= len xs } -> a @-} 
head :: [a] -> a --      ! 
head (x:_) = x 

{-@ head :: { xs : [a] | 1 <= len xs } -> a @-} 
head :: [a] -> a --      ! 
head (x:_) = x

, abs , n.

{-@ abs :: Int -> { n : Int | 0 <= n } @-} 
abs :: Int -> Int 
abs x = if x < 0 then 0 - x else x

, .

{-@ head :: { xs : [a] | 1 <= len xs } -> a @-} 
head :: [a] -> a --      ! 
head (x:_) = x

, , . x x.

{-@ example :: x : Int -> { y : Int | x == y } @-} 
example :: Int -> Int
example x = if abs x < 0 then head [] else x

, . , . , - . - - , , Eiffel, - .

?

type MyAPI = Get '[PlainText] String
    :<|> "conf" :> Get '[JSON] String
    :<|> "year" :> Get '[JSON] Int
    :<|> "like" :> Get '[JSON] Bool
myAPI :: Server MyAPI 
    = root :<|> year :<|> conf :<|> like

Haskell Servant, API . , url , , , JSON. , : String», Int», Bool.

.

root :: Handler String				
root = pure "Welcome to my REST API" 	
conf :: Handler String				
conf = pure "AppsConf"	   		
year :: Handler Int
year = pure 2019 conf
like :: Handler Bool
like = pure True

— , .

, . , , . — .

— . , . .

— « Haskell». 2018 . , . Haskell. 600 , .

«Haskell in Depth» . , , . «slbragilevsky» 42%.

Saint AppsConf , Introductory- , . , , . , iOS, Android, - — . , , .

telegram-, .

Ne me trompez pas avec votre programmation fonctionnelle

Bref historique

Fonction John McCarthy

?

Haskell

Swift

Haskell

— ?

—

Fusion

GPU? !

?

More articles: