Add recursion example

fractional/src/main.rs

@@ -68,7 +68,7 @@ fn sqrt() {
     let f       = Fractional(-9, 4);
     let fr :f64 = f.try_into().unwrap();
     let sq      = f.sqrt();
-    let _sq     = f64::sqrt(fr);
+    let _sq     = fr.sqrt();
 
     println!("{:>14} : {:?} / {}", format!("sqrt {}", f), sq, _sq);
 
@@ -79,7 +79,7 @@ fn sqrt() {
         let fr  :f64 = (*f).try_into().unwrap();
         let sq       = f.sqrt().unwrap();
         let sqr :f64 = sq.try_into().unwrap();
-        let _sqr     = f64::sqrt(fr);
+        let _sqr     = fr.sqrt();
 
         println!("{:>14} : {} {} / {}", format!("sqrt {}", f), sq, sqr, _sqr);
     }

recursion/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "recursion"
+version = "0.1.0"
+authors = ["Georg Hopp <georg@steffers.org>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

recursion/src/main.rs

@@ -0,0 +1,51 @@
+//
+// Try some recursion with pattern matching... especially in
+// conjunction with match to get a similar behavious as in e.g.
+// haskell...
+//
+// Georg Hopp <georg@steffers.org>
+//
+// Copyright © 2019 Georg Hopp
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+
+// Borrowing rules do not apply here because everything lives on the stack.
+fn faculty(x: u32) -> u32 {
+    match x {
+        0 => 1,
+        _ => x * faculty(x - 1),
+    }
+}
+
+// for a tail recursive version we need to pass the currently calculated
+// faculty to an inner tail recursive function.
+// This will probably be optimized better, because the compiler would be
+// able to unroll the complete recursion.
+fn tail_faculty(x: u32) -> u32 {
+    fn faculty(x: u32, f: u32) -> u32 {
+        match x {
+            0 => f,
+            _ => faculty(x - 1, x * f),
+        }
+    };
+    faculty(x, 1)
+}
+
+fn main() {
+    for i in 0..10 {
+        println!("Fakultät                {} = {}", i, faculty(i));
+        println!("tail recursive Fakultät {} = {}", i, tail_faculty(i));
+    }
+}