#![cfg(feature = "serde_core")]

use serde_core::de::{
    Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error, Unexpected, VariantAccess,
    Visitor,
};
use serde_core::ser::{Serialize, Serializer};

use crate::{Level, LevelFilter, LOG_LEVEL_NAMES};

use std::fmt;
use std::str::{self, FromStr};

// The Deserialize impls are handwritten to be case-insensitive using FromStr.

impl Serialize for Level {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match *self {
            Level::Error => serializer.serialize_unit_variant("Level", 0, "ERROR"),
            Level::Warn => serializer.serialize_unit_variant("Level", 1, "WARN"),
            Level::Info => serializer.serialize_unit_variant("Level", 2, "INFO"),
            Level::Debug => serializer.serialize_unit_variant("Level", 3, "DEBUG"),
            Level::Trace => serializer.serialize_unit_variant("Level", 4, "TRACE"),
        }
    }
}

impl<'de> Deserialize<'de> for Level {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct LevelIdentifier;

        impl<'de> Visitor<'de> for LevelIdentifier {
            type Value = Level;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("log level")
            }

            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let variant = LOG_LEVEL_NAMES[1..]
                    .get(v as usize)
                    .ok_or_else(|| Error::invalid_value(Unexpected::Unsigned(v), &self))?;

                self.visit_str(variant)
            }

            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
            where
                E: Error,
            {
                // Case-insensitive.
                FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES[1..]))
            }

            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let variant = str::from_utf8(value)
                    .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;

                self.visit_str(variant)
            }
        }

        impl<'de> DeserializeSeed<'de> for LevelIdentifier {
            type Value = Level;

            fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
            where
                D: Deserializer<'de>,
            {
                deserializer.deserialize_identifier(LevelIdentifier)
            }
        }

        struct LevelEnum;

        impl<'de> Visitor<'de> for LevelEnum {
            type Value = Level;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("log level")
            }

            fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
            where
                A: EnumAccess<'de>,
            {
                let (level, variant) = value.variant_seed(LevelIdentifier)?;
                // Every variant is a unit variant.
                variant.unit_variant()?;
                Ok(level)
            }
        }

        deserializer.deserialize_enum("Level", &LOG_LEVEL_NAMES[1..], LevelEnum)
    }
}

impl Serialize for LevelFilter {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match *self {
            LevelFilter::Off => serializer.serialize_unit_variant("LevelFilter", 0, "OFF"),
            LevelFilter::Error => serializer.serialize_unit_variant("LevelFilter", 1, "ERROR"),
            LevelFilter::Warn => serializer.serialize_unit_variant("LevelFilter", 2, "WARN"),
            LevelFilter::Info => serializer.serialize_unit_variant("LevelFilter", 3, "INFO"),
            LevelFilter::Debug => serializer.serialize_unit_variant("LevelFilter", 4, "DEBUG"),
            LevelFilter::Trace => serializer.serialize_unit_variant("LevelFilter", 5, "TRACE"),
        }
    }
}

impl<'de> Deserialize<'de> for LevelFilter {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct LevelFilterIdentifier;

        impl<'de> Visitor<'de> for LevelFilterIdentifier {
            type Value = LevelFilter;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("log level filter")
            }

            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let variant = LOG_LEVEL_NAMES
                    .get(v as usize)
                    .ok_or_else(|| Error::invalid_value(Unexpected::Unsigned(v), &self))?;

                self.visit_str(variant)
            }

            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
            where
                E: Error,
            {
                // Case-insensitive.
                FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES))
            }

            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let variant = str::from_utf8(value)
                    .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;

                self.visit_str(variant)
            }
        }

        impl<'de> DeserializeSeed<'de> for LevelFilterIdentifier {
            type Value = LevelFilter;

            fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
            where
                D: Deserializer<'de>,
            {
                deserializer.deserialize_identifier(LevelFilterIdentifier)
            }
        }

        struct LevelFilterEnum;

        impl<'de> Visitor<'de> for LevelFilterEnum {
            type Value = LevelFilter;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("log level filter")
            }

            fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
            where
                A: EnumAccess<'de>,
            {
                let (level_filter, variant) = value.variant_seed(LevelFilterIdentifier)?;
                // Every variant is a unit variant.
                variant.unit_variant()?;
                Ok(level_filter)
            }
        }

        deserializer.deserialize_enum("LevelFilter", &LOG_LEVEL_NAMES, LevelFilterEnum)
    }
}

#[cfg(test)]
mod tests {
    use crate::{Level, LevelFilter};
    use serde_test::{assert_de_tokens, assert_de_tokens_error, assert_tokens, Token};

    fn level_token(variant: &'static str) -> Token {
        Token::UnitVariant {
            name: "Level",
            variant,
        }
    }

    fn level_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
        [
            Token::Enum { name: "Level" },
            Token::Bytes(variant),
            Token::Unit,
        ]
    }

    fn level_variant_tokens(variant: u32) -> [Token; 3] {
        [
            Token::Enum { name: "Level" },
            Token::U32(variant),
            Token::Unit,
        ]
    }

    fn level_filter_token(variant: &'static str) -> Token {
        Token::UnitVariant {
            name: "LevelFilter",
            variant,
        }
    }

    fn level_filter_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
        [
            Token::Enum {
                name: "LevelFilter",
            },
            Token::Bytes(variant),
            Token::Unit,
        ]
    }

    fn level_filter_variant_tokens(variant: u32) -> [Token; 3] {
        [
            Token::Enum {
                name: "LevelFilter",
            },
            Token::U32(variant),
            Token::Unit,
        ]
    }

    #[test]
    fn test_level_ser_de() {
        let cases = &[
            (Level::Error, [level_token("ERROR")]),
            (Level::Warn, [level_token("WARN")]),
            (Level::Info, [level_token("INFO")]),
            (Level::Debug, [level_token("DEBUG")]),
            (Level::Trace, [level_token("TRACE")]),
        ];

        for (s, expected) in cases {
            assert_tokens(s, expected);
        }
    }

    #[test]
    fn test_level_case_insensitive() {
        let cases = &[
            (Level::Error, [level_token("error")]),
            (Level::Warn, [level_token("warn")]),
            (Level::Info, [level_token("info")]),
            (Level::Debug, [level_token("debug")]),
            (Level::Trace, [level_token("trace")]),
        ];

        for (s, expected) in cases {
            assert_de_tokens(s, expected);
        }
    }

    #[test]
    fn test_level_de_bytes() {
        let cases = &[
            (Level::Error, level_bytes_tokens(b"ERROR")),
            (Level::Warn, level_bytes_tokens(b"WARN")),
            (Level::Info, level_bytes_tokens(b"INFO")),
            (Level::Debug, level_bytes_tokens(b"DEBUG")),
            (Level::Trace, level_bytes_tokens(b"TRACE")),
        ];

        for (value, tokens) in cases {
            assert_de_tokens(value, tokens);
        }
    }

    #[test]
    fn test_level_de_variant_index() {
        let cases = &[
            (Level::Error, level_variant_tokens(0)),
            (Level::Warn, level_variant_tokens(1)),
            (Level::Info, level_variant_tokens(2)),
            (Level::Debug, level_variant_tokens(3)),
            (Level::Trace, level_variant_tokens(4)),
        ];

        for (value, tokens) in cases {
            assert_de_tokens(value, tokens);
        }
    }

    #[test]
    fn test_level_de_error() {
        let msg = "unknown variant `errorx`, expected one of \
                   `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
        assert_de_tokens_error::<Level>(&[level_token("errorx")], msg);
    }

    #[test]
    fn test_level_filter_ser_de() {
        let cases = &[
            (LevelFilter::Off, [level_filter_token("OFF")]),
            (LevelFilter::Error, [level_filter_token("ERROR")]),
            (LevelFilter::Warn, [level_filter_token("WARN")]),
            (LevelFilter::Info, [level_filter_token("INFO")]),
            (LevelFilter::Debug, [level_filter_token("DEBUG")]),
            (LevelFilter::Trace, [level_filter_token("TRACE")]),
        ];

        for (s, expected) in cases {
            assert_tokens(s, expected);
        }
    }

    #[test]
    fn test_level_filter_case_insensitive() {
        let cases = &[
            (LevelFilter::Off, [level_filter_token("off")]),
            (LevelFilter::Error, [level_filter_token("error")]),
            (LevelFilter::Warn, [level_filter_token("warn")]),
            (LevelFilter::Info, [level_filter_token("info")]),
            (LevelFilter::Debug, [level_filter_token("debug")]),
            (LevelFilter::Trace, [level_filter_token("trace")]),
        ];

        for (s, expected) in cases {
            assert_de_tokens(s, expected);
        }
    }

    #[test]
    fn test_level_filter_de_bytes() {
        let cases = &[
            (LevelFilter::Off, level_filter_bytes_tokens(b"OFF")),
            (LevelFilter::Error, level_filter_bytes_tokens(b"ERROR")),
            (LevelFilter::Warn, level_filter_bytes_tokens(b"WARN")),
            (LevelFilter::Info, level_filter_bytes_tokens(b"INFO")),
            (LevelFilter::Debug, level_filter_bytes_tokens(b"DEBUG")),
            (LevelFilter::Trace, level_filter_bytes_tokens(b"TRACE")),
        ];

        for (value, tokens) in cases {
            assert_de_tokens(value, tokens);
        }
    }

    #[test]
    fn test_level_filter_de_variant_index() {
        let cases = &[
            (LevelFilter::Off, level_filter_variant_tokens(0)),
            (LevelFilter::Error, level_filter_variant_tokens(1)),
            (LevelFilter::Warn, level_filter_variant_tokens(2)),
            (LevelFilter::Info, level_filter_variant_tokens(3)),
            (LevelFilter::Debug, level_filter_variant_tokens(4)),
            (LevelFilter::Trace, level_filter_variant_tokens(5)),
        ];

        for (value, tokens) in cases {
            assert_de_tokens(value, tokens);
        }
    }

    #[test]
    fn test_level_filter_de_error() {
        let msg = "unknown variant `errorx`, expected one of \
                   `OFF`, `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
        assert_de_tokens_error::<LevelFilter>(&[level_filter_token("errorx")], msg);
    }
}


eval_neutral.txt at the repository root is unchanged; this is a categorised copy carrying provenance

गोवा या गोआ (कोंकणी: गोंय), क्षेत्रफल के अनुसार से भारत का सबसे छोटा और जनसंख्या के अनुसार चौथा सबसे छोटा राज्य है। पूरी दुनिया में गोवा अपने सुन्दर समुद्र के किनारों और प्रसिद्ध स्थापत्य के लिये जाना जाता है। गोवा पहले पुर्तगाल का एक उपनिवेश था। पुर्तगालियों ने गोवा पर लगभग 450 सालों तक शासन किया और 19 दिसंबर 1961 में यह भारतीय प्रशासन को सौंपा गया।

गोवा

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

जनश्रुति के अनुसार गोवा जिसमें कोंकण क्षेत्र भी शामिल है (और जिसका विस्तार गुजरात से केरल तक बताया जाता है) की रचना भगवान परशुराम ने की थी। कहा जाता है कि परशुराम ने एक यज्ञ के दौरान अपने बाणो की वर्षा से समुद्र को कई स्थानों पर पीछे धकेल दिया था और लोगों का कहना है कि इसी वजह से आज भी गोवा में बहुत से स्थानों का नाम वाणावली, वाणस्थली इत्यादि हैं। उत्तरी गोवा में हरमल के पास आज भूरे रंग के एक पर्वत को परशुराम के यज्ञ करने का स्थान माना जाता है।

इतिहास

गोवा के लंबे इतिहास की शुरुआत् तीसरी सदी इसा पूर्व से शुरू होता है जब यहाँ मौर्य वंश के शासन की स्थापना हुई थी। बाद में पहली सदी के शुरुआत में इस पर कोल्हापुर के सातवाहन वंश के शासकों का अधिकार स्थापित हुआ और फिर बादामी के चालुक्य शासकों ने इस पर वर्ष 580 से 750 तक राज किया। इसके बाद के सालों में इस पर कई अलग अलग शासकों ने अधिकार किया। वर्ष 1312 में गोवा पहली बार दिल्ली सल्तनत के अधीन हुआ लेकिन उन्हें विजयनगर के शासक हरिहर प्रथम द्वार वहाँ से खदेड़ दिया गया। अगले सौ सालों तक विजयनगर के शासकों ने यहाँ शासन किया और 1469 में गुलबर्ग के बहामी सुल्तान द्वारा फिर से दिल्ली सल्तनत का हिस्सा बनाया गया। बहामी शासकों के पतन के बाद बीजापुर के आदिल शाह का यहाँ कब्जा हुआ जिसने गोअ-वेल्हा को अपनी दूसरी राजधानी बनाया।

1510 में, पुर्तगालियों ने एक स्थानीय सहयोगी, तिमैया की मदद से सत्तारूढ़ बीजापुर सुल्तान यूसुफ आदिल शाह को पराजित किया। उन्होंने वेल्हा गोवा में एक स्थायी राज्य की स्थापना की। यह गोवा में पुर्तगाली शासन का प्रारंभ था जो अगली साढ़े चार सदियों तक चला।

1843 में पुर्तगाली राजधानी को वेल्हा गोवा से पंजिम ले गए। मध्य 18 वीं शताब्दी तक, पुर्तगाली गोवा का वर्तमान राज्य सीमा के अधिकांश भाग तक विस्तार किया गया था।

भारत ने 1947 में अंग्रेजों से स्वतंत्रता प्राप्त की, भारत ने अनुरोध किया कि भारतीय उपमहाद्वीप में पुर्तगाली प्रदेशों को भारत को सौंप दिया जाए।किंतु पुर्तगाल ने अपने भारतीय परिक्षेत्रों की संप्रभुता पर बातचीत करना अस्वीकार कर दिया। पर 19 दिसंबर 1961 को, भारतीय सेना ने गोवा, दमन, दीव के भारतीय संघ में विलय के लिए ऑपरेशन विजय के साथ सैन्य संचालन किया और इसके परिणामस्वरूप गोवा, दमन और दीवभारत का एक केन्द्र प्रशासित क्षेत्र बना। 30 मई 1987 में केंद्र शासित प्रदेश को विभाजित किया गया था, और गोवा भारत का पच्चीसवां राज्य बनाया गया। जबकि दमन और दीव केंद्र शासित प्रदेश ही रहे।

भूगोल
गोवा का क्षेत्रफल 3702 वर्ग किलोमीटर है। गोवा का अक्षांश और देशान्तर क्रमश: 14°53'54" और 73°40'33" E है। गोवा का समुद्र तट 132 किलोमीटर लम्बा है।
गोआ भारत का सबसे छोटा राज्य है।

अर्थ जगत
गोवा का प्रमुख उद्योग पर्यटन है। पर्यटन के आलावा गोवा में लौह खनिज भी विपुल मात्रा में पाया जाता है जो जापान तथा चीन जैसे देशों में निर्यात होता है। गोवा मतस्य (मछली) उद्योग के लिए भी जाना जाता है लेकिन यहाँ की मछली निर्यात नहीं की जाती बल्कि स्थानीय बाजारों में बेची जाती है। यहाँ का काजू सउदी अरब, ब्रिटेन तथा अन्य यूरोपीय राष्ट्रों को निर्यात होता है। पर्यटन के वज़ह से बाकी उद्योग जो पर्यटन पर निर्भर करते है वो भी यहाँ पर जोर शोर से चालू हैं। गोवा में अभी तक सिर्फ़ एक ही विमानपत्तन है और दूसरा अभी बनने वाला है।

लोग और संस्कृति
गोवा करीब करीब 450 साल तक पुर्तगाली शासन के अधीन रहा, इस कारण यहाँ यूरोपीय संस्कृति का प्रभाव बहुत महसूस होता है। गोवा की लगभग 60% जनसंख्या हिंदू और लगभग 28% जनसंख्या ईसाई है। गोवा की एक खास बात यह है कि, यहाँ के ईसाई समाज में भी हिंदुओं जैसी जाति व्यवस्था पाई जाती है।

गोवा के दक्षिण भाग में ईसाई समाज का ज्यादा प्रभाव है लेकिन वहाँ के वास्तुशास्त्र में हिंदू प्रभाव दिखाई देता है। सबसे प्राचीन मन्दिर गोवा में दिखाई देते है। उत्तर गोवा में ईसाइ कम संख्या में हैं इसलिए वहाँ पुर्तगाली वास्तुकला के नमूने ज्यादा दिखाई देते है।

संस्कृति की दृष्टि से गोवा की संस्कृति काफी प्राचीन है। 1000 साल पहले कहा जाता है कि गोवा "कोंकण काशी" के नाम से जाना जाता था। हालाँकि पुर्तगाली लोगों ने यहाँ के संस्कृति का नामोनिशान मिटाने के लिए बहुत प्रयास किए लेकिन यहाँ की मूल संस्कृति इतनी शक्तिशाली थी की वह ऐसा नहीं कर पाए।

गोवा की भाषा कोंकणी और लिपि देवनागरी है। हिन्दी का भी अधिकाधिक उपयोग होता है।

यातायात

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

आंतरिक
 टैक्सी बिना मीटर और मीटर वाली टैक्सियाँ यहाँ पर्यटकों को एक स्थान से दूसरे स्थान ले जाने का सबसे लोकप्रिय साधन है। बिना मीटर वाली टैक्सियों में यात्री पहले से भाड़े के बारे में तय करते हैं।
 बस गोवा में ज्यादातर बसे प्राईवेट चालकों द्वारा चलाई जाती हैं। आम तौर पर बसों में काफी भीड़ होती है। गोवा सरकार द्वारा यहाँ कदम्ब बस सर्विस चलाई जाती है जिनमें धीरे चलनेवाली बसों से लेकर द्रुत सेवा की लंबी दूरी की बसें शामिल होती हैं।
  नाव

पर्यटन

वर्षा ऋतु के आगमन के साथ ही प्रकृति गोवा को कुछ ऐसा ही अलग, लेकिन अदभुत स्वरूप प्रदान करती है। यह स्थान शांतिप्रिय पर्यटकों और प्रकृति प्रेमियों को बहुत भाता है। गोवा एक छोटा-सा राज्य है। यहां छोटे-बड़े लगभग 40 समुद्री तट है। इनमें से कुछ समुद्र तट अंर्तराष्ट्रीय स्तर के हैं। इसी कारण गोवा की विश्व पर्यटन मानचित्र के पटल पर अपनी एक अलग पहचान है।

गोवा में पर्यटकों की भीड़ सबसे अधिक गर्मियों के महीनें में होती है। जब यह भीड़ समाप्त हो जाती है तब यहां शुरू होता है ऐसे सैलानियों के आने का सिलसिला जो यहां मानसून का लुत्‍फ उठाना चाहते हैं।

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

मांडवी नदी
पणजी गोवा की राजधानी है। यहां के आधुनिक बाजार भी पर्यटकों को आकर्षित करते हैं। मांडवी नदी के तट पर बसे इस शहर में शाम के समय सैलानी रिवर क्रूज का आनन्द लेने पहुंचते हैं। मांडवी पर तैरते क्रूज पर संगीत एवं नृत्य के कार्यक्रम में गोवा की संस्कृति की एक झलक देखने को मिलती है।

गोवा के जिले
गोवा में दो जिले हैं -

 उत्तर गोवा जिला
 दक्षिण गोवा जिला

खेल
गोवा में सबसे लोकप्रिय खेल फुटबाल है। यहाँ कई लोकप्रिय फुटबाल क्लब हैं। इसके अलावा गोवा के बहुत से खिलाड़ी हाकी में भी दिलचस्पी रखते हैं। गोवा में अनेक समुद्रतट हैं . उन्मे से कुछ हैं बागा समुद्रतट, कलांगुते समुद्रतट, कोला समुद्रतट, इतियादी।

सन्दर्भ

इन्हें भी देखें
गोवा का इतिहास
गोवा मुक्ति संग्राम

बाहरी कड़ियाँ

 Government of Goa official website
 Information on accommodation in hotels and resorts in Goa

भारत में पर्यटन


<!doctype html>

    <meta charset="utf-8">
    <title>lodash Performance Suite</title>


