Generics in Elm

-- Starting with version 0.19, Elm has added support for custom types,
-- which can be used to achieve similar functionality to generics in other languages.

-- As an example of a function that works with different types, 
-- `listIndex` takes a list of any type and an element of that
-- type and returns the index of the first occurrence of
-- v in the list, or Nothing if not present.

listIndex : List a -> a -> Maybe Int
listIndex list element =
    list
        |> List.indexedMap Tuple.pair
        |> List.filter (\(_, x) -> x == element)
        |> List.map Tuple.first
        |> List.head

-- As an example of a custom type that can hold different types of values,
-- we'll create a `List` type that is a singly-linked list with values of any type.

type List a
    = Empty
    | Cons a (List a)

-- We can define functions on our custom types just like we do on regular types.

push : a -> List a -> List a
push value list =
    Cons value list

-- allElements returns all the List elements as a standard Elm list.

allElements : List a -> List a
allElements list =
    case list of
        Empty ->
            []

        Cons x xs ->
            x :: allElements xs

main =
    let
        s = ["foo", "bar", "zoo"]

        -- When using our functions, Elm's type inference will automatically
        -- determine the correct types.
        zooIndex = listIndex s "zoo"
            |> Maybe.withDefault -1
            |> String.fromInt
    in
    "index of zoo: " ++ zooIndex
        |> Debug.log "Result"

    let
        myList = Empty
            |> push 10
            |> push 13
            |> push 23

        listElements = allElements myList
            |> List.map String.fromInt
            |> String.join " "
    in
    "list: " ++ listElements
        |> Debug.log "Result"

In this Elm translation:

We’ve created a listIndex function that mimics the behavior of SlicesIndex in the Go example. It works with lists of any type.
Instead of creating a generic List type, we’ve used Elm’s built-in custom types to create a singly-linked list that can hold any type of value.
We’ve implemented push and allElements functions for our custom List type.
In the main function, we demonstrate the usage of these functions.
Elm doesn’t have a direct equivalent to Go’s generics, but its type system and type inference provide similar capabilities in many cases.
We use Debug.log to output results, as Elm is typically used for web applications and doesn’t have a standard console output.

To run this Elm code, you would typically compile it and run it in a browser environment. The output would be visible in the browser’s console.

Result: "index of zoo: 2"
Result: "list: 23 13 10"

Note that Elm’s approach to handling different types is quite different from Go’s generics, but it achieves similar goals of code reuse and type safety.

Struct Embedding in Elm

Range Over Iterators in Elm

Learn X By Example

Title here

Generics in Elm