<?xml version="1.0" encoding="UTF-8"?>
<!-- generator="FeedCreator 1.8" -->
<?xml-stylesheet href="http://update.proggen.org/lib/exe/css.php?s=feed" type="text/css"?>
<rdf:RDF
    xmlns="http://purl.org/rss/1.0/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
    xmlns:dc="http://purl.org/dc/elements/1.1/">
    <channel rdf:about="http://update.proggen.org/feed.php">
        <title>proggen.org haskell</title>
        <description></description>
        <link>http://update.proggen.org/</link>
        <image rdf:resource="http://update.proggen.org/lib/tpl/proggenY/images/favicon.ico" />
       <dc:date>2026-04-19T13:01:01+0200</dc:date>
        <items>
            <rdf:Seq>
                <rdf:li rdf:resource="http://update.proggen.org/doku.php?id=haskell:higher_functions&amp;rev=1663868366"/>
                <rdf:li rdf:resource="http://update.proggen.org/doku.php?id=haskell:list&amp;rev=1663868366"/>
                <rdf:li rdf:resource="http://update.proggen.org/doku.php?id=haskell:logical&amp;rev=1663868366"/>
                <rdf:li rdf:resource="http://update.proggen.org/doku.php?id=haskell:pure_function&amp;rev=1663868366"/>
                <rdf:li rdf:resource="http://update.proggen.org/doku.php?id=haskell:recursion&amp;rev=1663868366"/>
                <rdf:li rdf:resource="http://update.proggen.org/doku.php?id=haskell:regulations&amp;rev=1663868366"/>
                <rdf:li rdf:resource="http://update.proggen.org/doku.php?id=haskell:setup&amp;rev=1663868366"/>
                <rdf:li rdf:resource="http://update.proggen.org/doku.php?id=haskell:start&amp;rev=1663868366"/>
                <rdf:li rdf:resource="http://update.proggen.org/doku.php?id=haskell:test&amp;rev=1663868366"/>
                <rdf:li rdf:resource="http://update.proggen.org/doku.php?id=haskell:tupel&amp;rev=1663868366"/>
                <rdf:li rdf:resource="http://update.proggen.org/doku.php?id=haskell:type&amp;rev=1663868366"/>
                <rdf:li rdf:resource="http://update.proggen.org/doku.php?id=haskell:why&amp;rev=1663868366"/>
            </rdf:Seq>
        </items>
    </channel>
    <image rdf:about="http://update.proggen.org/lib/tpl/proggenY/images/favicon.ico">
        <title>proggen.org</title>
        <link>http://update.proggen.org/</link>
        <url>http://update.proggen.org/lib/tpl/proggenY/images/favicon.ico</url>
    </image>
    <item rdf:about="http://update.proggen.org/doku.php?id=haskell:higher_functions&amp;rev=1663868366">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:39:26+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>haskell:higher_functions</title>
        <link>http://update.proggen.org/doku.php?id=haskell:higher_functions&amp;rev=1663868366</link>
        <description>Funktionen höherer Ordnung

Eine Funktion höherer Ordnung ist eine Funktion, die eine Funktion als Parameter erhält oder als Ergebnis liefern. Mit Funktionen höherer Ordnung kann es im Programm entschieden werden, welche Funktion auf bestimmte Werte ausgeführt werden. So kann es möglich sein, in Abhängigkeit von Werten andere Anweisungen anzuwenden.</description>
    </item>
    <item rdf:about="http://update.proggen.org/doku.php?id=haskell:list&amp;rev=1663868366">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:39:26+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>haskell:list</title>
        <link>http://update.proggen.org/doku.php?id=haskell:list&amp;rev=1663868366</link>
        <description>Listen

Listen sind in Haskell ein wichtiger Bestandteil der Sprache. Zum einen können quasi beliebig viele Werte gespeichert werden (bis der Speicher des Computers voll ist), allerdings ermöglicht die List Comprehension eine Art mathematische Definition von Listen. Des Weiteren sind auch unendliche Listen möglich, die nur bis zu einem bestimmten Punkt berechnet werden (siehe Lazy Evaluation).</description>
    </item>
    <item rdf:about="http://update.proggen.org/doku.php?id=haskell:logical&amp;rev=1663868366">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:39:26+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>haskell:logical</title>
        <link>http://update.proggen.org/doku.php?id=haskell:logical&amp;rev=1663868366</link>
        <description>Logische Ausdrücke

In Haskell gibt es auch logische Operatoren und Ausdrücke deren Ergebnis ein Wahrheitswert ist. Zum einen kann eine Funktion einen Bool-Wert zurückgeben, zum anderen können mit Bool-Werten Vergleiche angestellt werden. 

Bool zurückgeben</description>
    </item>
    <item rdf:about="http://update.proggen.org/doku.php?id=haskell:pure_function&amp;rev=1663868366">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:39:26+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>haskell:pure_function</title>
        <link>http://update.proggen.org/doku.php?id=haskell:pure_function&amp;rev=1663868366</link>
        <description>Pure Funktionen in Haskell definieren