> [!IMPORTANT]
> As announced on the [OpenJS Foundation blog](https://openjsf.org/blog/sta-supports-lodash), Lodash has received support from the Sovereign Tech Agency and will transition to the Feature-Complete maturity stage so that it remains stable, secure, and sustainable long-term. As part of this effort, Lodash is rebooting its governance. A draft charter will be published shortly. The upcoming Technical Steering Committee (TSC) is already at work. For transparency, its members are listed below.

# Lodash Governance

## Technical Steering Committee Members

The current Technical Steering Committee (TSC) members are:

- John-David Dalton ([@jdalton](https://github.com/jdalton)), _(Lodash creator)_
- Jon Church ([@jonchurch](https://github.com/jonchurch))
- Jordan Harband ([@ljharb](https://github.com/ljharb))
- Michał Lipiński ([@falsyvalues](https://github.com/falsyvalues))
- Tobie Langel ([@tobie](https://github.com/tobie))
- Ulises Gascón ([@ulisesgascon](https://github.com/UlisesGascon))

## Security Triage Team

The Security Triage Team is responsible for assessing and managing vulnerability and incident reports. Security triaging is currently handled by the [TSC](#technical-steering-committee-members).

## Release Team

The Release Team is solely responsible for publishing new versions of Lodash to npm. Its current member is:

- John-David Dalton ([@jdalton](https://github.com/jdalton))


//! Structured values.
//!
//! This module defines the [`Value`] type and supporting APIs for
//! capturing and serializing them.

use std::fmt;

pub use crate::kv::Error;

/// A type that can be converted into a [`Value`](struct.Value.html).
pub trait ToValue {
    /// Perform the conversion.
    fn to_value(&self) -> Value<'_>;
}

impl<T> ToValue for &T
where
    T: ToValue + ?Sized,
{
    fn to_value(&self) -> Value<'_> {
        (**self).to_value()
    }
}

impl<'v> ToValue for Value<'v> {
    fn to_value(&self) -> Value<'_> {
        Value {
            inner: self.inner.clone(),
        }
    }
}

/// A value in a key-value.
///
/// Values are an anonymous bag containing some structured datum.
///
/// # Capturing values
///
/// There are a few ways to capture a value:
///
/// - Using the `Value::from_*` methods.
/// - Using the `ToValue` trait.
/// - Using the standard `From` trait.
///
/// ## Using the `Value::from_*` methods
///
/// `Value` offers a few constructor methods that capture values of different kinds.
///
/// ```
/// use log::kv::Value;
///
/// let value = Value::from_debug(&42i32);
///
/// assert_eq!(None, value.to_i64());
/// ```
///
/// ## Using the `ToValue` trait
///
/// The `ToValue` trait can be used to capture values generically.
/// It's the bound used by `Source`.
///
/// ```
/// # use log::kv::ToValue;
/// let value = 42i32.to_value();
///
/// assert_eq!(Some(42), value.to_i64());
/// ```
///
/// ## Using the standard `From` trait
///
/// Standard types that implement `ToValue` also implement `From`.
///
/// ```
/// use log::kv::Value;
///
/// let value = Value::from(42i32);
///
/// assert_eq!(Some(42), value.to_i64());
/// ```
///
/// # Data model
///
/// Values can hold one of a number of types:
///
/// - **Null:** The absence of any other meaningful value. Note that
///   `Some(Value::null())` is not the same as `None`. The former is
///   `null` while the latter is `undefined`. This is important to be
///   able to tell the difference between a key-value that was logged,
///   but its value was empty (`Some(Value::null())`) and a key-value
///   that was never logged at all (`None`).
/// - **Strings:** `str`, `char`.
/// - **Booleans:** `bool`.
/// - **Integers:** `u8`-`u128`, `i8`-`i128`, `NonZero*`.
/// - **Floating point numbers:** `f32`-`f64`.
/// - **Errors:** `dyn (Error + 'static)`.
/// - **`serde`:** Any type in `serde`'s data model.
/// - **`sval`:** Any type in `sval`'s data model.
///
/// # Serialization
///
/// Values provide a number of ways to be serialized.
///
/// For basic types the [`Value::visit`] method can be used to extract the
/// underlying typed value. However, this is limited in the amount of types
/// supported (see the [`VisitValue`] trait methods).
///
/// For more complex types one of the following traits can be used:
///  * `sval::Value`, requires the `kv_sval` feature.
///  * `serde::Serialize`, requires the `kv_serde` feature.
///
/// You don't need a visitor to serialize values through `serde` or `sval`.
///
/// A value can always be serialized using any supported framework, regardless
/// of how it was captured. If, for example, a value was captured using its
/// `Display` implementation, it will serialize through `serde` as a string. If it was
/// captured as a struct using `serde`, it will also serialize as a struct
/// through `sval`, or can be formatted using a `Debug`-compatible representation.
#[derive(Clone)]
pub struct Value<'v> {
    inner: inner::Inner<'v>,
}

impl<'v> Value<'v> {
    /// Get a value from a type implementing `ToValue`.
    pub fn from_any<T>(value: &'v T) -> Self
    where
        T: ToValue,
    {
        value.to_value()
    }

    /// Get a value from a type implementing `std::fmt::Debug`.
    pub fn from_debug<T>(value: &'v T) -> Self
    where
        T: fmt::Debug,
    {
        Value {
            inner: inner::Inner::from_debug(value),
        }
    }

    /// Get a value from a type implementing `std::fmt::Display`.
    pub fn from_display<T>(value: &'v T) -> Self
    where
        T: fmt::Display,
    {
        Value {
            inner: inner::Inner::from_display(value),
        }
    }

    /// Get a value from a type implementing `serde::Serialize`.
    #[cfg(feature = "kv_serde")]
    pub fn from_serde<T>(value: &'v T) -> Self
    where
        T: serde_core::Serialize,
    {
        Value {
            inner: inner::Inner::from_serde1(value),
        }
    }

    /// Get a value from a type implementing `sval::Value`.
    #[cfg(feature = "kv_sval")]
    pub fn from_sval<T>(value: &'v T) -> Self
    where
        T: sval::Value,
    {
        Value {
            inner: inner::Inner::from_sval2(value),
        }
    }

    /// Get a value from a dynamic `std::fmt::Debug`.
    pub fn from_dyn_debug(value: &'v dyn fmt::Debug) -> Self {
        Value {
            inner: inner::Inner::from_dyn_debug(value),
        }
    }

    /// Get a value from a dynamic `std::fmt::Display`.
    pub fn from_dyn_display(value: &'v dyn fmt::Display) -> Self {
        Value {
            inner: inner::Inner::from_dyn_display(value),
        }
    }

    /// Get a value from a dynamic error.
    #[cfg(feature = "kv_std")]
    pub fn from_dyn_error(err: &'v (dyn std::error::Error + 'static)) -> Self {
        Value {
            inner: inner::Inner::from_dyn_error(err),
        }
    }

    /// Get a `null` value.
    pub fn null() -> Self {
        Value {
            inner: inner::Inner::empty(),
        }
    }

    /// Get a value from an internal primitive.
    fn from_inner<T>(value: T) -> Self
    where
        T: Into<inner::Inner<'v>>,
    {
        Value {
            inner: value.into(),
        }
    }

    /// Inspect this value using a simple visitor.
    ///
    /// When the `kv_serde` or `kv_sval` features are enabled, you can also
    /// serialize a value using its `Serialize` or `Value` implementation.
    pub fn visit(&self, visitor: impl VisitValue<'v>) -> Result<(), Error> {
        inner::visit(&self.inner, visitor)
    }
}

impl<'v> fmt::Debug for Value<'v> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self.inner, f)
    }
}

impl<'v> fmt::Display for Value<'v> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Display::fmt(&self.inner, f)
    }
}

#[cfg(feature = "kv_serde")]
impl<'v> serde_core::Serialize for Value<'v> {
    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
    where
        S: serde_core::Serializer,
    {
        self.inner.serialize(s)
    }
}

#[cfg(feature = "kv_sval")]
impl<'v> sval::Value for Value<'v> {
    fn stream<'sval, S: sval::Stream<'sval> + ?Sized>(&'sval self, stream: &mut S) -> sval::Result {
        sval::Value::stream(&self.inner, stream)
    }
}

#[cfg(feature = "kv_sval")]
impl<'v> sval_ref::ValueRef<'v> for Value<'v> {
    fn stream_ref<S: sval::Stream<'v> + ?Sized>(&self, stream: &mut S) -> sval::Result {
        sval_ref::ValueRef::stream_ref(&self.inner, stream)
    }
}

impl ToValue for str {
    fn to_value(&self) -> Value<'_> {
        Value::from(self)
    }
}

impl<'v> From<&'v str> for Value<'v> {
    fn from(value: &'v str) -> Self {
        Value::from_inner(value)
    }
}

impl ToValue for () {
    fn to_value(&self) -> Value<'_> {
        Value::from_inner(())
    }
}

impl<T> ToValue for Option<T>
where
    T: ToValue,
{
    fn to_value(&self) -> Value<'_> {
        match *self {
            Some(ref value) => value.to_value(),
            None => Value::from_inner(()),
        }
    }
}

macro_rules! impl_to_value_primitive {
    ($($into_ty:ty,)*) => {
        $(
            impl ToValue for $into_ty {
                fn to_value(&self) -> Value<'_> {
                    Value::from(*self)
                }
            }

            impl<'v> From<$into_ty> for Value<'v> {
                fn from(value: $into_ty) -> Self {
                    Value::from_inner(value)
                }
            }

            impl<'v> From<&'v $into_ty> for Value<'v> {
                fn from(value: &'v $into_ty) -> Self {
                    Value::from_inner(*value)
                }
            }
        )*
    };
}

macro_rules! impl_to_value_nonzero_primitive {
    ($($into_ty:ident,)*) => {
        $(
            impl ToValue for std::num::$into_ty {
                fn to_value(&self) -> Value<'_> {
                    Value::from(self.get())
                }
            }

            impl<'v> From<std::num::$into_ty> for Value<'v> {
                fn from(value: std::num::$into_ty) -> Self {
                    Value::from(value.get())
                }
            }

            impl<'v> From<&'v std::num::$into_ty> for Value<'v> {
                fn from(value: &'v std::num::$into_ty) -> Self {
                    Value::from(value.get())
                }
            }
        )*
    };
}

macro_rules! impl_value_to_primitive {
    ($(#[doc = $doc:tt] $into_name:ident -> $into_ty:ty,)*) => {
        impl<'v> Value<'v> {
            $(
                #[doc = $doc]
                pub fn $into_name(&self) -> Option<$into_ty> {
                    self.inner.$into_name()
                }
            )*
        }
    }
}

impl_to_value_primitive![
    usize, u8, u16, u32, u64, u128, isize, i8, i16, i32, i64, i128, f32, f64, char, bool,
];

#[rustfmt::skip]
impl_to_value_nonzero_primitive![
    NonZeroUsize, NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU128,
    NonZeroIsize, NonZeroI8, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI128,
];

impl_value_to_primitive![
    #[doc = "Try convert this value into a `u64`."]
    to_u64 -> u64,
    #[doc = "Try convert this value into a `i64`."]
    to_i64 -> i64,
    #[doc = "Try convert this value into a `u128`."]
    to_u128 -> u128,
    #[doc = "Try convert this value into a `i128`."]
    to_i128 -> i128,
    #[doc = "Try convert this value into a `f64`."]
    to_f64 -> f64,
    #[doc = "Try convert this value into a `char`."]
    to_char -> char,
    #[doc = "Try convert this value into a `bool`."]
    to_bool -> bool,
];

#[cfg(feature = "std")]
macro_rules! impl_to_value_from_display {
    ($($into_ty:ty,)*) => {
        $(
            impl ToValue for $into_ty {
                fn to_value(&self) -> Value<'_> {
                    Value::from_display(self)
                }
            }

            impl<'v> From<&'v $into_ty> for Value<'v> {
                fn from(value: &'v $into_ty) -> Self {
                    Value::from_display(value)
                }
            }
        )*
    };
}

#[cfg(feature = "std")]
impl_to_value_from_display![
    std::net::IpAddr,
    std::net::Ipv4Addr,
    std::net::Ipv6Addr,
    std::net::SocketAddr,
    std::net::SocketAddrV4,
    std::net::SocketAddrV6,
];

impl<'v> Value<'v> {
    /// Try to convert this value into an error.
    #[cfg(feature = "kv_std")]
    pub fn to_borrowed_error(&self) -> Option<&(dyn std::error::Error + 'static)> {
        self.inner.to_borrowed_error()
    }

    /// Try to convert this value into a borrowed string.
    pub fn to_borrowed_str(&self) -> Option<&'v str> {
        self.inner.to_borrowed_str()
    }
}

#[cfg(feature = "std")]
mod std_support {
    use std::borrow::Cow;
    use std::rc::Rc;
    use std::sync::Arc;

    use super::*;

