---

Master Valentines Day in Elm: The Complete Learning Path

The "Valentines Day" module in Elm is your essential starting point for mastering conditional logic—the core of decision-making in any application. This guide explains how to use Elm's powerful and safe `if/else` expressions to create functions that respond dynamically to different inputs, ensuring robust and error-free code.

---

The Developer's Crossroads: Why Decisions Matter in Code

Imagine you're building a user registration form. The "Submit" button should only be active if the password is strong enough, the email is valid, and the user has agreed to the terms. Or perhaps you're creating a game where a character levels up only after collecting 100 gold coins. In every line of code we write, we are constantly navigating a world of choices and conditions.

This fundamental need to make decisions can be a source of countless bugs in many languages. A forgotten condition, an unexpected `null` value, or a logical path that wasn't accounted for can bring an entire application crashing down. You've likely spent hours debugging issues that stemmed from a simple, flawed conditional check. It's a universal pain point for developers.

This is where Elm transforms the game. It approaches conditional logic not as a potential source of errors, but as an opportunity for clarity and safety. The kodikra learning path for "Valentines Day" isn't just about a whimsical theme; it's a carefully designed module to introduce you to Elm's bulletproof approach to decision-making. Here, you will learn how to build programs that make choices reliably, without ever worrying about runtime exceptions.

---

What is the "Valentines Day" Module?

The "Valentines Day" module, part of the exclusive kodikra.com Elm curriculum, is a foundational lesson focused on implementing conditional logic using Elm's if/else expressions. While the theme is lighthearted—determining an appropriate response for Valentine's Day—the underlying concept is one of the most critical in programming: how to execute different code paths based on specific criteria.

In this module, you will build a simple function that returns one of two possible string values. This task serves as a practical, hands-on introduction to the syntax and philosophy of conditionals in a purely functional language. You'll discover that in Elm, an if block is not a statement that *does* something, but an expression that *evaluates* to a value, a subtle but profound difference that guarantees code safety.

Think of this module as your first step into writing truly declarative Elm code. You will learn to tell the compiler *what* you want the outcome to be under different conditions, and the compiler, in turn, will ensure that all possibilities are handled correctly.

Key Concepts Covered:

• Conditional Expressions: Understanding the difference between expressions (which return a value) and statements (which perform an action).
• if/else Syntax: Mastering the structure of an Elm conditional, including the mandatory else branch.
• Boolean Logic: Using boolean values (True and False) to control program flow.
• Function Signatures: Defining functions that take inputs and return a consistent type, enforced by the compiler across all conditional branches.
• Immutability: Observing how conditional logic works with immutable data to produce new values without side effects.

---

Why is This Concept Crucial in Elm?

Elm's primary promise is "no runtime errors." This bold guarantee is achieved through a combination of a strong static type system, immutability, and a carefully designed language core. Conditional logic is a major potential source of runtime errors in other languages, so Elm's handling of it is uniquely strict and powerful.

Expressions, Not Statements

In languages like JavaScript, Python, or Java, an if block is a *statement*. It directs the program to perform an action but doesn't inherently return a value. You often use it to mutate a variable defined outside the block.

// JavaScript (Statement-based)
let message;
let isApproved = true;

if (isApproved) {
  message = "Yes, I'll be your valentine!";
} else {
  message = "No, thank you.";
}
// The 'message' variable is mutated.

Elm completely avoids this. An if/else construct is an *expression*, meaning it must evaluate to a single value. This forces you to think about logic in a more functional way and eliminates a whole class of bugs related to uninitialized variables or unintended side effects.

-- Elm (Expression-based)
isApproved : Bool
isApproved = True

message : String
message =
    if isApproved then
        "Yes, I'll be your valentine!"
    else
        "No, thank you."

-- The 'message' constant is assigned the value of the entire if/else expression.

The Mandatory `else` Branch

Because an if in Elm is an expression that must produce a value, it logically follows that it must *always* produce a value. What would happen if the condition were False and there was no else branch? The expression would have no value to return, which would break the type system and the "no runtime errors" guarantee.

Therefore, Elm's compiler enforces that every if has a corresponding else. This simple rule prevents developers from forgetting to handle the "negative" case, a common oversight that leads to bugs like `undefined` or `null` values in other languages.

This design decision pushes you towards writing exhaustive, complete logic from the very beginning, making your code more robust and easier to reason about.

---

How to Implement Decision-Making in Elm

The "Valentines Day" module centers on the most direct form of conditional logic in Elm: the if/else expression. Let's break down its structure and see it in action.

The Anatomy of an `if/else` Expression

The syntax is clean and readable. It always follows this pattern:

if <condition> then <value_if_true> else <value_if_false>

• <condition>: An expression that must evaluate to a Bool (either True or False).
• <value_if_true>: The value the entire expression will return if the condition is True.
• <value_if_false>: The value the entire expression will return if the condition is False.

Crucially, the type of <value_if_true> and <value_if_false> must be the same. The Elm compiler will throw an error if you try to return a String in one branch and an Int in the other. This ensures type safety throughout your application.

