Haskell (Programmiersprache) - Versionsgeschichte

Aka: falsches Komma entfernt, Kleinkram

2024-11-18T19:39:05Z

falsches Komma entfernt, Kleinkram

← Nächstältere Version		Version vom 18. November 2024, 21:39 Uhr
Zeile 6:		Zeile 6:
	\| Erscheinungsjahr = [[1990]]		\| Erscheinungsjahr = [[1990]]
	\| Designer =		\| Designer =
	\| Entwickler = [[Simon Peyton Jones]], [[Paul Hudak]],<ref>{{Webarchiv \|url=http://www.cs.yale.edu/homes/hudak-paul/ \|wayback=20110607204813 \|text=Professor Paul Hudak’s Website}} an der Yale University</ref> [[Philip Wadler]], et al.		\| Entwickler = [[Simon Peyton Jones]], [[Paul Hudak]],<ref>{{Webarchiv \|url=http://www.cs.yale.edu/homes/hudak-paul/ \|wayback=20110607204813 \|text=Professor Paul Hudak’s Website}} an der Yale University</ref> [[Philip Wadler]] et al.
	\| AktuelleVorabVersion =		\| AktuelleVorabVersion =
	\| AktuelleVorabVersionFreigabeDatum =		\| AktuelleVorabVersionFreigabeDatum =
Zeile 354:		Zeile 354:
	* [[International Conference on Functional Programming Contest]].		* [[International Conference on Functional Programming Contest]].
	* [[Pugs]] (eine Perl-6-Implementierung in Haskell).		* [[Pugs]] (eine Perl-6-Implementierung in Haskell).
	*DAML, eine [[Smart Contract\|smart contract]] Sprache basierend auf [[Glasgow Haskell Compiler]].		* DAML, eine [[Smart Contract\|smart contract]] Sprache basierend auf [[Glasgow Haskell Compiler]].

	== Literatur ==		== Literatur ==

Agentbla: /* Eigenschaften */ tippfehler

2024-04-14T20:37:06Z

Eigenschaften: tippfehler

← Nächstältere Version		Version vom 14. April 2024, 22:37 Uhr
Zeile 41:		Zeile 41:
	eingabe <- getLine		eingabe <- getLine
	putStr ("Hallo, " ++ eingabe)		putStr ("Hallo, " ++ eingabe)
	putStrLn "! ~~Wilkommen~~"		putStrLn "! Willkommen"
	</syntaxhighlight>Es gibt keine Unterscheidung zwischen Variablen und Konstanten, da der Wert einer Variable in Haskell nicht verändert werden kann. Man spricht von unveränderlichen oder nicht veränderbaren Variablen. Dies ist auch der Grund, weshalb es keine Unterscheidung von Identität und Gleichwertigkeit von Variablen gibt. Durch diese Eigenschaften ist Haskell der Mathematik sehr nahe und es ist möglich, die Richtigkeit gewisser Programme zu beweisen, beispielsweise durch [[Vollständige Induktion]].		</syntaxhighlight>Es gibt keine Unterscheidung zwischen Variablen und Konstanten, da der Wert einer Variable in Haskell nicht verändert werden kann. Man spricht von unveränderlichen oder nicht veränderbaren Variablen. Dies ist auch der Grund, weshalb es keine Unterscheidung von Identität und Gleichwertigkeit von Variablen gibt. Durch diese Eigenschaften ist Haskell der Mathematik sehr nahe und es ist möglich, die Richtigkeit gewisser Programme zu beweisen, beispielsweise durch [[Vollständige Induktion]].

Jonest.Nathan am 2. Februar 2024 um 14:37 Uhr

2024-02-02T14:37:33Z

← Nächstältere Version		Version vom 2. Februar 2024, 16:37 Uhr
Zeile 24:		Zeile 24:
	== Entwicklung ==		== Entwicklung ==
	{{Belege fehlen}}		{{Belege fehlen}}
	Gegen Ende der 1980er Jahre gab es bereits einige funktionale Programmiersprachen. Um der Wissenschaft eine einheitliche Forschungs- und Entwicklungsbasis bereitzustellen, sollte eine standardisierte und moderne Sprache die funktionale Programmierung vereinheitlichen. Zunächst wollte man dazu [[Miranda (Programmiersprache)\|Miranda]] als Ausgangspunkt benutzen, doch deren Entwickler waren ~~daran~~ nicht interessiert. So wurde 1990 Haskell 1.0 veröffentlicht.<ref>{{Literatur \|Autor=Bryan O’Sullivan, John Goerzen, Donald Bruce Stewart \|Titel=Real World Haskell: Code You Can Believe In \|Verlag="O’Reilly Media, Inc." \|Datum=2008 \|ISBN=978-0-596-55430-9 \|Seiten=xxx (Vorwort)}}</ref>		Gegen Ende der 1980er Jahre gab es bereits einige funktionale Programmiersprachen. Um der Wissenschaft eine einheitliche Forschungs- und Entwicklungsbasis bereitzustellen, sollte eine standardisierte und moderne Sprache die funktionale Programmierung vereinheitlichen. Zunächst wollte man dazu [[Miranda (Programmiersprache)\|Miranda]] als Ausgangspunkt benutzen, doch deren Entwickler waren nicht daran interessiert. So wurde 1990 Haskell 1.0 veröffentlicht.<ref>{{Literatur \|Autor=Bryan O’Sullivan, John Goerzen, Donald Bruce Stewart \|Titel=Real World Haskell: Code You Can Believe In \|Verlag="O’Reilly Media, Inc." \|Datum=2008 \|ISBN=978-0-596-55430-9 \|Seiten=xxx (Vorwort)}}</ref>

	Die Sprachderivate von Haskell sind zahlreich; dazu zählen ''Parallel Haskell'', ''Distributed Haskell'' (ehemals Goffin), ''Eager Haskell'', ''[[Eden (Programmiersprache)\|Eden]]'' mit einem neuen Ansatz zum [[Parallele Programmierung\|parallelen Programmieren]] und [[Bedarfsauswertung]], ''DNA-Haskell'' und sogar objektorientierte Varianten (''Haskell++'', ''O’Haskell'', ''Mondrian''). Des Weiteren diente Haskell beim Entwurf neuer Programmiersprachen als Vorlage. So wurde beispielsweise im Falle von [[Python (Programmiersprache)\|Python]] die [[Python (Programmiersprache)#Funktionales Programmieren\|Lambda-Notation]] sowie Listenverarbeitungssyntax übernommen.<ref>{{Internetquelle \|url=https://www.ionos.de/digitalguide/websites/web-entwicklung/was-ist-haskell/ \|titel=Haskell: Die funktionale Programmiersprache im Portrait \|datum=2020-07-28 \|abruf=2022-06-30}}</ref>		Die Sprachderivate von Haskell sind zahlreich; dazu zählen ''Parallel Haskell'', ''Distributed Haskell'' (ehemals Goffin), ''Eager Haskell'', ''[[Eden (Programmiersprache)\|Eden]]'' mit einem neuen Ansatz zum [[Parallele Programmierung\|parallelen Programmieren]] und [[Bedarfsauswertung]], ''DNA-Haskell'' und sogar objektorientierte Varianten (''Haskell++'', ''O’Haskell'', ''Mondrian''). Des Weiteren diente Haskell beim Entwurf neuer Programmiersprachen als Vorlage. So wurde beispielsweise im Falle von [[Python (Programmiersprache)\|Python]] die [[Python (Programmiersprache)#Funktionales Programmieren\|Lambda-Notation]] sowie Listenverarbeitungssyntax übernommen.<ref>{{Internetquelle \|url=https://www.ionos.de/digitalguide/websites/web-entwicklung/was-ist-haskell/ \|titel=Haskell: Die funktionale Programmiersprache im Portrait \|datum=2020-07-28 \|abruf=2022-06-30}}</ref>

AxelKing am 18. Dezember 2023 um 13:15 Uhr

2023-12-18T13:15:52Z

← Nächstältere Version		Version vom 18. Dezember 2023, 15:15 Uhr
Zeile 24:		Zeile 24:
	== Entwicklung ==		== Entwicklung ==
	{{Belege fehlen}}		{{Belege fehlen}}
	Gegen Ende der 1980er Jahre gab es bereits einige funktionale Programmiersprachen. Um der Wissenschaft eine einheitliche Forschungs- und Entwicklungsbasis bereitzustellen, sollte eine standardisierte und moderne Sprache die funktionale Programmierung vereinheitlichen. Zunächst wollte man dazu [[Miranda (Programmiersprache)\|Miranda]] als Ausgangspunkt benutzen; doch deren Entwickler waren daran nicht interessiert. So wurde 1990 Haskell 1.0 veröffentlicht.<ref>{{Literatur \|Autor=Bryan O’Sullivan, John Goerzen, Donald Bruce Stewart \|Titel=Real World Haskell: Code You Can Believe In \|Verlag="O’Reilly Media, Inc." \|Datum=2008 \|ISBN=978-0-596-55430-9 \|Seiten=xxx (Vorwort)}}</ref>		Gegen Ende der 1980er Jahre gab es bereits einige funktionale Programmiersprachen. Um der Wissenschaft eine einheitliche Forschungs- und Entwicklungsbasis bereitzustellen, sollte eine standardisierte und moderne Sprache die funktionale Programmierung vereinheitlichen. Zunächst wollte man dazu [[Miranda (Programmiersprache)\|Miranda]] als Ausgangspunkt benutzen, doch deren Entwickler waren daran nicht interessiert. So wurde 1990 Haskell 1.0 veröffentlicht.<ref>{{Literatur \|Autor=Bryan O’Sullivan, John Goerzen, Donald Bruce Stewart \|Titel=Real World Haskell: Code You Can Believe In \|Verlag="O’Reilly Media, Inc." \|Datum=2008 \|ISBN=978-0-596-55430-9 \|Seiten=xxx (Vorwort)}}</ref>

	Die Sprachderivate von Haskell sind zahlreich; dazu zählen ''Parallel Haskell'', ''Distributed Haskell'' (ehemals Goffin), ''Eager Haskell'', ''[[Eden (Programmiersprache)\|Eden]]'' mit einem neuen Ansatz zum [[Parallele Programmierung\|parallelen Programmieren]] und [[Bedarfsauswertung]], ''DNA-Haskell'' und sogar objektorientierte Varianten (''Haskell++'', ''O’Haskell'', ''Mondrian''). Des Weiteren diente Haskell beim Entwurf neuer Programmiersprachen als Vorlage. So wurde beispielsweise im Falle von [[Python (Programmiersprache)\|Python]] die [[Python (Programmiersprache)#Funktionales Programmieren\|Lambda-Notation]] sowie Listenverarbeitungssyntax übernommen.<ref>{{Internetquelle \|url=https://www.ionos.de/digitalguide/websites/web-entwicklung/was-ist-haskell/ \|titel=Haskell: Die funktionale Programmiersprache im Portrait \|datum=2020-07-28 \|abruf=2022-06-30}}</ref>		Die Sprachderivate von Haskell sind zahlreich; dazu zählen ''Parallel Haskell'', ''Distributed Haskell'' (ehemals Goffin), ''Eager Haskell'', ''[[Eden (Programmiersprache)\|Eden]]'' mit einem neuen Ansatz zum [[Parallele Programmierung\|parallelen Programmieren]] und [[Bedarfsauswertung]], ''DNA-Haskell'' und sogar objektorientierte Varianten (''Haskell++'', ''O’Haskell'', ''Mondrian''). Des Weiteren diente Haskell beim Entwurf neuer Programmiersprachen als Vorlage. So wurde beispielsweise im Falle von [[Python (Programmiersprache)\|Python]] die [[Python (Programmiersprache)#Funktionales Programmieren\|Lambda-Notation]] sowie Listenverarbeitungssyntax übernommen.<ref>{{Internetquelle \|url=https://www.ionos.de/digitalguide/websites/web-entwicklung/was-ist-haskell/ \|titel=Haskell: Die funktionale Programmiersprache im Portrait \|datum=2020-07-28 \|abruf=2022-06-30}}</ref>
Zeile 30:		Zeile 30:
	== Eigenschaften ==		== Eigenschaften ==
	=== Programmfluss ===		=== Programmfluss ===
	Haskell ist eine rein [[funktionale Programmiersprache]]. Funktionen geben nur Werte zurück, ändern aber nicht den Zustand eines Programms (d. h. Funktionen haben keine [[Wirkung (Informatik)\|Nebeneffekte]]). Das Ergebnis einer Funktion hängt deshalb nur von den Eingangsparametern ab, und nicht vom Kontext, in dem die Funktion aufgerufen wird (z. B. Zeitpunkt des Aufrufs). Daraus folgt, dass bei wiederholtem Aufrufen einer Funktion mit denselben Parametern auch jedes Mal dasselbe Ergebnis folgt. Dies können Haskell Implementationen nutzen um Funktionen zu [[Cache\|cachen]].		Haskell ist eine rein [[funktionale Programmiersprache]]. Funktionen geben nur Werte zurück, ändern aber nicht den Zustand eines Programms (d. h. Funktionen haben keine [[Wirkung (Informatik)\|Nebeneffekte]]). Das Ergebnis einer Funktion hängt deshalb nur von den Eingangsparametern ab, und nicht vom Kontext, in dem die Funktion aufgerufen wird (z. B. Zeitpunkt des Aufrufs). Daraus folgt, dass bei wiederholtem Aufrufen einer Funktion mit denselben Parametern auch jedes Mal dasselbe Ergebnis folgt. Dies können Haskell-Implementationen nutzen, um Funktionen zu [[Cache\|cachen]].

	Es gibt keine nativen [[Imperative Programmiersprache\|imperativen Sprachkonstrukte]]. Durch die IO [[Monade (Informatik)\|Monade]] ist es möglich, Ein- und Ausgabeoperationen und zustandsabhängige Berechnungen, wie [[Zufallszahlengenerator]]en, rein funktional zu behandeln. Haskell stellt jedoch die sogenannte do-Notation bereit, welche es erlaubt die Verkettung von Monaden in Stil von imperativen Sprachen darzustellen<syntaxhighlight lang="haskell">		Es gibt keine nativen [[Imperative Programmiersprache\|imperativen Sprachkonstrukte]]. Durch die IO-[[Monade (Informatik)\|Monade]] ist es möglich, Ein- und Ausgabeoperationen und zustandsabhängige Berechnungen, wie [[Zufallszahlengenerator]]en, rein funktional zu behandeln. Haskell stellt jedoch die sogenannte do-Notation bereit, welche es erlaubt, die Verkettung von Monaden in Stil von imperativen Sprachen darzustellen<syntaxhighlight lang="haskell">
	-- Die Definition einer IO aktion, welche einen Namen von der Konsole einliest		-- Die Definition einer IO aktion, welche einen Namen von der Konsole einliest
	-- und dann den String "Hallo <name>! Willkommen" ausgibt		-- und dann den String "Hallo <name>! Willkommen" ausgibt
Zeile 42:		Zeile 42:
	putStr ("Hallo, " ++ eingabe)		putStr ("Hallo, " ++ eingabe)
	putStrLn "! Wilkommen"		putStrLn "! Wilkommen"
	</syntaxhighlight>Es gibt keine Unterscheidung zwischen Variablen und Konstanten, da der Wert einer Variable in ~~haskell~~ nicht verändert werden kann. Man spricht von unveränderlichen oder nicht veränderbaren Variablen. Dies ist auch der Grund, weshalb es keine Unterscheidung von Identität und Gleichwertigkeit von Variablen gibt. Durch diese Eigenschaften ist Haskell der Mathematik sehr nahe und es ist möglich die Richtigkeit gewisser Programme zu ~~Beweisen~~, beispielsweise durch [[Vollständige Induktion]].		</syntaxhighlight>Es gibt keine Unterscheidung zwischen Variablen und Konstanten, da der Wert einer Variable in Haskell nicht verändert werden kann. Man spricht von unveränderlichen oder nicht veränderbaren Variablen. Dies ist auch der Grund, weshalb es keine Unterscheidung von Identität und Gleichwertigkeit von Variablen gibt. Durch diese Eigenschaften ist Haskell der Mathematik sehr nahe und es ist möglich, die Richtigkeit gewisser Programme zu beweisen, beispielsweise durch [[Vollständige Induktion]].

	Haskell ist nicht-strikt. Es werden nur Ausdrücke [[Auswertung (Informatik)\|ausgewertet]], die für die Berechnung des Ergebnisses gebraucht werden.		Haskell ist nicht-strikt. Es werden nur Ausdrücke [[Auswertung (Informatik)\|ausgewertet]], die für die Berechnung des Ergebnisses gebraucht werden.
Zeile 55:		Zeile 55:
	: Die Bedarfsauswertung ist vor allem wegen der strengen Einhaltung des funktionalen Konzepts möglich. Umgekehrt macht die Bedarfsauswertung die funktionale Programmierung angenehmer, denn sie erlaubt es besser, Funktionen, die reine Berechnungen durchführen, von Ein-/Ausgabefunktionen zu trennen.		: Die Bedarfsauswertung ist vor allem wegen der strengen Einhaltung des funktionalen Konzepts möglich. Umgekehrt macht die Bedarfsauswertung die funktionale Programmierung angenehmer, denn sie erlaubt es besser, Funktionen, die reine Berechnungen durchführen, von Ein-/Ausgabefunktionen zu trennen.
	: Die Bedarfsauswertung erlaubt das Arbeiten mit undefinierten Werten und potentiell unendlich großen Datenmengen. So kann man elegant mit Potenzreihen, Zeitreihen (etwa Audiosignalströmen), Kettenbruchzerlegungen, Entscheidungsbäumen und ähnlichem umgehen. Aber auch bei endlichen, aber großen, oder endlichen und noch nicht vollständig bekannten Daten erlaubt diese Art der Ausführung elegante Programme. So kann man etwa eine Transformation eines [[Extensible Markup Language\|XML]]-Dokumentes als Folge von Transformationen des gesamten XML-Baumes beschreiben. Ausgeführt wird die Gesamttransformation aber von Beginn zum Ende des XML-Dokumentes, auch wenn das Ende noch gar nicht verfügbar ist.		: Die Bedarfsauswertung erlaubt das Arbeiten mit undefinierten Werten und potentiell unendlich großen Datenmengen. So kann man elegant mit Potenzreihen, Zeitreihen (etwa Audiosignalströmen), Kettenbruchzerlegungen, Entscheidungsbäumen und ähnlichem umgehen. Aber auch bei endlichen, aber großen, oder endlichen und noch nicht vollständig bekannten Daten erlaubt diese Art der Ausführung elegante Programme. So kann man etwa eine Transformation eines [[Extensible Markup Language\|XML]]-Dokumentes als Folge von Transformationen des gesamten XML-Baumes beschreiben. Ausgeführt wird die Gesamttransformation aber von Beginn zum Ende des XML-Dokumentes, auch wenn das Ende noch gar nicht verfügbar ist.
	: Man beachte allerdings, dass Haskell nach Sprachdefinition lediglich ''nicht-strikt'' ist; die Bedarfsauswertung ist nur eine mögliche Implementierung der Nicht-Striktheit (die allerdings von allen gängigen Haskell-Übersetzern angewandt wird). Andere Implementierungen sind möglich (z. B. ''optimistic evaluation'', Ennals & Peyton Jones, ICFP’03).		: Man beachte allerdings, dass Haskell nach Sprachdefinition lediglich ''nicht-strikt'' ist; die Bedarfsauswertung ist nur eine mögliche Implementierung der Nicht-Striktheit - die allerdings von allen gängigen Haskell-Übersetzern angewandt wird. Andere Implementierungen sind möglich (z. B. ''optimistic evaluation'', Ennals & Peyton Jones, ICFP’03).

	=== Typsystem ===		=== Typsystem ===

195.200.70.42: Im Codeblock im Bereich Programmfluss waren Anführungszeichen falsch gesetzt

2023-12-11T17:46:13Z

Im Codeblock im Bereich Programmfluss waren Anführungszeichen falsch gesetzt

← Nächstältere Version		Version vom 11. Dezember 2023, 19:46 Uhr
Zeile 35:		Zeile 35:
	-- Die Definition einer IO aktion, welche einen Namen von der Konsole einliest		-- Die Definition einer IO aktion, welche einen Namen von der Konsole einliest
	-- und dann den String "Hallo <name>! Willkommen" ausgibt		-- und dann den String "Hallo <name>! Willkommen" ausgibt
	aktion = getLine >>= (\eingabe -> putStr ("Hallo, " ++ eingabe)) >> putStrLn ! "Willkommen"		aktion = getLine >>= (\eingabe -> putStr ("Hallo, " ++ eingabe)) >> putStrLn "! Willkommen"

	-- Eine Identische Definition mit do-Notation		-- Eine Identische Definition mit do-Notation

Thomas Dresler: Komma vor „sondern“, „indem“, „wobei“ etc.

2023-12-09T16:02:43Z

Komma vor „sondern“, „indem“, „wobei“ etc.

← Nächstältere Version		Version vom 9. Dezember 2023, 18:02 Uhr
Zeile 42:		Zeile 42:
	putStr ("Hallo, " ++ eingabe)		putStr ("Hallo, " ++ eingabe)
	putStrLn "! Wilkommen"		putStrLn "! Wilkommen"
	</syntaxhighlight>Es gibt keine Unterscheidung zwischen Variablen und Konstanten, da der Wert einer Variable in haskell nicht verändert werden kann. Man spricht von unveränderlichen oder nicht veränderbaren Variablen. Dies ist auch der Grund weshalb es keine Unterscheidung von Identität und Gleichwertigkeit von Variablen gibt. Durch diese Eigenschaften ist Haskell der Mathematik sehr nahe und es ist möglich die Richtigkeit gewisser Programme zu Beweisen, beispielsweise durch [[Vollständige Induktion]].		</syntaxhighlight>Es gibt keine Unterscheidung zwischen Variablen und Konstanten, da der Wert einer Variable in haskell nicht verändert werden kann. Man spricht von unveränderlichen oder nicht veränderbaren Variablen. Dies ist auch der Grund, weshalb es keine Unterscheidung von Identität und Gleichwertigkeit von Variablen gibt. Durch diese Eigenschaften ist Haskell der Mathematik sehr nahe und es ist möglich die Richtigkeit gewisser Programme zu Beweisen, beispielsweise durch [[Vollständige Induktion]].

	Haskell ist nicht-strikt. Es werden nur Ausdrücke [[Auswertung (Informatik)\|ausgewertet]], die für die Berechnung des Ergebnisses gebraucht werden.		Haskell ist nicht-strikt. Es werden nur Ausdrücke [[Auswertung (Informatik)\|ausgewertet]], die für die Berechnung des Ergebnisses gebraucht werden.

Invisigoth67: typo, form

2023-12-05T11:16:59Z

typo, form

← Nächstältere Version		Version vom 5. Dezember 2023, 13:16 Uhr
Zeile 30:		Zeile 30:
	== Eigenschaften ==		== Eigenschaften ==
	=== Programmfluss ===		=== Programmfluss ===
	Haskell ist eine rein [[funktionale Programmiersprache]]. Funktionen geben nur Werte zurück, ändern aber nicht den Zustand eines Programms (d. h. Funktionen haben keine [[Wirkung (Informatik)\|Nebeneffekte]]). Das Ergebnis einer Funktion hängt deshalb nur von den Eingangsparametern ab, und nicht vom Kontext in dem die Funktion aufgerufen wird (z. B. Zeitpunkt des Aufrufs). Daraus folgt, dass bei wiederholtem Aufrufen einer ~~Funktionen~~ mit denselben Parametern auch jedes ~~mal~~ dasselbe Ergebnis folgt. Dies können Haskell Implementationen nutzen um Funktionen zu [[Cache\|cachen]].		Haskell ist eine rein [[funktionale Programmiersprache]]. Funktionen geben nur Werte zurück, ändern aber nicht den Zustand eines Programms (d. h. Funktionen haben keine [[Wirkung (Informatik)\|Nebeneffekte]]). Das Ergebnis einer Funktion hängt deshalb nur von den Eingangsparametern ab, und nicht vom Kontext, in dem die Funktion aufgerufen wird (z. B. Zeitpunkt des Aufrufs). Daraus folgt, dass bei wiederholtem Aufrufen einer Funktion mit denselben Parametern auch jedes Mal dasselbe Ergebnis folgt. Dies können Haskell Implementationen nutzen um Funktionen zu [[Cache\|cachen]].

	Es gibt keine nativen [[Imperative Programmiersprache\|imperativen Sprachkonstrukte]]. Durch die IO [[Monade (Informatik)\|Monade]] ist es möglich, Ein- und Ausgabeoperationen und zustandsabhängige Berechnungen, wie [[Zufallszahlengenerator~~\|Zufallszahlengeneratoren~~]], rein funktional zu behandeln. Haskell stellt jedoch die sogenannte do-Notation bereit, welche es erlaubt die Verkettung von Monaden in Stil von imperativen Sprachen darzustellen<syntaxhighlight lang="haskell">		Es gibt keine nativen [[Imperative Programmiersprache\|imperativen Sprachkonstrukte]]. Durch die IO [[Monade (Informatik)\|Monade]] ist es möglich, Ein- und Ausgabeoperationen und zustandsabhängige Berechnungen, wie [[Zufallszahlengenerator]]en, rein funktional zu behandeln. Haskell stellt jedoch die sogenannte do-Notation bereit, welche es erlaubt die Verkettung von Monaden in Stil von imperativen Sprachen darzustellen<syntaxhighlight lang="haskell">
	-- Die Definition einer IO aktion, welche einen Namen von der Konsole einliest		-- Die Definition einer IO aktion, welche einen Namen von der Konsole einliest
	-- und dann den String "Hallo <name>! Willkommen" ausgibt		-- und dann den String "Hallo <name>! Willkommen" ausgibt

Jade.128: Ergänzende Informationen sowie umformulierungen der Eigenschaften Haskells

2023-12-04T18:32:09Z

Ergänzende Informationen sowie umformulierungen der Eigenschaften Haskells

@@ Zeile 30: / Zeile 30: @@
 == Eigenschaften ==
 === Programmfluss ===
-* Haskell ist eine rein [[funktionale Programmiersprache]]. Funktionen geben nur Werte zurück, ändern aber nicht den Zustand eines Programms (d.&nbsp;h. Funktionen haben keine [[Wirkung (Informatik)|Nebeneffekte]]). Das Ergebnis einer Funktion hängt deshalb nur von den Eingangsparametern ab, und nicht davon, wann oder wie oft die Funktion aufgerufen wird.
+Haskell ist eine rein [[funktionale Programmiersprache]]. Funktionen geben nur Werte zurück, ändern aber nicht den Zustand eines Programms (d. h. Funktionen haben keine [[Wirkung (Informatik)|Nebeneffekte]]). Das Ergebnis einer Funktion hängt deshalb nur von den Eingangsparametern ab, und nicht vom Kontext in dem die Funktion aufgerufen wird (z. B. Zeitpunkt des Aufrufs). Daraus folgt, dass bei wiederholtem Aufrufen einer Funktionen mit denselben Parametern auch jedes mal dasselbe Ergebnis folgt. Dies können Haskell Implementationen nutzen um Funktionen zu [[Cache|cachen]].
-* Es gibt keine [[Imperative Programmiersprache|imperativen Sprachkonstrukte]]. Durch [[Monade (Informatik)|Monaden]] ist es möglich, Ein- und Ausgabeoperationen und zustandsabhängige Berechnungen wie Zufallsgeneratoren rein funktional zu behandeln.
+Es gibt keine nativen [[Imperative Programmiersprache|imperativen Sprachkonstrukte]]. Durch die IO [[Monade (Informatik)|Monade]] ist es möglich, Ein- und Ausgabeoperationen und zustandsabhängige Berechnungen, wie [[Zufallszahlengenerator|Zufallszahlengeneratoren]], rein funktional zu behandeln. Haskell stellt jedoch die sogenannte do-Notation bereit, welche es erlaubt die Verkettung von Monaden in Stil von imperativen Sprachen darzustellen<syntaxhighlight lang="haskell">
 <syntaxhighlight lang="haskell">
         first x y = x

Thomas Dresler: Tippfehler korrigiert

2023-08-16T22:16:59Z

Tippfehler korrigiert

← Nächstältere Version		Version vom 17. August 2023, 00:16 Uhr
Zeile 24:		Zeile 24:
	== Entwicklung ==		== Entwicklung ==
	{{Belege fehlen}}		{{Belege fehlen}}
	Gegen Ende der 1980er Jahre gab es bereits einige funktionale Programmiersprachen. Um der Wissenschaft eine einheitliche Forschungs- und Entwicklungsbasis bereitzustellen, sollte eine standardisierte und moderne Sprache die funktionale Programmierung vereinheitlichen. Zunächst wollte man dazu [[Miranda (Programmiersprache)\|Miranda]] als Ausgangspunkt benutzen; doch deren Entwickler waren daran nicht interessiert. So wurde 1990 Haskell 1.0 veröffentlicht.<ref>{{Literatur \|Autor=Bryan ~~O'Sullivan~~, John Goerzen, Donald Bruce Stewart \|Titel=Real World Haskell: Code You Can Believe In \|Verlag="~~O'Reilly~~ Media, Inc." \|Datum=2008 \|ISBN=978-0-596-55430-9 \|Seiten=xxx (Vorwort)}}</ref>		Gegen Ende der 1980er Jahre gab es bereits einige funktionale Programmiersprachen. Um der Wissenschaft eine einheitliche Forschungs- und Entwicklungsbasis bereitzustellen, sollte eine standardisierte und moderne Sprache die funktionale Programmierung vereinheitlichen. Zunächst wollte man dazu [[Miranda (Programmiersprache)\|Miranda]] als Ausgangspunkt benutzen; doch deren Entwickler waren daran nicht interessiert. So wurde 1990 Haskell 1.0 veröffentlicht.<ref>{{Literatur \|Autor=Bryan O’Sullivan, John Goerzen, Donald Bruce Stewart \|Titel=Real World Haskell: Code You Can Believe In \|Verlag="O’Reilly Media, Inc." \|Datum=2008 \|ISBN=978-0-596-55430-9 \|Seiten=xxx (Vorwort)}}</ref>

	Die Sprachderivate von Haskell sind zahlreich; dazu zählen ''Parallel Haskell'', ''Distributed Haskell'' (ehemals Goffin), ''Eager Haskell'', ''[[Eden (Programmiersprache)\|Eden]]'' mit einem neuen Ansatz zum [[Parallele Programmierung\|parallelen Programmieren]] und [[Bedarfsauswertung]], ''DNA-Haskell'' und sogar objektorientierte Varianten (''Haskell++'', ''O’Haskell'', ''Mondrian''). Des Weiteren diente Haskell beim Entwurf neuer Programmiersprachen als Vorlage. So wurde beispielsweise im Falle von [[Python (Programmiersprache)\|Python]] die [[Python (Programmiersprache)#Funktionales Programmieren\|Lambda-Notation]] sowie Listenverarbeitungssyntax übernommen.<ref>{{Internetquelle \|url=https://www.ionos.de/digitalguide/websites/web-entwicklung/was-ist-haskell/ \|titel=Haskell: Die funktionale Programmiersprache im Portrait \|datum=2020-07-28 \|abruf=2022-06-30}}</ref>		Die Sprachderivate von Haskell sind zahlreich; dazu zählen ''Parallel Haskell'', ''Distributed Haskell'' (ehemals Goffin), ''Eager Haskell'', ''[[Eden (Programmiersprache)\|Eden]]'' mit einem neuen Ansatz zum [[Parallele Programmierung\|parallelen Programmieren]] und [[Bedarfsauswertung]], ''DNA-Haskell'' und sogar objektorientierte Varianten (''Haskell++'', ''O’Haskell'', ''Mondrian''). Des Weiteren diente Haskell beim Entwurf neuer Programmiersprachen als Vorlage. So wurde beispielsweise im Falle von [[Python (Programmiersprache)\|Python]] die [[Python (Programmiersprache)#Funktionales Programmieren\|Lambda-Notation]] sowie Listenverarbeitungssyntax übernommen.<ref>{{Internetquelle \|url=https://www.ionos.de/digitalguide/websites/web-entwicklung/was-ist-haskell/ \|titel=Haskell: Die funktionale Programmiersprache im Portrait \|datum=2020-07-28 \|abruf=2022-06-30}}</ref>
Zeile 49:		Zeile 49:

	=== Typsystem ===		=== Typsystem ===
	* Haskell ist [[Starke Typisierung\|stark typisiert]].<ref>{{Literatur \|Autor=Jens Ohlig, Hannes Mehnert, Stefanie Schirmer \|Titel=Das Curry-Buch: Funktional programmieren lernen mit JavaScript \|Verlag=~~O'Reilly~~ Germany \|Datum=2013 \|ISBN=978-3-86899-370-7 \|Seiten=144}}</ref> Es wird also zum Beispiel streng zwischen [[Wahrheitswert]]en, [[Char (Datentyp)\|Zeichen]], [[Ganze Zahl\|ganzen Zahlen]], [[Gleitkommazahl]]en und [[Funktion (Programmierung)\|Funktionen]] von und zu verschiedenen Typen unterschieden.		* Haskell ist [[Starke Typisierung\|stark typisiert]].<ref>{{Literatur \|Autor=Jens Ohlig, Hannes Mehnert, Stefanie Schirmer \|Titel=Das Curry-Buch: Funktional programmieren lernen mit JavaScript \|Verlag=O’Reilly Germany \|Datum=2013 \|ISBN=978-3-86899-370-7 \|Seiten=144}}</ref> Es wird also zum Beispiel streng zwischen [[Wahrheitswert]]en, [[Char (Datentyp)\|Zeichen]], [[Ganze Zahl\|ganzen Zahlen]], [[Gleitkommazahl]]en und [[Funktion (Programmierung)\|Funktionen]] von und zu verschiedenen Typen unterschieden.

	* Haskell erlaubt Typvariablen. Damit können Funktionen sehr allgemein formuliert werden. Wird eine allgemeingehaltene Funktion für bestimmte Typen verwendet, werden automatisch die Typen abgeglichen ([[Typinferenz]]).		* Haskell erlaubt Typvariablen. Damit können Funktionen sehr allgemein formuliert werden. Wird eine allgemeingehaltene Funktion für bestimmte Typen verwendet, werden automatisch die Typen abgeglichen ([[Typinferenz]]).

37.49.35.245 am 14. August 2023 um 20:57 Uhr

2023-08-14T20:57:42Z

← Nächstältere Version		Version vom 14. August 2023, 22:57 Uhr
Zeile 340:		Zeile 340:

	== Einfluss ==		== Einfluss ==
	Haskell dient wegen seiner stark akademischen Herkunft vielen Programmier- und Scriptsprachen als Vorbild für neue Sprachfunktionalität. So haben u. a. [[Perl (Programmiersprache)\|Perl]], [[Python (Programmiersprache)\|Python]], [[JavaScript]], [[Java (Programmiersprache)\|Java]], [[Scala (Programmiersprache)\|Scala]] und [[PHP]] Ideen der funktionalen Programmierung von Haskell übernommen. Dazu gehören Funktionen höherer Ordnung wie map, filter usw., Teile der Art, wie generische Programmierung implementiert wurde, und anderes.		Haskell dient wegen seiner stark akademischen Herkunft vielen Programmier- und Scriptsprachen als Vorbild für neue Sprachfunktionalität. So haben u. a. [[Perl (Programmiersprache)\|Perl]], [[Python (Programmiersprache)\|Python]], [[JavaScript]], [[Java (Programmiersprache)\|Java]], [[Scala (Programmiersprache)\|Scala]], [[Rust (Programmiersprache)\|Rust]] und [[PHP]] Ideen der funktionalen Programmierung von Haskell übernommen. Dazu gehören Funktionen höherer Ordnung wie map, filter usw., Teile der Art, wie generische Programmierung implementiert wurde, und anderes.

	== Siehe auch ==		== Siehe auch ==