Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Einstieg in Haskell

Werbeanzeige

Glocke

Treue Seele

  • »Glocke« ist der Autor dieses Themas

Beiträge: 341

  • Private Nachricht senden

1

03.02.2017, 14:13

Einstieg in Haskell

Hi, im Zuge meiner Arbeit fuchse ich mich gerade in Haskell ein. Habt ihr Erfahrungen mit Haskell? Mich würde euer Feedback zum Ansatz/Stil eines kleinen Haskell-Programms interessieren! :) ... um herauszufinden, ob ich mit meiner Denkweise tatsächlich richtig bin.

Grundgedanke ist eine Funktion zum Splitten einer Zeichenketten mit Hilfe eines Tokens, sodass eine Liste von Substrings geliefert wird.

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

-- search token using counter to return index (recursive helper)
find_rec list token count
    | null list            = 0
    | (head list) == token = count
    | otherwise            = find_rec (tail list) token (count + 1)

-- search token to return index
find list token = find_rec list token 1

-- copy first n elements of a list
copyUntil (x:xs) index
    | index <= 0 = []
    | otherwise  = [x] ++ copyUntil xs (index - 1)

-- copy last n elements of a list
copyAfter list index
    | null list  = []
    | index == 1 = list
    | otherwise  = copyAfter (tail list) (index - 1)

-- split list by token to list of sublists
split list token
    | null list = []
    | index == 0  = [list]
    | otherwise   = [first] ++ split (rest) token
    where
        first = copyUntil list (index - 1)
        rest  = copyAfter list (index + 1)
        index = find list token


Rein vom Funktionieren her läuft das schonmal:

Quellcode

 
1
2
3
4

*Main> split "hallo grausame welt" ' '
["hallo","grausame","welt"]
*Main> split [7, 1, 4, 2, 6, 2, 3, 1, 2, 3, 2] 2
[[7,1,4],[6],[3,1],[3]]


Feedback ist willkommen :)

LG

Dieser Beitrag wurde bereits 4 mal editiert, zuletzt von »Glocke« (03.02.2017, 14:29)

QuickAndDirty

Frischling

Beiträge: 45

  • Private Nachricht senden

2

03.02.2017, 21:27

Ich bin ehrlich gesagt ein riesen Haskell-Fan, weil ich die Sprache als extrem "schön" (ich weiß nicht wie ich es sonst nennen soll) empfinde.
Trotzdem habe ich meist Probleme komplexere Programme in Haskell zu schreiben und man findet auch nicht wirklich viele "Real-World"-Projekte die
in Haskell entwickelt wurden.
Wenn man es gewohnt ist in imperativen Sprache zu entwickeln ist es irgendwie extrem schwierig um zu denken (zu Gleich aber auch lohnenswert, um
mal über den Tellerrand zu schauen). Ich hoffe dass solche Pure Functional Sprachen in Zukunft ihre Niche finden werden, in der sie brillieren.

Elm ist zum Beispiel schonmal ein guter/interessanter Ansatz.

Was mich interessieren würd, was genau Arbeitest du den mit Haskell ? Also um was geht es in dem Projekt und warum verwendet ihr gerade Haskell ?

Viele Grüße !

Glocke

Treue Seele

  • »Glocke« ist der Autor dieses Themas

Beiträge: 341

  • Private Nachricht senden

3

04.02.2017, 16:23

Zitat von »QuickAndDirty«

Was mich interessieren würd, was genau Arbeitest du den mit Haskell ? Also um was geht es in dem Projekt und warum verwendet ihr gerade Haskell ?


Es geht um den Kontext der informatischen Schulbildung ;)

QuickAndDirty

Frischling

Beiträge: 45

  • Private Nachricht senden

4

05.02.2017, 22:51

Schade wieder keine Real-World Projekt. An Unis nimmt man auch Haskell gern als erste Sprache (wieso auch immer ...).

Bei Schülern ... ist das nicht etwas zu abstrakt ? Gut wenn man nur Funktionen macht und gar nicht erst über Monads oder
den Functor redet könnte es sogar verständlicher sein als andere imperative Sprachen :P

