Basic types, and a lot of function def mods.

Author: rizo

Anonymous_functions.fold

@@ -3,48 +3,63 @@
 --
 
 
--> \ x y -> x + y
--> \ 5
--> (~ + ~)
+
+map (x => x * x) [1..10]
+
+map { 2 => x * 4
+      x => x * x } [1..10]
+
+[1..10] . map { \1 * \2 }
+
+
+ tree . { Leaf => "x"
+          Node x => str x }
+
+=> \ x y => x + y
+=> \ 5
+=> (~ + ~)
 
 (-> system :fetcher :conf :credentials :username)
 
 -> system #fetcher #conf #credentials #username
 
--> map (data flag -> process data verbose: (not flag)) [1, 2, 3, 4, 5]
--> map (process ~ verbose: (not ~)) [1, 2, 3, 4, 5]
+-> map (data flag => process data verbose: (not flag)) [1, 2, 3, 4, 5]
+=> map (process _ verbose: (not _)) [1, 2, 3, 4, 5]
+
+=> map { data flag => process data verbose: (not flag) } [1, 2, 3, 4, 5]
+=> map { process _ verbose: (not _) } [1, 2, 3, 4, 5]
 
--> map (\data flag -> process data verbose: (not flag)) [1, 2, 3, 4, 5]
--> map \(process ~ verbose: (not ~)) [1, 2, 3, 4, 5]
+=> map (data flag => process data verbose: (not flag)) [1, 2, 3, 4, 5]
+=> map {process _ verbose: (not _)} [1, 2, 3, 4, 5]
 
--> map (λ data flag → process data verbose: (not flag)) [1, 2, 3, 4, 5]
--> map λ(process ~ verbose: (not ~)) [1, 2, 3, 4, 5]
+=> map (λ data flag ⇒ process data verbose: (not flag)) [1, 2, 3, 4, 5]
+=> map λ(process _ verbose: (not _)) [1, 2, 3, 4, 5]
 
--> map (data flag -> process data verbose: (not flag)) [1, 2, 3, 4, 5]
--> map {process ~ verbose: (not ~)} [1, 2, 3, 4, 5]
+=> map (data flag => process data verbose: (not flag)) [1, 2, 3, 4, 5]
+=> map {process _ verbose: (not _)} [1, 2, 3, 4, 5]
 
--> map (|data flag| -> process data verbose: (not flag)) [1, 2, 3, 4, 5]
--> map {process ~ verbose: (not ~)} [1, 2, 3, 4, 5]
+=> map (|data flag| => process data verbose: (not flag)) [1, 2, 3, 4, 5]
+=> map {process _ verbose: (not _)} [1, 2, 3, 4, 5]
 
--> map (|x| -> x * x) [1 .. 5]
+=> map (|x| => x * x) [1 .. 5]
  = [1, 4, 9, 16, 25]
 
--> map \(~1 * ~1) [1 .. 5]
+=> map \(_1 * _1) [1 .. 5]
  = [1, 4, 9, 16, 25]
 
--- Consider using ~0 as a reference to the anonymous function, allowing this way recursion.
+-- Consider using _0 as a reference to the anonymous function, allowing this way recursion.
 
 -- Mathematica
 -- If[#1 == 1, 1, #1 * #0[#1-1]]&
 
--> \(~1 == 1 ? 1 : ~1 * (~0 (~1 - 1)))
--> \(if (~1 == 1): 1 else: ~1 * (~0 (~1 - 1)))
+=> \(_1 == 1 ? 1 : _1 * (_0 (_1 - 1)))
+=> \(if (_1 == 1): 1 else: _1 * (_0 (_1 - 1)))
 
--> \(\1 == 1 ? 1 : @1 * (@0 (@1 - 1)))
+=> \(\1 == 1 ? 1 : @1 * (@0 (@1 - 1)))
 
 
-fix = \f -> (\x a -> f (x x) a) (\x a -> f (x x) a)
+fix = \f => (\x a => f (x x) a) (\x a => f (x x) a)
 
-f -> (x a -> f (x x) a) (x a -> f (x x) a)
+f => (x a => f (x x) a) (x a => f (x x) a)
 
 

Binary_search.fold

@@ -1,34 +1,58 @@
--- 
+--
 -- Binary search
 -- http://rosettacode.org/wiki/Binary_search#Metaphor
 --
 
 
-function {Ord a} binary_search haystack::[a] needle::a -> Int?
-	function recurse low high haystack needle
-		mid = (low + high) / 2
-		if | high < low            -> None
-		   | haystack.mid > needle -> recurse low (mid - 1) haystack needle
-		   | haystack.mid < needle -> recurse (mid + 1) high haystack needle
-		   | otherwise             -> Some mid
-	end
-	recurse 0 (#haystack - 1) haystack needle
+binary_search <Ord T> :: [T] -> T -> Int?
+binary_search haystack needle = do
+    search l h = do
+        m = (low + high) / 2
+        if | (h < l)                 => None
+           | (haystack # m > needle) => search l (m - 1)
+           | (haystack # m < needle) => search (m + 1) h
+           | otherwise               => Some m
+    end
+    search 0 (#haystack - 1)
 end
 
-
-fn binary_search_rec<T: Ord>(haystack: &[T], needle: T) -> Option<uint> {
-    fn recurse<T: Ord>(low: uint, high: uint, haystack: &[T], needle: T) -> Option<uint> {
-        match (low + high) / 2 {
-            _ if high < low => None,
-            mid if haystack[mid] > needle => recurse(low, mid - 1, haystack, needle),
-            mid if haystack[mid] < needle => recurse(mid + 1, high, haystack, needle),
-            mid => Some(mid)
-        }
+binary_search <Ord T> :: [T] -> T -> Int?
+binary_search haystack needle = {
+    search l h = {
+        m = (low + high) / 2
+        if | h < l                 => None
+           | haystack # m > needle => search l (m - 1)
+           | haystack # m < needle => search (m + 1) h
+           | otherwise             => Some m
     }
-    recurse::<T>(0, haystack.len() - 1, haystack, needle)
+    search 0 (#haystack - 1)
 }
 
 
+binarySearch :: Integral a => (a -> Ordering) -> (a, a) -> Maybe a
+binarySearch p (l, h)
+  | h < l = Nothing
+  | otherwise =
+      let mid = (low + high) `div` 2 in
+      case p mid of
+        LT -> binarySearch p (low, mid-1)
+        GT -> binarySearch p (mid+1, high)
+        EQ -> Just mid
+
+
+
+function {Ord a} binary_search haystack::[a] needle::a -> Int?
+  function recurse low high haystack needle
+    mid = (low + high) / 2
+    if | high < low            -> None
+       | haystack.mid > needle -> recurse low (mid - 1) haystack needle
+       | haystack.mid < needle -> recurse (mid + 1) high haystack needle
+       | otherwise             -> Some mid
+  end
+  recurse 0 (#haystack - 1) haystack needle
+end
+
+
 binarySearch :: Integral a => (a -> Ordering) -> (a, a) -> Maybe a
 binarySearch p (low,high)
   | high < low = Nothing