Solving the "Valentines Day" Challenge

Let's apply this to the core task from the kodikra module. We need to create an approval function. This function might take a poem and decide if it's good enough. For simplicity, we'll start with a function that takes a simple boolean sign of approval.

module ValentinesDay exposing (approval)

{-| Determines the correct response based on approval.
-}
approval : Bool -> String
approval isApproved =
    if isApproved then
        "Woohoo! I'll be your valentine!"
    else
        "I'm sorry, but I must decline."

In this code:

1. The function signature approval : Bool -> String clearly states that it takes a Bool as input and returns a String.
2. The if isApproved part checks the boolean condition.
3. The then and else branches both return a String, satisfying the type signature. The entire if/else block evaluates to one of these two strings.

Here is a visual representation of this simple logical flow:

    ● Start with `isApproved` (Bool)
    │
    ▼
  ┌──────────────────┐
  │ Function `approval` │
  └─────────┬────────┘
            │
            ▼
    ◆ isApproved == True?
   ╱                   ╲
  Yes                   No
  │                      │
  ▼                      ▼
┌───────────────┐   ┌───────────────┐
│ Return "Woohoo!.." │   │ Return "I'm sorry.." │
└───────────────┘   └───────────────┘
  ╲                      ╱
   └─────────┬─────────┘
             │
             ▼
    ● End with `String` value

Beyond Simple Booleans: Introducing `case` Expressions

While if/else is perfect for binary true/false decisions, what if you have more than two possibilities? You could chain if/else if/else expressions, but this can become messy.

-- Chaining if/else can be hard to read
ratePoem : Int -> String
ratePoem rating =
    if rating > 8 then
        "Excellent!"
    else if rating > 5 then
        "Good effort."
    else
        "Needs more work."

A more idiomatic and scalable solution in Elm is the case expression. It allows you to match a value against several patterns and execute code for the first matching pattern.

Let's imagine we have different levels of approval represented by a custom type.

module ValentinesDay exposing (responseFor)

type ApprovalLevel
    = Enthusiastic
    | Polite
    | Rejection

responseFor : ApprovalLevel -> String
responseFor level =
    case level of
        Enthusiastic ->
            "Yes! A thousand times, yes!"

        Polite ->
            "That's very sweet, thank you."

        Rejection ->
            "I'm flattered, but no."

The case expression is incredibly powerful. The Elm compiler will check it for exhaustiveness, meaning you *must* provide a branch for every possible variant of ApprovalLevel. This completely eliminates bugs from forgetting to handle a specific state.

This multi-branch logic can be visualized as follows:

      ● Start with `level` (ApprovalLevel)
      │
      ▼
  ┌──────────────────┐
  │ Function `responseFor` │
  └─────────┬────────┘
            │
            ▼
      ◆ case level of...
      │
      ├─ "Enthusiastic" ⟶ "Yes! A thousand times, yes!"
      │
      ├─ "Polite" ⟶ "That's very sweet, thank you."
      │
      └─ "Rejection" ⟶ "I'm flattered, but no."
      │
      ▼
      ● End with `String` value

---

Where to Apply Conditional Logic: Real-World Scenarios

The simple decision-making you learn in the "Valentines Day" module is the bedrock for complex application features. Here’s where you’ll use these skills every day as an Elm developer.

1. Dynamic User Interfaces (UI)

A huge part of frontend development is showing, hiding, or changing UI elements based on the application's state.

• Showing a loading spinner: if state.isLoading then showSpinner else showData
• Enabling/disabling a button: Use a conditional to add or remove the disabled attribute on a button based on form validity.
• Displaying error messages: if state.error /= Nothing then showError state.error else Html.text ""

2. Handling API Responses

When you fetch data from a server, the request can succeed or fail. A case expression is perfect for handling the Result type from Elm's Http package.

update : Msg -> Model -> ( Model, Cmd Msg )
update msg model =
    case msg of
        GotUserData (Ok user) ->
            ( { model | user = Just user, error = Nothing }, Cmd.none )

        GotUserData (Err httpError) ->
            ( { model | error = Just (parseError httpError) }, Cmd.none )

3. Form Validation

Before submitting a form, you need to check if the inputs are valid. Each field might have a function that uses conditional logic to return a validation status.

validateEmail : String -> Maybe String
validateEmail email =
    if String.contains "@" email && String.length email > 5 then
        Nothing -- Represents a valid email
    else
        Just "Please enter a valid email address." -- Represents an error message

4. Game Development and State Machines

In a game, the character's state (e.g., `Jumping`, `Running`, `Idle`) determines their actions. A `case` expression is the ideal way to manage transitions between these states in your main update loop.

---

When to Choose `if` vs. `case`

Both if/else and case expressions are tools for decision-making, but they have distinct strengths. Choosing the right one makes your code cleaner and more maintainable.

