<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<style type="text/css" style="display:none;"><!-- P {margin-top:0;margin-bottom:0;} --></style>
</head>
<body dir="ltr">
<div id="divtagdefaultwrapper" style="font-size: 12pt; color: rgb(0, 0, 0); font-family: Calibri, Helvetica, sans-serif, EmojiFont, 'Apple Color Emoji', 'Segoe UI Emoji', NotoColorEmoji, 'Segoe UI Symbol', 'Android Emoji', EmojiSymbols;" dir="ltr">
<p></p>
<div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">Hi, all!</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">I want to reply many people and it might annoy you if I write multiple replies...</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">As a result, I write them all in one post.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">----------------------------------------------------------------------------------</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">To </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">Christopher Barker, Ph.D.</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">----------------------------------------------------------------------------------</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">Hi, Dr. Christopher Barker Ph.D.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">Just as what you said,</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">> parentheses aren't that bad, and as far as I can tell, this is just another</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">> way to call a function on the results of a function.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">> The above is now spelled:</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">> list(map(lambda x: x+2, range(5)))</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">> which seems fine with me -- the only improvement I see is a more compact</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">> way to spell lambda. (though really, a list comp is considered more</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">> "pythonic" these days, yes?</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">> [x+2 for x in  range(5)]</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">> nicely, we have list comps and generator expressions, so we can avoid the</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">> list0 call.</span></div>
<div><br>
</div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">I'll try to talk something about why I think we need this grammar, the </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">reasons for it are not just to remove parentheses.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">Could you please think this way to define a variable:</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">>> var = expr() -> g1(_) if f(_) else g2(_)</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">which equals </span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">>> test = f(expr())</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>> var  = g1(test) if f(test) else g2(test)</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">which means that we have to use a temporary variable "test" to define "var". </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">I think the second example is a bit lengthy, isn't it?</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">The reason why I take this kind of grammar is that I can "flatten the programming logic". </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">In another words,I can clearly state what I mean to say in order of my thinking.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">For example, </span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">>> lambda x: f(g(x)) -> map(_, range(100)) </span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">The codes above means that I'm stressing on what(an action) I'm going to do on an object "range(100)".</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">However, sometimes the actions are not important, so if we want to stress on what we're going to do something on, we write this codes:</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">>> range(100) -> map( lambda x:f(g(x)), _ )</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">Additionally, coding with chaining expressions makes me feel like writing a poem (Although it's a little difficult to me :)</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">How do you think about writing the following codes?</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">>> someone -> dosomething( _, options=options) \</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">           -> is_meeting_some_conditions( _ )  \</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">           -> result1() if _ else result2()    where:</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">options = ...</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">result1 = lambda: ...</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">result2 = lambda: ...</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">def dosomething(obj, options) -> Any:</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">...</span></div>
<div><br>
</div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">def is_meeting_some_conditions( event : Any ) -> bool :</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">...</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">In my opinion, it's quite readable and "smooth". To be honest, I think we can totolly do coding like chatting and it can be quite enjoyable.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">However, I'm not sure whether '->' is a good choice, and it didn't lead to any conflics at all when I compiled the CPython source code. Moreover, It can be easily changed in Grammar/Grammar, so I
 think it not to be crucial.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">Finally, </span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">> Also,  we need to remember that functions can take *args, **kwargs, etc,</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">> and can return a tuple of just about anything -- not sure how well that</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">> maps to the "pipe" model. </span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">I think that using "pipe" model cannot be the right choice. </span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">We don't need to worry about this problem if we use the grammar I've implemented yet :)</span></div>
<div><span style="font-family: Consolas, Courier, monospace;"> </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">  >> (lambda x: (x%5, x) ) ->  max( range(99), key = _)</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">  >> 94</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">  >> def max_from_seq(*args): return max(args)</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">  >> [1,2,3] -> max_from_seq(*_)</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">  >> 3</span></div>
<div><br>
</div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">Thautwarm</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">----------------------------------------------------------------------------------</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">To </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">David Mertz</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">----------------------------------------------------------------------------------</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">I think what you mean to is partially correct, but auto-currying cannot be effective enough.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">For sure you can do this in "compose" function.</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>  ... -> ... -> ... -> map(lambda x:x+1,  _) </span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">However, the evaluated result can be used as any argument of map and other callable objects.</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>  ... -> ... -> ... -> map(_ , range(100))  </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>  ... -> ... -> ... -> min([1,2,3], key = _ )</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">Thautwarm</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">----------------------------------------------------------------------------------</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">To </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">Chris Angelico</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">----------------------------------------------------------------------------------</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">To be honest, I'm in favor of the grammar you prefer, like "expr1 | expr2 | expr3".</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">However, it might be annoying that I should firstly define a lot of kinds of pipeline operators like Map, Reduce and so on.</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">As for whether to allow implicit first/last argument, it seems to be a good idea but two points are in the way:</span></div>
<div><br>
</div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">1. We need to change almost all C functions related to expressions in the source code located
 at Python/ast.c,</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">while implementing the grammar I'm using now just needing nothing more than adding new C-function
 here.</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">2. Implicit methods makes it impossible to use following expressions. </span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">  >
