Elm 未捕获类型错误：无法读取属性'；第'周；未定义的

我在elm中遇到了一个未预料到的打字错误，不知道为什么

我正在解码来自api的json字符串；api提供了一个

名册

列表，每个名册都有一个

planningId

或

flexplanningId

。我想映射列表，并根据

planningId

或

flexplanningId

为每个

planningId

指定一个唯一的

id

，具体取决于它所具有的属性。代码如下：

记录定义和解码器：

type alias Rostar =
    { employee : Employee }


type alias Employee =
    { week : Week
    , name : String
    , id : Int
    , contractHours : Float
    }


type alias Week =
    { monday : List Planning
    , tuesday : List Planning
    , wednesday : List Planning
    , thursday : List Planning
    , friday : List Planning
    , saturday : List Planning
    , sunday : List Planning
    }


type alias Planning =
    { time : String
    , planningId : Maybe Int
    , groupId : Int
    , groupName : String
    , flex : Bool
    , employeeTimeslotId : Maybe Int
    , flexplanningId : Maybe Int
    , employeeId : Maybe Int
    , id : Maybe Int
    }


responseDecoder : Decoder (List Rostar)
responseDecoder =
    list rostarDecoder


rostarDecoder : Decoder Rostar
rostarDecoder =
    decode Rostar
        |> required "employee" employeeDecoder


employeeDecoder : Decoder Employee
employeeDecoder =
    decode Employee
        |> required "rostar" weekDecoder
        |> required "name" string
        |> required "id" int
        |> required "contract_hours" float


weekDecoder : Decoder Week
weekDecoder =
    decode Week
        |> required "monday" (list planningDecoder)
        |> required "tuesday" (list planningDecoder)
        |> required "wednesday" (list planningDecoder)
        |> required "thursday" (list planningDecoder)
        |> required "friday" (list planningDecoder)
        |> required "saturday" (list planningDecoder)
        |> required "sunday" (list planningDecoder)


planningDecoder : Decoder Planning
planningDecoder =
    decode Planning
        |> required "time" string
        |> optional "planning_id" (nullable int) Nothing
        |> required "group_id" int
        |> required "group_name" string
        |> required "flex" bool
        |> optional "employee_timeslot_id" (nullable int) Nothing
        |> optional "flexplanning_id" (nullable int) Nothing
        |> required "employee_id" (nullable int)
        |> hardcoded Nothing

映射：

update : Msg -> Model -> ( Model, Cmd Msg )
update msg model =
    case msg of
        HandleFeedResponse response ->
            let
                assignPlanningId : Planning -> Planning
                assignPlanningId planning =
                    case planning.planningId of
                        Just id ->
                            { planning | id = Just (id + 10000000) }

                        Nothing ->
                            case planning.flexplanningId of
                                Just id ->
                                    { planning | id = Just (id + 90000000) }

                                Nothing ->
                                    { planning | id = Nothing }

                planningWithId : List Planning -> List Planning
                planningWithId day =
                    List.map assignPlanningId day

                mapWeek : Week -> Week
                mapWeek week =
                    { week
                        | monday = planningWithId week.monday
                        , tuesday = planningWithId week.tuesday
                        , wednesday = planningWithId week.wednesday
                        , thursday = planningWithId week.thursday
                        , friday = planningWithId week.friday
                        , saturday = planningWithId week.saturday
                        , sunday = planningWithId week.sunday
                    }

                updateResponse : List Rostar
                updateResponse =
                    List.map
                        (\r ->
                            let
                                employee =
                                    { employee | week = mapWeek employee.week }
                            in
                                { r | employee = employee }
                        )
                        response

                check =
                    Debug.log "updatedResponse" updateResponse
            in
                { model | rostar = updateResponse } ! []

下面是我得到的错误：

未捕获的TypeError:无法读取未定义的属性“week” 大宗报价

---

谢谢你的帮助

这可能不是您的错误来源， 但是你的员工解码器说它需要一个

rostar

变量，它包含一个

week

。这是正确的吗？还是应该称之为

周

以下是代码片段：

employeeDecoder : Decoder Employee
employeeDecoder =
    decode Employee
--        |> required "rostar" weekDecoder -- is this correct?
        |> required "week" weekDecoder     -- what I would have expected
        |> required "name" string
        |> required "id" int
        |> required "contract_hours" float

---

我认为您的问题是由

updateResponse

映射函数中

employee

的

let

绑定引起的。标签

employee

已经存在，因此此行导致递归定义

let
雇员=
{employee | week=mapWeek employee.week}

在Elm 0.18中，这是一个编译错误，为您提供了详细的错误消息，而不是留下运行时错误的可能性：

在1个模块中检测到错误

-- BAD RECURSION ------------------------------------------------------ Main.elm

employee

直接根据自身定义，导致无限循环

132|>                                employee =
133|                                     { employee | week = mapWeek employee.week }

也许你在尝试变异一个变量？榆树没有变异，所以当我 请参见根据

employee

定义的

employee

，我将其视为递归 定义。尝试为新值指定一个新名称

也许你想要一个递归值？要定义员工，我们需要知道

employee

是，让我们展开它。等等，但是现在我们需要知道什么是

employee

是的，所以让我们扩展它。。。这将无限期地继续下去

要真正了解发生了什么以及如何修复，请查看：

在0.18之前，当意外执行某种非预期递归时，我会看到这些类型的奇怪的“未定义”运行时错误。在0.18中，他们添加了一些最基本类型问题的编译器检查