Any critique of my implementation of Merge sort would be much appreciated! I tested it using a driver function (shown below), and everything works. However, it still feels unwieldy, I am a beginner so I really want to hear any criticisms, constructive or not ðŸ™‚

```
def inplace_merge_sort( lst, start = 0 , end = None ):
def inplace_merge( lst1_start, lst1_end , lst2_start, lst2_end ): #needs to take in two sets of unsorted indices
start, end = lst1_start, lst2_end
for _ in range( (end - start) ):
if(lst(lst1_start) < lst(lst2_start)):
lst1_start += 1
else:
lst.insert(lst1_start , lst(lst2_start))
del lst(lst2_start + 1)
lst1_start += 1
lst2_start += 1
if( lst1_start == lst2_start or lst2_start == lst2_end):
break
return start, end #returns indices of sorted newly sublist
if( len(lst) == 1 or len(lst) == 0): #catches edge cases
return lst
if end is None: end = len(lst) #so I don't have to input parameters on first call
length_sublist = end - start
if( length_sublist > 1):
start1, end1 = inplace_merge_sort( lst, start, (end + start) // 2 )
start2, end2 = inplace_merge_sort( lst, (end + start) // 2 , end )
return inplace_merge(start1, end1, start2, end2)
else:
return start, end
```

Here is the test function

```
def inplace_driver_helper(f_n):
def modified_list_returner( lst ):
f_n(lst)
return lst
return modified_list_returner
def driver(f_n):
# NICK I added these two test cases to catch some popular edge cases.
assert f_n(()) == ()
assert f_n((4)) == (4)
assert f_n((1,2,3)) == (1,2,3)
assert f_n((3,2,1)) == (1,2,3)
assert f_n((1,2,3,1,2,3)) == (1,1,2,2,3,3)
assert f_n((1,2,3,1,1,2,3)) == (1,1,1,2,2,3,3)
assert f_n((-1,0,46,2,3,1,2,3)) == (-1,0,1,2,2,3,3,46)
```

and when we run this,

```
if __name__ == '__main__':
driver(inplace_driver_helper(inplace_merge_sort))
print('done')
```

The output is ‘done’! Thank you.