</span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">... -> func(some_var, some_var, _, some_eval(), some_key = _)</span></div>
<div><br>
</div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">  In other words, implicit methods weaken the grammar, </span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">  we need one more "where syntax" to do the same thing:</span></div>
<div><br>
</div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">  >    some -> new_func where:</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;"> 
</span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">new_func = lambda x: func(some_var, some_var, x, some_eval(), some_key = x)</span></div>
<div><br>
</div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">  </span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">Emmm... I'm not sure about that, how do you think about that?</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">Thautwarm</span></div>
<div><br>
</div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">----------------------------------------------------------------------------------</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">To</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">Steven D'Aprano</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">----------------------------------------------------------------------------------</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">Thank you very much for your reply, and it encouraged me a lot.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">I've just read your most recent post, and it seems that you've suffered a lot from the parentheses, and so did I.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">> Half of my key presses are moving backwards over code I've just written </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">> to insert a function call which is executed *after* what I wrote, but </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">> needs to be written *before* what I just wrote.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">I couldn't agree more about what you've said here!!!</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">My opinions about "chaining and pipeline" could be found in my reply to Chris Barker, </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">sorry for that I could not repeat myself in the same post.</span></div>
<div><br>
</div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">>> # where syntax</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>> </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>     from math import pi</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>     r = 1  # the radius</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>     h = 10 # the height</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>     S = (2*S_top + S_side) where:</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>         S_top  = pi*r**2</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>         S_side = C * h where:</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>             C = 2*pi*r</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">> This has been suggested a few times. The first time, I disliked it, but </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">> I've come across to seeing its value. I like it.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">> I wonder: could we make the "where" clause delay evaluation until the </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">> entire block was compiled, so that we could write something like this:</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">> </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>    S = (2*S_top + S_side) where:</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>        S_top  = pi*r**2</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>        S_side = C * h  # C is defined further on</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>        C = 2*pi*r</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">> That's more how "where" is used mathematically.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;"> As far as I'm concerned, it's not sure to tell how about you opinion.</span></div>
<div><span style="font-family: Consolas, Courier, monospace;"> The grammar you've just considered is quite Haskell-like, I think. And </span></div>
<div><span style="font-family: Consolas, Courier, monospace;"> the reason why I want to use "where synatx" is to divide the programming logic clearly into different layers.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;"> For example, sometimes we just need to know that surface area of a cylinder is </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">   </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">   2*S_top + S_side</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;"> If someone see the codes, he may not need to know how S_top and S_side are evaluated,getting </span></div>
<div><span style="font-family: Consolas, Courier, monospace;"> a knowledge of what it means to is enough. </span></div>
<div><span style="font-family: Consolas, Courier, monospace;"> And if you want to get more about how to evaluate S_side and S_top, just see </span></div>
<div><span style="font-family: Consolas, Courier, monospace;"> the next "where syntax" and find the answers.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;"> Here is another example, about forward propagation in neural networks.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;"> </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;">
</span><span style="font-family: Consolas, Courier, monospace;"># input_layer[i] : "np.ndarray[:]   " = np.array( ... )</span></div>
<div><span style="font-family: Consolas, Courier, monospace;"> </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;">
</span><span style="font-family: Consolas, Courier, monospace;"># weight[i]      : "np.ndarray[:][:]" = np.array( ... )</span></div>
<div><br>
</div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">    output_layer[i] = activate(input_layer[i])  where:</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">    </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span></div>
<div><span style="font-family: Consolas, Courier, monospace;">    </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">""" logic layer 1 """</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">    </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">def activate( layer ):</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">    </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">...</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">    </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">return activation[i](layer)
 # for example, activation[i] = lambda x:x</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">    </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">input_layer[i] = forward(weight[i-1],
 output_layer[i-1].T) where:</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">    </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">""" logic layer 2 """</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">    </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">def forward(weight, output):</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">    </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">...</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">    </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;"># if it's a normal multi-layer
 perceptron.</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">    </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">return np.matmul(weight,
 output.T)</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">  For some people, their works just need them to know that forward propagation of </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">  a neural network means that the output layer is generated from the input layer</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">  with some transformation.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">  For some people who want to know what the transformation is, they can go to the next "where syntax",</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">  and find the definition of the transformation which named "activate".</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">  For people who want to know how neural networks works with multiple layers, they can find that</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">  the input layer is defined by </span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">  </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">last output_layer, </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">  </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">last weight matrix  </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">  </span><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">how NN forwards.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">  I think it a good way to use "where syntax" to deconstruct the programming logic, which </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">  can strengthen the readability a lot!</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">  And then I'm going to talk something about Pattern Matching, and transform them to regular Python to make it clear to understand.</span></div>
<div><br>
</div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">>> Here is an example to use flowpython, which gives the permutations of a sequence.</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>> </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>     from copy import deepcopy</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>     permutations = .seq -> seq_seq where:</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>         condic+[] seq:</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>             case (a,  ) => seq_seq = [a,]</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>             case (a, b) => seq_seq = [[a,b],[b,a]]</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>             case (a,*b) =></span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>                 seq_seq = permutations(b) -> map(.x -> insertAll(x, a),  _) -> sum(_, []) where:</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>                      insertAll = . x, a -> ret where:</span></div>
<div><span style="font-family: Consolas, Courier, monospace;">>>                          ret = [ deepcopy(x) -> _.insert(i, a) or _ for i in  (len(x) -> range(_+1))  ]</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">> I find that almost unreadable. Too many new features all at once, it's </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">> like trying to read a completely unfamiliar language.</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">> How would you translate that into regular Python?</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">This algorithm can be fixed a little because the second case is redundant. And here is the regular Python codes transformed </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">from the codes above.</span></div>
<div><br>
</div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">from copy import deepcopy</span></div>
<div><br>
</div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">def permutations(seq):</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">try:</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;"># the first case </span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">(a, ) = seq</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">return [a ,]</span></div>
<div><br>
</div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">except:</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">try:</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;"># the third case (the second case is redundant)</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">def insertAll(x, a):</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;"># insertAll([1,2,3], 0) -> [[0, 1, 2, 3], [1, 0, 2, 3], [1, 2, 0, 3], [1, 2, 3, 0]]</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"><span style="font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;"></span></span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">ret = []</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">for i in range( len(x) + 1 ):</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">tmp = deepcopy(x)</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">tmp.insert(i, a)</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">ret.append(tmp)</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">return ret</span></div>
<div><br>
</div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">(a, *b) = seq  </span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">tmp     = permutations(b)</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">tmp     = map(lambda x : insertAll(x, a) , tmp)</span></div>
<div><br>
</div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">return sum(tmp, []) # sum([[1,2,3], [-1,-2,-3]], []) -> [1,2,3,-1,-2,-3]</span></div>
<div><br>
</div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">except:</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;"># no otherwise!</span></div>
<div><span class="Apple-tab-span" style="white-space: pre; font-family: Consolas, Courier, monospace;"></span><span style="font-family: Consolas, Courier, monospace;">pass</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">To be continue...(sorry for my lack of time</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">Thautwarm</span></div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">----------------------------------------------------------------------------------</span></div>
<div><br>
</div>
<div><br>
</div>
<div><br>
</div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">I'm sorry that I have to do some other works now and </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">didn't finished writing down all I want to say.</span></div>
<div><br>
</div>
<div><br>
</div>
<div><span style="font-family: Consolas, Courier, monospace;">I'd like to continue replying the posts tomorrow , and it's </span></div>
<div><span style="font-family: Consolas, Courier, monospace;">quite glad to discuss these topics with you all!!!</span></div>
<div><br>
</div>
<div><br>
</div>
<div><br>
</div>
<div><br>
</div>
<div><br>
</div>
<div><br>
</div>
<div><br>
</div>
<div><br>
</div>
<div><br>
</div>
<div><br>
</div>
</div>
<span style="font-family: Consolas, Courier, monospace;"></span><br>
<p></p>
</div>
</body>
</html>