using Printf

# As an example of a generic function, `slices_index` takes
# a collection of any type and an element of that type,
# and returns the index of the first occurrence of v in s,
# or nothing if not present.
function slices_index(s, v)
    for (i, elem) in enumerate(s)
        if elem == v
            return i
        end
    end
    return nothing
end

# As an example of a generic type, `List` is a
# singly-linked list with values of any type.
mutable struct List{T}
    head::Union{Nothing, ListNode{T}}
    tail::Union{Nothing, ListNode{T}}
end

mutable struct ListNode{T}
    next::Union{Nothing, ListNode{T}}
    val::T
end

# We can define methods on generic types just like we
# do on regular types.
function push!(lst::List{T}, v::T) where T
    new_node = ListNode{T}(nothing, v)
    if isnothing(lst.tail)
        lst.head = lst.tail = new_node
    else
        lst.tail.next = new_node
        lst.tail = new_node
    end
end

# all_elements returns all the List elements as an array.
function all_elements(lst::List{T}) where T
    elems = T[]
    current = lst.head
    while !isnothing(current)
        push!(elems, current.val)
        current = current.next
    end
    return elems
end

function main()
    s = ["foo", "bar", "zoo"]

    # When invoking generic functions, we can often rely
    # on type inference. Note that we don't have to
    # specify the types when calling `slices_index` - 
    # the compiler infers them automatically.
    @printf("index of zoo: %s\n", slices_index(s, "zoo"))

    lst = List{Int}()
    push!(lst, 10)
    push!(lst, 13)
    push!(lst, 23)
    @printf("list: %s\n", all_elements(lst))
end

main()