🗾 🔎 🤡 मुझे अपने कार्यात्मक प्रोग्रामिंग के साथ बेवकूफ मत बनाओ ⛹️ 👩‍👦‍👦 ◀️

कार्यात्मक प्रोग्रामिंग अनुयायियों को सही कोड अर्थकता, 100% शुद्धता, समर्थन में आसानी और रीफैक्टरिंग में आसानी के वादे के साथ नवागंतुकों को लुभाना पसंद है, और कभी-कभी उच्चतम प्रदर्शन की भविष्यवाणी भी करते हैं। हालांकि, अनुभवी डेवलपर्स जानते हैं कि ऐसा नहीं होता है। प्रोग्रामिंग कठिन काम है, और "जादू की गोलियाँ" मौजूद नहीं है।

दूसरी ओर, एक कार्यात्मक प्रोग्रामिंग शैली के तत्व पहले से ही स्विफ्ट और कोटलिन जैसी औद्योगिक प्रोग्रामिंग भाषाओं में प्रवेश कर चुके हैं। इन भाषाओं के डेवलपर्स अच्छी तरह से कार्यात्मक प्रोग्रामिंग से परिचित हैं, इसलिए वे इसे "छोटे" में उपयोग करने में सक्षम थे, कई के लिए प्रदान करते हैं, हालांकि सभी नहीं, आवश्यक घटकों के। दूर - एफआई के अधिक भागों को औद्योगिक परमाणु हथियारों में पेश किया जाता है, और बेहतर और पूरी तरह से समर्थन को लागू किया जाता है।

एक कार्यात्मक शैली में कार्यक्रम करने में सक्षम होना आपके काम को आसान बनाने के लिए उपयोगी है, और अब हम देखेंगे कि इसका उपयोग कैसे करें!

विटाली ब्रैगिल्वस्की , एफपी के एक शिक्षक, एल्गोरिदम और गणना के सिद्धांत, "हास्केल इन डेप्थ" पुस्तक के लेखक और हास्केल 2020 समितियों के सदस्य और जीएचसी संकलक की पर्यवेक्षी समिति है।

संक्षिप्त इतिहास

कार्यात्मक प्रोग्रामिंग कहानियां हमेशा सच नहीं होती हैं। अक्सर लोग एएफ के बारे में इस तरह की बात करते हैं।

“एक बार एक दूर, बहुत दूर आकाशगंगा में, प्रोग्रामिंग सरल, सीधी और अच्छी थी। एल्गोरिदम और डेटा संरचनाएं क्रमादेशित हैं और सब कुछ ठीक है - कोई समस्या नहीं!

तब ~~सिथ~~ डरावने लोग आए जिन्होंने तय किया कि सभी कार्यक्रमों में कक्षाएं शामिल हैं: '' सभी के लिए ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग! ऐसे तरीकों से ही सबकुछ लिखा जाना चाहिए। ''

जब उन्होंने ताकत हासिल की, तो सॉफ्टवेयर विकसित करना असंभव हो गया - बहुत सारी समस्याएं दिखाई दीं। दुर्भाग्यपूर्ण पीड़ित डेवलपर्स को बचाने के लिए, और कार्यात्मक प्रोग्रामिंग है। "

मोक्ष में मुख्य बात एक सुंदर और अर्थहीन तस्वीर खींचना है।

जब आप चित्र में सब कुछ लागू करते हैं, तो खुशी, शांति और शांति आ जाएगी, और सॉफ्टवेयर विकास की समस्याओं का समाधान हो जाएगा।

कहानी सुंदर है, लेकिन वास्तव में सब कुछ अलग है। इस प्रकार मैं कार्यात्मक और औद्योगिक प्रोग्रामिंग का प्रतिनिधित्व करता हूं।

कार्यात्मक प्रोग्रामिंग फैराडे की प्रयोगशाला है - उन विचारों का जन्मस्थान जो तब औद्योगिक प्रोग्रामिंग में लागू होते हैं।

औद्योगिक प्रोग्रामिंग भाषाओं के बारे में एक बातचीत में, कि वे कार्यात्मक हैं या नहीं, की अवधारणाएं कि वे एफपी का उपयोग करते हैं या नहीं, को नहीं उठाया जाना चाहिए!

एफपी का मुख्य मिशन अच्छे तत्वों को मुख्यधारा की भाषाओं तक पहुंचाना है।

सभी को कार्यात्मक रेल में स्थानांतरित करना चाहते हैं, वैज्ञानिकों को फैराडे जैसे प्रयोगों के लिए मजबूर करने के लिए समान है - इसका कोई मतलब नहीं है। वर्तमान में कोई भी इस तरह के अप्रचलित तरीकों के साथ बिजली पर प्रयोग नहीं कर रहा है।

आइए उदाहरणों को देखें।

जॉन मैकार्थी समारोह

जॉन मैकार्थी लिस्प के रचनाकारों में से एक हैं।

फोरट्रान 65 साल पहले मुख्य प्रोग्रामिंग भाषा थी। इसका एक सशर्त विवरण है:

        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-, .

मुझे अपने कार्यात्मक प्रोग्रामिंग के साथ बेवकूफ मत बनाओ

संक्षिप्त इतिहास

जॉन मैकार्थी समारोह

?

Haskell

Swift

Haskell

— ?

—

Fusion

GPU? !

?

More articles: