Okay, but how we think of the world is a pretty poor way to program computers. If you write objects to act how we think of the world, then you mutate state within your objects, and when you add threading it becomes a mess. You can avoid this with immutability, but then you start doing stuff like replacing one Person with another with one property changed, and you're no longer treating Objects like they are in the real world.
A lot of good OOP practices like this are built in and somewhat enforced in FP. For example, the single responsibility principle: which psuedocode implements single responsibility better?
immutable class Schema:
Schema(self, ...):
...
bool check_document(self, Document document):
...
Schema with_constraint(self, Constraint new_constraint):
...
Schema without_constraint(self, Constraint old_constraint):
...
...or...
... -> Schema
make_schema(...) ...
Schema -> Document -> bool
make_schema_checker(schema) ...
(Schema, Constraint) -> Schema
add_constraint(schema, constraint) ...
(Schema, Constraint) -> Schema
remove_constraint(schema, constraint) ...
Sure, you
could separate out `class ConstraintChecker` and `class SchemaBuilder`, but you might not think to do that at the time, it costs an extra file, what's the harm, right? And I really doubt many OO programmers would go to the lengths of separating `class SchemaBuilder` into `class ConstraintAdder` and `class ConstraintRemover`. In fact, that would be so verbose that I'd probably argue that it's not good code. Meanwhile, the same functions in a functional style are each already separated because that's the only option for to do it, and it doesn't come with the verbosity cost. Closures are inherently single-responsibility objects, so much so that you don't even need to specify which method on them you're calling, you just call the object itself and it does the only thing it could possibly do!
I suppose it might be more intuitive to do this:
(Schema, Document) -> true
check_document_against_schema(schema, document)
Which would force you to leak the concept of the Schema to places that don't need to touch it, but at least check_document_against_schema still has a single responsibility.