Glanz: aiMOOC über GPT aiMOOC Action erstellt

2026-08-29T12:25:51Z

aiMOOC über GPT aiMOOC Action erstellt

Neue Seite

{{T}}
[[Category:English]]
[[Category:Functional Programming Concepts]]

{{BR}}
= Introduction =

'''Functional programming''' is a programming paradigm that builds computations by applying and composing functions. Instead of describing a program mainly as a sequence of commands that repeatedly change shared state, functional programming encourages you to describe transformations from inputs to outputs. This approach can make programs easier to reason about, test, combine, and run safely in parallel.

This aiMOOC is designed for '''Grades 11–13'''. You should already understand basic variables, expressions, conditions, lists, and functions. You do not need previous experience with Haskell. Haskell is used here because its syntax makes important functional ideas especially visible, but the concepts also appear in languages such as [[English:Python|Python]], [[English:JavaScript|JavaScript]], [[English:Scala|Scala]], [[English:F Sharp|F Sharp]], [[English:Clojure|Clojure]], [[English:Elixir|Elixir]], and many others.

[[File:Haskell-Logo.svg|420px|frameless|center]]

By the end of the course, you should be able to explain and apply [[English:Pure function|pure functions]], [[English:Immutable object|immutability]], [[English:Higher-order function|higher-order functions]], [[English:Recursion|Recursion]], [[English:Function composition|Function composition]], [[English:Lazy evaluation|Lazy evaluation]], and basic ideas from the [[English:Lambda calculus|Lambda calculus]]. You should also be able to compare functional and imperative solutions and justify when each style is useful.

