First of, I think your code is working and not inelegant. There's no immediate reason not to use the code you presented.

There are a few things that could be better though:

<h3>Comparing the type</h3>

Your <a href="/javascript-c-code-contains-n-store-into-javacript-varible-code-example" rel="dofollow">code contains</a> the line:

<pre><code>if type(dict_foo[field]) == dict:
</code></pre>

That can be definitely improved. Generally (see also PEP8) you should use <code>isinstance</code> instead of comparing types:

<pre><code>if isinstance(dict_foo[field], dict)
</code></pre>

However that will also return <code>True</code> if <code>dict_foo[field]</code> is a subclass of <code>dict</code>. If you don't want that, you could also use <code>is</code> instead of <code>==</code>. That will be marginally (and probably unnoticeable) faster.

If you also want to allow arbitary dict-like objects you could go a step further and test if it's a <code>collections.abc.MutableMapping</code>. That will be <code>True</code> for <code>dict</code> and <code>dict</code> subclasses and for all mutable mappings that explicitly implement that interface without subclassing <code>dict</code>, for example <code>UserDict</code>:

<pre><code>&gt;&gt;&gt; from collections import MutableMapping
&gt;&gt;&gt; # from UserDict import UserDict # Python 2.x
&gt;&gt;&gt; from collections import UserDict # Python 3.x - 3.6
&gt;&gt;&gt; # from collections.abc import MutableMapping # Python 3.7+
&gt;&gt;&gt; isinstance(UserDict(), MutableMapping)
True
&gt;&gt;&gt; isinstance(UserDict(), dict)
False
</code></pre>

<h3>Inplace modification and return value</h3>

Typically functions either modify a data structure inplace or return a new (modified) data structure. Just to mention a few examples: <code>list.append</code>, <code>dict.clear</code>, <code>dict.update</code> all modify the data structure inplace and <code>return None</code>. That makes it easier to keep track what a function does. However that's not a hard rule and there are always valid exceptions from this rule. However personally I think a function like this doesn't need to be an exception and I would simply remove the <code>return dict_del</code> line and let it implicitly return <code>None</code>, but YMMV.

<h3>Removing the keys from the dictionary</h3>

You copied the dictionary to <a href="/javascript-how-to-avoid-problems-with-parseint-and-scientifics-numbers-code-example" rel="dofollow">avoid problems</a> when you remove key-value pairs during the iteration. However, as already mentioned by another answer you could just iterate over the keys that should be removed and try to delete them:

<pre><code>for key in keys_to_remove:
 try:
 del dict[key]
 except KeyError:
 pass
</code></pre>

That has the additional advantage that you don't need to nest two loops (which could be slower, especially if the number of keys that need to be removed is very long).

If you don't like empty <code>except</code> clauses you can also use: <code>contextlib.suppress</code> (requires Python 3.4+):

<pre><code>from contextlib import suppress

for key in keys_to_remove:
 with suppress(KeyError):
 del dict[key] 
</code></pre>

<h3>Variable names</h3>

There are a few variables I would rename because they are just not descriptive or even misleading:

<ul>
<li><code>delete_keys_from_dict</code> should probably mention the subdict-handling, maybe <code>delete_keys_from_dict_recursive</code>.</li>
<li><code>dict_del</code> sounds like a deleted dict. I tend to prefer names like <code>dictionary</code> or <code>dct</code> because the function name already describes what is done to the dictionary.</li>
<li><code>lst_keys</code>, same there. I'd probably use just <code>keys</code> there. If you want to be more specific something like <code>keys_sequence</code> would make more sense because it accepts any <code>sequence</code> (you just have to be able to iterate over it multiple times), not just lists.</li>
<li><code>dict_foo</code>, just no... </li>
<li><code>field</code> isn't really appropriate either, it's a key.</li>
</ul>

<h3>Putting it all together:</h3>

As I said before I personally would modify the dictionary in-place and not return the dictionary again. Because of that I present two solutions, one that modifies it in-place but doesn't return anything and one that creates a new dictionary with the keys removed.

The version that modifies in-place (very much like Ned Batchelders solution):

<pre><code>from collections import MutableMapping
from contextlib import suppress

def delete_keys_from_dict(dictionary, keys):
 for key in keys:
 with suppress(KeyError):
 del dictionary[key]
 for value in dictionary.values():
 if isinstance(value, MutableMapping):
 delete_keys_from_dict(value, keys)
</code></pre>

And the solution that returns a new object:

<pre><code>from collections import MutableMapping

