API question about ForeignError

[ssadler]

Currently ForeignError is quite limiting in what kinds of error a read operation can produce, that is, it covers type errors, but it only covers a parse error (say when parsing a String) IF it's parsing JSON.

In my case, I have a Type field which is parsed from a simple Haskell style string "Concrete -> Concrete". If the parse fails for any reason there isn't a ForeignError that covers this case, as it's not a type error but a syntax error. JSON gets special treatment in this case, but perhaps the JSONError should be generalized to cover other cases?

It seems like TypeMismatch isn't going to be useful in terms of implementing new Foreign instances because all the primitive types are already covered by the Foreign library.

[paf31]

Are you trying to use purescript-foreign to parse strings? That's really not what it's for, it's just for trying to turn untyped, untrusted data into typed data. Parsing would be better handled by a specific library, and it's not the sort of thing we'd add errors for here.

[ssadler]

That's really not what it's for, it's just for trying to turn untyped, untrusted data into typed data.

That is parsing though, just as reading JSON is parsing. I'm using Text.Parsing.StringParser to parse the string. I'm saying, Foreign is a useful abstraction for importing data, but it's not particularly extensible at the moment.

newtype Part = Part                                                            
    { id :: String                                                             
    , name :: String                                                           
    , "type" :: Type                                                           
    , exec :: Foreign                                                          
    , autocomplete :: Maybe Foreign                                            
    , args :: Array Part                                                       
    }                                                                          

instance partIsForeign :: IsForeign Part where                                 
    read fo = do                                                               
      n <- readProp "name" fo                                                  
      t <- readProp "type" fo                                                  
      e <- readProp "exec" fo                                                  
      auto <- runNullOrUndefined <$> readProp "autocomplete" fo                
      pure $ Part {id:"", name:n, "type":t, exec:e, autocomplete:auto, args:[]}

instance typeIsForeign :: IsForeign Type where                     
  read fo = read fo >>= (\str ->                                   
              unParser parseType {str, pos:0}                      
                (\pos err -> Left ... ) -- No sane way to return error
                (\typ _ -> Right typ))                             

Swapping out JSONError for ParseError would make it more useful. The alternative is not implementing Foreign for Type or Part, in which case I need to invent something else to contain that.

[garyb]

Actually this isn't that well suited to reading JSON either, I should update the readme to reflect that. For JSON you're better off using something like purescript-argonaut.

[ssadler]

Actually this isn't that well suited to reading JSON either, I should update the readme to reflect that. For JSON you're better off using something like purescript-argonaut.

Why is that? It's at least not the case if you are dealing with foreign JS code, since Argonaut is designed to go from "native" (or Generic) data representation, to Argonaut JSON types, to a JSON string, which doesn't include a Foreign representation anywhere.

[paf31]

This library doesn't deal with any of the usual parsing concerns like backtracking or alternation.

[ssadler]

https://github.com/libscott/purescript-foreign/blob/6afc9f049bda74ac0e0c6c0168020b13d9e9a349/src/Data/Foreign.purs#L48

> import ParseErrors
> main
Left (Error parsing JSON: SyntaxError: Unexpected token o)
Left (Type mismatch: expected Boolean, found Number)
Left (Error at array index 0: Type mismatch: expected Boolean, found Number)
Left (Error at property "y": Type mismatch: expected Number, found Boolean)

That's what I'm suggesting; personally I think it's an easy win from an API perspective, as the Foreign interface is a nice way to encapsulate data exchange between Purescript and Javascript.