Criterion	if/else Expression	case Expression
Best Use Case	Simple binary (True/False) decisions.	Handling multiple distinct possibilities or pattern matching on data structures.
Readability	Excellent for one or two conditions. Becomes messy when nested (else if).	Extremely clear for multiple branches. The structure scales well without deep nesting.
Compiler Safety	Guarantees an else branch is present. Ensures both branches return the same type.	Guarantees exhaustiveness. The compiler forces you to handle every possible variant of a custom type or value.
Power	Limited to evaluating a boolean expression.	Can deconstruct data. You can pull values out of custom types, tuples, or records right in the pattern match.
Example	if user.isLoggedIn then ... else ...	case user.role of Admin -> ...; Member -> ...; Guest -> ...

General Rule of Thumb: Start with an if/else for any simple boolean check. As soon as you find yourself writing an else if or checking a value against more than two specific possibilities, refactor to a case expression. The compiler's exhaustiveness checks for `case` are one of Elm's most powerful features for preventing bugs.

---

Your Learning Progression: The Valentines Day Module

This module contains one core exercise designed to give you a solid and practical foundation in Elm's conditional logic. Mastering this exercise is the first step toward writing dynamic and interactive Elm applications.

Beginner Level:

• Learn Valentines Day step by step: This is your starting point. You will implement the `approval` function and get comfortable with the basic `if/else` syntax and the concept of expressions.

Once you complete this module, you will be well-prepared to tackle more complex challenges in the main Elm Learning Roadmap that involve state management and user interaction.

---

Frequently Asked Questions (FAQ)

1. Is there an `else if` in Elm?

Yes, you can chain `if/else` expressions to create an `else if` structure. However, it's just syntactic sugar for nesting another `if` expression in the `else` branch.

-- This structure:
if conditionA then
    valueA
else if conditionB then
    valueB
else
    valueC

-- Is the same as this nested structure:
if conditionA then
    valueA
else
    (if conditionB then
        valueB
     else
        valueC
    )

While it works, a `case` expression is often a cleaner alternative if you have more than two or three branches.

2. Why is the `else` branch absolutely mandatory?

Because `if` in Elm is an expression that must always evaluate to a value. If there were no `else` branch, the expression would have no value to return when the condition is `False`. This would violate the type system and break Elm's guarantee of no runtime errors. The compiler enforces this rule to ensure your logic is always complete.

3. Can the `if` and `else` branches return values of different types?

No. The Elm compiler strictly enforces that both branches of an `if/else` expression return the exact same type. This is a core part of Elm's type safety. If one branch returns a `String` and the other returns an `Int`, the compiler will give you a friendly error message, forcing you to resolve the logical inconsistency at compile time, not at runtime.

4. What's the difference between an expression and a statement?

An expression is a piece of code that evaluates to a value. Examples: 2 + 2 (evaluates to 4), "hello" (evaluates to itself), and if x > 10 then "Big" else "Small" (evaluates to a string). A statement is a piece of code that performs an action or causes a side effect, but does not return a value. Examples in other languages include variable assignments (let x = 5;) or loops (for(...)). Elm is an expression-oriented language, meaning almost everything, including `if` and `case`, is an expression.

5. Can I use conditional logic inside my HTML view code?

Absolutely! This is one of its most common uses. Since your view is just a function that returns `Html`, you can use `if/else` or `case` expressions anywhere inside it to dynamically render different HTML based on your model's state.

view : Model -> Html Msg
view model =
    div []
        [ h1 [] [ text "Welcome" ]
        , if model.user.isLoggedIn then
            p [] [ text ("Hello, " ++ model.user.name) ]
          else
            a [ href "/login" ] [ text "Log In" ]
        ]

6. When should I put my logic in a separate helper function?

If your conditional logic inside a view or update function becomes more than a few lines long or involves multiple checks, it's a best practice to extract it into its own top-level or helper function. This improves readability and makes your code easier to test and reuse. For example, instead of a large `if` block in your view, you could have `viewGreeting model.user`, where `viewGreeting` is a separate function containing the logic.

---

Conclusion: Building Reliable Applications with Confidence

The "Valentines Day" module may seem simple, but the principle it teaches is profound. By enforcing that all conditional logic is explicit, exhaustive, and type-safe, Elm empowers you to build complex, dynamic applications with a level of confidence that is rare in software development. The mandatory `else` branch and the type consistency across branches aren't limitations; they are guardrails that keep your code correct and free of runtime errors.

As you move forward in your Elm journey, you will build on this foundation continuously. Every interactive feature, every piece of data you handle, and every user interface you design will rely on the robust decision-making patterns you first practiced here. Embrace this structured approach, and you'll spend less time debugging and more time creating amazing, reliable web applications.

Ready to put this theory into practice? Dive into the exercise and start making decisions the Elm way.

Back to the complete Elm Guide

---

Technology Disclaimer: The concepts and code snippets in this article are based on the latest stable version of Elm (currently 0.19.1). While the core principles of conditional logic are fundamental and unlikely to change, always refer to the official Elm documentation for the most current syntax and best practices.

---

Published by Kodikra — Your trusted Elm learning resource.