Question: One of the things I like most about Cocoa is the readability factor.

One of the things that annoys me the most is the convention of convenience constructors to force repetition.

Here's an example: 

```
[NSString stringWithString:s]

[NSNumber numberWithDouble:d]

[NSValue valueWithInt:i]

[NSDictionary dictionaryWithObjectsAndKeys:<blah>]

```

etc.

Why doesn't the convention simply start convenience constructors with the word "with"? so then we would have:

```
[NSString withString:s]

[NSNumber withDouble:d]

[NSValue withInt:i]

[NSDictionary withObjectsAndKeys:<blah>]

```

etc.

It's a minor discussion point, but one I thought I would just throw out there and see if anyone with more clout than me can explain all the echos in my head.

Obviously, I'm not going to petition AAPL to re-write the appKit in favour of my suggestion, but are there any arguments against naming my own convenience constructors as such? 

Of course I can use whatever conventions I want in my own code but I hate to swim upstream blindly.

Answer: 
Because it's consistent.

There are methods like:

```
[NSDictionary dictionary]
[NSArray array]

```

Getting rid of everything up to `with` is obviously not an option here. Keeping these, but shortening others would introduce inconsistency in naming of convenience methods.

And convenience methods are consistent with `init` and `initWith…` methods.
I think it's just part of the general "say exactly what you mean" wordiness philosophy of the cocoa framework. A few choice selections:

```
[UIView setAnimationBeginsFromCurrentState]
[UITableView scrollToNearestSelectedRowAtScrollPosition]
[UIApplication didRegisterForRemoteNotificationsWithDeviceToken]

```

etc.

ETA:

To answer the questions specifically about constructors, one thing I like about the way they are done is that it's easy within x-code to identify which methods are constructor type methods. For example, you start typing:

```
[NSString string

```

And the "intellisense" whittles down the list of methods to those that start with "string" which of course are all the constructor methods (and all conveniently grouped together as well). Same thing applies for the "init" convention.