Gibt es hier Haskell user?

[daniel (Gast)]

Wie bin jetzt etwas weiter in Haskell.
Ich denke jetzt darüber nach, wie ich die bekannten Konzepte
nach Haskell rüberbringe. Auffällig ist, dass Python viel
von Haskell ausgeliehen hat.

Vergleiche ...

import Data.Char
import Data.Char as DC

import sys
import sys as system

oder auch die list comprehensions, tupel

[(i,j) for i in range(10) for j in range(10) if i+j % 2 == 0]
[(i,j) | i<-[0..9], j<-[0..9], mod i+j 2 == 0]

ähnlich ist die Situation beim funktionaltypischen
filter, map, all, any, ...

mir fällt das Haskell'sche Pendant zum Python'ischem Ausdruck
filter(lambda x: type(x) in [int,float], [1,2.0,"3"])

how can i do it?

ich bin mir gar nicht sicher ob heterogene Listen in Haskell
möglich sind. Immerhin sind die Prototypen meist als [a]
angebenen. Teilweise mit Einschränkung auf TypeClass
(in meinen Augen eine Sicherstellung eines Interfaces)

add::(Num a)=>a->a->a
add x y = x + y

Wäre cool etwas Hilfe zu bekommen^^

Grüsse, daniel

[Thomas Prescher (Gast)]

ich glaube das was du suchst sind Klassen und Sorten (Kinds)

[Thomas Prescher (Gast)]

sorry noch vergessen. ich bin sehr schlecht in python, kannst du mir 
sagen, was der Ausdruck

filter(lambda x: type(x) in [int,float], [1,2.0,"3"])

genau tut?

[daniel (Gast)]

type(x) liefert den Typ zu einem Ausdruck
für die gebräuchlichsten Typen kommt dann:
int .. integer
long .. integers beliebiger länge
float .. floating point
str .. strings (char ist string mit lange 1)

in ist ein operator der True oder False zurückgibt, je nachdem
ob x in einer Sequenz ist
1 in [1,2,3] => True
"hello" in "hello world" => True

insgesamt werden aus der heterogenen liste alle elemente herausgefischt,
die "Zahlen" sind, also int,float (long hab ich jetzt nicht drin)

soweit ich jetzt Haskell verstehe, gibt es keine heterogenen listen
vielleicht ist übliche weg dafür tupeln zu benutzen?

grüsse & gute nacht

[daniel (Gast)]

achso lambda ist unbenannte funktion

lambda x: x==1
(\x->x==1)

[Thomas Prescher (Gast)]

Okay, ich weiss jetzt zwar nicht genau, ob das dass ist was du suchst 
aber eine Heterogene Liste haette ich auf die schnelle so geloest:

data HList el = EL | Itemi Int (HList el) | Itemf Float (HList el)


onlyInt::HList el->[Int]
onlyInt EL = []
onlyInt (Itemi e hlist) = [e] ++ onlyInt hlist
onlyInt (Itemf _ hlist) = onlyInt hlist

Der Aufruf

onlyInt (Itemi 1 (Itemf 2.3 (Itemf 4.7 (Itemi 6 EL))))

liefert dann nur die Intwerte der HList

[1,6]

[Thomas Prescher (Gast)]

noch besser sollte es sogar so sein:

data HList el = EL | Item ElemType (HList el)

data ElemType = MyInt Int | MyFloat Float | MyChar Char

onlyInt::HList el->[Int]
onlyInt EL = []
onlyInt (Item (MyInt e) hlist) = [e] ++ onlyInt hlist
onlyInt (Item _ hlist) = onlyInt hlist

Somit brauch man nicht jeden Typ einzeln abfangen.
Aufruf sieht z.B. so aus:

Main> onlyInt (Item (MyInt 5) (Item (MyInt 7) (Item (MyChar 'c') EL)))
[5,7]

[daniel (Gast)]

danke schon mal, probiere ich gleich aus wenn ich zu hause bin

[Thomas Prescher (Gast)]

hat es dein Problem geloest?

[daniel (Gast)]

ja, es war sehr hilfreich
im moment versuche ich zur übung die funktion words nachzuimpementieren
ist es nicht möglich in einem muster die auftrennung vorzunehmen?

mywords::[Char]->Char
mywords (x":"y) = ....

sodass y teilstring vor dem ":" und y der teilstring danach wird.

grüsse, daniel

[daniel (Gast)]

leider wurde der funktionsprototyp automatisch von der forumssoftware
ummanipuliert. rückgabetyp ist [_[Char]_]

[Thomas Prescher (Gast)]

wenn ich das richtig sehe moechtest du die Woerter eines Textes trennen 
(die Newline und Leerzeichen entfernen)
Ich hab das vor kurzem auch mal gebraucht, allerdings nur fuer Newline. 
Sollte aber ohne probleme auf space erweiterbar sein

import IO

main::IO()
main    =   readFile "text.txt" >>= \x ->
            putStr (show (genWordList x)++"\n")
            
genWordList::String->[String]
genWordList [] = []
genWordList str = [take (findNewl str) str] ++ genWordList (drop ((findNewl str)+1) str)

findNewl::String->Int
findNewl [] = 0
findNewl ('\n':tail) = 0
findNewl (h:tail) = (findNewl tail) + 1

ich hoffe ich konnte dir helfen

[Jürgen B. (jubu)]

In Haskell ist words eine Standardfunktion:
Prelude> :t words
words :: String -> [String]
Prelude>  words "hallo bla\nhaus stuhl\nApfel"
["hallo","bla","haus","stuhl","Apfel"]