@explorable-viz/fluid 0.7.8 → 0.7.10

package/dist/fluid/fluid/lib/prelude.fld

@@ -0,0 +1,266 @@
+-- "Num" throughout means (Int + Float).
+
+-- Bool -> Bool
+let and False y = False;
+    and True y = y;
+
+-- Bool -> Bool
+let or True y = True;
+    or False y = y;
+
+-- Bool -> Bool
+let not True = False;
+    not False = True;
+
+-- Int -> Int -> Ordering
+let compare x y =
+   if x > y
+   then GT
+   else if x < y
+      then LT
+      else EQ;
+
+-- Num -> Num
+let negate = (-) 0;
+
+-- Log of x in base y.
+-- Float -> Float -> Float
+let logBase x y = log y / log x;
+
+-- Float -> Float -> Float
+let ceilingToNearest n m =
+   ceiling (n / m) * m;
+
+-- (b -> c) -> (a -> b) -> a -> c
+-- Want infix <<<
+let compose f g x = f (g x);
+
+-- ((a, b) -> c) -> a -> b -> c
+let curry f x y = f (x, y);
+
+-- (a -> b -> c) -> (a, b) -> c
+let uncurry f (x, y) = f x y;
+
+-- a -> b -> a
+let const x _ = x;
+
+-- (a -> b) -> (a, c) -> (b, c)
+let first f (a, c) = (f a, c);
+
+-- (a, b) -> b
+let snd (_, y) = y;
+
+-- (a -> b) -> (c, a) -> (c, b)
+let second f (c, a) = (c, f a);
+
+-- (a -> b -> c) -> b -> a -> c
+let flip f x y = f y x;
+
+-- (a, b) -> a
+let fst (x, _) = x;
+
+-- a -> a
+let id x = x;
+
+-- (a -> b) -> (a -> c) -> a -> (b, c)
+-- Want infix &&&
+let prod f g x = (f x, g x);
+
+-- (a, b) -> (b, a)
+let swap (a, b) = (b, a);
+
+-- List a -> a
+let head [] = error "Can't take head of empty list";
+    head (x : _) = x;
+
+-- List a -> List a
+let tail [] = error "Can't take tail of empty list";
+    tail (_ : xs) = xs;
+
+-- Eq a => a -> List a -> Bool
+let elem x [] = False;
+    elem x (x' : xs) = (x == x') `or` (elem x xs);
+
+-- (a -> Bool) -> List a -> Option a
+let find p [] = error "not found";
+    find p (x : xs) = if p x then Some x else find p xs;
+
+-- String -> String -> List Dict -> Option Dict
+let findWithKey fname fval table = find (fun y -> y.[fname] == fval) table;
+
+let fromSome option = match option as {
+    None -> error "Expected Some!";
+    Some x -> x
+};
+
+-- (a -> Bool) -> List a -> List a
+let filter p [] = [];
+    filter p (x : xs) =
+      let ys = filter p xs in
+      if p x then x : ys else ys;
+
+-- (a -> Option b) -> List a -> List b
+let filterMap p [] = [];
+    filterMap p (x : xs) =
+      match p x as {
+         None -> filterMap f xs;
+         Some y -> y : filterMap f xs
+      };
+
+-- (a -> b -> a) -> a -> List b -> a
+let foldl op z [] = z;
+    foldl op z (x : xs) = foldl op (op z x) xs;
+
+-- (a -> b -> a) -> List b -> a
+let foldl1 op (x : xs) = foldl op x xs;
+
+-- (a -> b -> b) -> b -> List a -> b
+let foldr op z [] = z;
+    foldr op z (x : xs) = op x (foldr op z xs);
+
+-- (a -> b -> b) -> List a -> b
+let foldr1 op [x] = x;
+    foldr1 op (x : y : xs) = op x (foldr1 op (y : xs));
+
+-- (a -> b -> a) -> a -> List b -> List a
+let scanl1 op z xs =
+   let go x continue acc =
+      let next = op acc x in
+      next : continue next in
+   foldr go (const []) xs z;
+
+-- (a -> b -> a) -> a -> List b -> List a
+let scanl op z xs =
+   z : scanl1 op z xs;
+
+-- (a -> b) -> List a -> List b
+let map f [] = [];
+    map f (x : xs) = f x : map f xs;
+
+-- (List a, List a) -> List a
+let append ([], ys) = ys;
+    append (x : xs, ys) = x : append (xs, ys);
+
+-- List a -> List -> List a
+-- Want infix ++
+let concat2 [] ys = ys;
+    concat2 (x : xs) ys = x : concat2 xs ys;
+
+-- List (List a) -> List a
+let concat = foldl concat2 [];
+
+-- (a -> List b) -> List a -> List b
+let concatMap f xs = concat (map f xs);
+
+-- List a -> a -> List a
+let intersperse [] _ = [];
+    intersperse [x] _ = [x];
+    intersperse (x : y : ys) sep = x : sep : intersperse (y : ys) sep;
+
+-- Int -> (a -> a) -> a -> List a
+let iterate n f z =
+   if n == 0 then [] else z : map f (iterate (n - 1) f z);
+
+-- List Int -> Int
+let sum = foldr (+) 0;
+
+-- List a -> a
+let last [x] = x;
+    last (x : y : ys) = last (y : ys);
+
+-- List a -> Int
+let length [] = 0;
+    length (_ : xs) = 1 + length xs;
+
+-- List a -> List a
+let reverse [] = [];
+    reverse (x : xs) = append (reverse xs, [x]);
+
+-- Int -> a -> List a
+let repeat = flip iterate id;
+
+-- Int -> List a -> List a
+let take n xs =
+    if n <= 0
+    then []
+    else match xs as {
+       [] -> [];
+       x : xs -> x : take (n - 1) xs
+    };
+
+-- Int -> List a -> List a
+let drop n xs =
+   if n <= 0
+   then xs
+   else match xs as {
+      [] -> [];
+      _ : xs -> drop (n - 1) xs
+   };
+
+-- Int -> List a -> List a
+let lastN n xs =
+   foldl (compose const (drop 1)) xs (drop n xs);
+
+-- Expects non-negative integer as first argument and non-empty list as second argument.
+-- Int -> List a -> a
+let nth n (x : xs) =
+   if n == 0 then x else nth (n - 1) xs;
+
+-- Matrix Int -> Int -> Int -> Int
+let nth2 i j xss =
+   nth (j - 1) (nth (i - 1) xss);
+
+-- Partial; requires k to be in the map.
+-- Int -> List (Int, b) -> b
+let lookup k [] = error "Key not found in map";
+    lookup k ((k', v) : kvs) =
+       if k == k' then v else lookup k kvs;
+
+-- Int -> Int -> Int
+let max n m =
+   if n > m then n else m;
+
+-- Int -> Int -> Int
+let min n m =
+   if n < m then n else m;
+
+-- List Int -> Int
+let maximum = foldr1 max;
+
+-- List Int -> Int
+let minimum = foldr1 min;
+
+-- List (a, b) -> (List a, List b)
+let unzip [] = ([], []);
+    unzip ((x, y) : zs) =
+      let (xs, ys) = unzip zs in
+      (x : xs, y : ys);
+
+-- (a -> b -> c) -> List a -> List b -> List c
+let zipWith op [] ys = [];
+    zipWith op (x : xs) [] = [];
+    zipWith op (x : xs) (y : ys) = op x y : zipWith op xs ys;
+
+-- List a -> List b -> List (a, b)
+let zip = zipWith (curry id);
+
+-- Int -> Int -> List Int
+let enumFromTo n m =
+    if n <= m then n : [n + 1 .. m] else [];
+
+let range (m1, n1) (m2, n2) =
+      [ (i1, i2) | i1 <- [m1 .. m2], i2 <- [n1 .. n2] ];
+
+-- Int -> Int -> Int
+let abs x y =
+   if x - y < 0 then negate (x - y) else (x - y);
+
+-- Eq a => [a] -> [a]
+let nub xs =
+    let nub' [] _ = [];
+        nub' (x : xs) ys = if x `elem` ys then nub' xs ys else x : nub' xs (x : ys) in
+    nub' xs [];
+
+-- Int -> Int -> [a] -> [a]
+let slice begin end xs =
+   take (end - begin) (drop begin xs);

package/dist/fluid/fluid/lib/text-viz.fld

@@ -0,0 +1,18 @@
+let likelihoodMap table prob = (fromSome (find (fun x -> x.prob <= prob) table)).msg;
+
+let mkPercent num = (numToStr (num * 100)) ++ "%";
+
+let leqP n m = 
+    if n <= m
+    then "less"
+    else "more";
+
+let gradedLeqP n m = 
+    let ratio = n / m 
+    in if ratio <= 1.0 
+        then if ratio <=0.5
+            then "much less"
+            else "less"
+        else if ratio >= 2.0
+            then "much more"
+            else "more";