{{#ev:youtube|https://www.youtube.com/watch?v=LnX3B9oaKzw|500|center}}

{{BR}}
= Functions as the Main Building Blocks =

In mathematics, a function associates inputs with outputs. Functional programming takes this idea seriously: functions are treated as central program values, not merely as named blocks of instructions.

[[File:CPT functional basics.svg|500px|frameless|center]]

A simple function can be understood as a transformation. If a function called ''double'' receives 4 and returns 8, the important question is not which memory cell changed but which result follows from the given input.

<syntaxhighlight lang="haskell">
double :: Int -> Int
double x = x * 2
</syntaxhighlight>

The type declaration says that ''double'' takes an integer and returns an integer. Evaluating ''double 4'' produces 8.

{{BR}}
== Pure Functions ==

A '''pure function''' has two key properties. First, the same input produces the same output. Second, evaluating the function does not create an observable side effect such as changing a global variable, modifying a shared data structure, printing to the screen, or writing to a file.

For example, a function that calculates the area of a rectangle from width and height can be pure. A function that reads the current time is not pure in the same sense because its result can differ even when the explicit input is unchanged.

Purity supports '''referential transparency''': an expression can be replaced by its value without changing the meaning of the surrounding program. This makes local reasoning easier because you can study a function without tracing hidden changes elsewhere.

{{BR}}
== Immutability ==

'''Immutability''' means that a value is not changed after it has been created. Instead of updating an existing list, a functional program commonly creates a new list that represents the desired result.

Suppose the list is ''[2, 4, 6]'' and you want a version with 8 added. An immutable approach keeps the original list available and constructs a new list ''[2, 4, 6, 8]''. Implementations may internally share data efficiently, so immutability does not necessarily mean copying every element.

Immutability reduces problems caused by unexpected shared-state changes. This is especially helpful when several parts of a program use the same data or when tasks may execute concurrently.

{{BR}}
= First-Class and Higher-Order Functions =

In many functional languages, functions are '''first-class values'''. You can store them in variables or data structures, pass them as arguments, and return them from other functions.

A '''higher-order function''' is a function that takes one or more functions as arguments, returns a function, or both. Three common higher-order patterns are ''map'', ''filter'', and ''fold''.

{{BR}}
== Map ==

''Map'' applies a function to every element of a collection and produces a collection of results.

<syntaxhighlight lang="haskell">
squares = map (\x -> x * x) [1, 2, 3, 4]
</syntaxhighlight>

The result is ''[1, 4, 9, 16]''. The lambda expression ''\x -> x * x'' is an anonymous function.

[[File:CPT Haskell Map function.svg|600px|frameless|center]]

You can think of ''map'' as separating two decisions: '''what transformation should happen''' and '''how that transformation is applied across the collection'''.

{{BR}}
== Filter ==

''Filter'' keeps only elements that satisfy a predicate. A predicate is a function that produces a Boolean result.

<syntaxhighlight lang="haskell">
evens = filter even [1, 2, 3, 4, 5, 6]
</syntaxhighlight>

The result is ''[2, 4, 6]''. The original list is not modified.

{{BR}}
== Fold and Reduce ==

A '''fold''' combines the elements of a structure into a result by repeatedly applying a combining function. Many languages use the related name ''reduce''.

<syntaxhighlight lang="haskell">
total = foldl (+) 0 [3, 5, 7]
</syntaxhighlight>

The value starts at 0 and combines the list elements to produce 15.

[[File:CPT fold function example.svg|500px|frameless|center]]

Map, filter, and fold are powerful because they express common data-processing patterns without requiring you to write the control structure from scratch each time.

{{BR}}
= Lambda Expressions and the Lambda Calculus =

A '''lambda expression''' describes an anonymous function. In Haskell, ''\x -> x + 1'' means a function that takes ''x'' and returns ''x + 1''. In Python, a similar idea can be written as ''lambda x: x + 1''. JavaScript commonly uses an arrow function such as ''x => x + 1''.

[[File:LambdaAbstraction.svg|600px|frameless|center]]

The [[English:Lambda calculus|Lambda calculus]] is a formal system developed by Alonzo Church for expressing computation using function abstraction and application. Modern functional programming languages are not simply the untyped lambda calculus, but lambda-calculus ideas strongly influence how functions are represented and combined.

Three useful ideas are:
# [[English:Abstraction|Abstraction]]: defining a function in terms of a parameter and an expression.
# [[English:Function application|Function application]]: applying a function to an argument.
# [[English:Substitution|Substitution]]: replacing a bound variable with an argument when evaluating an expression.

{{#ev:youtube|https://www.youtube.com/watch?v=eis11j_iGMs|500|center}}

{{BR}}
= Function Composition =

'''Function composition''' combines smaller functions so that the output of one becomes the input of another. If ''f'' and ''g'' are functions, the composition ''f after g'' means: first apply ''g'', then apply ''f''.

<syntaxhighlight lang="haskell">
addOne x = x + 1
double x = x * 2
transform = double . addOne
</syntaxhighlight>

Evaluating ''transform 3'' first gives ''addOne 3 = 4'' and then ''double 4 = 8''.

Composition encourages you to build programs from small, testable parts. It is similar to creating a pipeline in which each stage has a clear responsibility.

{{BR}}
= Recursion =

'''Recursion''' occurs when a function solves a problem by calling itself on a smaller or simpler case. A recursive definition needs a '''base case''' that stops the process and a '''recursive case''' that moves toward the base case.

<syntaxhighlight lang="haskell">
factorial 0 = 1
factorial n = n * factorial (n - 1)
</syntaxhighlight>

For ''factorial 4'', the calls reduce the problem toward ''factorial 0''. The results then combine to produce 24.

In functional programming, recursion often replaces loops, although library functions such as ''map'', ''filter'', and ''fold'' are usually clearer than writing explicit recursion for standard collection tasks.

{{#ev:youtube|https://www.youtube.com/watch?v=Mv9NEXX1VHc|500|center}}

{{BR}}
= Pattern Matching =

'''Pattern matching''' lets a function choose a definition based on the structure of its input. It is common in functional languages and works especially well with lists and algebraic data types.

<syntaxhighlight lang="haskell">
listLength [] = 0
listLength (_:xs) = 1 + listLength xs
</syntaxhighlight>

The first pattern matches an empty list. The second matches a non-empty list, ignores its first element, and recursively processes the remaining list.

Pattern matching can make control flow closely match the structure of the data being processed.

{{BR}}
= Lazy Evaluation =

With '''lazy evaluation''', an expression is evaluated only when its result is needed. Haskell uses non-strict semantics and normally evaluates expressions lazily.

This can make infinite data structures useful. For example, you can conceptually define an unending sequence of natural numbers and then request only its first ten values. The program does not need to construct the entire infinite sequence.

<syntaxhighlight lang="haskell">
naturals = [0..]
firstTen = take 10 naturals
</syntaxhighlight>

A delayed computation is often described as a '''thunk'''. Lazy evaluation can support modular programs and avoid unnecessary work, but it can also make performance and memory use less obvious if you do not understand when expressions are forced.

[[File:Thunk-layers.png|450px|frameless|center]]

{{BR}}
= Types and Functional Programming =

Functional programming is not defined by a single type system. Some functional languages use strong static typing, while others use dynamic typing. Haskell uses static typing and type inference, which means the compiler can often determine types without requiring every type annotation to be written.

Type signatures help communicate what a function can accept and return.

<syntaxhighlight lang="haskell">
isPositive :: Int -> Bool
isPositive x = x > 0
</syntaxhighlight>

A useful principle is that types can describe interfaces between functions. When you compose functions, compatible types help ensure that the output of one stage can become the input of the next.

{{BR}}
= Side Effects and Controlled Interaction =

Real programs must interact with the world. They read input, display information, use networks, store files, and update databases. Functional programming does not eliminate these needs. Instead, functional languages provide ways to '''separate pure transformations from effectful actions'''.

Haskell makes this separation especially explicit through types such as ''IO''. Other languages may use different mechanisms, but the architectural goal is similar: keep as much logic as practical pure and isolate effects at clear boundaries.

This design can simplify testing. A pure function that transforms validated input into a result can be tested without opening files, connecting to a network, or changing global state.

{{BR}}
= Functional and Imperative Styles Compared =

'''Imperative programming''' often emphasizes commands and state changes: initialize a variable, update it in a loop, and stop when a condition is met. '''Functional programming''' often emphasizes expressions and transformations: map values, filter them, combine them, and compose functions.

Neither style is automatically best for every problem. Many modern languages are multi-paradigm, so good programmers learn to choose ideas that make a particular task clear, reliable, and maintainable.

A functional solution can be especially useful when:
# [[English:Data transformation|Data transformation]] is naturally described as a pipeline.
# [[English:Concurrency|Concurrency]] would be safer with less shared mutable state.
# [[English:Testing|Testing]] benefits from deterministic pure functions.
# [[English:Modularity|Modularity]] improves when complex behavior is composed from small functions.

An imperative solution may be more direct when step-by-step state changes closely match the problem or when performance constraints require careful low-level control.

{{BR}}
= From Expressions to Data Pipelines =

Consider a list of temperatures in degrees Celsius. You want to keep only temperatures above freezing, convert them to Fahrenheit, and calculate an average.

A functional approach can divide the task into transformations:
# Filter the list to keep values above zero.
# Map the conversion function across the remaining values.
# Fold or reduce the converted values to compute a total.
# Divide by the number of retained values.

This pipeline can be read as a description of '''what''' happens to the data. Each stage can be tested independently.

{{BR}}
= Media Reflection =

The following spoken recording provides another medium for reviewing the general topic of functional programming. As you listen, note which concepts overlap with the course and which ideas are presented with different terminology.

[[File:En-Functional programming.ogg|center]]

{{BR}}
= Interactive Tasks =

{{BR}}
== Quiz: Test Your Knowledge ==

{{MC}}

'''Which statement best describes a pure function?'''
(It returns the same result for the same input and has no observable side effects)
(!It must always be recursive)
(!It must modify at least one variable)
(!It can only return numbers)

{{E}}
<br>

{{MC}}

'''What does immutability mean in functional programming?'''
(Existing values are not changed after creation)
(!Every variable must be global)
(!Data can never be stored in a list)
(!Programs cannot create new values)

{{E}}
<br>

{{MC}}

'''What makes a function higher-order?'''
(It accepts a function as input or returns a function)
(!It contains more than one loop)
(!It always runs faster than other functions)
(!It can only process mathematical formulas)

{{E}}
<br>

{{MC}}

'''What is the main purpose of map?'''
(To apply a function to every element of a collection)
(!To remove all duplicate elements)
(!To sort a collection into alphabetical order)
(!To store values in mutable variables)

{{E}}
<br>

{{MC}}

'''What does filter do?'''
(It keeps elements that satisfy a predicate)
(!It transforms every element into a number)
(!It combines all elements into one result)
(!It reverses a collection)

{{E}}
<br>

{{MC}}

'''What is a fold used for?'''
(To combine a structure into an accumulated result)
(!To create side effects automatically)
(!To rename all functions in a program)
(!To delay every computation forever)

{{E}}
<br>

{{MC}}

'''What must a well-designed recursive function include?'''
(A base case that stops the recursion)
(!A global variable that changes each time)
(!An infinite loop)
(!A file input operation)

{{E}}
<br>

{{MC}}

'''What is function composition?'''
(Combining functions so one function processes the output of another)
(!Changing a function into a variable)
(!Running unrelated functions at random)
(!Copying the same function many times)

{{E}}
<br>

{{MC}}

'''What is lazy evaluation?'''
(Delaying evaluation until a result is needed)
(!Evaluating every possible expression immediately)
(!Preventing functions from returning results)
(!Replacing all recursion with loops)

{{E}}
<br>

{{MC}}

'''Why can pure functions be easier to test?'''
(Their results depend only on their explicit inputs)
(!They never require any input values)
(!They automatically generate test cases)
(!They always contain fewer lines of code)

{{E}}
<br>

{{BR}}
== Memory Game ==

<div class="memo-quiz">
{|
|-
| Pure function || Produces the same output for the same input without observable side effects
|-
| Immutability || Keeps an existing value unchanged after creation
|-
| Higher-order function || Accepts or returns another function
|-
| Recursion || Solves a problem through self-calls on smaller cases
|-
| Composition || Connects functions so one output becomes another input
|-
| Thunk || Represents a computation that can be evaluated later
|}
{{E}}
<br>

{{BR}}
== Drag and Drop ==

<div class="lueckentext-quiz">

{| class="wikitable"
! Match the correct terms.
! Topic
|-
| '''Applies one transformation to each item'''
| Map
|-
| '''Keeps items that satisfy a condition'''
| Filter
|-
| '''Combines items into an accumulated result'''
| Fold
|-
| '''Stops a recursive definition'''
| Base case
|-
| '''Delays a computation until needed'''
| Lazy evaluation
|}
{{E}}

<br>
...
<br />

{{BR}}
== Crossword Puzzle ==

<div class="kreuzwort-quiz">
{|
|-
| Purity || Which property means that a function has no observable side effects and is deterministic for the same input?
|-
| Immutable || What adjective describes a value that is not changed after it is created?
|-
| Recursion || What technique lets a function call itself on a smaller case?
|-
| Lambda || What word names an anonymous function notation and a foundational calculus?
|-
| Composition || What technique links functions so that one output becomes another input?
|-
| Predicate || What kind of function returns a Boolean result used by filter?
|}
{{E}}
<br>

{{BR}}
== LearningApps ==

<iframe> https://learningapps.org/index.php?s=Functional+Programming+Concepts </iframe>

{{BR}}
== Cloze Text ==

<quiz display=simple>
{'''Complete the text.'''<br>
|type="{}"}
A { pure function } produces the same result for the same explicit input and avoids observable side effects. With { immutability }, existing values are not modified after they are created. A { higher-order function } can accept another function as an argument or return one as a result. The operation { map } applies a transformation to every element of a collection. The operation { filter } keeps elements that satisfy a predicate. A { fold } combines elements into an accumulated result. A recursive definition needs a { base case } so that evaluation can stop. With { lazy evaluation }, an expression may be delayed until its value is required.
</quiz>

<br>

{{BR}}
= Open-Ended Tasks =

{{BR}}
=== Easy ===
# [[English:Pure Function Test|Pure Function Test]]: Write two small functions, one pure and one impure, and explain which observable behavior makes them different.
# [[English:Map a Dataset|Map a Dataset]]: Choose a short list of numbers and use a map operation to transform every element; show both the input and output.
# [[English:Predicate Design|Predicate Design]]: Create three predicates for a list of integers and explain what each predicate would keep when used with filter.
# [[English:Functional Vocabulary Poster|Functional Vocabulary Poster]]: Produce a one-page visual poster that explains purity, immutability, higher-order functions, recursion, and composition with your own examples.

{{BR}}
=== Standard ===
# [[English:Recursive List Processing|Recursive List Processing]]: Implement a recursive function that calculates the length or sum of a list, identify its base case, and trace the first four calls.
# [[English:Pipeline Challenge|Pipeline Challenge]]: Build a data-processing pipeline using map, filter, and fold, then explain the role of each stage in clear English.
# [[English:Paradigm Interview|Paradigm Interview]]: Interview a programmer, teacher, or advanced student about when functional programming ideas are useful, then compare the interview with concepts from this course.
# [[English:Functional Video Explanation|Functional Video Explanation]]: Create a two-minute teaching video that demonstrates function composition with at least three small functions and one complete input-to-output trace.

{{BR}}
=== Advanced ===
# [[English:Imperative to Functional Refactoring|Imperative to Functional Refactoring]]: Take a short loop-based program and refactor it toward a functional style, then compare readability, state changes, and testability.
# [[English:Lazy Evaluation Experiment|Lazy Evaluation Experiment]]: Use a language or environment that supports lazy or generator-style evaluation, observe when values are produced, and document what changes when only part of a sequence is requested.
# [[English:Lambda Calculus Model|Lambda Calculus Model]]: Represent two simple functions as lambda expressions, demonstrate function application step by step, and connect the notation to a real programming-language example.
# [[English:Functional Architecture Project|Functional Architecture Project]]: Design a small application that separates pure domain logic from input and output effects, implement a prototype, and justify where you placed each effectful boundary.

{{:Open Task - Create a MOOC}}

{{BR}}
= Learning Assessment =

# [[English:Reasoning About Purity|Reasoning About Purity]]: Given three short program fragments, classify each as pure or impure and justify your decision using determinism and side effects.
# [[English:Transformation Design|Transformation Design]]: Solve a collection-processing problem with map, filter, and fold, then explain why the chosen order of operations is correct.
# [[English:Recursion Analysis|Recursion Analysis]]: Trace a recursive function, identify its base and recursive cases, and explain whether every valid input moves toward termination.
# [[English:Composition Transfer|Composition Transfer]]: Decompose a new real-world data transformation into small functions and show how they can be composed into a pipeline.
# [[English:Paradigm Comparison|Paradigm Comparison]]: Compare functional and imperative solutions to the same problem using criteria such as state management, testability, readability, and concurrency.
# [[English:Effect Boundary Design|Effect Boundary Design]]: Propose an architecture for a small interactive program and explain which parts should remain pure and which parts must perform side effects.

<br>
<br>

{{BR}}
= Evidence of Learning =

Strong evidence of learning includes both knowledge and practical performance. You should be able to explain the meaning of purity, referential transparency, immutability, first-class functions, higher-order functions, map, filter, fold, recursion, composition, lambda expressions, pattern matching, lazy evaluation, and controlled side effects.

You should also be able to:
# [[English:Code Reading|Code Reading]]: Predict the result of short functional expressions and trace recursive evaluation.
# [[English:Program Construction|Program Construction]]: Write small pure functions and combine them into larger transformations.
# [[English:Program Analysis|Program Analysis]]: Identify hidden state changes, side effects, base cases, predicates, and data-flow stages.
# [[English:Refactoring|Refactoring]]: Transform a suitable imperative solution into a more functional form without changing its intended result.
# [[English:Testing Strategy|Testing Strategy]]: Design tests that take advantage of deterministic pure functions.
# [[English:Transfer|Transfer]]: Recognize functional ideas when they appear in a language that is not primarily functional.
# [[English:Communication|Communication]]: Explain design choices using accurate computer-science vocabulary and clear examples.
# [[English:Product Evidence|Product Evidence]]: Present code, diagrams, traces, reflections, or a working prototype that demonstrates the concepts in context.

<br>
<br>

{{BR}}
= OERs on the Topic =

The English Wikipedia article on functional programming provides a broad open reference that you can use to review terminology, history, language examples, and related concepts.

<iframe> https://en.m.wikipedia.org/wiki/Functional_programming </iframe>

<br>

{{BR}}
= Linked Learning Areas =

{| align=center
{{:D-Tab}}
'''[[English:Functional Programming Concepts|Functional Programming Concepts]]'''
# [[English:Pure function|Pure function]]
# [[English:Referential transparency|Referential transparency]]
# [[English:Immutable object|Immutable object]]
# [[English:Higher-order function|Higher-order function]]
# [[English:Lambda calculus|Lambda calculus]]
# [[English:Recursion|Recursion]]
# [[English:Function composition|Function composition]]
# [[English:Pattern matching|Pattern matching]]
# [[English:Lazy evaluation|Lazy evaluation]]
# [[English:Type system|Type system]]
# [[English:Programming paradigm|Programming paradigm]]
|}

Functional programming connects computer science with mathematical reasoning, software engineering, data processing, concurrency, and the study of programming-language design. It is especially useful for learning how abstraction can reduce complexity and how careful control of state can improve reliability.

[[Category:English]]
[[Category:Computer Science]]
[[Category:Programming]]
[[Category:Software Engineering]]
[[Category:Programming Paradigms]]
[[Category:Grades 11-13]]

{{BR}}
= aiMOOC Projects =
[[Category:English]]
[[Category:Functional Programming Concepts]]
[[Category:Computer Science]]
[[Category:Programming]]
[[Category:Software Engineering]]
[[Category:Grades 11-13]]
[[Category:AI_MOOC]]
[[Category:GPT aiMOOC]]
{{MT}}

English:Functional Programming Concepts - Versionsgeschichte

Glanz: aiMOOC über GPT aiMOOC Action erstellt