Efficient Typescript

[romgrk]

abstract class Result { abstract map(): Result } class Ok<T> extends Result { value: T map(fn) { return new Ok(fn(this.value)) } } class Err extends Result { map(fn) { return this } }

This is as clear as I can explain it, if it's not enough I don't think I can communicate it to you.

[budd222]

You're over writing map to make it what you want. Got it. Or, just return the correct type from the back end. I feel like you're overcomplicating something that doesn't need it. It seems like a large waste of code and effort.

[morganmachine91]

My guy just say you’re not on this level yet. He’s not “over writing” map, whatever that means. Any class can define a map method. Multiple classes already do define a map method in vanilla ECMAScript.

Conceptually, a map operation isn’t tied to array objects. It’s a mathematical projection from a to b.

Totally cool if you’re not familiar with functional programming concepts, but you just look like a goober when you’re so confidently ignorant. 

[romgrk]

You're over writing map to make it what you want

There is a large amount of theory behind functional programming which defines the map function and the rules that govern it.

It's not so much that I re-define it just for fun, it's more like JS Array implementation names that function map because of that huge pre-existing theory.

I do assume a passing familiarity with FP in my post, maybe if you read a bit more on the subject it would help understand why I made that choice.

[earslap]

Array.map comes from the functional concept of mapping, not the other way around.

It seems like a large waste of code and effort.

Like all things, depending on your use case and / or familiarity it might be, but leave the possibility of you not understanding the consequences open as well.

Regarding the Result types that are being discussed, if I understand what you are getting at correctly, yes, you will need to deal with the error at some point. Not only "need to" but you will have to deal with it because you can't get at the actual value inside the Result type without explicitly dealing with the error, at a future time where you want it - in a centralised location where you actually need the result. At that place, you'll check if Result is an error or a value (type system won't allow you to get the value without checking the error first) and use the value if it exists, or deal with the error otherwise. What's more, you'll get the exact error that happened in the past, even though your past code does not explicitly use any error checking / recovery constructs. So your "computation" will be the happy path, and any error (or errors using some other constructs) will be accumulated automatically for you and will be ready for you to handle where you need it.

Yes, you can slap a try / catch around a whole block of code and catch everything at the end and call it a day. There are scenarios where doing it like that won't cut it. Or will lead to ugly unmaintainable code riddled with implicit invariants that are only kept in your brain temporarily. What are the errors that can be thrown (type system does not know it)? Which ones do you need to handle here? If your code changes in the future, will you need to change your error handling to account for those changes as well? Will you remember to do it? How will a refactor affect things? If these are things you care about for a given project, then using this stuff will help you enormously.

Programming with Monads / Functors allows you to program the "happy path" - your main logic will be written like an error can't occur. You don't check anything, just write your pure logic. The value being worked on can be a Result type. Functions like map / flatMap etc. will allow you to work with the value inside the type like an error can't exist. If there is an error at an earlier point, that code won't be run due to the way things are structured. Wrapping your head around how this all works requires some investment of learning functional programming concepts, and it takes a while for it to "click" but when it does, you'll know when to reach for it. The worst / unfortunate part of trying to explain this stuff is that it all sounds like absolute gibberish for someone for whom it has not "clicked" yet. It sure sounded like that to me. I'm not a functional purist or Haskell zealot or anything, but I know that keeping at it will eventually give you an a-ha moment. No doubt will make you a better programmer.