Pipeline operator refuses to work

Question

I can't understand why this

let data = 
    JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, string>>>(
         File.ReadAllText <| Path.Combine(myPath, "ejv.json"))

is ok, while this

let data = 
    JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, string>>> 
    <| File.ReadAllText
    <| Path.Combine(myPath, "ejv.json")

Gives me two errors, first is:

First error

and second is:

Second error

What did I do wrong?

UPDATE @Patryk Ćwiek suggested a good edit, which seems to fix errors with types:

let data = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, string>>> 
       << File.ReadAllText 
       <| Path.Combine(myPath, "ejv.json")

But it produces another puzzling message: Unexpected type arguments. Here's a screenshot:

Unexpected type arguments.

I can easily get rid of it removing <Dictionary<string, Dictionary<string, string>>> but in this case my data is of object type, not a Dictionary. Can I somehow save type information an use pipelining as well?

SOLUTION

Thanks to @Patryk Ćwiek solution is as follows:

let d<'a>(s:string) = JsonConvert.DeserializeObject<'a>(s)
let data = 
    Path.Combine(myPath, "ejv.json") 
    |> File.ReadAllText 
    |> d<Dictionary<string, Dictionary<string, string>>> with

I don't know why, but without that alias d it doesn't work.

Patryk Ćwiek · Accepted Answer · 2013-12-25T11:32:43.983

7

As far as I know, the evaluation goes from left to right, so your second expression is an equivalent of:

let data = 
    (JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, string>>> <| File.ReadAllText)
    <| Path.Combine(myPath, "ejv.json")

Notice how the operations flow. That means that you're passing a function to DeserializeObject first, probably not what you meant to do.

When you do this:

let data = 
    JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, string>>> 
    <| (File.ReadAllText <| Path.Combine(myPath, "ejv.json"))

it will work. It's an equivalent of your first option.

Other solution is to invert piping to make the data flow more naturally:

let data = Path.Combine(myPath, "ejv.json") 
           |> File.ReadAllText 
           |> JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, string>>>

Edit

I've overlooked one option, that's not-so-commonly used. You can use function composition operator << to make it work, too:

let data = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, string>>> 
           << File.ReadAllText 
           <| Path.Combine(myPath, "ejv.json")

It essentially combines DeserializeObject : string -> 'a and ReadAllText : string -> string into (unnamed in the example above) function f : string -> 'a, where f(s) = DeserializeObject(ReadAllText(s)). Then it feeds the result of Path.Combine via pipe into f.

edited Dec 25 '13 at 11:32

answered Dec 25 '13 at 11:12

Patryk Ćwiek

14,078
3
55
76

Thank you for your help! Unforunately both ways you suggest lead to a same stange error: Unexpected type arguments. I attach screenshot in the update – Rustam Dec 25 '13 at 14:59
@Rustam What is the full signature of `DeserializeObject`? Quite possibly, if there are multiple overloads, F# may have problems picking the right one. To 'test' piping and composition, I actually used a stub method `let deserialize<'a>(s : string) = Unchecked.defaultof<'a>`, which is a `string -> 'a` function. – Patryk Ćwiek Dec 25 '13 at 15:38
All methods are listed here: http://james.newtonking.com/json/help/index.html?topic=html/T_Newtonsoft_Json_JsonConvert.htm – Rustam Dec 25 '13 at 15:42
There are both generic and simple methods there, with several overloads – Rustam Dec 25 '13 at 15:43
@Rustam I *think* it's the overload resolution issue, because both methods take `String`, but one is not generic and returns `Object`, and second one is generic in `T`. 'Aliasing' the method by `let deserialize<'a>(s : string) = JsonConvert.DeserializeObject<'a>(s)` and using the function later on should work... – Patryk Ćwiek Dec 25 '13 at 15:44
Yes! Aliasing helped! Now it is like that: `let data = Path.Combine(myPath, "ejv.json") |> File.ReadAllText |> d>>` with `let d<'a>(s:string) = JsonConvert.DeserializeObject<'a>(s)` – Rustam Dec 25 '13 at 15:49
1

@Rustam Glad it worked. :) I'm not quite sure what overload resolution rules are in F#, but as someone [smarter than me once said - admittedly, in different context - *overloading is typically the bugaboo of type-inferenced languages*](http://stackoverflow.com/a/501356/1180426) – Patryk Ćwiek Dec 25 '13 at 15:51

Pipeline operator refuses to work

1 Answers1

Edit