🎼 👨🏽‍🏫 👧🏼 नहीं, डायनामिक टाइप सिस्टम अनिवार्य रूप से अधिक खुले नहीं हैं 🌹 🧐 🙋🏿

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

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

दो प्रकार के बारे में झूठ

, . , , /r/programming:

[…], . , , «» , , - .
, , . JSON , . , . […] « » , .

, , , , . , - , , ? , , .

Hacker News :

, , pickle.load()?

, , , . , , .

, , . , , : . , ; , .

,

: , , , , ! , . , .

. , , . (payload), . , - , JSON EDN.

, , :

{
  "event_type": "signup",
  "timestamp": "2020-01-19T05:37:09Z",
  "data": {
    "user": {
      "id": 42,
      "name": "Alyssa",
      "email": "alyssa@example.com"
    }
  }
}

signup- . , . JavaScript, :

const handleEvent = ({ event_type, data }) => {
  switch (event_type) {
    case 'login':
      /* ... */
      break
    case 'signup':
      sendEmail(data.user.email, `Welcome to Blockchain Emporium, ${data.user.name}!`)
      break
  }
}

, Haskell? , Haskell, , , :

data Event = Login LoginPayload | Signup SignupPayload
data LoginPayload = LoginPayload { userId :: Int }
data SignupPayload = SignupPayload
  { userId :: Int
  , userName :: Text
  , userEmail :: Text
  }

instance FromJSON Event where
  parseJSON = withObject "Event" \obj -> do
    eventType <- obj .: "event_type"
    case eventType of
      "login" -> Login <$> (obj .: "data")
      "signup" -> Signup <$> (obj .: "signup")
      _ -> fail $ "unknown event_type: " <> eventType

instance FromJSON LoginPayload where { ... }
instance FromJSON SignupPayload where { ... }

handleEvent :: JSON.Value -> IO ()
handleEvent payload = case fromJSON payload of
  Success (Login LoginPayload { userId }) -> {- ... -}
  Success (Signup SignupPayload { userName, userEmail }) ->
    sendEmail userEmail $ "Welcome to Blockchain Emporium, " <> userName <> "!"
  Error message -> fail $ "could not parse event: " <> message

, (, , ). . , Reddit, , Haskell , ! Event, . , ? .

, JavaScript . , switch . , JavaScript . , .

, , . Event, , handleEvent. JavaScript, , :

const handleEvent = ({ event_type, data }) => {
  switch (event_type) {
    /* ... */
    default:
      throw new Error(`unknown event_type: ${event_type}`)
  }
}

, . , , . , , Haskell:

handleEvent :: JSON.Value -> IO ()
handleEvent payload = case fromJSON payload of
  {- ... -}
  Error _ -> pure ()

- «, », , . , ( ) . , ! , .

: Event Haskell « », , . , , . , , , .

, , , :

Haskell, . , , timestamp, . , , , , , !
, , Haskell userId SignupPayload, . , (, , userId ), ; , , , .
, , (shotgun parsing), , .

, , , , , . , , . , , , , , , .

JavaScript , Haskell: , JSON event_type «» signup data.user.name data.user.email. ! , JavaScript , . , ; , , - .

, , , , .

, , , - -. , , . , . JavaScript :

const handleEvent = (payload) => {
  const signedPayload = { ...payload, signature: signature(payload) }
  retransmitEvent(signedPayload)
}

( signature JSON), , . , ?

, : , . Haskell:

handleEvent :: JSON.Value -> IO ()
handleEvent (Object payload) = do
  let signedPayload = Map.insert "signature" (signature payload) payload
  retransmitEvent signedPayload
handleEvent payload = fail $ "event payload was not an object " <> show payload

, , JSON.Value. Event — JSON , , .

: , JSON- ( -), - JSON, - . , , , , . .

, , Haskell, JavaScript! JavaScript handleEvent ( JSON ), , , , spread- … :

> { ..."payload", signature: "sig" }
{0: "p", 1: "a", 2: "y", 3: "l", 4: "o", 5: "a", 6: "d", signature: "sig"}

, . , . «» JSON Object, . -, , .

, . , API, , , UUID. «, » , API Haskell UUID:

type UserId = UUID

, Reddit, , ! API , UUID, , . UUID , , , ! , ?

, — . , — . , UserId — :

newtype UserId = UserId Text
  deriving (Eq, FromJSON, ToJSON)

, UUID, UserId, , Text. ( , ), UserId — FromJSON. , , UserId — UserId ToJSON. : .

, , . UserId , UserId .

, FromJSON UserId, , , fromJSON . , - . , , … UserId. , , ( , , , ).

— , . , , , .

-

, , , , , . pickle.load() Python? , , Python. pickle.dump(), pickle.load().

, , pickle.load(), — , pickle.dump(). , , . , , , .

, JSON, , pickle Python Python , . ? , , pickle.load(). , :

def load_value(f):
  val = pickle.load(f)
  #  -  `val`

, val , , , , , - . - - , , pickle.load(f) , , val!

, , , val val.foo() , . Java, val — , :

interface Foo extends Serializable {
  String foo();
}

, pickle.load() Java:

static <T extends Serializable> Optional<T> load(InputStream in, Class<? extends T> cls);

, , pickle.load(), Class<T> . Serializable.class , . : , -, - , ! , , JSON-.

Haskell? — serialise, API, , Java, . API , Haskell JSON, aeson, , , JSON Haskell — - - , -.

, , pickle.load(), . , . - , , , , . , (, REPL ), , .

. , , , , - , «» , , . , , , , , .

. , , , ( ). , , «» .

: ,

: . , , , , , .

, , . -, - (nominal typing). , , , , . , . , .

, , , , . , , -, , ( ).

. JavaScript Clojure - , - , . ( ) .

, , - , , . ( ) , (nominal typing). , ; (boilerplate).

, , . , , , . , :

, , , , . ( ), : , .
, , - . , , , . , .

Python, , , , TypeScript, , . , . - Clojure — , - — , - Clojure, - .

, : TypeScript, Flow, PureScript, Elm, OCaml Reason, . — Haskell, ; Haskell ( , ) .

, Haskell .

, Haskell , ? , ; Haskell, , . Haskell, , . , Haskell, , , . ( , , Haskell!)

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

नहीं, डायनामिक टाइप सिस्टम अनिवार्य रूप से अधिक खुले नहीं हैं

दो प्रकार के बारे में झूठ

,

-

: ,

More articles: