[Haskell-cafe] ParallelListComp strange behavior

[Michael Jones]

I am trying to use ParallelListComp and have code that compiles but only produces one value, but I am not clear why.

The code is something like:

gen :: (a -> b) -> [MyType]
gen f = [MyType (Just []) (Just c) (Just d) Nothing
             | c <- f
             | d <- [1,2,3,4]

When the gen function is used with take or any other function, only one value is returned.

Is there something here that can’t desugar properly to mzip that will still compile?

Note I did not test this specific code, I am just writing it here to represent the different pieces of a larger piece of real code which is below.

Mike

———— Real Code ————


data Config = Config {  onOffControl::Maybe [DEVICE_ON_OFF_CONTROL_BITS]
                                    , seqUpPos::[Maybe ([DEVICE_SEQ_UP_POSITION_BITS], Word16)]
                                    , seqDownPos::[Maybe ([DEVICE_SEQ_DOWN_POSITION_BITS], Word16)]
                                    , tonTimers::[Maybe ([DEVICE_TON_TIMERS_BITS], Word16)]
                                    , toffTimers::[Maybe ([DEVICE_TOFF_TIMERS_BITS], Word16)]
                                    , vRange::Maybe [DEVICE_V_RANGE_BITS]
                                    , vThresh::[Maybe (Word16, Word16)]
                                    , rstbConfig::Maybe [DEVICE_RSTB_CONFIG_BITS]
                                    , faultResponse::Maybe [DEVICE_FAULT_RESPONSE_BITS]
                                    , breakpoint::Maybe ([DEVICE_BREAK_POINT_BITS], Word16)
                                    , writeProtect::Maybe ([DEVICE_WRITE_PROTECTION_BITS], Word16)
                                    , specialLot::Maybe Word16
                                    , deviceId::Maybe Word16
                                    , statusInfo::Maybe ([DEVICE_STATUS_INFORMATION_BITS])
                                    , monitorStatus::Maybe ([DEVICE_MONITOR_STATUS_BITS])
                                    , monitorStatusHistory::Maybe ([DEVICE_MONITOR_STATUS_HISTORY_BITS])
                                    , monitorBackup::Maybe ([DEVICE_MONITOR_BACKUP_BITS])
                                    , seqPosCount::Maybe ([DEVICE_SEQ_POSITION_COUNT_BITS], Word16)

generateConfigs seqValues delayValues threshValues = return [Config 
                                                                    (Just []) -- On off
                                                                    ([Just (suPol, suPos),Just (suPol, suPos),Just (suPol, suPos),Just (suPol, suPos),Just (suPol, suPos),Just (suPol, suPos)])
                                                                    ([Just (sdPol, sdPos),Just (sdPol, sdPos),Just (sdPol, sdPos),Just (sdPol, sdPos),Just (sdPol, sdPos),Just (sdPol, sdPos)])
                                                                    ([Just ([tonMax], tonDelay),Just ([tonMax], tonDelay),Just ([tonMax], tonDelay),Just ([tonMax], tonDelay),Just ([tonMax], tonDelay),Just ([tonMax], tonDelay)])
                                                                    ([Just ([toffMax], toffDelay),Just ([toffMax], toffDelay),Just ([toffMax], toffDelay),Just ([toffMax], toffDelay),Just ([toffMax], toffDelay),Just ([toffMax], toffDelay)])
                                                                    (Just [rng1, rng2, rng3, rng4, rng5, rng6])
                                                                    ([Just (threshOv, threshUv),Just (threshOv, threshUv),Just (threshOv, threshUv),Just (threshOv, threshUv),Just (threshOv, threshUv),Just (threshOv, threshUv)])
                                                                    (Just ([rst_en] ++ [rst_time]))
                                                                    (Just ([fault_number] ++ [fault_action] ++  [fault_delay] ++ fault_other ++ [fault_count]))
                                                                    (Just ([], 0)) 
                                                                    (Just ([], 0))
                                                                    (Just 0)
                                                                    Nothing
                                                                    Nothing
                                                                    Nothing
                                                                    Nothing
                                                                    Nothing
                                                                    Nothing
                                                                            | suPol <- [DEVICE_seq_up_position_bits]
                                                                            | suPos <- seqValues
                                                                            | sdPol <- [DEVICE_seq_down_position_bits]
                                                                            | sdPos <- seqValues
                                                                            | tonMax <- DEVICE_ton_timers_bits
                                                                            | tonDelay <- delayValues
                                                                            | toffMax <- DEVICE_toff_timers_bits
                                                                            | toffDelay <- delayValues
                                                                            | rng1 <- DEVICE_v_range_bits1
                                                                            | rng2 <- DEVICE_v_range_bits2
                                                                            | rng3 <- DEVICE_v_range_bits3
                                                                            | rng4 <- DEVICE_v_range_bits4
                                                                            | rng5 <- DEVICE_v_range_bits5
                                                                            | rng6 <- DEVICE_v_range_bits6
                                                                            | threshOv <- threshValues
                                                                            | threshUv <- threshValues
                                                                            | rst_time <- DEVICE_rstb_config_bits_time
                                                                            | rst_en <- DEVICE_rstb_config_bits_en 
                                                                            | fault_number <- DEVICE_fault_response_bits_retry_number
                                                                            | fault_other <- [DEVICE_fault_response_bits_other]
                                                                            | fault_count <- DEVICE_fault_response_bits_count
                                                                            | fault_delay <- DEVICE_fault_response_bits_delay
                                                                            | fault_action <- DEVICE_fault_response_bits_action
                                                              ]

generateSeqValues :: IO [Word16]
generateSeqValues = do 
  vs <- replicateM 10  (randomRIO (0x0000, 0x03FF))
  return vs

generateDelayValues :: IO [Word16]
generateDelayValues = do 
  vs <- replicateM 10 (randomRIO (0x0000, 0x1FFF))
  return vs


generateThreshValues :: IO [Word16]
generateThreshValues = do 
  vs <- replicateM 10 (randomRIO (0x0000, 0x00FF))
  return vs