def delete_keys_from_dict(dictionary, keys):
 keys_set = set(keys) # Just an optimization for the "if key in keys" lookup.

 modified_dict = {}
 for key, value in dictionary.items():
 if key not in keys_set:
 if isinstance(value, MutableMapping):
 modified_dict[key] = delete_keys_from_dict(value, keys_set)
 else:
 modified_dict[key] = value # or copy.deepcopy(value) if a copy is desired for non-dicts.
 return modified_dict
</code></pre>

However it only makes copies of the dictionaries, the other values are not returned as copy, you could easily wrap these in <code>copy.deepcopy</code> (I put a comment in the appropriate place of the code) if you want that.
 <pre><code>def delete_keys_from_dict(dict_del, lst_keys):
 for k in lst_keys:
 try:
 del dict_del[k]
 except KeyError:
 pass
 for v in dict_del.values():
 if isinstance(v, dict):
 delete_keys_from_dict(v, lst_keys)

 return dict_del
</code></pre>
 Since the question requested an elegant way, I'll submit my general-purpose solution to wrangling nested structures. First, install the boltons utility package with <code>pip install boltons</code>, then:



<pre><code>from boltons.iterutils import remap

data = {'one': 'remains', 'this': 'goes', 'of': 'course'}
bad_keys = set(['this', 'is', 'a', 'list', 'of', 'keys'])

drop_keys = lambda path, key, value: key not in bad_keys
clean = remap(data, visit=drop_keys)
print(clean)

# Output:
{'one': 'remains'}
</code></pre>

In short, the remap utility is a full-featured, yet succinct approach to handling real-world data structures which are often nested, and can even contain cycles and special containers.

This page has many more examples, including ones working with much larger objects from Github's API.

It's pure-Python, so it works everywhere, and is fully tested in Python 2.7 and 3.3+. Best of all, I wrote it for exactly cases like this, so if you find a case it doesn't handle, you can bug me to fix it right here.

Elegant way to remove fields from nested dictionaries

Have a look at the SandboxPostCopy Interface. It should be possible to have Apex run after the Sandbox is created and then modify the specific User records email address fields.
 Instead of relying on the email address (which is "munged" during the sandbox copy), you can use your mobile number and self-verify in the sandbox with a text message. To do so, edit your User record in your production org, and put your <a href="/i-gave-my-cell-number-to-a-stranger-on-the-internet-have-i-fallen-victim-to-a-scam" rel="dofollow">cell number</a> in the "mobile" field.

Sandboxes created after that point will properly copy your mobile number. When you log into sandboxes for the first time, you will be given the option to self-verify by receiving a text message to your phone number.

Sandbox verification emails

It obviously depends on the machine you're on but very generally speaking:

<ol>
<li>Your computer stores parts of your program's memory in a cache that has a much smaller latency than main memory (even when compensating for cache hit time).</li>
<li>C arrays are stored in a contiguous by row major order. This means if you ask for element <code>x</code>, then element <code>x+1</code> is stored in main memory at a location directly following where <code>x</code> is stored.</li>
<li>It's typical for your computer cache to "pre-emptively" fill cache with <a href="/why-do-two-references-to-the-same-vector-return-different-memory-addresses-for-each-element-of-the-vector" rel="dofollow">memory addresses</a> that haven't been used yet, but that are locally close to memory that your program has used already. Think of your computer as saying: "well, you wanted memory at address X so I am going to assume that you will shortly want memory at X+1, therefore I will pre-emptively grab that for you and place it in your cache".</li>
</ol>

When you enumerate your array via row major order, you're enumerating it in such a way where it's stored in a contiguous manner in memory, and your machine has already taken the liberty of pre-loading those addresses into cache for you because it guessed that you wanted it. Therefore you achieve a higher rate of cache hits. When you're enumerating an array in another non-contiguous manner then your machine likely won't predict the memory access pattern you're applying, so it wont be able to pre-emptively pull memory addresses into cache for you, and you won't incur as many cache hits, so main memory will have to be accessed more frequently which is slower than your cache.

Also, this might be better suited for https://cs.stackexchange.com/ because the way your system cache behaves is implemented in hardware, and spatial locality questions seem better suited there.
 Your array is actually a ragged array, so row major isn't entirely a factor.

You're seeing better performance iterating over columns then rows because the row memory is laid out linearly, which reading sequentially is easy for the cache predictor to predict, and you amortize the pointer dereference to the second dimension since it only needs to be done once per row.

When you iterate over the rows then columns, you incur a pointer dereference to the second dimension per iteration. So by iterating over rows, you're adding a pointer dereference. Aside from the intrinsic cost, it's bad for cache prediction.

