Hallo Elena,

hier kommen die Lösungen für das fünfte Übungsblatt.
In unserer Gruppe sind folgende Leute:
André (ateichi@cs.tu-berlin.de)
Marisa (marisa@cs.tu-berlin.de)
Florian (cerbff@cs.tu-berlin.de)
und ich (mbirth@cs.tu-berlin.de).

Und jetzt die Lösungen:


1.2.: FUN myFold : (nat**nat->nat)**nat->seq[nat]->nat
      DEF myFold == \\f,e. \\s. IF <>?(s) THEN e
                                          ELSE myFold(f,f(e,ft(s)))(rt(s))
                                FI

      ListFunc.impl>e myFold(\\\\x,y. x+y,5)(%(1,2,3,4))
      15                                                



      FUN newfD : seq[nat]->nat
      DEF newfD == \\s. myFold(-,2*ft(s))(s)

      ListFunc.impl>e newfD(%(8,3,1))
      4                              

1.3.: FUN zip3 : (nat**nat**nat->nat)->seq[nat]**seq[nat]**seq[nat]->seq[nat]
      DEF zip3 == \\f. \\s1,s2,s3. IF <>?(s1) or (<>?(s2) or <>?(s3)) THEN <>
                                                                      ELSE f(ft(s1),ft(s2),ft(s3))::zip3(f)(rt(s1),rt(s2),rt(s3))
                                   FI

      ListFunc.impl>e zip3(\\\\x,y,z. x+y-z)(%(1,2,3),%(4,5,6),%(3,2,1))
      <2,5,8>                                                           



2.3.: Konstruktoren: FUN person : denotation**denotation**date -> person

      Diskriminatoren: FUN person? : person -> bool

      Selektoren: FUN name surname : person -> denotation
                  FUN birthdate : person -> date


2.4.: FUN earlier? : date**date -> bool
      DEF earlier?(date(a,b,c),date(d,e,f)) == IF c<f THEN true
                                                      ELSE IF (c=f) and (b<e) THEN true
                                                      ELSE IF (c=f) and (b=e) and (a<d) THEN true
                                                      ELSE false
                                                      FI
                                                      FI
                                               FI

      Person.impl>e earlier?(date(1,1,"2001"!),date("31"!,"12"!,"2000"!))
      false                                                              
      Person.impl>e earlier?(date(1,1,"2001"!),date(2,1,"2001"!))
      true                                                       



      FUN older? : person**person -> bool
      DEF older?(person(_,_,a),person(_,_,b)) == IF earlier?(b,a) THEN true ELSE false FI

      Person.impl>e older?(person("Max","Muster",date(1,1,"1979"!)),person("Mina","Muster",date(1,1,"1982"!)))                                                         
      false                                                                            
      Person.impl>e older?(person("Max","Muster",date(1,1,"1979"!)),person("Mina","Muster",date(1,1,"1974"!)))                                                         
      true                                                                             


      FUN birthday : person -> nat**nat
      DEF birthday(person(_,_,date(a,b,_))) == (a,b)

      Person.impl>e birthday(person("Max","Muster",date("29"!,2,"1979"!)))
      (29,2)                                                              



      FUN sameName? : person**person -> bool
      DEF sameName?(person(_,a,_),person(_,b,_)) == IF a=b THEN true ELSE false FI

      Person.impl>e sameName?(person("Max","Muster",date(1,1,1)),person("Mini","Muster",date(1,1,1)))                                                                  
      true                                                                             
      Person.impl>e sameName?(person("Max","Muster",date(1,1,1)),person("Mini","Müller",date(1,1,1)))                                                                  
      false                                                                            


3.1.: Konstruktoren: FUN ok : nat -> safeNat
                     FUN error : denotation -> safeNat
      Diskriminatoren: FUN ok? error? : safeNat -> bool
      Selektoren: FUN value : safeNat -> nat
                  FUN error : safeNat -> denotation

3.4.: FUN safeLift2 : (nat**nat->nat)**(nat**nat->bool)**denotation->safeNat**safeNat->safeNat
      DEF safeLift2(_,_,_)(error(msg),_) == error(msg)
      DEF safeLift2(_,_,_)(_,error(msg)) == error(msg)
      DEF safeLift2(_,_,_)(error(msg1),error(msg2)) == error(msg1 ++ msg2)
      DEF safeLift2(f,p,d)(ok(n1),ok(n2)) == IF p(n1,n2) THEN ok(f(n1,n2)) ELSE error(d) FI

      !!Beispiele siehe safeAdd, safeSub, safeMult, safeDiv!!

3.5.: FUN safeAdd : safeNat**safeNat -> safeNat
      DEF safeAdd == \\x,y. safeLift2(+,\\a,b. true,"")(x,y)

      FUN safeSub : safeNat**safeNat -> safeNat
      DEF safeSub == \\x,y. safeLift2(-,\\a,b. a>=b,"Geht nicht!")(x,y)

      FUN safeMult : safeNat**safeNat -> safeNat
      DEF safeMult == \\x,y. safeLift2(*,\\a,b. true,"")(x,y)
 
      FUN safeDiv : safeNat**safeNat -> safeNat
      DEF safeDiv == \\x,y. safeLift2(/,\\a,b. b>0,"Div durch 0 nicht erklaert!")(x,y)

      SafeNat.impl>e safeSub(ok(5),ok(4))
      ok(1)                              
      SafeNat.impl>e safeSub(ok(5),ok(6))
      error("Geht nicht!")               
      SafeNat.impl>e safeDiv(ok(5),ok(2)) 
      ok(2)                               
      SafeNat.impl>e safeDiv(ok(5),ok(0)) 
      error("Div durch 0 nicht erklaert!")

3.6.: FUN safeMap : (nat->nat)**(nat->bool)**denotation->seq[safeNat]->seq[safeNat]
      DEF safeMap(_,_,_)(<>) == <>
      DEF safeMap(a,b,c)(error(msg)::s) == error(msg)::safeMap(a,b,c)(s)
      DEF safeMap(f,p,m)(ok(a)::s) == IF p(a) THEN ok(f(a))::safeMap(f,p,m)(s) ELSE error(m)::safeMap(f,p,m)(s) FI

      SafeNat.impl>e safeMap(\\\\x. x+5,\\\\x. true,"Fehler!")(%(ok(1),ok(2),ok(3)))
      <ok(6),ok(7),ok(8)>                                                              
      SafeNat.impl>e safeMap(\\\\x. 100 / x,\\\\x. x>0,"Div durch 0")(%(ok(1),ok(2),ok(0)))
      <ok(100),ok(50),error("Div durch 0")>                                            

So, das war's.

Ich hab darauf verzichtet, die ganzen FUNs in die .sign-Dateien zu schieben,
da ich das so übersichtlicher finde und für unsere Testzwecke das eh
belanglos ist.

Grüsse,
   -mARKUS