5 ms·
In C#, there's expression trees which handle things like this and it's how Entity Framework is able to convert the lambdas it's given into SQL. This means that
by mdasen 1y ago
In C#, there's expression trees which handle things like this and it's how Entity Framework is able to convert the lambdas it's given into SQL. This means that you can pass around code that can be inspected or transformed instead of being executed. Take this EntityFramework snippet:
db.People.Where(p => p.Name == "Joe")
`Where` takes an `Expression<Func<T, bool>> predicate`. It isn't taking the `Func` itself, but an `Expression` of it so that it can look at the code rather than execute it. It can see that it's trying to match the `Name` field to the value "Joe" and translate that into a SQL WHERE clause.
Since JS doesn't have this, they have to pass in a special placeholder value and try to record what the code is doing to that value.
- drysart 1y agoThere are inherent limitations with the "execute it once and see what happens" approach; namely that any conditional logic that might be in the mapping function is going to silently get ignored. For example, `db.people.map(p => p.IsPerson ? (p.FirstName + ' ' + p.LastName) : p.EntityName)` would either be seen as reading `(IsPerson, FirstName, LastName)` or `(p.IsPerson, p.EntityName)` depending on the specific behavior of the placeholder value ... and neither of those sets is fully correct. I wonder why they don't just do `.toString()` on the mapping function and then parse the resulting Javascript into an AST and figure out property accesses from that. At the very least, that'd allow the code to properly throw an error in the event the callback contains any forbidden or unsupported constructs.
- kentonv 1y agoThe placeholder value is an RpcPromise. Which means that all its properties are also RpcPromises. So `p.IsPerson` is an RpcPromise. I guess that's truthy, so the expression will always evaluate to `(p.FirstName + ' ' + p.LastName)`. But that's going to evaluate to '[object Object] [object Object]'. So your mapper function will end up not doing anything with the input at all, and you'll get back an array full of '[object Object] [object Object]'. Unfortunately, "every object is truthy" and "every object can be coerced to a string even if it doesn't have a meaningful stringifier" are just how JavaScript works and there's not much we can do about it. If not for these deficiencies in JS itself, then your code would be flagged by the TypeScript compiler as having multiple type errors.
- skybrian 1y agoAnother way to screw this up would be to have an index counter and do something different based on the index. I think the answer is "don't do that."
- kentonv 1y agoHmm, but I should make it so the map callback can take the index as the second parameter probably. Of course, it would actually be a promise for the index, so you couldn't compute on it, but there might be other uses...
- drysart 1y agoYeah I'll definitely chalk this up to my not having more than a very very passing idea of the API surface of your library based on a quick read over just the blog post. On a little less trivial skim over it looks like the intention here isn't to map property-level subsets returned data (e.g., only getting the `FirstName` and `LastName` properties of a larger object); as much as it is to do joins and it's not data entities being provided to the mapping function but RpcPromises so individual property values aren't even available anyway. So I guess I might argue that map() isn't a good name for the function because it immediately made me think it's for doing a mapping transformation and not for basically just specifying a join (since you can't really transform the data) since that's what map() can do everywhere else in Javascript. But for all I know that's more clear when you're actually using the library, so take what I think with a heaping grain of salt. ;)
- Aeolun 1y agoCouldn’t you make this safer by passing the map something that’s not a plain JS function? I confess to that being the only thing that had me questioning the logic. If I can express everything, then everything should work. If it’s not going to work, I don’t want to be able to express it.
- kentonv 1y agoI think any other syntax would likely be cumbersome. What we actually want to express here is function-shaped: you have a parameter, and then you want to substitute it into one or more RPC calls, and then compute a result. If you're going to represent that with a bunch of data structures, you end up with a DSL-in-JSON type of thing and it's going to be unwieldy.
- kentonv 1y ago> I wonder why they don't just do `.toString()` on the mapping function and then parse the resulting Javascript into an AST and figure out property accesses from that. That sounds incredibly complicated, and not something we could do in a <10kB library!
- actionfromafar 1y agoMaybe Fabrice Bellard could spare an afternoon.
- sonthonax 1y agoTo the contrary, a simple expression language is one of those things that can easily be done in that size.
- kentonv 1y agoBut the suggestion wasn't to design a simple expression language. The suggestion was to parse _JavaScript_. (That's what `.toString()` on a function does... gives you back the JavaScript.)
- javier2 1y agoIt dont think C# looks at the code? I suspect it can track that you called p.Name, then generate sql with this information?
- adzm 1y agoThe lambda is converted into an Expression, basically a syntax tree, which is then analyzed to see what is accessed.
- javier2 1y agoOk, so its a step in the compile that rewrites and analyzes it?
- adzm 1y agoIt's actually really neat. Normally a lambda would just be a function but if it gets cast to an Expression then you get the AST at runtime. Entity Framework analyzes these at runtime to generate the SQL and logic/mapping etc. You can get the AST at compile time in some situations with a Roslyn plug-in or etc I believe as well.
- ziml77 1y agoThe C# compiler is looking at that code. It sees that the lambda is being passed into a function which accepts an Expression as a parameter, so it compiles the lambda as an expression tree rather than behaving like it's a normal delegate.
- squirrellous 1y agoIs there anything C# _doesn’t_ have? :-) It feels like C# has an answer to every problem I’ve ever had with other languages - dynamic loading, ADTs with pattern matching, functional programming, whatever this expression tree is, reflection, etc etc. Yet somehow it’s still a niche language that isn't widely used (outside of particular ecosystems).
- rjbwork 1y agoIt's one of the most widely used languages out there actually. But it's primarily used at buttoned up and boring SMB's/enterprise backoffices. We're not out here touting our new framework of the month to kafloogle the whatzit. We're just building systems with a good language and ecosystem that's getting better every year. I've worked only at startups/small businesses since I graduated university and it's all been in C#.
- brainzap 1y agogetting better? many packages we been using did a license swap on us xD fucking nice ecosystem
- rjbwork 1y agoFork it. End of the day some guys decided they wanted to make money and the corporations profiting off their labor weren't paying up. These things don't happen in a vacuum. Does your company have a multi-thousand dollar a year budget to make sure your dependencies are sustainable?
- deleted 1y ago[deleted]
- uzerfcwn 1y ago> Is there anything C# _doesn’t_ have? Pi types, existential types and built-in macros to name a few.
- 1y ago
- notpushkin 1y agoPonyORM does something similar in Python: select(c for c in Customer if sum(c.orders.total_price) > 1000) I love the hackiness of it.
- porridgeraisin 1y agoPonyORM is my favourite python ORM. Along with https://pypi.org/project/pony-stubs/ https://pypi.org/project/pony-stubs/, you get decent static typing as well. It's really quite something.
- rafaelgoncalves 1y agowhoa, didn't know PonyORM, looks really neat! thanks for showing
- keyle 1y agoC#, Swift, Dart, Rust... Python. Many languages take lambda/predicate/closure as filter/where. It generally unrolls as a `for loop` underneath, or in this case LINQ/SQL. C# was innovative for doing it first in the scope of SQL. I remember the arrival of LINQ... Good times.
- deleted 1y ago[deleted]
- sobani 1y agoHow many of those languages can take an expression instead of a lambda? Func<..> is lambda that can only be invoked. Expression<Func..>> is an AST of a lambda that can be transformed by your code/library.
- Tyr42 1y agoR let's you do that, and it gets used by the tidy verse libraries to do things like change the scope variables in the functions are looked up in.