I haven't tried swift, and it's not obvious to me from the swift documentation if their options support arbitrary transformations, or just method chaining. In ruby (with ActiveSupport) this is the difference between:
might_be_nil.try(:method)
might_be_nil.try { |value| my_function(value) }
def try(*a, &b)
if a.empty? && block_given?
yield self
else
public_send(*a, &b) if respond_to?(a.first)
end
end
Should be easy to do the same in swift. Let me take a stab at it.
extension Optional {
func try<U>(f: (T) -> U) -> Optional<U> {
if let unwrapped = self {
return f(unwrapped)
} else {
return nil
}
}
}
def print_favorite_dinosaur(user: nil) def print_favorite_dinosaur(user = nil)
In either language, you still signal that the argument could be nil, and you still have to guard against it. Or so I think
In ruby, you choose whether to signal and you choose whether to guard. Here are some ruby examples that may be more clear:
Does not signal
user = User.find_by_favorite_dinosaur("Dromiceiomimus")
def print_favorite_dinosaur(user)
p "User's favorite dinosaur is #{user.dino})"
end
def print_favorite_dinosaur(user)
if user
p "User's favorite dinosaur is #{user.dino})"
else
p "No user. (Let's assume she likes T-rexs)"
end
end
possible_user = User.find_by_favorite_dinosaur("Dromiceiomimus")
print_favorite_dinosaur(possible_user)