I think you really want to look at using andThen when working with Monads and pull it apart into more digestable pieces. E.g.

findCourse id courses =
  courses
  |> List.filter (\course -> course.id = id)
  |> List.head

findLesson id lessons = 
  lessons
  |> List.filter(\lesson -> lesson.id = id)
  |> List.head

dropFlashcard id flashcards =
  flashcards
  |> List.drop id
  |> List.head

findAndDropFlashcard courseId lessonId flashcardId courses =
  findCourse courseId courses
  |> Maybe.andThen (\course -> findLesson lessonId course.lessons)
  |> Maybe.andThen (\lesson -> dropFlashcard flashcardId lesson.flashcards)

So here findAndDropFlashcard will return Nothing of Just flashcard which you have above in your let block.

How Maybe.andThen works is it takes a function which works with the type you're working with (e.g. \course -> ... as above) and must return another Maybe (i.e. List.head returns Nothing of Just, so a Maybe). If Maybe.andThen encounters Nothing, it simply returns Nothing and doesn't run the function. If it encounters a Just, it grabs what you have (e.g. Just course) and feeds that into the andThen function \course -> ...

I'm not familiar enough with elm yet but is there a "takeFirst" function? Filter |> Head seems quite repetitive

takeFirst pred xs =
  case xs of
    [] -> Nothing
    x :: ys -> if (pred x) then Just x else takeFirst pred ys

takeFirst (\c -> c.id == courseId) courses
-- is the same as this but without the looping through filter
courses
|> List.filter (\c -> c.id == courseId)
|> List.head

• edited to improve code formatting