DOCSEARCHbyAlgolia
Submit Docs

elm/core

repository·master·Indexed 25 days ago

https://github.com/elm/core

The foundational library for the Elm programming language. It provides essential data structures such as List, Dict, and Set, basic arithmetic functionality, and platform integration primitives. The library includes default imports like Basics, Maybe, Result, String, Char, Tuple, Debug, and Platform modules.

Tokens
1.9K
Snippets
1
Records
13
Agent score
83%

What's inside elm/core

  1. Overview of Elm Core Libraries

    master
    The elm/core package provides the fundamental building blocks for every Elm project. It includes basic arithmetic functionality (such as addition and subtraction) and essential data structures including List, Dict (Dictionaries), and Set.

  2. Understand Elm's default imports

    master

    To simplify development, Elm automatically imports several common modules into every Elm file. You do not need to manually import these modules to use their functionality. The default imports include:

    • Basics: Basic arithmetic and functions.
    • List: List operations and the cons operator (::).
    • Maybe: The Maybe type and its constructors.
    • Result: The Result type and its constructors.
    • String: The String type.
    • Char: The Char type.
    • Tuple: Tuple support.
    • Debug: Debugging utilities.
    • Platform: The Program type.
    • Platform.Cmd: Command support (Cmd).
    • Platform.Sub: Subscription support (Sub).
    import Basics exposing (..)
import List exposing (List, (::))
import Maybe exposing (Maybe(..))
import Result exposing (Result(..))
import String exposing (String)
import Char exposing (Char)
import Tuple

import Debug

import Platform exposing (Program)
import Platform.Cmd as Cmd exposing (Cmd)
import Platform.Sub as Sub exposing (Sub)

  3. Troubleshoot virtual-dom runtime errors

    master

    If your application encounters a runtime error indicating a bug in elm-lang/virtual-dom, the issue may stem from your own code or a dependency.

    To resolve or report this:

    1. Reproduce the issue: Attempt to reproduce the error while running in dev mode.
    2. Create an SSCCE: Generate a Small, Self-Contained Code Example (SSCCE) that reproduces the bug.
    3. Report the bug: If you cannot resolve it locally, report the issue on the virtual-dom GitHub issues page. Use a title format like Implementation bug: ... and provide a description explaining your understanding of the problem.

  4. Resolve Elm module name clashes on the global Elm object

    master

    If your application displays a error page stating that multiple Elm scripts are attempting to expose the same module name to the global Elm object, you have a name clash. This occurs when two different scripts (e.g., a.js and b.js) both attempt to expose a module with the same name (e.g., Main) to the global Elm namespace.

    To resolve this:

    1. Ensure unique module names: If you need multiple Elm scripts to coexist on the same page via the global Elm object, ensure every Elm module has a unique name.
    2. Check for duplicate scripts: Verify that you are not accidentally loading the same script multiple times.
    3. Use Dev Mode for identification: If you can reproduce the error in development mode, Elm will explicitly identify the specific module name that is causing the collision.

  5. Troubleshoot invalid port values

    master

    If you encounter an error stating that you are trying to send an invalid value through a port, it means the data being sent from your Elm application to the JavaScript side via a Port does not match the expected format or type.

    To debug this:

    1. Reproduce in Dev Mode: Run your application in development mode to receive more detailed error information in the browser console.
    2. Verify Port Types: Ensure the value being passed to the Cmd that sends data to the port matches the type expected by the JavaScript listener.

  6. Troubleshoot `modBy 0 n` runtime crashes

    master

    If your Elm application crashes with a runtime error indicating that modBy 0 n is being called, it means a modulo operation is being attempted with a divisor of 0. This is a mathematical impossibility that causes the Elm runtime to crash to prevent undefined behavior.

    To resolve this:

    1. Identify the source: Check your code or your project's dependencies for any calls to modBy where the second argument (the divisor) evaluates to 0.
    2. Debug in Dev Mode: Reproduce the error while running in development mode to get more detailed information about the exact location of the crash.
    3. Fix the logic: Ensure that the divisor passed to modBy is never zero, typically by adding a check or using a default value.

  7. Troubleshoot Url.Parser.toUrl errors

    master

    If your application encounters an error stating that Url.Parser.toUrl could not handle a transitioned URL, it is likely due to an unsupported URL scheme (such as file:// or data://).

    To debug this:

    1. Reproduce in Dev Mode: Run your application in development mode to obtain more detailed error information.
    2. Verify URL Schemes: Check if the URL being parsed uses a scheme that the elm-lang/url package might not support.
    3. Report Bugs: If you can definitively prove the error is a bug in the elm-lang/url package, provide a Small, Self-Contained Code Example (SSCCE) in their GitHub repository.

  8. Troubleshoot Debug.crash errors

    master

    If your application displays a generic error page stating that it 'ran into a problem', it is likely because Debug.crash is being called within a case expression somewhere in your code or in one of your dependencies.

    To identify the source of the crash:

    1. Reproduce the error in dev mode.
    2. Use the detailed information provided by the runtime in dev mode to trace which part of the application is triggering the Debug.crash call.

  9. Troubleshoot 'Trying to use (==) on functions' error

    master

    This error occurs when your code (or a dependency) attempts to use the equality operator (==) on function types. In Elm, functions do not have a defined equality because there is no way to determine if two functions are semantically identical.

    To resolve this:

    1. Check your code for instances where (==) is applied to a function.
    2. If the error originates from a dependency, investigate if you are passing a function to a part of that dependency that expects a comparable type (like a String or Int).
    3. If you can reproduce the error in dev mode, you can obtain more detailed information about the specific location of the failure.

  10. Troubleshoot the application crash error

    master

    If an application displays a generic error page stating it 'ran into a problem', it is because the code (or one of its dependencies) is explicitly calling Debug.crash.

    To identify the source of the crash:

    1. Reproduce the error in dev mode to obtain more detailed information about the call stack.
    2. Check your own code for calls to Debug.crash.
    3. Inspect third-party dependencies for calls to Debug.crash.

  11. Troubleshoot bad flags during application initialization

    master

    If your Elm application displays a generic error page stating that the application ran into a problem, it is often caused by providing invalid or malformed flags during initialization.

    To diagnose the specific cause, reproduce the error in dev mode to obtain more detailed error information.

  12. Resolve duplicate port name errors

    master
    If your Elm application crashes with a runtime error stating that the application has multiple ports with the same name, you must ensure that every port defined in your Elm code has a unique name. Ports are used to communicate between Elm and the JavaScript runtime; duplicate names cause a collision that prevents the application from initializing correctly.