    impl<T> ToValue for Box<T>
    where
        T: ToValue + ?Sized,
    {
        fn to_value(&self) -> Value<'_> {
            (**self).to_value()
        }
    }

    impl<T> ToValue for Arc<T>
    where
        T: ToValue + ?Sized,
    {
        fn to_value(&self) -> Value<'_> {
            (**self).to_value()
        }
    }

    impl<T> ToValue for Rc<T>
    where
        T: ToValue + ?Sized,
    {
        fn to_value(&self) -> Value<'_> {
            (**self).to_value()
        }
    }

    impl ToValue for String {
        fn to_value(&self) -> Value<'_> {
            Value::from(&**self)
        }
    }

    impl<'v> ToValue for Cow<'v, str> {
        fn to_value(&self) -> Value<'_> {
            Value::from(&**self)
        }
    }

    #[cfg(feature = "kv_std")]
    impl<'v> Value<'v> {
        /// Try convert this value into a string.
        pub fn to_cow_str(&self) -> Option<Cow<'v, str>> {
            self.inner.to_str()
        }
    }

    impl<'v> From<&'v String> for Value<'v> {
        fn from(v: &'v String) -> Self {
            Value::from(&**v)
        }
    }
}

/// A visitor for a [`Value`].
///
/// Also see [`Value`'s documentation on serialization]. Value visitors are a simple alternative
/// to a more fully-featured serialization framework like `serde` or `sval`. A value visitor
/// can differentiate primitive types through methods like [`VisitValue::visit_bool`] and
/// [`VisitValue::visit_str`], but more complex types like maps and sequences
/// will fallthrough to [`VisitValue::visit_any`].
///
/// If you're trying to serialize a value to a format like JSON, you can use either `serde`
/// or `sval` directly with the value. You don't need a visitor.
///
/// [`Value`'s documentation on serialization]: Value#serialization
pub trait VisitValue<'v> {
    /// Visit a `Value`.
    ///
    /// This is the only required method on `VisitValue` and acts as a fallback for any
    /// more specific methods that aren't overridden.
    /// The `Value` may be formatted using its `fmt::Debug` or `fmt::Display` implementation,
    /// or serialized using its `sval::Value` or `serde::Serialize` implementation.
    fn visit_any(&mut self, value: Value) -> Result<(), Error>;

    /// Visit an empty value.
    fn visit_null(&mut self) -> Result<(), Error> {
        self.visit_any(Value::null())
    }

    /// Visit an unsigned integer.
    fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
        self.visit_any(value.into())
    }

    /// Visit a signed integer.
    fn visit_i64(&mut self, value: i64) -> Result<(), Error> {
        self.visit_any(value.into())
    }

    /// Visit a big unsigned integer.
    fn visit_u128(&mut self, value: u128) -> Result<(), Error> {
        self.visit_any((value).into())
    }

    /// Visit a big signed integer.
    fn visit_i128(&mut self, value: i128) -> Result<(), Error> {
        self.visit_any((value).into())
    }

    /// Visit a floating point.
    fn visit_f64(&mut self, value: f64) -> Result<(), Error> {
        self.visit_any(value.into())
    }

    /// Visit a boolean.
    fn visit_bool(&mut self, value: bool) -> Result<(), Error> {
        self.visit_any(value.into())
    }

    /// Visit a string.
    fn visit_str(&mut self, value: &str) -> Result<(), Error> {
        self.visit_any(value.into())
    }

    /// Visit a string.
    fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
        self.visit_str(value)
    }

    /// Visit a Unicode character.
    fn visit_char(&mut self, value: char) -> Result<(), Error> {
        let mut b = [0; 4];
        self.visit_str(&*value.encode_utf8(&mut b))
    }

    /// Visit an error.
    #[cfg(feature = "kv_std")]
    fn visit_error(&mut self, err: &(dyn std::error::Error + 'static)) -> Result<(), Error> {
        self.visit_any(Value::from_dyn_error(err))
    }

    /// Visit an error.
    #[cfg(feature = "kv_std")]
    fn visit_borrowed_error(
        &mut self,
        err: &'v (dyn std::error::Error + 'static),
    ) -> Result<(), Error> {
        self.visit_any(Value::from_dyn_error(err))
    }
}

#[allow(clippy::needless_lifetimes)] // Not needless.
impl<'a, 'v, T: ?Sized> VisitValue<'v> for &'a mut T
where
    T: VisitValue<'v>,
{
    fn visit_any(&mut self, value: Value) -> Result<(), Error> {
        (**self).visit_any(value)
    }

    fn visit_null(&mut self) -> Result<(), Error> {
        (**self).visit_null()
    }

    fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
        (**self).visit_u64(value)
    }

    fn visit_i64(&mut self, value: i64) -> Result<(), Error> {
        (**self).visit_i64(value)
    }

    fn visit_u128(&mut self, value: u128) -> Result<(), Error> {
        (**self).visit_u128(value)
    }

    fn visit_i128(&mut self, value: i128) -> Result<(), Error> {
        (**self).visit_i128(value)
    }

    fn visit_f64(&mut self, value: f64) -> Result<(), Error> {
        (**self).visit_f64(value)
    }

    fn visit_bool(&mut self, value: bool) -> Result<(), Error> {
        (**self).visit_bool(value)
    }

    fn visit_str(&mut self, value: &str) -> Result<(), Error> {
        (**self).visit_str(value)
    }

    fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
        (**self).visit_borrowed_str(value)
    }

    fn visit_char(&mut self, value: char) -> Result<(), Error> {
        (**self).visit_char(value)
    }

    #[cfg(feature = "kv_std")]
    fn visit_error(&mut self, err: &(dyn std::error::Error + 'static)) -> Result<(), Error> {
        (**self).visit_error(err)
    }

    #[cfg(feature = "kv_std")]
    fn visit_borrowed_error(
        &mut self,
        err: &'v (dyn std::error::Error + 'static),
    ) -> Result<(), Error> {
        (**self).visit_borrowed_error(err)
    }
}

#[cfg(feature = "value-bag")]
pub(in crate::kv) mod inner {
    /**
    An implementation of `Value` based on a library called `value_bag`.

    `value_bag` was written specifically for use in `log`'s value, but was split out when it outgrew
    the codebase here. It's a general-purpose type-erasure library that handles mapping between
    more fully-featured serialization frameworks.
    */
    use super::*;

    pub use value_bag::ValueBag as Inner;

    pub use value_bag::Error;

    #[cfg(test)]
    pub use value_bag::test::TestToken as Token;

