Programming Chapter 9: Subprograms

A generic type that can represent any type of collection; a wildcard type for collection classes. It allows a method to accept any collection, regardless of the specific type of elements it contains.

Methods that can work with various data types. Type parameters in function calls can be omitted if the compiler can determine the unspecified type.

F# automatically determines a generic type if it cannot determine the type of a parameter or return type.

The process in F# where generic types are automatically inferred if the type is unknown.

When function parameters are used with arithmetic operators, resulting in type constraints, even if they're generic.

Operators (like addition) can be customized to work with custom data types (such as in Python).

Python's add method is how you define the addition operation for a Complex data type.

F# generic functions, though useful, are less so than in other languages due to type inference and lack of type coercion.

Parameter passing where no initial value is transmitted. The subprogram's formal parameter acts as a local variable and the caller's corresponding actual parameter receives the value from the subprogram.

A combination of pass-by-value and pass-by-result. Formal parameters have local storage and the value is returned to the caller.

Passing an access path to a parameter, efficient because of sharing.

Potential for unwanted side effects (collisions) and broadened access (aliases) because of shared reference.

In languages like C, formal parameters can be changed in the subprogram. Implementation varies amongst languages, some prevent changes.

Parameter binding is via textual substitution; the actual binding to a value or address happens later, and the environment of the caller is passed enabling later address calculation.

Different parameter passing methods have varying efficiency in terms of copying and storage needs.

Multiple names or references can refer to the same memory location or object, creating potential for unexpected consequences when modifying these references.

Local variables that are allocated on the stack when a subprogram is called and deallocated when the subprogram returns. This allows storage to be shared among subprograms but can lead to overhead for allocation, de-allocation, and initialization.

Local variables whose memory is allocated once, at the beginning of program execution, and remains allocated throughout the program's lifetime. They retain their values between calls to the subprogram, making them suitable for storing state.

A parameter passing mechanism where the value of the actual parameter is copied into the formal parameter. Changes to the formal parameter do not affect the actual parameter.

A parameter passing mechanism where the value of the formal parameter is copied back to the actual parameter when the function completes. The actual parameter is used as an output variable.

A parameter passing mechanism where the formal parameter uses the same memory location as the actual parameter. Changes to the formal parameter directly affect the actual parameter.

A copying mechanism where a copy of the actual parameter's value is made and used for the formal parameter. Changes made to the formal parameter only affect the copy, not the original.

A parameter passing mechanism where the actual parameter's value is physically copied into the memory location of the formal parameter.

A parameter passing mechanism where the formal parameter receives an access path (pointer or reference) to the actual parameter's memory location, allowing direct modification of the original value.

Local variables that are created and destroyed as needed during program execution.

Static local variables maintain their state between function calls, while dynamic local variables are created and destroyed with each call.

The ability to define multiple functions in the same scope with the same name but different parameter lists (types and number of parameters).

A function or procedure that can work with different data types. It uses type parameters to represent the data types, allowing the subprogram to be reused with different types.

The set of variables and functions that are accessible to a subprogram at the time it is executed. It includes not only the subprogram's local variables but also variables from any enclosing scopes.

A combination of a function and its referencing environment. This allows the function to retain access to variables that are no longer in scope.

A subprogram that generalizes subroutines for non-preemptive multitasking. Allows multiple entry points and suspension of execution without losing state.

Enhance code reusability and flexibility. Reduce code complexity by allowing one function name for multiple functionalities. Improve maintainability and readability.

Promote code reusability and flexibility by working with varying data types. Allow for generic algorithms and data structures. Reduce the need for repetitive code generation.

Allow functions to maintain state across calls, enabling complex behavior. Facilitate data hiding and encapsulation. Support for functional programming paradigms.

A parameter passing mechanism where the value of the actual parameter is copied into the formal parameter. Changes to the formal parameter do not affect the actual parameter.

A parameter passing mechanism where the value of the formal parameter is copied back to the actual parameter after the function completes. The actual parameter is used as an output variable.

A parameter passing mechanism where the formal parameter uses the same memory location as the actual parameter. Changes to the formal parameter directly affect the actual parameter.

The combination of a subprogram's name and the data types of its parameters. It defines the kind of information a subprogram needs to operate correctly.

Static local variables are more efficient when the variable needs to maintain state across multiple function calls. Dynamic variables add overhead with creation and destruction.

Unexpected consequences caused by modifying data in a subprogram that affects the calling function.

Different parameter passing methods offer varying efficiency in terms of copying and storage needs. Pass-by-value might be less efficient for large objects compared to pass-by-reference.

Unexpected changes to the original data outside the function due to modifications made to the parameter within the function. This can happen with pass-by-reference methods.

Provides safety against unintentional side effects by working with a copy of the original value. Useful for passing configuration values that shouldn't be modified.

Can be inefficient for large parameters, like complex objects or arrays, because it requires copying the entire data.

Pass-by-Reference is more memory-efficient because it doesn't create a copy of the original data. It works directly with the original data.

It increases the risk of unintentional side effects. Changes made to the parameter within the function can affect the original data.

By creating a copy of the parameter, changes made within the function are isolated to the copy, leaving the original value intact.

A programming technique where a subprogram calls itself within its own code, often used for tasks like calculating factorials or traversing tree structures.

The current condition or information held by a subprogram, including the values of its variables and its position in execution.

Storing values in a memory location to avoid repeating calculations. This can improve efficiency by reducing the need to recalculate values.

They are suitable for recursive algorithms, where each call needs independent state, like calculating factorials or traversing tree structures.

They're useful for scenarios where maintaining state is required, such as caching computed values, as the value persists across calls.

Multiple functions sharing the same name but differentiated by their parameter profiles (data types and number of parameters).

Enhanced code reusability, reduced complexity through a single name for multiple functionalities, improved maintainability and readability.

Increased code reusability, flexibility by working with different data types, generic algorithms and data structures, less repetitive code.

By having a single logical name for different functionalities, the API becomes easier to understand and use.

Subprograms that enable non-preemptive multitasking, allowing execution to be paused and resumed without losing state, making them ideal for tasks requiring concurrency without full threading.

Often used in I/O-bound applications, such as web servers or user interfaces, where tasks like waiting for user input or database interaction can be suspended to improve responsiveness.

Coroutines are more efficient than threads because they don't need complex synchronization mechanisms, making them easier to debug and maintain.

'async' defines a coroutine function, while 'await' pauses the coroutine until the awaited task completes.

Similar to Python, 'async' marks a function as a coroutine, and 'await' pauses execution.

They offer efficient multitasking without thread management overhead, simplified concurrency compared to threads, and reduced debugging complexity.

Coroutines are used to animate characters or manage user input across frames, ensuring smooth game flow.

'yield' is used in coroutines to return a value and pause execution until resumed, often with a 'next()' call.

Closures are useful for creating factory functions, where you can create functions with specific initial parameters.

Closures simplify code by eliminating the need to create separate classes or objects to manage state.

Functions in JavaScript retain access to their surrounding variables, creating closures.

Functions in Python also form closures, allowing them to hold onto outer variables.

Closures are essential in functional programming because they enable state management without altering the global state.

In web development, closures can be used to create event listeners that retain information about UI elements when created.

When a button is clicked, the closure associated with that button can access its unique ID to execute specific actions.