"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; function _createMdxContent(props) { const _components = { a: "a", code: "code", h2: "h2", h3: "h3", li: "li", ol: "ol", p: "p", pre: "pre", span: "span", strong: "strong", table: "table", tbody: "tbody", td: "td", th: "th", thead: "thead", tr: "tr", ul: "ul", ..._provideComponents(), ...props.components }, {RelatedComparisons} = _components; if (!RelatedComparisons) _missingMdxReference("RelatedComparisons", true); return _jsxs(_Fragment, { children: [_jsxs(_components.p, { children: ["Declarative Programming is a powerful paradigm that emphasizes ", _jsx(_components.strong, { children: "what" }), " the program should accomplish rather than ", _jsx(_components.strong, { children: "how" }), " to achieve it. This comprehensive guide delves into the essence of declarative programming, elucidating its core principles, practical applications, benefits, drawbacks, and essential resources to help you master this influential approach."] }), "\n", _jsx(_components.h2, { children: "What is Declarative Programming? Definition and Overview" }), "\n", _jsx(_components.h3, { children: "Defining Declarative Programming: Core Principles and Concepts" }), "\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Declarative Programming (DP)" }), " is a programming paradigm that focuses on describing ", _jsx(_components.strong, { children: "what" }), " the desired outcome is, without explicitly outlining the steps to achieve it. Unlike imperative programming, which emphasizes control flow and state changes, declarative programming abstracts the execution process, allowing developers to specify logic and rules that define the desired results."] }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Core Principles of Declarative Programming:" }) }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "High-Level Abstractions" }), ": Focuses on the logic of computation without detailing the control flow."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Immutability" }), ": Encourages the use of immutable data structures, reducing side effects."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Function Composition" }), ": Utilizes functions as first-class citizens, enabling the composition of complex operations from simpler ones."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Expressiveness" }), ": Provides concise and readable code by abstracting underlying implementation details."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Declarative Syntax" }), ": Utilizes domain-specific languages (DSLs) or declarative constructs within general-purpose languages to express logic."] }), "\n"] }), "\n", _jsx(_components.h3, { children: "Declarative Programming in the Broader Programming Landscape" }), "\n", _jsxs(_components.p, { children: ["Declarative programming is one of several paradigms that coexist within the programming ecosystem, alongside imperative, object-oriented, and functional paradigms. While imperative programming focuses on ", _jsx(_components.strong, { children: "how" }), " to perform tasks through explicit instructions and control flow, declarative programming centers on ", _jsx(_components.strong, { children: "what" }), " needs to be accomplished by defining desired outcomes and constraints. This abstraction makes DP particularly suited for tasks that benefit from high-level reasoning, parallelism, and optimization."] }), "\n", _jsx(_components.p, { children: "Declarative programming encompasses various sub-paradigms, including:" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Functional Programming" }), ": Emphasizes pure functions and immutability."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Logic Programming" }), ": Uses formal logic to express computation."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Database Query Languages" }), ": Such as SQL, which specify what data to retrieve rather than how to retrieve it."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Markup Languages" }), ": Like HTML and XML, which define data structures and presentation without specifying behavior."] }), "\n"] }), "\n", _jsx(_components.h2, { children: "Key Concepts in Declarative Programming: Deep Dive into DP Principles" }), "\n", _jsx(_components.p, { children: "Understanding the foundational concepts of declarative programming is crucial for leveraging its full potential. Below is an expanded exploration of the most pivotal DP concepts, complete with detailed explanations and illustrative code snippets." }), "\n", _jsx(_components.h3, { children: "Higher-Order Functions: Empowering Abstraction and Reusability" }), "\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Higher-Order Functions (HOFs)" }), " are functions that can take other functions as arguments or return them as results. They enable powerful abstractions by allowing developers to create generic and reusable components."] }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Benefits of Higher-Order Functions:" }) }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Abstraction" }), ": Simplifies complex operations by abstracting common patterns."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Reusability" }), ": Promotes the reuse of functions across different contexts."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Composability" }), ": Facilitates the composition of functions to build more complex behavior."] }), "\n"] }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Example in JavaScript:" }) }), "\n", _jsx(_components.pre, { children: _jsxs(_components.code, { className: "hljs language-javascript", children: [_jsx(_components.span, { className: "hljs-comment", children: "// Higher-order function example" }), "\n", _jsx(_components.span, { className: "hljs-keyword", children: "const" }), " ", _jsx(_components.span, { className: "hljs-title function_", children: "withLogging" }), " = (", _jsx(_components.span, { className: "hljs-params", children: "fn" }), ") => {\n ", _jsx(_components.span, { className: "hljs-keyword", children: "return" }), " ", _jsxs(_components.span, { className: "hljs-function", children: ["(", _jsx(_components.span, { className: "hljs-params", children: "...args" }), ") =>"] }), " {\n ", _jsx(_components.span, { className: "hljs-variable language_", children: "console" }), ".", _jsx(_components.span, { className: "hljs-title function_", children: "log" }), "(", _jsxs(_components.span, { className: "hljs-string", children: ["`Calling function ", _jsx(_components.span, { className: "hljs-subst", children: "${fn.name}" }), " with arguments:`"] }), ", args);\n ", _jsx(_components.span, { className: "hljs-keyword", children: "const" }), " result = ", _jsx(_components.span, { className: "hljs-title function_", children: "fn" }), "(...args);\n ", _jsx(_components.span, { className: "hljs-variable language_", children: "console" }), ".", _jsx(_components.span, { className: "hljs-title function_", children: "log" }), "(", _jsxs(_components.span, { className: "hljs-string", children: ["`Function ", _jsx(_components.span, { className: "hljs-subst", children: "${fn.name}" }), " returned:`"] }), ", result);\n ", _jsx(_components.span, { className: "hljs-keyword", children: "return" }), " result;\n };\n};\n\n", _jsx(_components.span, { className: "hljs-keyword", children: "const" }), " ", _jsx(_components.span, { className: "hljs-title function_", children: "add" }), " = (", _jsx(_components.span, { className: "hljs-params", children: "a, b" }), ") => a + b;\n", _jsx(_components.span, { className: "hljs-keyword", children: "const" }), " addWithLogging = ", _jsx(_components.span, { className: "hljs-title function_", children: "withLogging" }), "(add);\n\n", _jsx(_components.span, { className: "hljs-title function_", children: "addWithLogging" }), "(", _jsx(_components.span, { className: "hljs-number", children: "3" }), ", ", _jsx(_components.span, { className: "hljs-number", children: "4" }), ");\n", _jsx(_components.span, { className: "hljs-comment", children: "// Output:" }), "\n", _jsx(_components.span, { className: "hljs-comment", children: "// Calling function add with arguments: [3, 4]" }), "\n", _jsx(_components.span, { className: "hljs-comment", children: "// Function add returned: 7" }), "\n"] }) }), "\n", _jsx(_components.h3, { children: "Immutability: Maintaining Data Integrity" }), "\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Immutability" }), " refers to the practice of preventing data from being altered after its creation. In declarative programming, immutability ensures that data remains consistent and predictable, reducing side effects and making programs easier to reason about."] }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Benefits of Immutability:" }) }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Predictability" }), ": Immutable data structures prevent unexpected changes, enhancing program reliability."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Concurrency" }), ": Simplifies concurrent programming by eliminating the risks associated with mutable shared state."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Undo/Redo Functionality" }), ": Facilitates features like undo/redo by preserving previous states."] }), "\n"] }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Example in Python:" }) }), "\n", _jsx(_components.pre, { children: _jsxs(_components.code, { className: "hljs language-python", children: [_jsx(_components.span, { className: "hljs-comment", children: "# Immutability using tuples" }), "\nuser = (", _jsx(_components.span, { className: "hljs-string", children: "\"Alice\"" }), ", ", _jsx(_components.span, { className: "hljs-number", children: "30" }), ")\n", _jsx(_components.span, { className: "hljs-comment", children: "# To \"update\" age, create a new tuple" }), "\nupdated_user = (user[", _jsx(_components.span, { className: "hljs-number", children: "0" }), "], ", _jsx(_components.span, { className: "hljs-number", children: "31" }), ")\n\n", _jsx(_components.span, { className: "hljs-built_in", children: "print" }), "(user) ", _jsx(_components.span, { className: "hljs-comment", children: "# Output: ('Alice', 30)" }), "\n", _jsx(_components.span, { className: "hljs-built_in", children: "print" }), "(updated_user) ", _jsx(_components.span, { className: "hljs-comment", children: "# Output: ('Alice', 31)" }), "\n"] }) }), "\n", _jsx(_components.h3, { children: "Function Composition: Building Complex Operations from Simple Functions" }), "\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Function Composition" }), " is the process of combining two or more functions to produce a new function. It allows developers to build complex operations by chaining simpler, reusable functions, enhancing code readability and maintainability."] }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Benefits of Function Composition:" }) }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Modularity" }), ": Breaks down complex logic into manageable, reusable parts."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Readability" }), ": Creates clear and expressive code through function chaining."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Maintainability" }), ": Simplifies updates by allowing individual functions to be modified without affecting the entire system."] }), "\n"] }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Example in JavaScript:" }) }), "\n", _jsx(_components.pre, { children: _jsxs(_components.code, { className: "hljs language-javascript", children: [_jsx(_components.span, { className: "hljs-comment", children: "// Function composition example" }), "\n", _jsx(_components.span, { className: "hljs-keyword", children: "const" }), " ", _jsx(_components.span, { className: "hljs-title function_", children: "double" }), " = (", _jsx(_components.span, { className: "hljs-params", children: "x" }), ") => x * ", _jsx(_components.span, { className: "hljs-number", children: "2" }), ";\n", _jsx(_components.span, { className: "hljs-keyword", children: "const" }), " ", _jsx(_components.span, { className: "hljs-title function_", children: "addThree" }), " = (", _jsx(_components.span, { className: "hljs-params", children: "x" }), ") => x + ", _jsx(_components.span, { className: "hljs-number", children: "3" }), ";\n\n", _jsx(_components.span, { className: "hljs-keyword", children: "const" }), " ", _jsx(_components.span, { className: "hljs-title function_", children: "doubleThenAddThree" }), " = (", _jsx(_components.span, { className: "hljs-params", children: "x" }), ") => ", _jsx(_components.span, { className: "hljs-title function_", children: "addThree" }), "(", _jsx(_components.span, { className: "hljs-title function_", children: "double" }), "(x));\n\n", _jsx(_components.span, { className: "hljs-variable language_", children: "console" }), ".", _jsx(_components.span, { className: "hljs-title function_", children: "log" }), "(", _jsx(_components.span, { className: "hljs-title function_", children: "doubleThenAddThree" }), "(", _jsx(_components.span, { className: "hljs-number", children: "5" }), ")); ", _jsx(_components.span, { className: "hljs-comment", children: "// Output: 13" }), "\n"] }) }), "\n", _jsx(_components.h3, { children: "Declarative Syntax: Expressing Logic with Clarity and Precision" }), "\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Declarative Syntax" }), " allows developers to specify what the program should accomplish without detailing the control flow or state changes. This leads to more concise and readable code, making it easier to understand and maintain."] }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Benefits of Declarative Syntax:" }) }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Conciseness" }), ": Reduces boilerplate code by abstracting implementation details."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Readability" }), ": Enhances code clarity by focusing on the logic rather than the control flow."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Maintainability" }), ": Simplifies updates and modifications by providing a clear expression of intent."] }), "\n"] }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Example in SQL:" }) }), "\n", _jsx(_components.pre, { children: _jsxs(_components.code, { className: "hljs language-sql", children: [_jsx(_components.span, { className: "hljs-comment", children: "-- Declarative syntax to retrieve user names older than 25" }), "\n", _jsx(_components.span, { className: "hljs-keyword", children: "SELECT" }), " name ", _jsx(_components.span, { className: "hljs-keyword", children: "FROM" }), " users ", _jsx(_components.span, { className: "hljs-keyword", children: "WHERE" }), " age ", _jsx(_components.span, { className: "hljs-operator", children: ">" }), " ", _jsx(_components.span, { className: "hljs-number", children: "25" }), ";\n"] }) }), "\n", _jsx(_components.h3, { children: "Logic Programming: Defining Rules and Relationships" }), "\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Logic Programming" }), " involves defining rules and relationships that describe the problem domain. Programs consist of a set of logical statements, and computation is performed through logical inference, allowing the system to derive conclusions based on the defined rules."] }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Benefits of Logic Programming:" }) }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Expressiveness" }), ": Allows complex relationships and constraints to be defined clearly."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Flexibility" }), ": Facilitates dynamic problem-solving through logical inference."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Declarative Nature" }), ": Aligns with human reasoning and problem-solving approaches."] }), "\n"] }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Example in Prolog:" }) }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "hljs language-prolog", children: "% Defining family relationships\nparent(john, mary).\nparent(mary, susan).\n\n% Rule to determine grandparent\ngrandparent(X, Z) :- parent(X, Y), parent(Y, Z).\n\n% Query\n?- grandparent(john, susan).\n% Output: true.\n" }) }), "\n", _jsx(_components.h3, { children: "Domain-Specific Languages (DSLs): Tailoring Languages to Specific Problem Domains" }), "\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Domain-Specific Languages (DSLs)" }), " are specialized languages designed to express solutions within a particular domain. They provide high-level abstractions and constructs tailored to specific tasks, enhancing productivity and clarity."] }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Benefits of DSLs:" }) }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Efficiency" }), ": Streamlines problem-solving within specific domains by providing relevant abstractions."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Clarity" }), ": Improves code readability and maintainability by using terminology familiar to the domain."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Productivity" }), ": Reduces development time by offering constructs that directly map to domain-specific requirements."] }), "\n"] }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Example: HTML for Web Development" }) }), "\n", _jsx(_components.pre, { children: _jsxs(_components.code, { className: "hljs language-html", children: [_jsx(_components.span, { className: "hljs-comment", children: "" }), "\n", _jsxs(_components.span, { className: "hljs-meta", children: [""] }), "\n", _jsxs(_components.span, { className: "hljs-tag", children: ["<", _jsx(_components.span, { className: "hljs-name", children: "html" }), ">"] }), "\n", _jsxs(_components.span, { className: "hljs-tag", children: ["<", _jsx(_components.span, { className: "hljs-name", children: "head" }), ">"] }), "\n ", _jsxs(_components.span, { className: "hljs-tag", children: ["<", _jsx(_components.span, { className: "hljs-name", children: "title" }), ">"] }), "Declarative Programming Example", _jsxs(_components.span, { className: "hljs-tag", children: [""] }), "\n", _jsxs(_components.span, { className: "hljs-tag", children: [""] }), "\n", _jsxs(_components.span, { className: "hljs-tag", children: ["<", _jsx(_components.span, { className: "hljs-name", children: "body" }), ">"] }), "\n ", _jsxs(_components.span, { className: "hljs-tag", children: ["<", _jsx(_components.span, { className: "hljs-name", children: "h1" }), ">"] }), "Welcome to Declarative Programming", _jsxs(_components.span, { className: "hljs-tag", children: [""] }), "\n ", _jsxs(_components.span, { className: "hljs-tag", children: ["<", _jsx(_components.span, { className: "hljs-name", children: "p" }), ">"] }), "This is a simple HTML document demonstrating declarative syntax.", _jsxs(_components.span, { className: "hljs-tag", children: [""] }), "\n", _jsxs(_components.span, { className: "hljs-tag", children: [""] }), "\n", _jsxs(_components.span, { className: "hljs-tag", children: [""] }), "\n"] }) }), "\n", _jsx(_components.h2, { children: "Declarative Programming Examples: Languages and Real-World Applications" }), "\n", _jsx(_components.p, { children: "Declarative programming principles are embodied in various programming languages and technologies, each offering unique features that support the DP paradigm. Below are examples of languages and technologies that exemplify declarative programming, along with code snippets and real-world analogies to clarify the paradigm." }), "\n", _jsx(_components.h3, { children: "Top Declarative Programming Languages and Technologies: Features and Use Cases" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "SQL (Structured Query Language)" }), ": Designed for managing and querying relational databases. SQL allows developers to specify what data to retrieve or manipulate without detailing how to perform the operations."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "HTML (HyperText Markup Language)" }), ": A markup language used for structuring and presenting content on the web. HTML declaratively defines the structure and layout of web pages."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "CSS (Cascading Style Sheets)" }), ": Used for styling web pages. CSS declaratively specifies the appearance of elements without describing the steps to achieve the styling."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Prolog" }), ": A logic programming language used for artificial intelligence and computational linguistics. Prolog allows developers to define rules and relationships, letting the system perform logical inference."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "XSLT (eXtensible Stylesheet Language Transformations)" }), ": Used for transforming XML documents into other formats. XSLT declaratively defines the transformation rules."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Haskell" }), ": While primarily a functional programming language, Haskell supports declarative paradigms through its emphasis on pure functions and high-level abstractions."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "React (with JSX)" }), ": A JavaScript library for building user interfaces. React uses a declarative approach to define what the UI should look like based on the application state."] }), "\n"] }), "\n"] }), "\n", _jsx(_components.h3, { children: "Practical Code Examples: Applying Declarative Programming Concepts" }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Example in SQL: Querying a Database" }) }), "\n", _jsx(_components.pre, { children: _jsxs(_components.code, { className: "hljs language-sql", children: [_jsx(_components.span, { className: "hljs-comment", children: "-- Declarative syntax to retrieve names of employees in the 'Engineering' department" }), "\n", _jsx(_components.span, { className: "hljs-keyword", children: "SELECT" }), " name ", _jsx(_components.span, { className: "hljs-keyword", children: "FROM" }), " employees ", _jsx(_components.span, { className: "hljs-keyword", children: "WHERE" }), " department ", _jsx(_components.span, { className: "hljs-operator", children: "=" }), " ", _jsx(_components.span, { className: "hljs-string", children: "'Engineering'" }), ";\n"] }) }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Example in HTML: Structuring a Web Page" }) }), "\n", _jsx(_components.pre, { children: _jsxs(_components.code, { className: "hljs language-html", children: [_jsx(_components.span, { className: "hljs-comment", children: "" }), "\n", _jsxs(_components.span, { className: "hljs-meta", children: [""] }), "\n", _jsxs(_components.span, { className: "hljs-tag", children: ["<", _jsx(_components.span, { className: "hljs-name", children: "html" }), ">"] }), "\n", _jsxs(_components.span, { className: "hljs-tag", children: ["<", _jsx(_components.span, { className: "hljs-name", children: "head" }), ">"] }), "\n ", _jsxs(_components.span, { className: "hljs-tag", children: ["<", _jsx(_components.span, { className: "hljs-name", children: "title" }), ">"] }), "Declarative Programming Example", _jsxs(_components.span, { className: "hljs-tag", children: [""] }), "\n", _jsxs(_components.span, { className: "hljs-tag", children: [""] }), "\n", _jsxs(_components.span, { className: "hljs-tag", children: ["<", _jsx(_components.span, { className: "hljs-name", children: "body" }), ">"] }), "\n ", _jsxs(_components.span, { className: "hljs-tag", children: ["<", _jsx(_components.span, { className: "hljs-name", children: "h1" }), ">"] }), "Welcome to Declarative Programming", _jsxs(_components.span, { className: "hljs-tag", children: [""] }), "\n ", _jsxs(_components.span, { className: "hljs-tag", children: ["<", _jsx(_components.span, { className: "hljs-name", children: "p" }), ">"] }), "This is a simple HTML document demonstrating declarative syntax.", _jsxs(_components.span, { className: "hljs-tag", children: [""] }), "\n", _jsxs(_components.span, { className: "hljs-tag", children: [""] }), "\n", _jsxs(_components.span, { className: "hljs-tag", children: [""] }), "\n"] }) }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Example in React: Building a User Interface" }) }), "\n", _jsx(_components.pre, { children: _jsxs(_components.code, { className: "hljs language-jsx", children: [_jsx(_components.span, { className: "hljs-comment", children: "// Declarative syntax using React to define a component" }), "\n", _jsx(_components.span, { className: "hljs-keyword", children: "import" }), " ", _jsx(_components.span, { className: "hljs-title class_", children: "React" }), " ", _jsx(_components.span, { className: "hljs-keyword", children: "from" }), " ", _jsx(_components.span, { className: "hljs-string", children: "'react'" }), ";\n\n", _jsx(_components.span, { className: "hljs-keyword", children: "const" }), " ", _jsx(_components.span, { className: "hljs-title function_", children: "Greeting" }), " = (", _jsx(_components.span, { className: "hljs-params", children: "{ name }" }), ") => (\n ", _jsxs(_components.span, { className: "xml", children: [_jsxs(_components.span, { className: "hljs-tag", children: ["<", _jsx(_components.span, { className: "hljs-name", children: "div" }), ">"] }), "\n ", _jsxs(_components.span, { className: "hljs-tag", children: ["<", _jsx(_components.span, { className: "hljs-name", children: "h1" }), ">"] }), "Hello, {name}!", _jsxs(_components.span, { className: "hljs-tag", children: [""] }), "\n ", _jsxs(_components.span, { className: "hljs-tag", children: ["<", _jsx(_components.span, { className: "hljs-name", children: "p" }), ">"] }), "Welcome to the declarative programming paradigm.", _jsxs(_components.span, { className: "hljs-tag", children: [""] }), "\n ", _jsxs(_components.span, { className: "hljs-tag", children: [""] })] }), "\n);\n\n", _jsx(_components.span, { className: "hljs-keyword", children: "export" }), " ", _jsx(_components.span, { className: "hljs-keyword", children: "default" }), " ", _jsx(_components.span, { className: "hljs-title class_", children: "Greeting" }), ";\n"] }) }), "\n", _jsx(_components.p, { children: _jsx(_components.strong, { children: "Example in Prolog: Defining Logical Relationships" }) }), "\n", _jsx(_components.pre, { children: _jsx(_components.code, { className: "hljs language-prolog", children: "% Defining family relationships\nparent(john, mary).\nparent(mary, susan).\n\n% Rule to determine grandparent\ngrandparent(X, Z) :- parent(X, Y), parent(Y, Z).\n\n% Query\n?- grandparent(john, susan).\n% Output: true.\n" }) }), "\n", _jsx(_components.h3, { children: "Real-World Analogy: Declarative Programming as Ordering Food at a Restaurant" }), "\n", _jsxs(_components.p, { children: ["Imagine ordering food at a restaurant. You specify ", _jsx(_components.strong, { children: "what" }), " you want (e.g., \"I would like a cheeseburger with fries\"), but you don't need to describe ", _jsx(_components.strong, { children: "how" }), " the kitchen should prepare it. The restaurant's staff handles the preparation process, ensuring your order is fulfilled. Similarly, in declarative programming, you specify ", _jsx(_components.strong, { children: "what" }), " you want to achieve, and the underlying system determines ", _jsx(_components.strong, { children: "how" }), " to accomplish it."] }), "\n", _jsx(_components.h2, { children: "When to Use Declarative Programming: Optimal Scenarios and Project Types" }), "\n", _jsxs(_components.p, { children: ["Declarative programming excels in scenarios that benefit from its high-level abstractions, immutability, and focus on ", _jsx(_components.strong, { children: "what" }), " needs to be accomplished rather than ", _jsx(_components.strong, { children: "how" }), ". Understanding when to apply DP can lead to more efficient, maintainable, and scalable software solutions."] }), "\n", _jsx(_components.h3, { children: "Ideal Use Cases for Declarative Programming" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Database Management and Querying" }), ": SQL is inherently declarative, allowing complex data retrieval and manipulation without detailing the execution steps."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Web Development" }), ": Technologies like HTML, CSS, and frameworks like React use declarative approaches to define UI structure and styling, enhancing maintainability and scalability."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Configuration Management" }), ": Tools like Ansible and Terraform use declarative configurations to manage infrastructure, enabling consistent and reproducible deployments."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Data Transformation and Processing" }), ": Languages and tools like XSLT and Spark SQL allow declarative specifications for transforming and processing large datasets."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Artificial Intelligence and Logic-Based Applications" }), ": Prolog and similar languages enable the definition of logical rules and relationships, facilitating complex problem-solving and inference."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Domain-Specific Languages (DSLs)" }), ": Tailored DSLs allow developers to express solutions within specific domains more effectively and intuitively."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Event Handling and Reactive Programming" }), ": Declarative paradigms in event-driven systems simplify the management of asynchronous data flows and state changes."] }), "\n"] }), "\n"] }), "\n", _jsx(_components.h3, { children: "Project Types That Benefit from Declarative Programming" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Enterprise Applications" }), ": Complex systems with extensive data management and user interfaces benefit from declarative approaches to enhance maintainability and scalability."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Web Applications" }), ": Building dynamic and responsive user interfaces is streamlined through declarative frameworks like React and Vue.js."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Infrastructure as Code (IaC)" }), ": Managing and provisioning infrastructure through declarative configurations ensures consistency and reproducibility across environments."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Data Analysis and ETL Pipelines" }), ": Declarative tools simplify the extraction, transformation, and loading of data, improving efficiency and reducing errors."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "AI and Expert Systems" }), ": Declarative languages enable the definition of complex logical rules and inference mechanisms necessary for intelligent applications."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Content Management Systems (CMS)" }), ": Declarative approaches facilitate the flexible management of content types and user roles, enhancing system adaptability."] }), "\n"] }), "\n"] }), "\n", _jsx(_components.h2, { children: "Advantages and Disadvantages of Declarative Programming: Comprehensive Analysis" }), "\n", _jsx(_components.p, { children: "Declarative programming offers a myriad of benefits but also presents certain challenges. Understanding these pros and cons is essential for making informed decisions about adopting DP in your projects." }), "\n", _jsx(_components.h3, { children: "Advantages of Declarative Programming" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Conciseness and Readability" }), ": Declarative code is often more concise and easier to read, as it focuses on the desired outcomes rather than the control flow."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Maintainability" }), ": High-level abstractions and clear expressions of intent simplify code maintenance and updates."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Reduced Side Effects" }), ": Emphasizing immutability and pure functions minimizes unintended side effects, enhancing program reliability."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Parallelism and Concurrency" }), ": Declarative paradigms naturally support parallelism and concurrency by abstracting state management and control flow."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Expressiveness" }), ": Allows developers to express complex logic and relationships succinctly through high-level constructs and abstractions."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Abstraction and Reusability" }), ": High-level abstractions promote code reuse and modularity, reducing duplication and enhancing scalability."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Easier Debugging and Testing" }), ": Clear separation of logic and abstraction levels simplifies the debugging and testing processes."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Optimization Opportunities" }), ": Abstracting the ", _jsx(_components.strong, { children: "how" }), " allows underlying systems to optimize execution, potentially improving performance."] }), "\n"] }), "\n"] }), "\n", _jsx(_components.h3, { children: "Disadvantages of Declarative Programming" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Performance Overhead" }), ": High-level abstractions can introduce performance overhead compared to low-level imperative approaches."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Steep Learning Curve" }), ": Developers accustomed to imperative or object-oriented paradigms may find DP concepts challenging to grasp initially."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Limited Control Over Execution" }), ": Abstracting the ", _jsx(_components.strong, { children: "how" }), " can limit developers' ability to optimize or control specific execution details."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Debugging Complexity" }), ": High-level abstractions and implicit execution flows can make debugging more difficult, as it may be harder to trace issues through the layers of abstraction."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Tooling and Library Support" }), ": While improving, some declarative paradigms and languages may lack the mature tooling and comprehensive library support found in more mainstream paradigms."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Potential for Over-Abstraction" }), ": Excessive abstraction can lead to code that is hard to understand and maintain, especially if the abstractions are not well-designed."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Integration Challenges" }), ": Integrating declarative components with imperative or object-oriented systems can sometimes be complex, requiring careful design considerations."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Expressiveness Limitations" }), ": For certain types of problems, declarative approaches may be less intuitive or expressive compared to imperative methods."] }), "\n"] }), "\n"] }), "\n", _jsx(_components.h3, { children: "Declarative Programming vs. Other Paradigms: Comparative Overview" }), "\n", _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Feature" }), _jsx(_components.th, { children: "Declarative Programming" }), _jsx(_components.th, { children: "Imperative Programming" }), _jsx(_components.th, { children: "Object-Oriented Programming" }), _jsx(_components.th, { children: "Functional Programming" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "State Management" }) }), _jsx(_components.td, { children: "Immutable state, focus on what" }), _jsx(_components.td, { children: "Mutable state, focus on how" }), _jsx(_components.td, { children: "Encapsulated state within objects" }), _jsx(_components.td, { children: "Immutable state" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Functions" }) }), _jsx(_components.td, { children: "Pure functions, higher-order" }), _jsx(_components.td, { children: "Procedures and routines" }), _jsx(_components.td, { children: "Methods tied to objects" }), _jsx(_components.td, { children: "Pure, first-class functions" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Concurrency" }) }), _jsx(_components.td, { children: "Easier with immutability and statelessness" }), _jsx(_components.td, { children: "More prone to race conditions" }), _jsx(_components.td, { children: "Can be complex due to mutable state" }), _jsx(_components.td, { children: "Easier with immutability" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Modularity" }) }), _jsx(_components.td, { children: "High through function composition and abstractions" }), _jsx(_components.td, { children: "Varies" }), _jsx(_components.td, { children: "High through classes and objects" }), _jsx(_components.td, { children: "High through function composition" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Code Predictability" }) }), _jsx(_components.td, { children: "High due to declarative nature" }), _jsx(_components.td, { children: "Lower due to side effects" }), _jsx(_components.td, { children: "Moderate" }), _jsx(_components.td, { children: "High due to pure functions" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Learning Curve" }) }), _jsx(_components.td, { children: "Steep for newcomers" }), _jsx(_components.td, { children: "Generally easier" }), _jsx(_components.td, { children: "Moderate to steep" }), _jsx(_components.td, { children: "Steep for newcomers" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Performance" }) }), _jsx(_components.td, { children: "Potential overhead from high-level abstractions" }), _jsx(_components.td, { children: "Typically faster for low-level operations" }), _jsx(_components.td, { children: "Potential overhead from abstraction" }), _jsx(_components.td, { children: "Potential optimization with lazy evaluation" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Abstraction Level" }) }), _jsx(_components.td, { children: "High with DSLs and function composition" }), _jsx(_components.td, { children: "Lower with direct state manipulation" }), _jsx(_components.td, { children: "High with class hierarchies and polymorphism" }), _jsx(_components.td, { children: "High with function composition and monads" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: _jsx(_components.strong, { children: "Expressiveness" }) }), _jsx(_components.td, { children: "High for certain domains" }), _jsx(_components.td, { children: "High for detailed control" }), _jsx(_components.td, { children: "High for modeling real-world entities" }), _jsx(_components.td, { children: "High for mathematical operations" })] })] })] }), "\n", _jsx(_components.h2, { children: "Top Resources to Learn Declarative Programming: Books, Courses, and Documentation" }), "\n", _jsx(_components.p, { children: "Embarking on the journey to master declarative programming requires access to quality resources. Below is a curated list of books, online courses, and official documentation to help you build a strong foundation in DP." }), "\n", _jsx(_components.h3, { children: "Must-Read Books for Declarative Programming Enthusiasts" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "\"SQL in a Nutshell\" by Kevin Kline, Brand Hunt, and Daniel Kline" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "A comprehensive reference for SQL, covering declarative querying and database management." }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "\"Prolog Programming for Artificial Intelligence\" by Ivan Bratko" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "An in-depth guide to Prolog, a logic programming language used for AI and declarative problem-solving." }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "\"Eloquent JavaScript\" by Marijn Haverbeke" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Covers declarative programming techniques in JavaScript, integrating DP concepts into web development." }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "\"Domain-Specific Languages\" by Martin Fowler" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Explores the creation and use of DSLs, enhancing declarative programming capabilities within specific domains." }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "\"Clojure for the Brave and True\" by Daniel Higginbotham" }), "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Introduces Clojure, a modern Lisp dialect that emphasizes declarative and functional programming principles." }), "\n"] }), "\n"] }), "\n"] }), "\n", _jsx(_components.h3, { children: "Top Online Courses for Learning Declarative Programming" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: [_jsx(_components.a, { href: "https://www.coursera.org/learn/intro-sql", children: "Introduction to SQL" }), " by University of Michigan on Coursera"] }), "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Covers the basics of SQL, teaching declarative querying and database management." }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: [_jsx(_components.a, { href: "https://www.udemy.com/course/react-the-complete-guide-incl-redux/", children: "React - The Complete Guide" }), " on Udemy"] }), "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Teaches declarative UI development using React, covering component-based architecture and state management." }), "\n"] }), "\n"] }), "\n"] }), "\n", _jsx(_components.h3, { children: "Official Documentation and Online Resources for Declarative Programming Languages" }), "\n", _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.a, { href: "https://www.iso.org/standard/63555.html", children: "SQL Documentation" }) }), "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Comprehensive references and tutorials for SQL, covering declarative querying and database management." }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.a, { href: "https://www.swi-prolog.org/pldoc/", children: "Prolog Documentation" }) }), "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Official documentation for SWI-Prolog, including tutorials, language references, and advanced topics." }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.a, { href: "https://react.dev/learn", children: "React Documentation" }) }), "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Official resources for learning React, covering declarative UI development and component-based architecture." }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.a, { href: "https://clojure.org/reference/reader", children: "Clojure Documentation" }) }), "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Comprehensive resources for learning Clojure, emphasizing declarative and functional programming principles." }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.a, { href: "https://www.w3.org/TR/xslt-30/", children: "XSLT Documentation" }) }), "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Official specifications and tutorials for XSLT, a declarative language for transforming XML documents." }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.a, { href: "https://developer.mozilla.org/en-US/docs/Web", children: "HTML and CSS Documentation" }) }), "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Extensive guides and references for HTML and CSS, foundational declarative languages for web development." }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: _jsx(_components.a, { href: "https://www.haskell.org/documentation/", children: "Haskell Documentation" }) }), "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Comprehensive official documentation for Haskell, including tutorials and language references focused on declarative and functional programming." }), "\n"] }), "\n"] }), "\n"] }), "\n", _jsx(_components.h2, { children: "Conclusion: Embracing Declarative Programming for Robust Software Development" }), "\n", _jsxs(_components.p, { children: ["Declarative programming offers a robust and elegant approach to software development, emphasizing high-level abstractions, immutability, and a clear focus on ", _jsx(_components.strong, { children: "what" }), " needs to be achieved. By mastering DP principles, developers can write more concise, maintainable, and scalable code, especially in applications that benefit from predictable outcomes and parallel processing."] }), "\n", _jsx(_components.p, { children: "While declarative programming presents a steeper learning curve and certain performance considerations, its benefits in terms of code quality, modularity, and concurrency management make it a valuable paradigm in the modern programming landscape. Whether you're developing complex web applications, managing databases, or automating infrastructure, declarative programming provides the tools and methodologies to enhance your development process." }), "\n", _jsx(_components.p, { children: "Utilize the recommended books, courses, and official documentation to deepen your understanding and apply declarative programming concepts to your projects. Embracing DP not only elevates your coding skills but also contributes to building more efficient and resilient software solutions." }), "\n", _jsx(RelatedComparisons, { currentTechnology: "Declarative-Functional-Imperative-OOP-Prolog-React-SQL-JavaScript" })] }); } function MDXContent(props = {}) { const {wrapper: MDXLayout} = { ..._provideComponents(), ...props.components }; return MDXLayout ? _jsx(MDXLayout, { ...props, children: _jsx(_createMdxContent, { ...props }) }) : _createMdxContent(props); } return { default: MDXContent }; function _missingMdxReference(id, component) { throw new Error("Expected " + (component ? "component" : "object") + " `" + id + "` to be defined: you likely forgot to import, pass, or provide it."); }