    pub fn visit<'v>(
        inner: &Inner<'v>,
        visitor: impl VisitValue<'v>,
    ) -> Result<(), crate::kv::Error> {
        struct InnerVisitValue<V>(V);

        impl<'v, V> value_bag::visit::Visit<'v> for InnerVisitValue<V>
        where
            V: VisitValue<'v>,
        {
            fn visit_any(&mut self, value: value_bag::ValueBag) -> Result<(), Error> {
                self.0
                    .visit_any(Value { inner: value })
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_empty(&mut self) -> Result<(), Error> {
                self.0.visit_null().map_err(crate::kv::Error::into_value)
            }

            fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
                self.0
                    .visit_u64(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_i64(&mut self, value: i64) -> Result<(), Error> {
                self.0
                    .visit_i64(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_u128(&mut self, value: u128) -> Result<(), Error> {
                self.0
                    .visit_u128(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_i128(&mut self, value: i128) -> Result<(), Error> {
                self.0
                    .visit_i128(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_f64(&mut self, value: f64) -> Result<(), Error> {
                self.0
                    .visit_f64(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_bool(&mut self, value: bool) -> Result<(), Error> {
                self.0
                    .visit_bool(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_str(&mut self, value: &str) -> Result<(), Error> {
                self.0
                    .visit_str(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
                self.0
                    .visit_borrowed_str(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_char(&mut self, value: char) -> Result<(), Error> {
                self.0
                    .visit_char(value)
                    .map_err(crate::kv::Error::into_value)
            }

            #[cfg(feature = "kv_std")]
            fn visit_error(
                &mut self,
                err: &(dyn std::error::Error + 'static),
            ) -> Result<(), Error> {
                self.0
                    .visit_error(err)
                    .map_err(crate::kv::Error::into_value)
            }

            #[cfg(feature = "kv_std")]
            fn visit_borrowed_error(
                &mut self,
                err: &'v (dyn std::error::Error + 'static),
            ) -> Result<(), Error> {
                self.0
                    .visit_borrowed_error(err)
                    .map_err(crate::kv::Error::into_value)
            }
        }

        inner
            .visit(&mut InnerVisitValue(visitor))
            .map_err(crate::kv::Error::from_value)
    }
}

#[cfg(not(feature = "value-bag"))]
pub(in crate::kv) mod inner {
    /**
    This is a dependency-free implementation of `Value` when there's no serialization frameworks involved.
    In these simple cases a more fully featured solution like `value_bag` isn't needed, so we avoid pulling it in.

    There are a few things here that need to remain consistent with the `value_bag`-based implementation:

    1. Conversions should always produce the same results. If a conversion here returns `Some`, then
       the same `value_bag`-based conversion must also. Of particular note here are floats to ints; they're
       based on the standard library's `TryInto` conversions, which need to be converted to `i32` or `u32`,
       and then to `f64`.
    2. VisitValues should always be called in the same way. If a particular type of value calls `visit_i64`,
       then the same `value_bag`-based visitor must also.
    */
    use super::*;

    #[derive(Clone)]
    pub enum Inner<'v> {
        // NOTE: New variants can't be added here; see the module-level doc above
        None,
        Bool(bool),
        Str(&'v str),
        Char(char),
        I64(i64),
        U64(u64),
        F64(f64),
        I128(i128),
        U128(u128),
        Debug(&'v dyn fmt::Debug),
        Display(&'v dyn fmt::Display),
    }

    impl<'v> From<()> for Inner<'v> {
        fn from(_: ()) -> Self {
            Inner::None
        }
    }

    impl<'v> From<bool> for Inner<'v> {
        fn from(v: bool) -> Self {
            Inner::Bool(v)
        }
    }

    impl<'v> From<char> for Inner<'v> {
        fn from(v: char) -> Self {
            Inner::Char(v)
        }
    }

    impl<'v> From<f32> for Inner<'v> {
        fn from(v: f32) -> Self {
            Inner::F64(v as f64)
        }
    }

    impl<'v> From<f64> for Inner<'v> {
        fn from(v: f64) -> Self {
            Inner::F64(v)
        }
    }

    impl<'v> From<i8> for Inner<'v> {
        fn from(v: i8) -> Self {
            Inner::I64(v as i64)
        }
    }

    impl<'v> From<i16> for Inner<'v> {
        fn from(v: i16) -> Self {
            Inner::I64(v as i64)
        }
    }

    impl<'v> From<i32> for Inner<'v> {
        fn from(v: i32) -> Self {
            Inner::I64(v as i64)
        }
    }

    impl<'v> From<i64> for Inner<'v> {
        fn from(v: i64) -> Self {
            Inner::I64(v as i64)
        }
    }

    impl<'v> From<isize> for Inner<'v> {
        fn from(v: isize) -> Self {
            Inner::I64(v as i64)
        }
    }

    impl<'v> From<u8> for Inner<'v> {
        fn from(v: u8) -> Self {
            Inner::U64(v as u64)
        }
    }

    impl<'v> From<u16> for Inner<'v> {
        fn from(v: u16) -> Self {
            Inner::U64(v as u64)
        }
    }

    impl<'v> From<u32> for Inner<'v> {
        fn from(v: u32) -> Self {
            Inner::U64(v as u64)
        }
    }

    impl<'v> From<u64> for Inner<'v> {
        fn from(v: u64) -> Self {
            Inner::U64(v as u64)
        }
    }

    impl<'v> From<usize> for Inner<'v> {
        fn from(v: usize) -> Self {
            Inner::U64(v as u64)
        }
    }

    impl<'v> From<i128> for Inner<'v> {
        fn from(v: i128) -> Self {
            Inner::I128(v)
        }
    }

    impl<'v> From<u128> for Inner<'v> {
        fn from(v: u128) -> Self {
            Inner::U128(v)
        }
    }

    impl<'v> From<&'v str> for Inner<'v> {
        fn from(v: &'v str) -> Self {
            Inner::Str(v)
        }
    }

    impl<'v> fmt::Debug for Inner<'v> {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            match self {
                Inner::None => fmt::Debug::fmt(&None::<()>, f),
                Inner::Bool(v) => fmt::Debug::fmt(v, f),
                Inner::Str(v) => fmt::Debug::fmt(v, f),
                Inner::Char(v) => fmt::Debug::fmt(v, f),
                Inner::I64(v) => fmt::Debug::fmt(v, f),
                Inner::U64(v) => fmt::Debug::fmt(v, f),
                Inner::F64(v) => fmt::Debug::fmt(v, f),
                Inner::I128(v) => fmt::Debug::fmt(v, f),
                Inner::U128(v) => fmt::Debug::fmt(v, f),
                Inner::Debug(v) => fmt::Debug::fmt(v, f),
                Inner::Display(v) => fmt::Display::fmt(v, f),
            }
        }
    }

    impl<'v> fmt::Display for Inner<'v> {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            match self {
                Inner::None => fmt::Debug::fmt(&None::<()>, f),
                Inner::Bool(v) => fmt::Display::fmt(v, f),
                Inner::Str(v) => fmt::Display::fmt(v, f),
                Inner::Char(v) => fmt::Display::fmt(v, f),
                Inner::I64(v) => fmt::Display::fmt(v, f),
                Inner::U64(v) => fmt::Display::fmt(v, f),
                Inner::F64(v) => fmt::Display::fmt(v, f),
                Inner::I128(v) => fmt::Display::fmt(v, f),
                Inner::U128(v) => fmt::Display::fmt(v, f),
                Inner::Debug(v) => fmt::Debug::fmt(v, f),
                Inner::Display(v) => fmt::Display::fmt(v, f),
            }
        }
    }

    impl<'v> Inner<'v> {
        pub fn from_debug<T: fmt::Debug>(value: &'v T) -> Self {
            Inner::Debug(value)
        }

        pub fn from_display<T: fmt::Display>(value: &'v T) -> Self {
            Inner::Display(value)
        }

        pub fn from_dyn_debug(value: &'v dyn fmt::Debug) -> Self {
            Inner::Debug(value)
        }

        pub fn from_dyn_display(value: &'v dyn fmt::Display) -> Self {
            Inner::Display(value)
        }

        pub fn empty() -> Self {
            Inner::None
        }

        pub fn to_bool(&self) -> Option<bool> {
            match self {
                Inner::Bool(v) => Some(*v),
                _ => None,
            }
        }

        pub fn to_char(&self) -> Option<char> {
            match self {
                Inner::Char(v) => Some(*v),
                _ => None,
            }
        }

        pub fn to_f64(&self) -> Option<f64> {
            match self {
                Inner::F64(v) => Some(*v),
                Inner::I64(v) => {
                    let v: i32 = (*v).try_into().ok()?;
                    v.try_into().ok()
                }
                Inner::U64(v) => {
                    let v: u32 = (*v).try_into().ok()?;
                    v.try_into().ok()
                }
                Inner::I128(v) => {
                    let v: i32 = (*v).try_into().ok()?;
                    v.try_into().ok()
                }
                Inner::U128(v) => {
                    let v: u32 = (*v).try_into().ok()?;
                    v.try_into().ok()
                }
                _ => None,
            }
        }

        pub fn to_i64(&self) -> Option<i64> {
            match self {
                Inner::I64(v) => Some(*v),
                Inner::U64(v) => (*v).try_into().ok(),
                Inner::I128(v) => (*v).try_into().ok(),
                Inner::U128(v) => (*v).try_into().ok(),
                _ => None,
            }
        }

        pub fn to_u64(&self) -> Option<u64> {
            match self {
                Inner::U64(v) => Some(*v),
                Inner::I64(v) => (*v).try_into().ok(),
                Inner::I128(v) => (*v).try_into().ok(),
                Inner::U128(v) => (*v).try_into().ok(),
                _ => None,
            }
        }

        pub fn to_u128(&self) -> Option<u128> {
            match self {
                Inner::U128(v) => Some(*v),
                Inner::I64(v) => (*v).try_into().ok(),
                Inner::U64(v) => (*v).try_into().ok(),
                Inner::I128(v) => (*v).try_into().ok(),
                _ => None,
            }
        }

        pub fn to_i128(&self) -> Option<i128> {
            match self {
                Inner::I128(v) => Some(*v),
                Inner::I64(v) => (*v).try_into().ok(),
                Inner::U64(v) => (*v).try_into().ok(),
                Inner::U128(v) => (*v).try_into().ok(),
                _ => None,
            }
        }

        pub fn to_borrowed_str(&self) -> Option<&'v str> {
            match self {
                Inner::Str(v) => Some(v),
                _ => None,
            }
        }

        #[cfg(test)]
        pub fn to_test_token(&self) -> Token<'_> {
            match self {
                Inner::None => Token::None,
                Inner::Bool(v) => Token::Bool(*v),
                Inner::Str(v) => Token::Str(*v),
                Inner::Char(v) => Token::Char(*v),
                Inner::I64(v) => Token::I64(*v),
                Inner::U64(v) => Token::U64(*v),
                Inner::F64(v) => Token::F64(*v),
                Inner::I128(_) => unimplemented!(),
                Inner::U128(_) => unimplemented!(),
                Inner::Debug(_) => unimplemented!(),
                Inner::Display(_) => unimplemented!(),
            }
        }
    }

    #[cfg(test)]
    #[derive(Debug, PartialEq)]
    pub enum Token<'v> {
        None,
        Bool(bool),
        Char(char),
        Str(&'v str),
        F64(f64),
        I64(i64),
        U64(u64),
    }

    pub fn visit<'v>(
        inner: &Inner<'v>,
        mut visitor: impl VisitValue<'v>,
    ) -> Result<(), crate::kv::Error> {
        match inner {
            Inner::None => visitor.visit_null(),
            Inner::Bool(v) => visitor.visit_bool(*v),
            Inner::Str(v) => visitor.visit_borrowed_str(*v),
            Inner::Char(v) => visitor.visit_char(*v),
            Inner::I64(v) => visitor.visit_i64(*v),
            Inner::U64(v) => visitor.visit_u64(*v),
            Inner::F64(v) => visitor.visit_f64(*v),
            Inner::I128(v) => visitor.visit_i128(*v),
            Inner::U128(v) => visitor.visit_u128(*v),
            Inner::Debug(v) => visitor.visit_any(Value::from_dyn_debug(*v)),
            Inner::Display(v) => visitor.visit_any(Value::from_dyn_display(*v)),
        }
    }
}

impl<'v> Value<'v> {
    /// Get a value from a type implementing `std::fmt::Debug`.
    #[cfg(feature = "kv_unstable")]
    #[deprecated(note = "use `from_debug` instead")]
    pub fn capture_debug<T>(value: &'v T) -> Self
    where
        T: fmt::Debug + 'static,
    {
        Value::from_debug(value)
    }

    /// Get a value from a type implementing `std::fmt::Display`.
    #[cfg(feature = "kv_unstable")]
    #[deprecated(note = "use `from_display` instead")]
    pub fn capture_display<T>(value: &'v T) -> Self
    where
        T: fmt::Display + 'static,
    {
        Value::from_display(value)
    }

    /// Get a value from an error.
    #[cfg(feature = "kv_unstable_std")]
    #[deprecated(note = "use `from_dyn_error` instead")]
    pub fn capture_error<T>(err: &'v T) -> Self
    where
        T: std::error::Error + 'static,
    {
        Value::from_dyn_error(err)
    }

    /// Get a value from a type implementing `serde::Serialize`.
    #[cfg(feature = "kv_unstable_serde")]
    #[deprecated(note = "use `from_serde` instead")]
    pub fn capture_serde<T>(value: &'v T) -> Self
    where
        T: serde_core::Serialize + 'static,
    {
        Value::from_serde(value)
    }

    /// Get a value from a type implementing `sval::Value`.
    #[cfg(feature = "kv_unstable_sval")]
    #[deprecated(note = "use `from_sval` instead")]
    pub fn capture_sval<T>(value: &'v T) -> Self
    where
        T: sval::Value + 'static,
    {
        Value::from_sval(value)
    }

    /// Check whether this value can be downcast to `T`.
    #[cfg(feature = "kv_unstable")]
    #[deprecated(
        note = "downcasting has been removed; log an issue at https://github.com/rust-lang/log/issues if this is something you rely on"
    )]
    pub fn is<T: 'static>(&self) -> bool {
        false
    }

    /// Try downcast this value to `T`.
    #[cfg(feature = "kv_unstable")]
    #[deprecated(
        note = "downcasting has been removed; log an issue at https://github.com/rust-lang/log/issues if this is something you rely on"
    )]
    pub fn downcast_ref<T: 'static>(&self) -> Option<&T> {
        None
    }
}

// NOTE: Deprecated; but aliases can't carry this attribute
#[cfg(feature = "kv_unstable")]
pub use VisitValue as Visit;

/// Get a value from a type implementing `std::fmt::Debug`.
#[cfg(feature = "kv_unstable")]
#[deprecated(note = "use the `key:? = value` macro syntax instead")]
#[macro_export]
macro_rules! as_debug {
    ($capture:expr) => {
        $crate::kv::Value::from_debug(&$capture)
    };
}

/// Get a value from a type implementing `std::fmt::Display`.
#[cfg(feature = "kv_unstable")]
#[deprecated(note = "use the `key:% = value` macro syntax instead")]
#[macro_export]
macro_rules! as_display {
    ($capture:expr) => {
        $crate::kv::Value::from_display(&$capture)
    };
}

/// Get a value from an error.
#[cfg(feature = "kv_unstable_std")]
#[deprecated(note = "use the `key:err = value` macro syntax instead")]
#[macro_export]
macro_rules! as_error {
    ($capture:expr) => {
        $crate::kv::Value::from_dyn_error(&$capture)
    };
}

#[cfg(feature = "kv_unstable_serde")]
#[deprecated(note = "use the `key:serde = value` macro syntax instead")]
/// Get a value from a type implementing `serde::Serialize`.
#[macro_export]
macro_rules! as_serde {
    ($capture:expr) => {
        $crate::kv::Value::from_serde(&$capture)
    };
}

/// Get a value from a type implementing `sval::Value`.
#[cfg(feature = "kv_unstable_sval")]
#[deprecated(note = "use the `key:sval = value` macro syntax instead")]
#[macro_export]
macro_rules! as_sval {
    ($capture:expr) => {
        $crate::kv::Value::from_sval(&$capture)
    };
}

#[cfg(test)]
pub(crate) mod tests {
    use super::*;

    // For new `ToValue` implementations, also add a test to the `tests/macros` file

    impl<'v> Value<'v> {
        #[allow(mismatched_lifetime_syntaxes)]
        pub(crate) fn to_token(&self) -> inner::Token {
            self.inner.to_test_token()
        }
    }

    fn unsigned() -> impl Iterator<Item = Value<'static>> {
        vec![
            Value::from(8u8),
            Value::from(16u16),
            Value::from(32u32),
            Value::from(64u64),
            Value::from(1usize),
            Value::from(std::num::NonZeroU8::new(8).unwrap()),
            Value::from(std::num::NonZeroU16::new(16).unwrap()),
            Value::from(std::num::NonZeroU32::new(32).unwrap()),
            Value::from(std::num::NonZeroU64::new(64).unwrap()),
            Value::from(std::num::NonZeroUsize::new(1).unwrap()),
        ]
        .into_iter()
    }

    fn signed() -> impl Iterator<Item = Value<'static>> {
        vec![
            Value::from(-8i8),
            Value::from(-16i16),
            Value::from(-32i32),
            Value::from(-64i64),
            Value::from(-1isize),
            Value::from(std::num::NonZeroI8::new(-8).unwrap()),
            Value::from(std::num::NonZeroI16::new(-16).unwrap()),
            Value::from(std::num::NonZeroI32::new(-32).unwrap()),
            Value::from(std::num::NonZeroI64::new(-64).unwrap()),
            Value::from(std::num::NonZeroIsize::new(-1).unwrap()),
        ]
        .into_iter()
    }

    fn float() -> impl Iterator<Item = Value<'static>> {
        vec![Value::from(32.32f32), Value::from(64.64f64)].into_iter()
    }

    fn bool() -> impl Iterator<Item = Value<'static>> {
        vec![Value::from(true), Value::from(false)].into_iter()
    }

    fn str() -> impl Iterator<Item = Value<'static>> {
        vec![Value::from("a string"), Value::from("a loong string")].into_iter()
    }

    fn char() -> impl Iterator<Item = Value<'static>> {
        vec![Value::from('a'), Value::from('⛰')].into_iter()
    }

    #[test]
    fn test_to_value_display() {
        assert_eq!(42u64.to_value().to_string(), "42");
        assert_eq!(42i64.to_value().to_string(), "42");
        assert_eq!(42.01f64.to_value().to_string(), "42.01");
        assert_eq!(true.to_value().to_string(), "true");
        assert_eq!('a'.to_value().to_string(), "a");
        assert_eq!("a loong string".to_value().to_string(), "a loong string");
        assert_eq!(Some(true).to_value().to_string(), "true");
        assert_eq!(().to_value().to_string(), "None");
        assert_eq!(None::<bool>.to_value().to_string(), "None");
    }

    #[test]
    #[cfg(feature = "std")]
    fn test_net_to_value_display() {
        use std::str::FromStr;

        assert_eq!(
            std::net::Ipv4Addr::new(192, 168, 10, 100)
                .to_value()
                .to_string(),
            "192.168.10.100"
        );
        assert_eq!(
            std::net::Ipv6Addr::from_str("f33c::1")
                .unwrap()
                .to_value()
                .to_string(),
            "f33c::1"
        );
        assert_eq!(
            std::net::IpAddr::V4(std::net::Ipv4Addr::new(192, 168, 10, 100))
                .to_value()
                .to_string(),
            "192.168.10.100"
        );
        assert_eq!(
            std::net::IpAddr::V6(std::net::Ipv6Addr::from_str("f33c::1").unwrap())
                .to_value()
                .to_string(),
            "f33c::1"
        );
        assert_eq!(
            std::net::SocketAddrV4::new(std::net::Ipv4Addr::new(192, 168, 10, 100), 12345)
                .to_value()
                .to_string(),
            "192.168.10.100:12345"
        );
        assert_eq!(
            std::net::SocketAddrV6::new(
                std::net::Ipv6Addr::from_str("f33c::1").unwrap(),
                12345,
                0,
                0
            )
            .to_value()
            .to_string(),
            "[f33c::1]:12345"
        );
        assert_eq!(
            std::net::SocketAddr::V4(std::net::SocketAddrV4::new(
                std::net::Ipv4Addr::new(192, 168, 10, 100),
                12345
            ))
            .to_value()
            .to_string(),
            "192.168.10.100:12345"
        );
        assert_eq!(
            std::net::SocketAddr::V6(std::net::SocketAddrV6::new(
                std::net::Ipv6Addr::from_str("f33c::1").unwrap(),
                12345,
                0,
                0
            ))
            .to_value()
            .to_string(),
            "[f33c::1]:12345"
        );
    }

    #[test]
    fn test_to_value_structured() {
        assert_eq!(42u64.to_value().to_token(), inner::Token::U64(42));
        assert_eq!(42i64.to_value().to_token(), inner::Token::I64(42));
        assert_eq!(42.01f64.to_value().to_token(), inner::Token::F64(42.01));
        assert_eq!(true.to_value().to_token(), inner::Token::Bool(true));
        assert_eq!('a'.to_value().to_token(), inner::Token::Char('a'));
        assert_eq!(
            "a loong string".to_value().to_token(),
            inner::Token::Str("a loong string".into())
        );
        assert_eq!(Some(true).to_value().to_token(), inner::Token::Bool(true));
        assert_eq!(().to_value().to_token(), inner::Token::None);
        assert_eq!(None::<bool>.to_value().to_token(), inner::Token::None);
    }

    #[test]
    fn test_to_number() {
        for v in unsigned() {
            assert!(v.to_u64().is_some());
            assert!(v.to_i64().is_some());
        }

        for v in signed() {
            assert!(v.to_i64().is_some());
        }

        for v in unsigned().chain(signed()).chain(float()) {
            assert!(v.to_f64().is_some());
        }

        for v in bool().chain(str()).chain(char()) {
            assert!(v.to_u64().is_none());
            assert!(v.to_i64().is_none());
            assert!(v.to_f64().is_none());
        }
    }

    #[test]
    fn test_to_float() {
        // Only integers from i32::MIN..=u32::MAX can be converted into floats
        assert!(Value::from(i32::MIN).to_f64().is_some());
        assert!(Value::from(u32::MAX).to_f64().is_some());

        assert!(Value::from((i32::MIN as i64) - 1).to_f64().is_none());
        assert!(Value::from((u32::MAX as u64) + 1).to_f64().is_none());
    }

    #[test]
    fn test_to_cow_str() {
        for v in str() {
            assert!(v.to_borrowed_str().is_some());

            #[cfg(feature = "kv_std")]
            assert!(v.to_cow_str().is_some());
        }

        let short_lived = String::from("short lived");
        let v = Value::from(&*short_lived);

        assert!(v.to_borrowed_str().is_some());

        #[cfg(feature = "kv_std")]
        assert!(v.to_cow_str().is_some());

        for v in unsigned().chain(signed()).chain(float()).chain(bool()) {
            assert!(v.to_borrowed_str().is_none());

            #[cfg(feature = "kv_std")]
            assert!(v.to_cow_str().is_none());
        }
    }

    #[test]
    fn test_to_bool() {
        for v in bool() {
            assert!(v.to_bool().is_some());
        }

        for v in unsigned()
            .chain(signed())
            .chain(float())
            .chain(str())
            .chain(char())
        {
            assert!(v.to_bool().is_none());
        }
    }

    #[test]
    fn test_to_char() {
        for v in char() {
            assert!(v.to_char().is_some());
        }

        for v in unsigned()
            .chain(signed())
            .chain(float())
            .chain(str())
            .chain(bool())
        {
            assert!(v.to_char().is_none());
        }
    }

    #[test]
    fn test_visit_integer() {
        struct Extract(Option<u64>);

        impl<'v> VisitValue<'v> for Extract {
            fn visit_any(&mut self, value: Value) -> Result<(), Error> {
                unimplemented!("unexpected value: {value:?}")
            }

            fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
                self.0 = Some(value);

                Ok(())
            }
        }

        let mut extract = Extract(None);
        Value::from(42u64).visit(&mut extract).unwrap();

        assert_eq!(Some(42), extract.0);
    }

    #[test]
    fn test_visit_borrowed_str() {
        struct Extract<'v>(Option<&'v str>);

        impl<'v> VisitValue<'v> for Extract<'v> {
            fn visit_any(&mut self, value: Value) -> Result<(), Error> {
                unimplemented!("unexpected value: {value:?}")
            }

            fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
                self.0 = Some(value);

                Ok(())
            }
        }

        let mut extract = Extract(None);

        let short_lived = String::from("A short-lived string");
        Value::from(&*short_lived).visit(&mut extract).unwrap();

        assert_eq!(Some("A short-lived string"), extract.0);
    }
}