If you want a true two-dimensional array, laid out in memory using row-major ordering, you would want...

<pre><code>int A[1000][1000];
</code></pre>

This lays out the memory contiguously in row-major order, instead of one array of pointers to arrays (which are not laid out contiguously). Iterating over this array using row-major would still perform faster than iterating column-major because of spatial locality and cache prediction.
 The short answer is <a href="/in-vmware-esxi-5-x-does-it-make-a-difference-if-i-select-2-cpu-cores-vs-2-cpu-sockets" rel="dofollow">CPU</a> caches.
Scott Mayers explains it very clearly here

Why is iterating 2D array row major faster than column major?

First let us clear up some definitions of the terms "reaction force", "normal force", and "frictional force".

Whenever there is a contact between two bodies, there is a reaction force on each body at every point of contact. A reaction force can be split into a normal component (sometimes called the "normal contact force"), and a tangential component (sometimes called the "force due to friction"). The direction of the force due to friction⁠ - the tangential component⁠ - is such that it opposes relative motion due to sliding / slipping.

This means that a perfectly rigid cylinder can roll on a perfectly rigid and rough surface forever since there is no sliding so no friction to provide a torque.

So why do balls we observe normally slow down?

The answer lies in something called "rolling resistance" (sometimes confusingly referred to as "rolling friction", or just "friction"), and entirely explains why a football comes to a stop after rolling it along the ground.

The key is that footballs and dirt are both compressible - they are not rigid bodies. On contact, the weight of the ball deforms both it and the dirt. This means that there are many points of contact between the ball and the dirt. Due to our definition, there are now many normal forces - to be precise, one per point of contact. We will ignore the tangential frictional components for now.

The deformation of the ball and the surface means that the line of action of these normal components is not through the center of the ball (see diagram).

<img src="https://i.stack.imgur.com/nndHY.gif" alt="normal forces after ">

As a result, the ball experiences two torques: a counter-clockwise one from the normal components to the right of the centerline, and a clockwise torque from the normal components to the left.

Since the normal forces are larger on the right side, the counter-clockwise torques are greater, and thus there is a net counter-clockwise torque and the ball slows to a stop.

Notice how we did not even consider any tangential frictional components at all. Just due to the normal components the ball is slowed.