Eine pure Funktion ist eine Funktion, die keine Ausgabe tätigt, dh. eine Funktion, die lediglich Berechnungen ausführt und das Ergebnis der Berechnung zurückliefert. Haskell macht eine deutliche Unterscheidung zwischen puren Funktionen und nicht-puren Funktionen (dazu mehr unter</description>
    </item>
    <item rdf:about="http://update.proggen.org/doku.php?id=haskell:recursion&amp;rev=1663868366">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:39:26+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>haskell:recursion</title>
        <link>http://update.proggen.org/doku.php?id=haskell:recursion&amp;rev=1663868366</link>
        <description>Rekursion

Bisher haben wir uns nicht darum gekümmert, wie man Anweisungen wiederholt ausführen kann, also wie man Schleifen verwendet. Der Trick ist: es gibt keine Schleifen in Haskell. Wenn Sie Code mehrfach ausführen wollen oder müssen, dann verwenden Sie Rekursion.</description>
    </item>
    <item rdf:about="http://update.proggen.org/doku.php?id=haskell:regulations&amp;rev=1663868366">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:39:26+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>haskell:regulations</title>
        <link>http://update.proggen.org/doku.php?id=haskell:regulations&amp;rev=1663868366</link>
        <description>Festlegungen / Wichtige Informationen

Bevor wir uns aufmachen können und Haskell lernen, gibt es einige Informationen, die man als Haskell-Programmierer im Hinterkopf halten sollte.

Kommentare

Kommentare sollen den Quellcode erklären und helfen ihn auch in einem halben Jahr wieder zu verstehen. Bei Haskell ist es, wenn man C gewohnt ist, schwieriger später lesbaren Quellcode zu schreiben. Die Denkweise, die man in Haskell braucht unterscheidet sich einfach zu sehr von der C-Denkweise. Daher i…</description>
    </item>
    <item rdf:about="http://update.proggen.org/doku.php?id=haskell:setup&amp;rev=1663868366">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:39:26+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>haskell:setup</title>
        <link>http://update.proggen.org/doku.php?id=haskell:setup&amp;rev=1663868366</link>
        <description>Haskell: Compiler einrichten

Es gibt verschiedene Compiler bzw. Interpreter für die Programmiersprache Haskell. Bekanntere Compiler sind:

	*  Hugs
	*  Ghc (Glasgow Haskell Compiler)

Für eine vollständigere Liste siehe [1]. In diesem Tutorial wird Ghc verwendet, daher hier nur dessen Einrichtung.</description>
    </item>
    <item rdf:about="http://update.proggen.org/doku.php?id=haskell:start&amp;rev=1663868366">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:39:26+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>haskell:start</title>
        <link>http://update.proggen.org/doku.php?id=haskell:start&amp;rev=1663868366</link>
        <description>Haskell-Tutorial

Haskell ist eine funktionale Programmiersprache.

Inhalt

Vorspann

	*  Warum Haskell / Warum überhaupt funktionale Programmiersprachen?
	*  Einrichtung
	*  Einrichtung testen

Grundlagen

	*  Einige Festlegungen
	*  pure Funktionen definieren
	*  Logische Ausdrücke / Boolean verwenden
	*  Datentypen
	*  Tupeltypen
	*  Listen
	*  Schleifen / Rekursion
	*  Funktionen höherer Ordnung</description>
    </item>
    <item rdf:about="http://update.proggen.org/doku.php?id=haskell:test&amp;rev=1663868366">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:39:26+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>haskell:test</title>
        <link>http://update.proggen.org/doku.php?id=haskell:test&amp;rev=1663868366</link>
        <description>Compiler testen

Als erstes Programm in einer imperativen Programmiersprache lernt man das „Hello World“-Programm. Das wäre in Haskell auch möglich, aber nicht ohne auf einen Großteil der Sprachelemente einzugehen. Deshalb hier ein anderes Beispielprogramm.</description>
    </item>
    <item rdf:about="http://update.proggen.org/doku.php?id=haskell:tupel&amp;rev=1663868366">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:39:26+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>haskell:tupel</title>
        <link>http://update.proggen.org/doku.php?id=haskell:tupel&amp;rev=1663868366</link>
        <description>Tupeltypen

In Haskell besteht die Möglichkeit Funktionen Tupel zu übergeben oder Tupel zurückliefern zu lassen. Die Angabe der Datentypen erfolgt dann in Klammern (die einzelnen Typen durch Komma getrennt), damit Haskell weiß, dass diese Werte als Tupel übergeben werden sollen:</description>
    </item>
    <item rdf:about="http://update.proggen.org/doku.php?id=haskell:type&amp;rev=1663868366">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:39:26+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>haskell:type</title>
        <link>http://update.proggen.org/doku.php?id=haskell:type&amp;rev=1663868366</link>
        <description>Datentypen

In Haskell bezeichnet der Datentyp einer Variablen, den Wertebereich dieser Variablen. Es gibt folgende einfache Datentypen:

	*  Int
	*  Integer
	*  Float
	*  Double
	*  Bool
	*  Char

Datentypen beginnen immer mit Großbuchstaben, anders als Variablennamen, die immer mit Kleinbuchstaben beginnen.</description>
    </item>
    <item rdf:about="http://update.proggen.org/doku.php?id=haskell:why&amp;rev=1663868366">
        <dc:format>text/html</dc:format>
        <dc:date>2022-09-22T19:39:26+0200</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>haskell:why</title>
        <link>http://update.proggen.org/doku.php?id=haskell:why&amp;rev=1663868366</link>
        <description>Warum funktional programmieren?

:?:

Programmieranfänger beginnen meistens mit einer imperativen Programmiersprache, dh. einer Programmiersprache, deren Konzept auf Variablen beruht, die im Programmlauf verändert werden - also darauf beruht, dass das Programm einen impliziten Zustand hat (angegeben durch den Instruction Pointer und den Zustand der Speicherzellen) und der Veränderung des Zustands. Daraus ergibt sich, dass, wenn man zwei Funktionen mit gleichen Parametern ruft, nicht immer die gl…</description>
    </item>
</rdf:RDF>
