т.е. "если ты хочешь наследоваться от такого-то абстрактного типа, то реализуй пожалуйста такие-то функции"

Это интерфейс скорее

Это да, обычно через описания делают

Или можно писать fallback функции для абстрактного класса, которые ошибку выкидывают, если нет имплементации для конкретного типа.

Но это, к сожалению должны делать писатели соответствующих классов, язык ничего не запрещает и не разрешает.

т.е. вопросы к составителям пакетов

Типа того

Хаха, объединяя несколько идей из этого чата, можно такой код написать (не очень эффективный по скорости, зато довольно высокоуровневый)

function slice_when(f, a::Vector{T}) where {T <: AbstractFloat}
    a1 = [-Inf; a; Inf]
    idx = f.(a1[1:end - 1], a1[2:end])
    b = (collect(1:length(a) + 1))[idx]
    map(x -> a1[x[1] + 1:x[2]], zip(b[1:end-1], b[2:end]))
end

a = [100, 38, 1, 1.5, 2, 1, 6, 34, 35, 34.5, 10,  23, 11, 11.5, 12, 11.8, 11.4]

slice_when(a) do x, y
    abs(x - y) > 2.0
end |> x -> filter(i -> length(i) > 1, x)

Немного от руби, немного от джулии, немного манипуляции с индексами 😊

Ну и многословный, но зато удобный вариант с итераторами (удобный, что его можно сделать ленивым и накатывать на что хочешь)

struct SliceIter{T, F}
    a::Vector{T}
    f::F
end

slices(a, f) = SliceIter(a, f)

function Base.iterate(iter::SliceIter, state = 1)
    state > length(iter.a) && nothing
    while true
        state1 = state
        while state1 < length(iter.a)
            state1 += 1
            if iter.f(iter.a[state1 - 1], iter.a[state1])
                if state1 - state > 1
                    return (iter.a[state:state1-1], state1)
                else
                    state = state1
                end
            end
        end
        state1 - state > 1 ? (return (iter.a[state:state1 - 1], state1)) : return nothing
    end
end

for arr in slices(a, (x, y) -> abs(x - y) > 2.0)
    println(arr)  # do whatever you like
end

Поправил, чтобы не было лишних аллокаций Теперь совсем хорошо стало 😊

struct SliceIter{T, F}
    a::Vector{T}
    f::F
end

slices(a, f) = SliceIter(a, f)

function Base.iterate(iter::SliceIter, state = 1)
    state > length(iter.a) && nothing
    while true
        state1 = state
        while state1 < length(iter.a)
            state1 += 1
            if iter.f(iter.a[state1 - 1], iter.a[state1])
                if state1 - state > 1
                    return (iter.a[state:state1-1], state1)
                else
                    state = state1
                end
            end
        end
        state1 - state > 1 ? (return (iter.a[state:state1 - 1], state1)) : return nothing
    end
end

for arr in slices(a, (x, y) -> abs(x - y) > 2.0)
    println(arr)  # do whatever you like
end

👍

Но я за функцию в первом аргументе

slices(a, f) = SliceIter(a, f)

А!!!

Я понял, да

Можно переставить,не проблема

Интересно, как итераторы смешиваются с do синтаксисом

Ну, там правило вроде такое.
Если хочешь do стиль, то на первый аргумент надо ставить функцию. Если хочешь broadcast, то на первое место нужно ставить то, что будешь броадкастить.

Как написать функцию, которая принимает два tuple и делает из них третий, при этом type stable

В данном случае правда и то и другое не подходит

То есть я знаю к примеру, что у одного тип ntuple N int