«Перестро́йка» — общее название, используемое для обозначения кардинальных перемен в экономической и политической структуре СССР, инициированных генеральным секретарём ЦК КПСС Михаилом Сергеевичем Горбачёвым в 1985—1991 годах. Началом перестройки считают 1987 год, когда на январском пленуме ЦК КПСС перестройка была объявлена новым государственным курсом. Перестройка в конечном счёте привела к распаду Советского союзного государства и фактически превращению Страны Советов из единого государства в исторический регион в Восточной Европе, Средней и Центральной Азии, Дальнем Востоке и Сибири с 15 международно признанными и несколькими непризнанными государствами, завершила и переосмыслила советскую эпоху и дала начало новой, постсоветской, современной эпохе с её либеральными реформами, частной собственностью, свободным рынком, правами человека, упрощённым визовым режимом, возвратом в некоторых местах к досоветскому, традиционному строю (обществу), пересмотру отношений со странами Востока и Запада, а также США, возрождению религиозной жизни и общин на местах и т. д.

Целью реформ была заявлена всесторонняя демократизация сложившегося в СССР общественно-политического и экономического строя, то есть иными словами переход к «народовластию» (досл. перевод понятия demokratia) на местах в самом широком смысле этого понятия. Планы экономических реформ разрабатывались ещё в 1983—1984 годах по поручению генерального секретаря ЦК КПСС Юрия Владимировича Андропова.

Впервые необходимость совершенствования существовавшей экономической системы — так называемого Ускорения — была провозглашена М. С. Горбачёвым на пленуме ЦК КПСС 23 апреля 1985 года. Однако эти меры касались только экономики, носили в основном административный характер и не затрагивали существа «развитого социализма». Кардинальная же реформа всей системы, включая политические изменения, началась после пленума ЦК КПСС 27 января 1987 года. Перестройка была обозначена в качестве задачи и как необходимое «преодоление эпохи застоя и обновление всех сторон жизни страны».

