soedar

    NSArray* paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString* documentsDirectory = [paths objectAtIndex:0];
    
    NSString *plistfile = [documentsDirectory stringByAppendingString:@"Global.plist"];
    
    
    NSDictionary *dictionaryToSerialize = @{@"Hello": @"World", @"Dictionary": @{@"InnerHello": @"InnerWorld"}};
    [dictionaryToSerialize writeToFile:plistfile atomically:YES];
     
    

soedar

def bank_account(balance):
    # Inner functions are created in the scope of the
    # outer function, and as such have 'knowledge' of
    # the scope.
    #
    # In this case, it knows about the balance.
    # This function returns a string telling us
    # whether the owner is rich or poor
    def are_you_rich():
        # The inner function can access/read the variables

soedar

# GCD HOF Question

# For the filtered accumulate function, notice that the filtered function takes in 1 parameter, the
# term number, and returns True/False, depending on whether we want to accept the term or not.
# For the prime question, we can directly use the same is_prime function, because it takes in 
# a number, and returns True if it is prime, and False otherwise. Since we want to sum the square
# of the prime numbers between a and b, is_prime works well as the filtered function.

# For the GCD question, it is not that straightforward. The function that is provided to us, gcd, 
# takes in 2 values, and worse, it returns an integer which describes the GCD of the 2 numbers.

soedar

# For this question, you are suppose to create a poly generator function, that would create
# a *function* that when passed in a value x, calculate the polynomial of using the coefficient
# that was used when the function is created.

# In short, we are given this function has already been defined for us:
def poly(coefficient, x):
  # returns the following:
  # (coeff[0] * x^0) + (coeff[1] * x^1) + (coeff[2] * x^2) + ...
  
# and we want to create a function which would create a function that looks like the above, but has fixed

soedar

## Data Abstraction
 
# Variable Naming
# The key idea behind data abstraction is that we want to give meaning to data types. We already have 
# seen how the naming your variables more meaninfully would help us give meaning to primitive data. 
# For instance,

x = 24                # Not exactly clear what x refers to, and what does 24 mean

# Consider:

soedar

is_word = lambda word: word in ['hot', 'el', 'fate', 'elf', 'ate', 'hotel', 'fate']

def str_set(input_str):
    if input_str == "":
        return [[]]

    result = []
    for i in range(1, len(input_str)+1):
        s = input_str[:i]

soedar

#import "hello.h"

// Anonymous class extension
@interface Hello ()
@property (nonatomic, strong) NSString *privateString;
@end

@implementation Hello

// do something with self.privateString

soedar

def find_rate(principal, gap, monthly, years):
  # principal - starting principal
  # gap - number of months before 1st payment
  # monthly - monthly payment
  # years - number of years of payment

  def remainder(interest): # monthly interest
    left = principal

    #compute total before starting payment

soedar

Higher Order Function is the idea that functions can be used as the input parameters to other functions, as well as functions can be returned from the function. It is a little harder to understand the latter, so we'll spend some more time talking about it.

The reason why we can do HOF is because our function can be stored in our variables.

Background: Creating Functions

A good way to think about functions is that they are just like any other variables types (like int, boolean, tuple). Just like how we can create new tuple by using the tuple notation ( my_tuple = (1, 2, 3)), we can also create a new function using the create function notation.

There are 2 main ways to create function, and in the following example, a variable named square is created, that 'holds' the function that is created.

soedar

The key idea behind data abstraction is that we want a way for us to reason about data at a higher level (as oppose to data at a primitive level). We would need to discuss first what are primitive types, and why there is a need to express these primitive types at a higher level for our convenience.

Primitive Types

Primitive types are languages features that are provided by the programming environment. You should be familiar with some of the primitive types: integers, floats, boolean, tuples, functions, etc.

For each primitive types, the language also provide us with a way to interact with the primitive types. For example, the + operator allows us to add between numbers, and the len function allows us to get the size a tuple.

User Defined Types

As the name clearly imply, user defined types are defined by the users, ie us. They are not provided by the language, but they allow a way for us to more easily reason about our program and their behavior. Like primitive types, we can also define ways we