There are a couple of points I have not covered, such as what role the frictional components do actually play and what happens in different types of deformations (e.g. the surface doesn't deform). Also you may be wondering why the normal forces on the right are greater. The answer to all these can be found at: https://lockhaven.edu/~dsimanek/scenario/rolling.htm . This is also where my diagram came from and I credit for these explanations. The exact diagram from your question is also used here and cited as a "naive pictures of friction and a rolling cylinder."
 Rolling resistance, a.k.a., rolling friction, is basically the result of inelastic compression and decompression of the materials at the contacting surfaces (wheel and/or surface upon which it rolls). The inelastic behavior results in friction internal to the materials and a loss of energy dissipated as heat, known as hysteresis. 

See the picture of a tire below.

The leading edge of the contact surface materials between the <a href="/circle-inscribed-between-quarter-circles-proving-its-center-point" rel="dofollow">center point</a> of contact and the starting point of contact compress. The resultant reaction force acts backwards on the wheel as shown.

When the materials separate at the rear side they decompress. The reaction force acts forward on the wheel as shown.

The squeezing and un-squeezing of the materials is not purely elastic and therefore internal friction dissipates energy in the form of heat. This loss of available energy for rolling due to heating is called hysteresis. As a result the reaction force acting forwards during un-squeezing is less than the reaction force acting backwards during squeezing eventually bringing the wheel to a stop. 

Hope this helps.
<img src="https://i.stack.imgur.com/3HZx2.jpg" alt="enter image description here">
 Suppose nothing slows the sphere. It rolls forever. In that case, it would roll the same on ice. The friction in your diagram would be $0$. 

Suppose it rolls on a rough surface and something (wind resistance? ) slows it. That is, a force on the center of mass acts in the backward direction. Friction of the surface would keep the sphere from slipping. That is, friction would act in the forward direction. Those two forces form the torque that slows the rotation.

Why doesn't friction accelerate a ball undergoing rolling?

You can find a non-trivial interpolation for the fractional iteration-height when you write down the consecutive iterates in log-polar-form (with center at the fixpoint). The nearer you come to the final fixpoint the log of the distance as well as the angle come nearer and nearer to a linear relation with the index and this suggests an obvious method of interpolation for fractional iteration-heights. 

I found it interesting that that type of interpolation agrees well with the solution, which you would find via the method invented by E. Schröder in the late 19 century. Although this log-polar/Schröder-interpolation gives a straightforward solution, there seems to be a better one (better in what sense? - too difficult to discuss it here) in the spirit of Kneser's analytic solution for the fractional interpolation of the $\exp()$-function (implementations available by tetrationforum). The latter can seemingly be approximated by a simple (but computationally much involved) procedure involving matrix-diagonalization and computing fractional powers of that matrix. 

You can find an introductory comparision of that mentioned methods (however for a different base for the exponentiation) in this small essay of mine

<hr> 

Here is an image for an interpolation to fractional heights starting at $z_0=1$ going to $z_1=î,z_2 \approx 0.2078,...,z_\infty \approx 0.438+0.361 î$ using the Schröder-mechanism. For instance for the half-iterate we find by this method $z_{0.5} \approx 1.1667+0.734 î$. The grey dotted line indicates the integer-iterates (should be the same as that of @GEdgar) 

<img src="https://i.stack.imgur.com/KRHdP.png" alt="image"> 

<hr> 
I got Sh. Levenstein's Pari/GP-program "fatou.gp" (from the tetrationforum) for the (extended) Kneser-method working. Here is a comparision of the orbits produced by the two methods. For instance, the half-iterates differ even visually: 

<img src="https://i.stack.imgur.com/lIn19.png" alt="image2">
 As Gottfried hints, there is yet another solution to $^{0.5}i \approx 1.07571355731 + 0.873217399108i$

I will use this question to describe a unique Abel function for $f(z)=i^z$. I wrote a pari-gp complex base tetration program available for download at math.eretrandre.org. The results posted here were generated with that program. I will use this question about base(i) to show that if there is a solution of this type, than it has to be unique. This tetration can be regarded as an extension of Kneser's solution for real bases&gt;$\exp(\frac{1}{e})$, to tetration for complex bases. So what is "this type" of complex base slog/abel function solution?

The answer is this Abel function involves both primary fixed points. The op points out the attracting fixed point, $l_1 \approx 0.438282936727 + 0.360592471871i\;$. There is also a repelling fixed point $l_2 \approx -1.86174307501 - 0.410799968836i\;$. Henryk Trapmann's uniqueness criteria 
says if you can make a sickle between the two fixed points, bounded on one side by a defined curve f(z), and bounded on the other side by $i^{f(z)}$. For sexp base(i), we can choose f(z) as a straight line between the primary fixed points. Henryk's proof says if there is a one to one analytic mapping between the sickle, and the Abel function, excluding the two fixed points, and if the derivative of the Abel function is never zero, than it is unique to an additive constant. The additive constant is uniquely determined by the requirement that Tetration have the slog(1)=abel(1)=0.

Here is a picture of the sickle, and $\alpha(z)$ or the abel/slog on the sickel. You can see the one-to-one mapping between the two fixed points, extending between $-\Im \infty$ and $+\Im \infty$. The mapping between the straight line, and f(z) are always be definition exactly one cycle apart, since $\alpha(f(z))=\alpha(z)+1$. I also filled in vertical <a href="/python-add-more-grid-lines-matplotlib-code-example" rel="dofollow">grid lines</a> for sexp(z+0.25), sexp(z+0.5) and sexp(z+0.75). The two graphs are colored identical to allow visual verification of the one to one mapping. Because $\exp_i(z)$ is well defined, the sexp(z) function can be extended to the right over the entire complex plane, and extended to the left except for logarithmic branch singularities. So this slog on a sickle defines sexp(z) base(i) for the entire complex plane! Henryk Trapmann's uniqueness proof generates a mapping function between this solution and the other purported solution. Since both functions are analytic on the strip, it turns out both the mapping function and its inverse have to be entire, which can only be the case if the two slogs are the same except for an additive constant.

Near the attracting fixed point, the function approaches arbitrarily closely to the attracting fixed point Abel/Schroeder function, and near the repelling fixed point, the function approaches the repelling fixed point Abel/Schroeder function. 

<img src="https://i.stack.imgur.com/dnZNd.png" alt="slog and abel function baes(i) on a sickel">

sexp base i in the complex plane, grids are 1 unit apart. You can see the logarithmic singularity at z=-2. 

<img src="https://i.stack.imgur.com/MKozX.png" alt="sexp base i on the complex plane">

The Abel function Taylor series was computed using the following form:
$$\alpha(z)=\frac{\ln(z-l_1)}{\ln(\lambda_1)} + \frac{\ln(z-l_2)}{\ln(\lambda_2)} + p(z)$$ 

$\lambda_1$ and $\lambda_2$ are the multipliers at the two fixed points, $l_1$ and $l_2$, 
$$i^{l_1+z} = l_1 + \lambda_1 \cdot z + a_2 \cdot z^2 + a_3 \cdot z^3...$$

It turns out $p(z)$ has a relatively mild singularity at each of the two fixed points when this form is used for the Abel/slog function. For example, $p(z)$ and its derivative are both continuous and differentiable at both of the two fixed points, although the 3rd and higher derivatives are not continuous, since the periodicity at the two fixed points is less than 3.

The pari-gp fatou.gp complex base sexp program would be used as follows:

<pre><code>\r fatou.gp
setmaxconvergence(); /* base i is poorly behaved */
sexpinit(i);
sexp(0.5)
1.07571355731392 + 0.873217399108003*I
</code></pre>

Here are numerical values for $l_1, l_2, r_1=\frac{1}{\ln(\lambda_1)}$, $r_2=\frac{1}{\ln(\lambda_1)}$, and p(z), and equation for the slogestimation. The radius of convergence for p(z) is $|\frac{l1-l2}{2}|$, centered between the fixed points.

<pre><code>l1 = 0.4382829367270321116269751636 + 0.3605924718713854859529405269*I;
l2 = -1.861743075013160391397055791 - 0.4107999688363923093542478071*I;
r1 = -0.02244005259030164710115539234 - 0.4414842544742195824980579384*I; 
r2 = 0.3613567874856575121871741974 + 0.4459440823588587557573111438*I;
slogest(z) = {
 z = r1*(log(I*(z-l1))-Pi*I/2) + r2*(log(-I*(z-l2))+Pi*I/2) + 
 subst(p,x,(z-0.5*(l1+l2)));
 return(z);
}
{p= -0.06582860911769610907611153624 - 0.6391834058813427803550150237*I
+x^ 1* ( 0.0004701290774740458290098771596 - 0.04537158729375693129580356342*I)
+x^ 2* (-0.003324372336079859782821095201 + 0.001495132937745569349230811243*I)
+x^ 3* ( 0.0007980787520098490845820065316 - 0.001533441799004958947560304185*I)
+x^ 4* (-0.001108786744422696031980666816 - 2.731877902187453470989686831 E-6*I)
+x^ 5* ( 0.0001798802115603965459766944797 + 0.0001776744851391085901363383617*I)
+x^ 6* (-0.0001598048157256642978352955851 - 3.381203527058705270044424867 E-5*I)
+x^ 7* ( 4.834500417029476499351747515 E-5 + 7.971199385246578717457250724 E-5*I)
+x^ 8* (-2.079867322054674351760533351 E-5 - 1.406842037326640069256998532 E-5*I)
+x^ 9* ( 1.690770367738385075341590185 E-5 + 2.135309134452918173269411762 E-5*I)
+x^10* (-3.353412252728033524441156034 E-6 - 5.845155821267264231283805042 E-6*I)
+x^11* ( 6.565965239846111713090140941 E-6 + 4.769875342842561685863158675 E-6*I)
+x^12* (-1.296330399893039321872277846 E-6 - 2.456868593278006094540299988 E-6*I)
+x^13* ( 2.533916981224509417637955994 E-6 + 7.218102304226136498196092124 E-7*I)
+x^14* (-8.409501999009543726430092781 E-7 - 9.279879295518162345796637972 E-7*I)
+x^15* ( 9.275250588492317644336514121 E-7 - 9.631817386499723279878826279 E-8*I)
+x^16* (-5.215083989292973029369039510 E-7 - 2.615530503953161606154084492 E-7*I)
+x^17* ( 3.116111111914753868488936298 E-7 - 1.665350480228628392912034933 E-7*I)
+x^18* (-2.781400382567721610094378621 E-7 - 1.112607415413251118507915520 E-8*I)
+x^19* ( 9.051635326999330520247332230 E-8 - 1.085008978701155103767460830 E-7*I)
+x^20* (-1.238964597578335282733301968 E-7 + 5.485260567253507938012071652 E-8*I)
+x^21* ( 1.846113879795222761048581419 E-8 - 5.632856406052825347059503708 E-8*I)
+x^22* (-4.197980145789475821721904427 E-8 + 5.240770851948157536559348001 E-8*I)
+x^23* (-1.428548543349343274791836858 E-9 - 2.602689861858463106421605234 E-8*I)
+x^24* (-6.065810598994532136326922961 E-9 + 3.328188440463381773510055778 E-8*I)
+x^25* (-4.925408783783587354755417128 E-9 - 1.098256950809547844459017995 E-8*I)
+x^26* ( 5.571041113925408468110396754 E-9 + 1.638316780708641282846896470 E-8*I)
+x^27* (-4.149193648847472629362625045 E-9 - 4.116268895249720851777701930 E-9*I)
+x^28* ( 6.721271351954440168744328856 E-9 + 5.947866395141685553477517779 E-9*I)
+x^29* (-2.739160795070694522203609350 E-9 - 1.172354292086004770247804721 E-9*I)
+x^30* ( 4.623071483414304725202549852 E-9 + 9.232228309095999063811309141 E-10*I)
+x^31* (-1.585766089923197553788716462 E-9 - 1.651307950491239271118345156 E-11*I)
+x^32* ( 2.363704675846105632188520360 E-9 - 8.296748095830550218237145087 E-10*I)
+x^33* (-8.032209583204614846555211647 E-10 + 3.448796470634182196661522301 E-10*I)
+x^34* ( 8.586697889632180390697042972 E-10 - 1.035571885972986467540525699 E-9*I)
+x^35* (-3.283321823970989260857161769 E-10 + 3.700931769620798039214959724 E-10*I)
+x^36* ( 1.060749698244576767546142485 E-10 - 7.216733126248904197113800569 E-10*I)
+x^37* (-7.435780239422554167112328213 E-11 + 2.755791031783421936772787526 E-10*I)
+x^38* (-1.572500505206983217824447542 E-10 - 3.667364964073739957874509082 E-10*I)
+x^39* ( 3.623731852785295824889239864 E-11 + 1.629657324418246834695914694 E-10*I)
+x^40* (-1.802976354364813915048318195 E-10 - 1.261880617212203404824890625 E-10*I) }
</code></pre>
 Consider the functions $$f_n(z) = \frac{\sin \pi z}{z - n}$$ for $n\in\Bbb Z$. Note that $f_n(k) = 0$ if $n \ne k$ and $f_n(n) = 1$.

Define $$f(z) := \sum_{n=-\infty}^{\infty} a_{|n|}f_n(z) = \sin \pi z \sum_{n=-\infty}^{\infty} \frac{a_{|n|}}{z - n} = \sin \pi z\left(\frac{a_0} z + 2z\sum_{n=1}^{\infty} \frac{a_n}{z^2 - n^2}\right)$$

(for the appropriate definition of the double-infinite sum). Since the $a_n$ converge, they are bounded, so the last sum converges for all non-integer $z$, with simple poles that the integers, which are cancelled out by the multiplication of $\sin \pi z$, leaving $f(n) = a_{|n|}$ for all $n \in \Bbb Z$.

You can define $a_z = f(z)$ for arbitrary $z$.

However, this is just one possible function. For any entire function $h$, the function $g(z) = f(z) + h(z)\sin \pi z$ also satisfies $g(n) = a_{|n|}$ for $n\in \Bbb Z$, but generally has different values from $f$ off of $\Bbb Z$.

There are other choices as well. Maybe you want to define $a_n$ for negatives by the inverse recursion formula $a_n = -\frac {2\log a_{n+1}}{\pi}$. A similar construction can be done, though one has to take more care to ensure convergence (the reason I went with an even function for $f$).

So without some extra criteria, there is not a well-defined answer. Your formula $f(z + 1) = i^{f(z)}$ may resolve the issue, but I haven't worked that out yet.

An obvious pattern to $i\uparrow\uparrow n$ that is eluding us all?

I'm surprised no one mentioned MetadataTypeAttribute. But yes, this works.

<pre><code>[MetadataType(typeof(ICustomerMetaData))]
public partial class Customer
{
}


public interface ICustomerMetaData
{
 // Apply RequiredAttribute
 [Required(ErrorMessage = "Title is required.")]
 string Title { get; }
}
</code></pre>

As for using an Interface directly (using <code>Customer: ICustomerMetaData</code>):

<blockquote>
 The product team does not want to implement this feature, for two main reasons:
 
 • Consistency with DataAnnotations.Validator
 
 • Consistency with validation behavior in ASP.Net MVC
 
 • Tricky scenario: a <a href="/csharp-c-if-class-implements-have-function-code-example" rel="dofollow">class implements</a> two interfaces that have the same property, but with conflicting attributes on them. Which attribute would take precedence?
</blockquote>

While MVC automatically registers the MetaData with the TypeDescriptor, you may have to manually add it yourself:

<pre><code> using System;
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.ComponentModel.DataAnnotations;

 public class Program
 {
 public static void Main()
 {
 var customer = new Customer();

 TypeDescriptor.AddProviderTransparent(
 new AssociatedMetadataTypeTypeDescriptionProvider(typeof(Customer), 
 typeof(ICustomerMetaData)), 
 typeof(Customer));

 var context = new ValidationContext(customer);
 var validationResults = new List&lt;ValidationResult&gt;();

 var isValid = Validator.TryValidateObject(
 customer, context, validationResults, true);
 Console.WriteLine($"is Valid = {isValid}");

 customer.Title = "I has Title";

 isValid = Validator.TryValidateObject(
 customer, context, validationResults, true);
 Console.WriteLine($"is Valid = {isValid}");


 Console.ReadKey();
 }

 [MetadataType(typeof(ICustomerMetaData))]
 public partial class Customer
 {
 public string Title { get; set; }
 }

 public interface ICustomerMetaData
 {
 // Apply RequiredAttribute
 [Required(ErrorMessage = "Title is required.")]
 string Title { get; }
 }
 }
</code></pre>

Output:

<blockquote>
 is Valid = False
 
 is Valid = True
</blockquote>
 If you use a base class instead of an interface, the attributes will work fine.

Is it possible to use DataAnnotations with Interfaces?

In Kotlin <code>val</code> declares final, read only, reference - and that is exactly what compiler error is telling you with

<blockquote>
 Val cannot be reassigned
</blockquote>

Once you assign value to <code>val</code>, it cannot be changed. If you want to be able to reassign it you have to declare it as <code>var</code>

In Kotlin method parameters are implicitly declared as final <code>val</code>, so you cannot reassign them just like you could in Java.

But the core error in your code is that you are trying to swap <a href="/how-to-enumerate-passed-method-parameters" rel="dofollow">method parameters</a>. Since method parameters are passed by value and not by reference what you want to achieve is impossible in Kotlin (just as well as it is impossible in Java). Even if you would reassign parameters inside method call original variables passed to the method would not change.
 There are two misunderstandings here:

First, in Kotlin all parameters are <code>final</code> and this cannot be changed. Just as in Java a <code>final</code> reference cannot be changed. So you get an error when trying to reassign a <code>final</code> or <code>val</code> reference. 

Second, since you have a copy of a reference to a String, your swap function would have no affect on the caller's original references. Your swap function wouldn't work in Java either. 

For example, calling your code does nothing:

<pre><code>val s1 = "howdy"
val s2 = "goodbye"
swap(s1,s2) // Java or Kotlin, doesn't matter
println(s1)
println(s2)

// output:
// howdy
// goodbye
</code></pre>

And definitely calling it with literals or expressions does nothing:

<pre><code>swap("happy","day") // what references is it supposed to be swapping?
</code></pre>

You can only swap the contents inside of an object for which you hold the same reference as the caller. To make a swap routine, you would do something like:

<pre><code>data class MutablePair(var one: String, var two: String)

fun swap(pair: MutablePair) { // not thread safe 
 val temp = pair.one
 pair.one = pair.two
 pair.two = temp
}
</code></pre>

Which you could call:

<pre><code>val stringies = MutablePair("howdy", "goodbye")
println("${stringies.one} ${stringies.two}")
swap(MutablePair()
println("${stringies.one} ${stringies.two}")

// output:
// howdy goodbye
// goodbye howdy
</code></pre>

Val cannot be reassigned a compile time error for a local variable in fun in Kotlin

If you don't need full debugging support, you can now view JavaScript <a href="/shell-kubectl-console-logs-nodejs-code-example" rel="dofollow">console logs</a> directly within Chrome for iOS at chrome://inspect.

https://blog.chromium.org/2019/03/debugging-websites-in-chrome-for-ios.html

<img src="https://i.stack.imgur.com/UKhdD.png" alt="Chrome for iOS Console">
 Old Answer (July 2016):

You can't directly debug Chrome for iOS due to restrictions on the published <code>WKWebView</code> apps, but there are a few options already discussed in other SO threads:

<ol>
<li>If you can reproduce the issue in Safari as well, then use Remote Debugging with Safari Web Inspector. This would be the easiest approach.</li>
<li>WeInRe allows some simple debugging, using a simple client-server model. It's not fully featured, but it may well be enough for your problem. See instructions on set up here.</li>
<li>You could try and create a simple <code>WKWebView</code> browser app (some instructions here), or look for an existing one on GitHub. Since Chrome uses the same rendering engine, you could debug using that, as it will be close to what Chrome produces. </li>
</ol>

There's a "bug" opened up for WebKit: Allow Web Inspector usage for release builds of WKWebView. If and when we get an API to <code>WKWebView</code>, Chrome for iOS would be debuggable.

Update January 2018:

Since my answer back in 2016, some work has been done to improve things. 

There is a recent project called RemoteDebug iOS WebKit Adapter,
 by some of the Microsoft team. It's an adapter that handles the API differences between Webkit Remote Debugging Protocol and Chrome Debugging Protocol, and this allows you to debug iOS WebViews in any app that supports the protocol - Chrome DevTools, VS Code etc. 

Check out the getting started guide in the repo, which is quite detailed.

If you are interesting, you can read up on the background and architecture
here.

Is there any way to debug chrome in any IOS device

Place this in the constructor:

<pre><code>if (window.performance) {
 if (performance.navigation.type == 1) {
 alert( "This page is reloaded" );
 } else {
 alert( "This page is not reloaded");
 }
}
</code></pre>

It will work, please see this example on stackblitz.
 Your code seems to be working just fine, your alert won't work because you aren't stopping the refresh. If you <code>console.log('hello')</code> the output is shown.

UPDATE ---

This should stop the user refreshing but it depends on what you want to happen.

<pre><code>componentDidMount() {
 window.onbeforeunload = function() {
 this.onUnload();
 return "";
 }.bind(this);
}
</code></pre>
 Unfortunately currently accepted answer cannot be more considered as acceptable since performance.navigation.type is deprecated

The newest API for that is experimental ATM.
As a workaround I can only suggest to save some value in redux (or whatever you use) store to indicate state after reload and on first <a href="/javascript-on-route-change-update-angular-code-example" rel="dofollow">route change update</a> it to indicate that route was changed not because of refresh.

React | How to detect Page Refresh (F5)

<h3>Using Named Function Expressions:</h3>

You can give a function expression a name that is actually private and is only visible from inside of the function ifself:

<pre><code>var factorial = function myself (n) {
 if (n &lt;= 1) {
 return 1;
 }
 return n * myself(n-1);
}
typeof myself === 'undefined'
</code></pre>

Here <code>myself</code> is visible only inside of the function itself.

You can use this private name to call the function recursively.

See <code>13. Function Definition</code> of the ECMAScript 5 spec:

<blockquote>
 The Identifier in a FunctionExpression can be referenced from inside the FunctionExpression's FunctionBody to allow the function to call itself recursively. However, unlike in a FunctionDeclaration, the Identifier in a FunctionExpression cannot be referenced from and does not affect the scope enclosing the FunctionExpression.
</blockquote>

Please note that Internet Explorer up to version 8 doesn't behave correctly as the name is actually visible in the enclosing variable environment, and it references a duplicate of the actual function (see patrick dw's comment below).

<h3>Using arguments.callee:</h3>

Alternatively you could use <code>arguments.callee</code> to refer to the current function:

<pre><code>var factorial = function (n) {
 if (n &lt;= 1) {
 return 1;
 }
 return n * arguments.callee(n-1);
}
</code></pre>

The 5th edition of ECMAScript forbids use of arguments.callee() in strict mode, however:

<blockquote>
 (From MDN): In normal code arguments.callee refers to the enclosing function. This use case is weak: simply name the enclosing function! Moreover, arguments.callee substantially hinders optimizations like inlining functions, because it must be made possible to provide a reference to the un-inlined function if arguments.callee is accessed. arguments.callee for strict <a href="/python-mean-median-mode-functions-in-python-code-example" rel="dofollow">mode functions</a> is a non-deletable property which throws when set or retrieved.
</blockquote>
 You can access the function itself using <code>arguments.callee</code> [MDN]:

<pre><code>if (counter&gt;0) {
 arguments.callee(counter-1);
}
</code></pre>

This will break in strict mode, however.
 You can use the Y-combinator: (Wikipedia)

<pre><code>// ES5 syntax
var Y = function Y(a) {
 return (function (a) {
 return a(a);
 })(function (b) {
 return a(function (a) {
 return b(b)(a);
 });
 });
};

// ES6 syntax
const Y = a=&gt;(a=&gt;a(a))(b=&gt;a(a=&gt;b(b)(a)));

// If the function accepts more than one parameter:
const Y = a=&gt;(a=&gt;a(a))(b=&gt;a((...a)=&gt;b(b)(...a)));
</code></pre>

And you can use it as this:

<pre><code>// ES5
var fn = Y(function(fn) {
 return function(counter) {
 console.log(counter);
 if (counter &gt; 0) {
 fn(counter - 1);
 }
 }
});

// ES6
const fn = Y(fn =&gt; counter =&gt; {
 console.log(counter);
 if (counter &gt; 0) {
 fn(counter - 1);
 }
});
</code></pre>

New posts