Важную роль в разработке идей перестройки играли видные учёные-обществоведы: Александр Николаевич Яковлев (ИМЭМО), Станислав Сергеевич Шаталин (ЦЭМИ), Татьяна Ивановна Заславская (ВЦИОМ), Евгений Максимович Примаков (ИМЭМО), Леонид Иванович Абалкин (Институт экономики АН СССР).

Оценки результатов перестройки в обществе разнятся. Цели реформ были достигнуты лишь частично: произошла демократизация общества, внедрена гласность, отменена цензура, достигнута разрядка в отношениях с Западом. В то же время в экономике СССР наступил спад, а с политической точки зрения итогами перестройки стали межэтнические конфликты, вооружённая борьба за власть и распад Советского Союза.

Термин

15—17 мая 1985 года состоялась поездка генерального секретаря ЦК КПСС Горбачёва в Ленинград, где на встрече с активом Ленинградского горкома партии он впервые упомянул о необходимости перестройки общественно-политической жизни:

Слово было подхвачено СМИ и стало лозунгом начавшейся в СССР новой эпохи.

8 апреля 1986 года во время визита в Тольятти М. С. Горбачёв впервые употребил слово «перестройка», обозначив им политические и экономические перемены.

Историк Виктор Петрович Данилов отмечает, что «на языке того времени это понятие отнюдь не означало коренного изменения социально-экономических форм и сводилось к реорганизации некоторых хозяйственных функций и связей».

Этапы перестройки

Первый этап (март 1985 — январь 1987)

11 марта 1985 года к власти в СССР пришёл Михаил Сергеевич Горбачёв, а уже 23 апреля на состоявшемся пленуме ЦК КПСС он заявил о необходимости реформирования системы под лозунгом «ускорения социально-экономического развития страны», то есть ускорения продвижения по социалистическому пути на основе эффективного использования достижений научно-технического прогресса, активизации человеческого фактора и изменения порядка планирования. Главной задачей стала интенсификация экономики и ускорение научно-технического прогресса. Ещё не шла речь о гласности, демократизации, социалистическом рынке и прочих вещах, которые позднее прочно войдут в обиход горбачёвской эпохи. В мае широко транслировавшаяся ленинградская речь Горбачёва взбудоражила жителей страны, и именно с этой речью у них стала ассоциироваться перестройка, хотя термин «перестройка» как лозунг в этот период не использовался и идеологического значения не имел; признавались отдельные недостатки существовавшей социально-экономической системы СССР и предпринимались попытки исправить их несколькими крупными кампаниями административного характера: ускорение развития народного хозяйства, автоматизация и компьютеризация, антиалкогольная кампания, «борьба с нетрудовыми доходами», введение Госприёмки за контролем производственного сектора, демонстрация борьбы с коррупцией.

Каких-либо радикальных шагов в этот период не предпринималось, внешне практически всё оставалось по-старому. В то же время в 1985—1986 годах была произведена замена основной массы старых кадров брежневского призыва на новую команду управленцев. Именно тогда в руководство страны были введены Александр Николаевич Яковлев, Егор Кузьмич Лигачёв, Николай Иванович Рыжков, Борис Николаевич Ельцин, Анатолий Иванович Лукьянов, Владимир Иванович Долгих и другие активные участники будущих событий. Николай Рыжков вспоминал (в газете «Новый Взгляд», 1992): «В ноябре 82-го года меня — совершенно неожиданно — избрали секретарём ЦК, и Андропов ввёл меня в команду, готовившую реформы. Туда входили и Горбачёв, Долгих… Мы стали разбираться с экономикой, а с этого началась перестройка в 85-м году, где практически были использованы итоги того, что сделали в 1983—1984-х годах. Не пошли бы на это — было бы ещё хуже».

Состоявшийся в феврале — марте 1986 года XXVII съезд КПСС изменил программу партии: провозглашался курс на «совершенствование социализма» (а не «построение коммунизма», как ранее); предполагалось к 2000 году удвоить экономический потенциал СССР и предоставить каждой семье отдельную квартиру (программа «Жильё—2000»).

Внешняя политика СССР в 1985—1986 годах продолжала оставаться достаточно жёсткой, несмотря на наметившееся сразу после прихода к власти Горбачёва небольшое потепление в отношениях с США и Западом. Существенный сдвиг на международной арене произошёл только осенью 1987 года, когда СССР согласился пойти на серьёзные уступки при подготовке соглашения об РСМД.

Второй этап (январь 1987 — июнь 1989)
К концу 1986 — началу 1987 годов горбачёвская команда пришла к выводу, что административными мерами ситуацию в стране не изменить и предприняла попытку реформирования системы в духе демократического социализма. Этому шагу способствовали два удара по советской экономике в 1986 году: резкое падение цен на нефть и Чернобыльская катастрофа.

Новый этап начался с январского пленума ЦК КПСС 1987 года, на котором была выдвинута задача коренной перестройки управления экономикой, и характеризовался он началом масштабных реформ во всех сферах жизни советского общества (хотя отдельные меры начали приниматься ещё в конце 1986 года, например, Закон «Об индивидуальной трудовой деятельности»):
 В общественной жизни провозглашается политика гласности — смягчение цензуры в СМИ и снятие запретов на обсуждение тем, которые раньше замалчивались (в первую очередь сталинские репрессии, а также секс вообще и проституция в частности, наркомания, бытовое насилие, подростковая жестокость и т. д.).

 В экономике узаконивается частное предпринимательство в форме кооперативов (хотя слова «предпринимательство» и «частная собственность» произносить вслух пока не осмеливаются, кооперативы вводятся как элемент рынка в существующую социалистическую модель), начинают активно создаваться совместные предприятия с зарубежными компаниями.
 В международной политике основной доктриной становится «Новое мышление» — курс в сторону отказа от классового подхода в дипломатии и улучшения отношений с Западом.

В октябре 1987 года Горбачёв заявил, что перестройка рассчитана на "16–20 лет"

Выдвигаются лозунги о необходимости избавить социализм от «деформаций», о возвращении к «ленинским нормам», «идеалам Октября» и «социализму с человеческим лицом» посредством демократизации всех сторон жизни общества, реформирования политических институтов. В этот период были опубликованы почти все запрещённые ранее произведения Василия Гроссмана, Андрея Платонова, Евгения Замятина, Михаила Булгакова, Бориса Пастернака; резонанс в обществе вызвали новые книги: романы Чингиза Айтматова «Плаха», Анатолия Рыбакова «Дети Арбата», Владимира Дудинцева «Белые одежды», сборник рассказов Татьяны Толстой «На золотом крыльце сидели…». Вновь встал вопрос о сталинских репрессиях и реабилитации их жертв. В сентябре 1987 г. была создана комиссия Политбюро ЦК КПСС по реабилитации, которую возглавил Александр Николаевич Яковлев. Открытие в конце 1987 года Оптиной пустыни и Толгского монастыря и относительно публичное празднование 1000-летия крещения Руси в 1988 году воспринимались как знаки перемен в политике государства в отношении церкви.

Часть населения (в основном молодёжь и либеральная интеллигенция — «шестидесятники», заставшие предыдущую, хрущёвскую либерализацию) охвачена эйфорией от начавшихся после двух десятилетий застоя перемен и невиданной по прежним меркам свободы. Общественная апатия начала 80-х сменяется верой в светлое будущее.

Вместе с тем, с 1988 года в стране начинает постепенно нарастать общая неустойчивость: ухудшается экономическое положение, появляются сепаратистские настроения на национальных окраинах, вспыхивают первые межнациональные столкновения (Карабах).

Третий этап (июнь 1989 — сентябрь 1991)
Заключительный этап, в этот период происходит резкая дестабилизация обстановки в стране. После I Съезда народных депутатов начинается противостояние коммунистической партии с возникшими в итоге демократизации общества новыми политическими группировками. Изначально начатые по инициативе сверху, во второй половине 1989 года перемены выходят из-под контроля властей. Трудности в экономике перерастают в полномасштабный кризис: в 1989 году экономический рост резко замедляется, в 1990-м сменяется падением, а к концу 1991-го страна оказывается на грани экономического коллапса. Происходит катастрофический обвал жизненного уровня населения: реальностью советского общества начала 90-х становятся массовая нищета и безработица. Достигает апогея хронический товарный дефицит: пустые полки магазинов становятся символом рубежа 1980—1990-х гг, с 1991 г. Европа активно помогает СССР в поставках гуманитарной помощи. Перестроечная эйфория в обществе сменяется разочарованием, неуверенностью в завтрашнем дне и массовыми антикоммунистическими настроениями. Усиливается эмиграция за рубеж. С 1990 года основной идеей становится уже не «совершенствование социализма», а построение демократии западного образца и рыночной экономики капиталистического типа.

В 1987—1991 гг. социально-экономический строй СССР начинает приобретать черты капитализма: легализуется частная собственность, образуются фондовый и валютный рынки, кооперация, СП и ИТД (индивидуально-трудовые доходы) начинают принимать форму бизнеса западного типа. «Новое мышление», половинчатые реформы, и политика ускорения (1985—1987) на международной арене сводится к односторонним уступкам Западу, в итоге чего СССР утрачивает многие свои позиции и фактически перестаёт быть сверхдержавой, ещё несколько лет назад контролировавшей половину мира. В РСФСР c июня 1988 года после 19-й партконференции КПСС и других республиках Союза к власти приходят сепаратистски настроенные силы — начинается «парад суверенитетов» — провозглашается независимость республик. Середина 80-начало 90-х гг. в политике ознаменовалось кровавыми боестолкновениями:
Декабрь 1986 г. — Алма-Ата (Казахстан);
Декабрь 1987 — февраль 1988 г. — Карабах (Армения и Азербайджан);
Апрель 1989 г. — Тбилиси (Грузия);
Январь 1990 г. — Баку (Азербайджан);
Январь 1991 г. — Рига (Латвия), Вильнюс (Литва).

17 марта 1991 г. в проведённом общесоюзном референдуме за сохранение единства СССР высказалось около 77 %, в нём участвовало 9 из 15 республик державы, в апреле — новый акт Союзного Договора перенесли на 20 августа. За сутки до подписания акта в Москву были введены войска — начался 3-дневный августовский путч 1991 г, после которого уже не было ни малейшего шанса на спасение СССР.
1 декабря 1991 года Украина заявила о своей независимости. 7-8 декабря в резиденции Вискули (Минск) лидеры РСФСР, Украины и Белоруссии подписали Беловежскую Декларацию о создании СНГ, вступившую в силу после Алма-Атинских переговоров (21.12.1991), куда вошли все 11 республик бывшего СССР.
Итогом такого развития событий стали ликвидация власти КПСС, Августовский кризис 1991 года и распад Советского Союза в августе — декабре 1991 года.

Четвёртый этап — окончание перестройки или пост-Перестройка (сентябрь — декабрь 1991 г.)