Glocke

Treue Seele

  • »Glocke« ist der Autor dieses Themas

Beiträge: 341

  • Private Nachricht senden

5

06.02.2017, 08:00

Zitat von »QuickAndDirty«

Bei Schülern ... ist das nicht etwas zu abstrakt ? Gut wenn man nur Funktionen macht und gar nicht erst über Monads oder
den Functor redet könnte es sogar verständlicher sein als andere imperative Sprachen :P


Insbesondere wenn die Schüler "noch nichts anderes kennen", ist die Art und Weise - Dinge zu beschreiben - eher an deren Vorstellungswelt dran. Abschnittsweise Funktionen gibt's ja auch in der Schule :)
Genau, es muss ja nicht alles thematisiert werden. Ziel ist weniger eine Sprache "zu lernen" sondern die Konzepte dahinter. Das wird bei prozeduraler Programmierung ja auch getan. Btw werden da ja auch nicht alle Konzepte durchgekaut (z.B. Exceptions oder Optimierung von Anweisungsfolgen).

Zitat von »QuickAndDirty«

Schade wieder keine Real-World Projekt.

Je nach Freizeit würde ich das schonmal probieren ;-)

Harry222

Alter Hase

Beiträge: 864

Beruf: Student

  • Private Nachricht senden

6

01.03.2017, 00:29

Da du ja nach Tipps zum Ansatz und Stil gefragt hast hier einfach mal Dasselbse in meinem Stil:

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

import Data.Maybe

find :: Eq a => [a] -> a -> Maybe Int
find [] _ = Nothing
find (x:xs) tkn
    | x == tkn = Just 0
    | isNothing idx = Nothing
    | otherwise = Just ((fromJust idx) + 1)
    where
        idx = find xs tkn

splitAt' :: [a] -> Int -> ([a],[a])
splitAt' l 0 = ([], l)
splitAt' [] _ = ([], [])
splitAt' (x:xs) idx = (x:x', xs')
    where
        (x', xs') = splitAt' xs (idx - 1)

split :: Eq a => [a] -> a -> [[a]]
split [] _ = []
split l tkn
    | isNothing idx = [l]
    | otherwise     = [x] ++ (split xs tkn)
    where
        idx = find l tkn
        (x, _:xs) = splitAt' l (fromJust idx)


Die wichtigsen Änderungen:
  • type declarations für die Funktionen
  • Statt copyUntil und copyAfter einfach ein splitAt-Funktion. Bei deinem Ansatz merkt man dass besser gehen muss daran, dass du eine spezialisierte Funktion für das letzte Element benötigst, was i.d.R. nicht nötig sein sollte und nebenbei auch Algorithmisch nie allzu schön ist.
  • Bei copyUntil hast du ein pattern matching angewendet, dass eine nicht-leere Liste verlangt. Eine einfache Möglichkeit, diesen Fall abzufangen, ist pattern matching. (siehe bspw. Z. 13,14)
  • Da haskell nullbasierte Indizes verwendet, ist ein index 0 eine gültige Rückgabe von find. Eine Alternative wäre (length l) + 1 oder -1 zurückzugeben. Schöner ist es direkt Maybe zu verwenden, da ein Maybe entweder ein Nothing oder aber ein Just <value> sein kann. find l tkn ist genau dann Nothing, wenn das Token nicht gefunden wurde.

LG

Schorsch

Supermoderator

Beiträge: 5 145

Wohnort: Wickede

Beruf: Softwareentwickler

  • Private Nachricht senden

7

01.03.2017, 15:04

Real World Haskell Projekte gibt es schon. Du kannst ja mal nach Haskell Game googlen. Hier mal ein Beispiel von einem Spiel welches auch hier im Forum vorgestellt wurde. Hier ist der Thread dazu.
„Es ist doch so. Zwei und zwei macht irgendwas, und vier und vier macht irgendwas. Leider nicht dasselbe, dann wär's leicht.
Das ist aber auch schon höhere Mathematik.“

Werbeanzeige

Ähnliche Themen