Период между провалом ГКЧП и юридическим оформлением распада СССР к Перестройке обычно относить не принято; это своего рода «безвременье», когда, с одной стороны, единое государство формально ещё продолжало существовать, а с другой — советская история подошла к своему завершению и окончательная ликвидация СССР стала лишь вопросом времени. В этот период происходит демонтаж коммунистического строя и всей системы государственной власти в Советском Союзе. К концу 1991 года происходит фактический коллапс союзной экономики. Республики Прибалтики де-юре выходят из состава СССР, остальные республики также берут курс на независимость. Деятельность КПСС сначала приостанавливается, а затем окончательно запрещается. Вместо полноценных органов власти создаются суррогатные неконституционные структуры (Госсовет, КОУНХ, МЭК). Вся полнота реальной власти переходит с союзного на республиканский уровень. Работа над новым союзным договором продолжается до ноября, однако чем дальше, тем очевиднее становится стремление республиканских элит, почувствовавших вкус реальной власти, к окончательному размежеванию и обособлению. 8 декабря в резиденции «Вискули» в Беловежской пуще лидеры России, Украины и Белоруссии провозглашают, что Советского Союза больше нет. Центральная власть во главе с Горбачёвым парализована и уже ничего не может противопоставить этим действиям. 25 декабря 1991 года Михаил Горбачёв слагает с себя полномочия Президента Союза Советских Социалистических Республик, и 26 декабря 1991 года СССР перестаёт существовать.

Некоторые вехи

1985 год

Наиболее ранней вехой в начале «Перестройки» является приход в марте 1985 года к власти М. С. Горбачёва, главного проводника преобразований в СССР.
 для широких масс населения Советского Союза перестройка началась с транслировавшейся широко по всей стране Ленинградской речи Горбачёва в мае 1985 года; именно эту речь можно считать началом перестройки
  — Постановление Совета министров СССР «О мерах по преодолению пьянства и искоренению самогоноварения».

1986 год
  — Авария на Чернобыльской атомной электростанции.
  — Постановление Совета министров СССР «О мерах по усилению борьбы с нетрудовыми доходами».
 Сентябрь 1986 года — впервые президент Аргентины (Рауль Альфонсин) посетил СССР.
  — Верховный Совет СССР принял Закон СССР «Об индивидуальной трудовой деятельности».
 17—18 декабря — события в Алма-Ате

1987 год
  — Первая несанкционированная демонстрация неправительственной и некоммунистической организации — общества «Память» в Москве.
  — Пленум ЦК КПСС рассмотрел вопрос «О задачах партии по коренной перестройке управления экономикой».

 Принят закон СССР «О государственном предприятии (объединении)».
 Принят «Закон о порядке обжалования в суд неправомерных действий должностных лиц, ущемляющих права гражданина»
 август 1987 года — Впервые разрешена безлимитная подписка на газеты и журналы.
 декабрь 1987 года — по решению Политбюро ЦК КПСС и Совета Министров СССР был создан Всесоюзный центр изучения общественного мнения (ВЦИОМ).

1988 год
  — статья Нины Александровны Андреевой в газете «Советская Россия» — «Не могу поступаться принципами»
 Март 1988 года — впервые президент Уругвая (Хулио Мария Сангинетти) посетил СССР.
  — Принят закон «О кооперации в СССР».
 5—18 июня 1988 года — Всесоюзные торжественные мероприятия, приуроченные к 1000-летнему юбилею принятия христианства на Руси.
  —  — XIX Всесоюзная конференция КПСС, принявшая резолюции «О некоторых неотложных мерах по практическому осуществлению реформы политической системы страны», «О ходе реализации решений XXVII съезда КПСС и задачах по углублению перестройки», «О демократизации советского общества и реформе политической системы», «О борьбе с бюрократизмом», «О межнациональных отношениях», «О гласности», «О правовой реформе».
  — Указы Президиума ВС СССР «О порядке организации и проведения собраний, митингов, уличных шествий и демонстраций в СССР» и «Об обязанностях и правах внутренних войск МВД СССР при охране общественного порядка».
  — в Чимкенте (Казахская ССР) зарегистрирован первый в СССР кооперативный банк («Союз-банк»), его уставной капитал составил 1 млн рублей.
  — Начался суд над Юрием Михайловичем Чурбановым (5 сентября — 30 декабря).
  — На Пленуме ЦК КПСС проходит крупнейшая со сталинских времён «чистка» Политбюро.
 Октябрь 1988 года — впервые президент Бразилии (Жозе Сарней) посетил СССР.

1989 год
 январь 1989 года — Началось первое свободное выдвижение кандидатов в народные депутаты СССР.
  — завершился вывод советских войск из Афганистана.
  — впервые советский хоккеист (Сергей Пряхин) официально принял участие в матче НХЛ.
  — разгон оппозиционного митинга у дома правительства ГССР в Тбилиси.
  —  — Визит главы СССР и КПСС М. Горбачёва в КНР. Начало процесса нормализации советско-китайских отношений.
  — Верховный Совет Литовской ССР принял декларацию о государственном суверенитете.
  —  — Первый съезд народных депутатов СССР.
  — Верховный Совет Латвийской ССР принял декларацию о государственном суверенитете.
  — Верховный Совет Эстонской ССР объявил незаконным присоединение республики к СССР в 1940 году.
 1989 год — Университеты и ВУЗы СССР начали готовить специалистов по специальности «социология».

1990 год
 Январь 1990 года — армянские погромы в Баку; ввод советских войск в город Баку с целью подавления политической оппозиции, закончившееся гибелью более сотни жителей города, в основном азербайджанцев.
  — МИД Чехословакии потребовало вывести войска СССР с территории страны до конца 1990 года.
  — МИД Венгрии потребовало вывести войска СССР с территории страны до конца 1990 года.
  — На первых свободных выборах в Литве одержало победу движение «Саюдис».
  — Начало вывода советских войск из Чехословакии.
  — В итоге советско-монгольских переговоров принято решение о выводе советских войск из Монголии до 1992 года.
  — В результате выборов в Верховный Совет РСФСР избирательный блок «Демократическая Россия» получила около 20 % голосов избирателей.
  — Принят «Закон о собственности в СССР».
 Весна 1990 года — Эстония, Литва и Латвия, в одностороннем порядке, провозглашают независимость и объявляют о выходе из состава СССР. Начинается процесс распада государства на независимые республики.
  — На первых свободных выборах в ГДР одержало победу движение «Альянс за Германию».
  — На первых свободных выборах в Венгрии одержало победу движение «Венгерский демократический форум».
  — В результате переговоров сандинистского правительства Никарагуа и «контрас» подписано соглашение о немедленном прекращении огня.
  — Встреча министров иностранных дел Великобритании (Дуглас Хёрд), СССР (Эдуард Шеварднадзе), США (Джеймс Бейкер), Франции (Ролан Дюма), ГДР (Маркус Меккель) и ФРГ (Ганс-Дитрих Геншер) по проблеме объединения Германии.
  — Борис Николаевич Ельцин избран председателем Верховного Совета РСФСР.
  — СССР и США подписали соглашение об уничтожении и запрещении производства химического оружия и о подготовке многосторонней конвенции о запрещении химического оружия.
  — Первая встреча президента СССР Михаила Горбачёва и президента Южной Кореи Ро Дэ У, положившая начало процессу нормализации отношений между СССР и Южной Кореей.
  — На первых свободных выборах в Чехословакии одержало победу движение «Чешский гражданский форум».
  — съезд народных депутатов принимает Декларацию о государственном суверенитете России.
  — Принят «Закон о печати в СССР». Авторы: Михаил Александрович Федотов, Юрий Михайлович Батурин и Владимир Львович Энтин.
  — М. С. Горбачёв подписал президентский указ «О восстановлении прав всех жертв политических репрессий 20-50-х годов». Этим указом репрессии по политическим, социальным, национальным, религиозным и другим мотивам были признаны незаконными, а все права граждан, подвергшихся этим репрессиям, восстанавливались.
  — М. С. Горбачёв подписал президентский «Указ о возвращении советского гражданства лицам, его лишённым».
  — Принятие Закона СССР «О свободе совести и религиозных организациях».
  — Объединение Германии.
  — В Париже подписан договор об обычных вооружённых силах в Европе.
  — В Париже подписана Парижская хартия.

1991 год
  — На референдуме в Литве по вопросу о независимости государства из 84,5 % имевших право голоса граждан за независимость высказались 90,5 %, против — 6,5 %.
  — На референдумах в Эстонии и Латвии по вопросу о независимости государства, в Эстонии из 82,68 % имевших право голоса граждан за независимость высказались 77,83 %, в Латвии из 87,57 % имевших право голоса граждан за независимость высказались 73,8 %.
  — Прошёл общесоюзный референдум о судьбе СССР. В России за сохранение союзного государства высказались 77 % участвовавших в голосовании, 26,4 % высказались против.
  — Верховный Совет Грузии принял Акт о восстановлении государственной независимости.
  — Завершился вывод советских войск из Чехословакии.
  — В Эфиопии войска Революционно-демократического фронта эфиопских народов заняли Аддис-Абебу.
  — В Лиссабоне президент Анголы Жозе Эдуарду душ Сантуш и лидер повстанческого движения УНИТА Жонаш Савимби подписали пакет соглашений о мирном урегулировании.
  — Выборы президента в РСФСР. Борис Николаевич Ельцин избран президентом. Он победил в первом туре с 57,3 % голосов.
  — Завершился вывод советских войск из Венгрии.
  —  — В Словении произошли вооружённые столкновения между югославской союзной армией и словенскими силами территориальной обороны.
  — Представители 9 государств — членов СЭВ подписали в Будапеште соглашение о роспуске организации.
  — На заседании Политического консультативного комитета ОВД в Праге 6 государств-членов приняли решение о роспуске организации.
  — В Москве в ходе визита президента США Джорджа Буша-старшего подписан советско-американский договор о сокращении и ограничении стратегических наступательных вооружений (СНВ-1).
  —  — Августовский путч. Ввод танков в Москву, штурм баррикад на Садовом кольце, 3 человека погибли. 22 августа вводится новый государственный флаг — Российский триколор в противовес советскому красному знамени с серпом и молотом.
  — Парламент Эстонии объявил о введении в действие Декларации независимости.
  — Парламент Латвии объявил о введении в действие Декларации независимости.
  — Верховный Совет Украины принял Декларацию независимости с условием её подтверждения на референдуме 1 декабря 1991 г.
  — Верховный Совет Беларуси принял Декларацию независимости.
  — Парламент Молдовы принял Декларацию независимости.
  — Верховный Совет Азербайджана принял решение о восстановлении государственной независимости на основе Акта 1918 г.
  — Верховный Совет Кыргызстана принял Декларацию независимости.
  — Верховный Совет Узбекистана принял Декларацию независимости.
  — Государственный Совет СССР признал независимость Литвы, Латвии и Эстонии.
  — В югославской Республике Македонии в ходе референдума большинство голосовавших высказались за независимость.
  — Верховный Совет Таджикистана принял Декларацию независимости.
  — Литва, Латвия и Эстония приняты в СБСЕ.
  — Литва, Латвия, Эстония, КНДР, Республика Корея, Микронезия и Маршалловы острова стали членам ООН.
  — Верховный Совет Армении принял Деклара